-- GENERATED by C->Haskell Compiler, version 0.16.3 Crystal Seed, 24 Jan 2009 (Haskell)
-- Edit the ORIGNAL .chs file instead!


{-# LINE 1 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE TypeSynonymInstances #-}

-- This source file is part of HGamer3D
-- (A project to enable 3D game development in Haskell)
-- For the latest info, see http://www.althainz.de/HGamer3D.html
-- 

-- (c) 2011, 2012 Peter Althainz
-- 
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
-- 
--     http://www.apache.org/licenses/LICENSE-2.0
-- 
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
-- 


-- ClassSceneManager.chs

-- 

module HGamer3D.Bindings.Ogre.ClassSceneManager where

import C2HS
import Foreign
import Foreign.Ptr
import Foreign.C
import Monad         (liftM, liftM2)

import HGamer3D.Data.HG3DClass
import HGamer3D.Data.Vector
import HGamer3D.Data.Colour
import HGamer3D.Data.Angle

import HGamer3D.Bindings.Ogre.Utils
{-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
import HGamer3D.Bindings.Ogre.ClassPtr
{-# LINE 43 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
import HGamer3D.Bindings.Ogre.StructHG3DClass
{-# LINE 44 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
import HGamer3D.Bindings.Ogre.EnumSceneManagerPrefabType
{-# LINE 45 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
import HGamer3D.Bindings.Ogre.StructColour
{-# LINE 46 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
import HGamer3D.Bindings.Ogre.StructQuaternion
{-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
import HGamer3D.Bindings.Ogre.EnumSceneManagerSpecialCaseRenderQueueMode
{-# LINE 48 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
import HGamer3D.Bindings.Ogre.EnumLightType
{-# LINE 49 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
import HGamer3D.Bindings.Ogre.StructSharedPtr
{-# LINE 50 ".\\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 55 ".\\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 60 ".\\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 65 ".\\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 71 ".\\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 77 ".\\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 83 ".\\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 88 ".\\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 93 ".\\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 97 ".\\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 103 ".\\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 108 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Returns a pointer to the named LightThrows 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 114 ".\\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 120 ".\\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 125 ".\\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 130 ".\\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 134 ".\\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 139 ".\\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 145 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Destroys a SceneNodeThis 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 150 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Destroys a SceneNodeThis 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 155 ".\\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 160 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Retrieves a named SceneNodeIf 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 166 ".\\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 172 ".\\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 180 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Create an Entity
createEntity2 :: 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)
 -- ^ 
createEntity2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  alloca $ \a3' -> 
  createEntity2'_ a1' a2' a3' >>= \res ->
  peek  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 186 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Create an Entity
createEntity3 :: 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)
 -- ^ 
createEntity3 a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  let {a3' = cIntFromEnum a3} in 
  alloca $ \a4' -> 
  createEntity3'_ a1' a2' a3' a4' >>= \res ->
  peek  a4'>>= \a4'' -> 
  return (a4'')
{-# LINE 193 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Create an Entity
createEntity4 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  EnumSceneManagerPrefabType  -- ^ ptype - The prefab type. 
  ->  IO (HG3DClass)
 -- ^ 
createEntity4 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = cIntFromEnum a2} in 
  alloca $ \a3' -> 
  createEntity4'_ a1' a2' a3' >>= \res ->
  peek  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 199 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Retrieves a pointer to the named EntityThrows 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 205 ".\\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 211 ".\\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 216 ".\\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 221 ".\\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 225 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Create a ManualObject
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 231 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Create a ManualObject
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 236 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Retrieves a pointer to the named ManualObjectThrows 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 242 ".\\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 248 ".\\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 253 ".\\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 258 ".\\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 262 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Create a BillboardChain
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 268 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Create a BillboardChain
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 273 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Retrieves a pointer to the named BillboardChainThrows 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 279 ".\\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 285 ".\\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 290 ".\\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 295 ".\\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 299 ".\\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 305 ".\\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 310 ".\\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 314 ".\\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 320 ".\\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 325 ".\\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 329 ".\\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 333 ".\\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 338 ".\\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 343 ".\\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 348 ".\\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 353 ".\\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 359 ".\\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 365 ".\\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 370 ".\\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 375 ".\\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 380 ".\\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 390 ".\\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 395 ".\\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 400 ".\\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 405 ".\\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 apparant '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 420 ".\\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 425 ".\\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 430 ".\\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 435 ".\\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 440 ".\\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 445 ".\\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 450 ".\\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 455 ".\\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 462 ".\\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 468 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Retrieves a pointer to the named BillboardSetThrows 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 474 ".\\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 480 ".\\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 485 ".\\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 490 ".\\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 494 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Tells the SceneManagerThis 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 499 ".\\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 504 ".\\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 511 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Looks up an AnimationThrows 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 517 ".\\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 523 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Destroys an AnimationYou 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 528 ".\\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 532 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Create an AnimationStateYou 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 538 ".\\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 544 ".\\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 550 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Destroys an AnimationStateYou 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 555 ".\\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 559 ".\\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 563 ".\\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 568 ".\\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 573 ".\\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 578 ".\\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 583 ".\\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 588 ".\\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 593 ".\\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 598 ".\\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 603 ".\\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 608 ".\\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 613 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Sets the default maximum distance away from the camera that shadows will be visible. You have to call this function before you create lights or the default distance of zero will be used. 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 618 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Gets the default maximum distance away from the camera that shadows will be visible. 
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 623 ".\\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 628 ".\\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 633 ".\\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 638 ".\\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 643 ".\\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 648 ".\\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 653 ".\\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 659 ".\\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 665 ".\\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 671 ".\\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 676 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Gets 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. 
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 681 ".\\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 686 ".\\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 691 ".\\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 696 ".\\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 701 ".\\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 706 ".\\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 711 ".\\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 716 ".\\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 721 ".\\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 726 ".\\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 731 ".\\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 736 ".\\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 741 ".\\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 746 ".\\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 751 ".\\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 756 ".\\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 761 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Gets whether when using a built-in additive shadow mode, user clip planes should be used to restrict light rendering. 
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 766 ".\\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 771 ".\\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 776 ".\\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 782 ".\\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 787 ".\\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 791 ".\\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 796 ".\\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 800 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Destroys a MovableObjectThe 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 806 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Destroys a MovableObjectThe 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 811 ".\\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 816 ".\\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 820 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Get a reference to a previously created MovableObjectThrows 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 827 ".\\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 834 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Inject a MovableObjectThis 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 839 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Extract a previously injected MovableObjectEssentially 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 845 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Extract a previously injected MovableObjectEssentially 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 850 ".\\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 855 ".\\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 860 ".\\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 865 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}

-- | Sets whether the SceneManagerThis 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 870 ".\\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 875 ".\\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 880 ".\\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 885 ".\\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 890 ".\\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 895 ".\\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 900 ".\\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 905 ".\\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 910 ".\\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)
 -- ^ 
getCameraRelativeRendering a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getCameraRelativeRendering'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 915 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}


foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destruct"
  delete'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getName"
  getName'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getTypeName"
  getTypeName'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_createCamera"
  createCamera'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getCamera"
  getCamera'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_hasCamera"
  hasCamera'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyCamera"
  destroyCamera'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyCamera2"
  destroyCamera2'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyAllCameras"
  destroyAllCameras'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_createLight"
  createLight'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_createLight2"
  createLight2'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getLight"
  getLight'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_hasLight"
  hasLight'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyLight"
  destroyLight'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyLight2"
  destroyLight2'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyAllLights"
  destroyAllLights'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_createSceneNode"
  createSceneNode'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_createSceneNode2"
  createSceneNode2'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroySceneNode"
  destroySceneNode'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroySceneNode2"
  destroySceneNode2'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getRootSceneNode"
  getRootSceneNode'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getSceneNode"
  getSceneNode'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_hasSceneNode"
  hasSceneNode'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_createEntity"
  createEntity'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CChar) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_createEntity2"
  createEntity2'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_createEntity3"
  createEntity3'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (CInt -> ((HG3DClassPtr) -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_createEntity4"
  createEntity4'_ :: ((HG3DClassPtr) -> (CInt -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getEntity"
  getEntity'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_hasEntity"
  hasEntity'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyEntity"
  destroyEntity'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyEntity2"
  destroyEntity2'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyAllEntities"
  destroyAllEntities'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_createManualObject"
  createManualObject'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_createManualObject2"
  createManualObject2'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getManualObject"
  getManualObject'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_hasManualObject"
  hasManualObject'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyManualObject"
  destroyManualObject'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyManualObject2"
  destroyManualObject2'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyAllManualObjects"
  destroyAllManualObjects'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_createBillboardChain"
  createBillboardChain'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_createBillboardChain2"
  createBillboardChain2'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getBillboardChain"
  getBillboardChain'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_hasBillboardChain"
  hasBillboardChain'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyBillboardChain"
  destroyBillboardChain'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyBillboardChain2"
  destroyBillboardChain2'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyAllBillboardChains"
  destroyAllBillboardChains'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_hasRibbonTrail"
  hasRibbonTrail'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyRibbonTrail2"
  destroyRibbonTrail2'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyAllRibbonTrails"
  destroyAllRibbonTrails'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_hasParticleSystem"
  hasParticleSystem'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyParticleSystem2"
  destroyParticleSystem2'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyAllParticleSystems"
  destroyAllParticleSystems'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_clearScene"
  clearScene'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setAmbientLight"
  setAmbientLight'_ :: ((HG3DClassPtr) -> ((ColourPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getAmbientLight"
  getAmbientLight'_ :: ((HG3DClassPtr) -> ((ColourPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_prepareWorldGeometry"
  prepareWorldGeometry'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setWorldGeometry"
  setWorldGeometry'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_estimateWorldGeometry"
  estimateWorldGeometry'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_hasOption"
  hasOption'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setSkyPlaneEnabled"
  setSkyPlaneEnabled'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_isSkyPlaneEnabled"
  isSkyPlaneEnabled'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getSkyPlaneNode"
  getSkyPlaneNode'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setSkyBox"
  setSkyBox'_ :: ((HG3DClassPtr) -> (CInt -> ((Ptr CChar) -> (CFloat -> (CInt -> ((QuaternionPtr) -> ((Ptr CChar) -> (IO ()))))))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setSkyBoxEnabled"
  setSkyBoxEnabled'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_isSkyBoxEnabled"
  isSkyBoxEnabled'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getSkyBoxNode"
  getSkyBoxNode'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setSkyDome"
  setSkyDome'_ :: ((HG3DClassPtr) -> (CInt -> ((Ptr CChar) -> (CFloat -> (CFloat -> (CFloat -> (CInt -> ((QuaternionPtr) -> (CInt -> (CInt -> (CInt -> ((Ptr CChar) -> (IO ())))))))))))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setSkyDomeEnabled"
  setSkyDomeEnabled'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_isSkyDomeEnabled"
  isSkyDomeEnabled'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getSkyDomeNode"
  getSkyDomeNode'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getFogColour"
  getFogColour'_ :: ((HG3DClassPtr) -> ((ColourPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getFogStart"
  getFogStart'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getFogEnd"
  getFogEnd'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getFogDensity"
  getFogDensity'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_createBillboardSet"
  createBillboardSet'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (CUInt -> ((HG3DClassPtr) -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_createBillboardSet2"
  createBillboardSet2'_ :: ((HG3DClassPtr) -> (CUInt -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getBillboardSet"
  getBillboardSet'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_hasBillboardSet"
  hasBillboardSet'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyBillboardSet"
  destroyBillboardSet'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyBillboardSet2"
  destroyBillboardSet2'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyAllBillboardSets"
  destroyAllBillboardSets'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setDisplaySceneNodes"
  setDisplaySceneNodes'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getDisplaySceneNodes"
  getDisplaySceneNodes'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_createAnimation"
  createAnimation'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (CFloat -> ((HG3DClassPtr) -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getAnimation"
  getAnimation'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_hasAnimation"
  hasAnimation'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyAnimation"
  destroyAnimation'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyAllAnimations"
  destroyAllAnimations'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_createAnimationState"
  createAnimationState'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getAnimationState"
  getAnimationState'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_hasAnimationState"
  hasAnimationState'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyAnimationState"
  destroyAnimationState'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyAllAnimationStates"
  destroyAllAnimationStates'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_clearSpecialCaseRenderQueues"
  clearSpecialCaseRenderQueues'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setSpecialCaseRenderQueueMode"
  setSpecialCaseRenderQueueMode'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getSpecialCaseRenderQueueMode"
  getSpecialCaseRenderQueueMode'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_showBoundingBoxes"
  showBoundingBoxes'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getShowBoundingBoxes"
  getShowBoundingBoxes'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setShowDebugShadows"
  setShowDebugShadows'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getShowDebugShadows"
  getShowDebugShadows'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setShadowColour"
  setShadowColour'_ :: ((HG3DClassPtr) -> ((ColourPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getShadowColour"
  getShadowColour'_ :: ((HG3DClassPtr) -> ((ColourPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setShadowDirectionalLightExtrusionDistance"
  setShadowDirectionalLightExtrusionDistance'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getShadowDirectionalLightExtrusionDistance"
  getShadowDirectionalLightExtrusionDistance'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setShadowFarDistance"
  setShadowFarDistance'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getShadowFarDistance"
  getShadowFarDistance'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getShadowFarDistanceSquared"
  getShadowFarDistanceSquared'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setShadowIndexBufferSize"
  setShadowIndexBufferSize'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getShadowIndexBufferSize"
  getShadowIndexBufferSize'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setShadowTextureSize"
  setShadowTextureSize'_ :: ((HG3DClassPtr) -> (CUShort -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setShadowTextureCount"
  setShadowTextureCount'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getShadowTextureCount"
  getShadowTextureCount'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setShadowTextureCountPerLightType"
  setShadowTextureCountPerLightType'_ :: ((HG3DClassPtr) -> (CInt -> (CInt -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getShadowTextureCountPerLightType"
  getShadowTextureCountPerLightType'_ :: ((HG3DClassPtr) -> (CInt -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getShadowTexture"
  getShadowTexture'_ :: ((HG3DClassPtr) -> (CInt -> ((SharedPtrPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setShadowDirLightTextureOffset"
  setShadowDirLightTextureOffset'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getShadowDirLightTextureOffset"
  getShadowDirLightTextureOffset'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setShadowTextureFadeStart"
  setShadowTextureFadeStart'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setShadowTextureFadeEnd"
  setShadowTextureFadeEnd'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setShadowTextureSelfShadow"
  setShadowTextureSelfShadow'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getShadowTextureSelfShadow"
  getShadowTextureSelfShadow'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setShadowTextureCasterMaterial"
  setShadowTextureCasterMaterial'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setShadowTextureReceiverMaterial"
  setShadowTextureReceiverMaterial'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setShadowCasterRenderBackFaces"
  setShadowCasterRenderBackFaces'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getShadowCasterRenderBackFaces"
  getShadowCasterRenderBackFaces'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setShadowUseInfiniteFarPlane"
  setShadowUseInfiniteFarPlane'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_isShadowTechniqueStencilBased"
  isShadowTechniqueStencilBased'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_isShadowTechniqueTextureBased"
  isShadowTechniqueTextureBased'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_isShadowTechniqueModulative"
  isShadowTechniqueModulative'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_isShadowTechniqueAdditive"
  isShadowTechniqueAdditive'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_isShadowTechniqueIntegrated"
  isShadowTechniqueIntegrated'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_isShadowTechniqueInUse"
  isShadowTechniqueInUse'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setShadowUseLightClipPlanes"
  setShadowUseLightClipPlanes'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getShadowUseLightClipPlanes"
  getShadowUseLightClipPlanes'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setLateMaterialResolving"
  setLateMaterialResolving'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_isLateMaterialResolving"
  isLateMaterialResolving'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_hasStaticGeometry"
  hasStaticGeometry'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyStaticGeometry2"
  destroyStaticGeometry2'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyAllStaticGeometry"
  destroyAllStaticGeometry'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyInstancedGeometry2"
  destroyInstancedGeometry2'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyAllInstancedGeometry"
  destroyAllInstancedGeometry'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyMovableObject"
  destroyMovableObject'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CChar) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyMovableObject2"
  destroyMovableObject2'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyAllMovableObjectsByType"
  destroyAllMovableObjectsByType'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_destroyAllMovableObjects"
  destroyAllMovableObjects'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getMovableObject"
  getMovableObject'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_hasMovableObject"
  hasMovableObject'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_injectMovableObject"
  injectMovableObject'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_extractMovableObject"
  extractMovableObject'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CChar) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_extractMovableObject2"
  extractMovableObject2'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_extractAllMovableObjectsByType"
  extractAllMovableObjectsByType'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setVisibilityMask"
  setVisibilityMask'_ :: ((HG3DClassPtr) -> (CUInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getVisibilityMask"
  getVisibilityMask'_ :: ((HG3DClassPtr) -> ((Ptr CUInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setFindVisibleObjects"
  setFindVisibleObjects'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getFindVisibleObjects"
  getFindVisibleObjects'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setNormaliseNormalsOnScale"
  setNormaliseNormalsOnScale'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getNormaliseNormalsOnScale"
  getNormaliseNormalsOnScale'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setFlipCullingOnNegativeScale"
  setFlipCullingOnNegativeScale'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getFlipCullingOnNegativeScale"
  getFlipCullingOnNegativeScale'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getDestinationRenderSystem"
  getDestinationRenderSystem'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getCurrentViewport"
  getCurrentViewport'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_setCameraRelativeRendering"
  setCameraRelativeRendering'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs.h ogre_scmgr_getCameraRelativeRendering"
  getCameraRelativeRendering'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))