-- 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\\ClassCamera.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.
-- 


-- ClassCamera.chs

-- 

module HGamer3D.Bindings.Ogre.ClassCamera where

import Foreign
import Foreign.Ptr
import Foreign.C

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

import HGamer3D.Bindings.Ogre.Utils
{-# LINE 40 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
import HGamer3D.Bindings.Ogre.ClassPtr
{-# LINE 41 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
import HGamer3D.Bindings.Ogre.StructHG3DClass
{-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
import HGamer3D.Bindings.Ogre.StructVec3
{-# LINE 43 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
import HGamer3D.Bindings.Ogre.StructRadians
{-# LINE 44 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
import HGamer3D.Bindings.Ogre.StructQuaternion
{-# LINE 45 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
import HGamer3D.Bindings.Ogre.EnumFrustumPlane
{-# LINE 46 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Standard constructor. 
new :: String  -- ^ name
  ->  HG3DClass  -- ^ sm
  ->  IO (HG3DClass)
 -- ^ 
new a1 a2 =
  withCString a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  alloca $ \a3' -> 
  new'_ a1' a2' a3' >>= \res ->
  peek  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 53 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Standard destructor. 
delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
  ->  IO ()
 -- ^ 
delete a1 =
  withHG3DClass a1 $ \a1' -> 
  delete'_ a1' >>= \res ->
  return ()
{-# LINE 57 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Returns a pointer to the SceneManager
getSceneManager :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ 
getSceneManager a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getSceneManager'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 62 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Sets the camera's position. 
setPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ x
  ->  Float  -- ^ y
  ->  Float  -- ^ z
  ->  IO ()
 -- ^ 
setPosition a1 a2 a3 a4 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  let {a3' = realToFrac a3} in 
  let {a4' = realToFrac a4} in 
  setPosition'_ a1' a2' a3' a4' >>= \res ->
  return ()
{-# LINE 69 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Sets the camera's position. 
setPosition2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec3  -- ^ vec
  ->  IO ()
 -- ^ 
setPosition2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withVec3 a2 $ \a2' -> 
  setPosition2'_ a1' a2' >>= \res ->
  return ()
{-# LINE 74 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Retrieves the camera's position. 
getPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getPosition a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getPosition'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 79 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Moves the camera's position by the vector offset provided along world axes. 
move :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec3  -- ^ vec
  ->  IO ()
 -- ^ 
move a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withVec3 a2 $ \a2' -> 
  move'_ a1' a2' >>= \res ->
  return ()
{-# LINE 84 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Moves the camera's position by the vector offset provided along it's own axes (relative to orientation). 
moveRelative :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec3  -- ^ vec
  ->  IO ()
 -- ^ 
moveRelative a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withVec3 a2 $ \a2' -> 
  moveRelative'_ a1' a2' >>= \res ->
  return ()
{-# LINE 89 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Sets the camera's direction vector. Note that the 'up' vector for the camera will automatically be recalculated based on the current 'up' vector (i.e. the roll will remain the same). 
setDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ x
  ->  Float  -- ^ y
  ->  Float  -- ^ z
  ->  IO ()
 -- ^ 
setDirection a1 a2 a3 a4 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  let {a3' = realToFrac a3} in 
  let {a4' = realToFrac a4} in 
  setDirection'_ a1' a2' a3' a4' >>= \res ->
  return ()
{-# LINE 96 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Sets the camera's direction vector. 
setDirection2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec3  -- ^ vec
  ->  IO ()
 -- ^ 
setDirection2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withVec3 a2 $ \a2' -> 
  setDirection2'_ a1' a2' >>= \res ->
  return ()
{-# LINE 101 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | 
getDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getDirection a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getDirection'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 106 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Gets the camera's up vector. 
getUp :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getUp a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getUp'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 111 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Gets the camera's right vector. 
getRight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getRight a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getRight'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 116 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Points the camera at a location in worldspace. This is a helper method to automatically generate the direction vector for the camera, based on it's current position and the supplied look-at point. 
lookAt :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec3  -- ^ targetPoint - A vector specifying the look at point. 
  ->  IO ()
 -- ^ 
lookAt a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withVec3 a2 $ \a2' -> 
  lookAt'_ a1' a2' >>= \res ->
  return ()
{-# LINE 121 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Points the camera at a location in worldspace. This is a helper method to automatically generate the direction vector for the camera, based on it's current position and the supplied look-at point. 
lookAt2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ x
  ->  Float  -- ^ y
  ->  Float  -- ^ z - Co-ordinates of the point to look at. 
  ->  IO ()
 -- ^ 
lookAt2 a1 a2 a3 a4 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  let {a3' = realToFrac a3} in 
  let {a4' = realToFrac a4} in 
  lookAt2'_ a1' a2' a3' a4' >>= \res ->
  return ()
{-# LINE 128 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Rolls the camera anticlockwise, around its local z axis. 
roll :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Radians  -- ^ angle
  ->  IO ()
 -- ^ 
roll a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withRadians a2 $ \a2' -> 
  roll'_ a1' a2' >>= \res ->
  return ()
{-# LINE 133 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Rotates the camera anticlockwise around it's local y axis. 
yaw :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Radians  -- ^ angle
  ->  IO ()
 -- ^ 
yaw a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withRadians a2 $ \a2' -> 
  yaw'_ a1' a2' >>= \res ->
  return ()
{-# LINE 138 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Pitches the camera up/down anticlockwise around it's local z axis. 
pitch :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Radians  -- ^ angle
  ->  IO ()
 -- ^ 
pitch a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withRadians a2 $ \a2' -> 
  pitch'_ a1' a2' >>= \res ->
  return ()
{-# LINE 143 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Rotate the camera around an arbitrary axis. 
rotate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec3  -- ^ axis
  ->  Radians  -- ^ angle
  ->  IO ()
 -- ^ 
rotate a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  withVec3 a2 $ \a2' -> 
  withRadians a3 $ \a3' -> 
  rotate'_ a1' a2' a3' >>= \res ->
  return ()
{-# LINE 149 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Rotate the camera around an arbitrary axis using a Quaternion
rotate2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Quaternion  -- ^ q
  ->  IO ()
 -- ^ 
rotate2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withQuaternion a2 $ \a2' -> 
  rotate2'_ a1' a2' >>= \res ->
  return ()
{-# LINE 154 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Tells the camera whether to yaw around it's own local Y axis or a fixed axis of choice. This method allows you to change the yaw behaviour of the camera
--
setFixedYawAxis :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ useFixed - If true, the axis passed in the second parameter will always be the yaw axis no matter what the camera orientation. If false, the camera yaws around the local Y. 
  ->  Vec3  -- ^ fixedAxis - The axis to use if the first parameter is true. 
  ->  IO ()
 -- ^ 
setFixedYawAxis a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  withVec3 a3 $ \a3' -> 
  setFixedYawAxis'_ a1' a2' a3' >>= \res ->
  return ()
{-# LINE 160 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Returns the camera's current orientation. 
getOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Quaternion)
 -- ^ 
getOrientation a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getOrientation'_ a1' a2' >>= \res ->
  peekQuaternion  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 165 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Sets the camera's orientation. 
setOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Quaternion  -- ^ q
  ->  IO ()
 -- ^ 
setOrientation a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withQuaternion a2 $ \a2' -> 
  setOrientation'_ a1' a2' >>= \res ->
  return ()
{-# LINE 170 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Gets the derived orientation of the camera, including any rotation inherited from a node attachment and reflection matrix. 
getDerivedOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Quaternion)
 -- ^ 
getDerivedOrientation a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getDerivedOrientation'_ a1' a2' >>= \res ->
  peekQuaternion  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 175 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Gets the derived position of the camera, including any translation inherited from a node attachment and reflection matrix. 
getDerivedPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getDerivedPosition a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getDerivedPosition'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 180 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Gets the derived direction vector of the camera, including any rotation inherited from a node attachment and reflection matrix. 
getDerivedDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getDerivedDirection a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getDerivedDirection'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 185 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Gets the derived up vector of the camera, including any rotation inherited from a node attachment and reflection matrix. 
getDerivedUp :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getDerivedUp a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getDerivedUp'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 190 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Gets the derived right vector of the camera, including any rotation inherited from a node attachment and reflection matrix. 
getDerivedRight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getDerivedRight a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getDerivedRight'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 195 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Gets the real world orientation of the camera, including any rotation inherited from a node attachment 
getRealOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Quaternion)
 -- ^ 
getRealOrientation a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getRealOrientation'_ a1' a2' >>= \res ->
  peekQuaternion  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 200 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Gets the real world position of the camera, including any translation inherited from a node attachment. 
getRealPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getRealPosition a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getRealPosition'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 205 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Gets the real world direction vector of the camera, including any rotation inherited from a node attachment. 
getRealDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getRealDirection a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getRealDirection'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 210 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Gets the real world up vector of the camera, including any rotation inherited from a node attachment. 
getRealUp :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getRealUp a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getRealUp'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 215 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Gets the real world right vector of the camera, including any rotation inherited from a node attachment. 
getRealRight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getRealRight a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getRealRight'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 220 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Overridden from MovableObject
getMovableType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (String)
 -- ^ 
getMovableType a1 =
  withHG3DClass a1 $ \a1' -> 
  alloc64k $ \a2' -> 
  getMovableType'_ a1' a2' >>= \res ->
  peekCString  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 225 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Enables / disables automatic tracking of a SceneNodeIf you enable auto-tracking, this CameraSceneNodeSceneNodeCameraCameraSceneNode
setAutoTracking :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ enabled - If true, the Camera will track the SceneNode supplied as the next parameter (cannot be null). If false the camera will cease tracking and will remain in it's current orientation. 
  ->  HG3DClass  -- ^ target - Pointer to the SceneNode which this Camera will track. Make sure you don't delete this SceneNode before turning off tracking (e.g. SceneManager::clearScene will delete it so be careful of this). Can be null if and only if the enabled param is false. 
  ->  Vec3  -- ^ offset - If supplied, the camera targets this point in local space of the target node instead of the origin of the target node. Good for fine tuning the look at point. 
  ->  IO ()
 -- ^ 
setAutoTracking a1 a2 a3 a4 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  withHG3DClass a3 $ \a3' -> 
  withVec3 a4 $ \a4' -> 
  setAutoTracking'_ a1' a2' a3' a4' >>= \res ->
  return ()
{-# LINE 232 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Sets the level-of-detail factor for this CameraThis method can be used to influence the overall level of detail of the scenes rendered using this camera. Various elements of the scene have level-of-detail reductions to improve rendering speed at distance; this method allows you to hint to those elements that you would like to adjust the level of detail that they would normally use (up or down). The most common use for this method is to reduce the overall level of detail used for a secondary camera used for sub viewports like rear-view mirrors etc. Note that scene elements are at liberty to ignore this setting if they choose, this is merely a hint. 
setLodBias :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ factor - The factor to apply to the usual level of detail calculation. Higher values increase the detail, so 2.0 doubles the normal detail and 0.5 halves it. 
  ->  IO ()
 -- ^ 
setLodBias a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  setLodBias'_ a1' a2' >>= \res ->
  return ()
{-# LINE 237 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Returns the level-of-detail bias factor currently applied to this camera. See Camera::setLodBias
getLodBias :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getLodBias a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getLodBias'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 242 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Get a pointer to the camera which should be used to determine LOD settings. Sometimes you don't want the LOD of a render to be based on the camera that's doing the rendering, you want it to be based on a different camera. A good example is when rendering shadow maps, since they will be viewed from the perspective of another camera. Therefore this method lets you associate a different camera instance to use to determine the LOD. To revert the camera to determining LOD based on itself, call this method with a pointer to itself. 
setLodCamera :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ lodCam
  ->  IO ()
 -- ^ 
setLodCamera a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  setLodCamera'_ a1' a2' >>= \res ->
  return ()
{-# LINE 247 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Get a pointer to the camera which should be used to determine LOD settings. If setLodCamera hasn't been called with a different camera, this method will return 'this'. 
getLodCamera :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ 
getLodCamera a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getLodCamera'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 252 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Sets the viewing window inside of viewport. This method can be used to set a subset of the viewport as the rendering target. 
setWindow :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ Left - Relative to Viewport - 0 corresponds to left edge, 1 - to right edge (default - 0). 
  ->  Float  -- ^ Top - Relative to Viewport - 0 corresponds to top edge, 1 - to bottom edge (default - 0). 
  ->  Float  -- ^ Right - Relative to Viewport - 0 corresponds to left edge, 1 - to right edge (default - 1). 
  ->  Float  -- ^ Bottom - Relative to Viewport - 0 corresponds to top edge, 1 - to bottom edge (default - 1). 
  ->  IO ()
 -- ^ 
setWindow a1 a2 a3 a4 a5 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  let {a3' = realToFrac a3} in 
  let {a4' = realToFrac a4} in 
  let {a5' = realToFrac a5} in 
  setWindow'_ a1' a2' a3' a4' a5' >>= \res ->
  return ()
{-# LINE 260 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Cancel view window. 
resetWindow :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
resetWindow a1 =
  withHG3DClass a1 $ \a1' -> 
  resetWindow'_ a1' >>= \res ->
  return ()
{-# LINE 264 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Returns if a viewport window is being used. 
isWindowSet :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isWindowSet a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isWindowSet'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 269 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Overridden from MovableObject
getBoundingRadius :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getBoundingRadius a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getBoundingRadius'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 274 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Get the auto tracking target for this camera, if any. 
getAutoTrackTarget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ 
getAutoTrackTarget a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getAutoTrackTarget'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 279 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Get the auto tracking offset for this camera, if it is auto tracking. 
getAutoTrackOffset :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getAutoTrackOffset a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getAutoTrackOffset'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 284 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Get the last viewport which was attached to this camera. This is not guaranteed to be the only viewport which is using this camera, just the last once which was created referring to it. 
getViewport :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ 
getViewport a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getViewport'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 289 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | If set to true a viewport that owns this frustum will be able to recalculate the aspect ratio whenever the frustum is resized. You should set this to true only if the frustum / camera is used by one viewport at the same time. Otherwise the aspect ratio for other viewports may be wrong. 
setAutoAspectRatio :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ autoratio
  ->  IO ()
 -- ^ 
setAutoAspectRatio a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setAutoAspectRatio'_ a1' a2' >>= \res ->
  return ()
{-# LINE 294 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Retrieves if AutoAspectRatio is currently set or not 
getAutoAspectRatio :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
getAutoAspectRatio a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getAutoAspectRatio'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 299 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Tells the camera to use a separate FrustumBy calling this method, you can tell the camera to perform culling against a different frustum to it's own. This is mostly useful for debug cameras that allow you to show the culling behaviour of another camera, or a manual frustum instance. 
setCullingFrustum :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ frustum - Pointer to a frustum to use; this can either be a manual Frustum instance (which you can attach to scene nodes like any other MovableObject), or another camera. If you pass 0 to this method it reverts the camera to normal behaviour. 
  ->  IO ()
 -- ^ 
setCullingFrustum a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  setCullingFrustum'_ a1' a2' >>= \res ->
  return ()
{-# LINE 304 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Returns the custom culling frustum in use. 
getCullingFrustum :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ 
getCullingFrustum a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getCullingFrustum'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 309 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Tests whether the given container is visible in the FrustumOtherwise, false is returned. 
isVisible3 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec3  -- ^ vert
  ->  IO (EnumFrustumPlane, Bool)
 -- ^ culledBy
isVisible3 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withVec3 a2 $ \a2' -> 
  alloca $ \a3' -> 
  alloca $ \a4' -> 
  isVisible3'_ a1' a2' a3' a4' >>= \res ->
  peekEnumUtil  a3'>>= \a3'' -> 
  peekBoolUtil  a4'>>= \a4'' -> 
  return (a3'', a4'')
{-# LINE 316 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Gets the world space corners of the frustum. The corners are ordered as follows: top-right near, top-left near, bottom-left near, bottom-right near, top-right far, top-left far, bottom-left far, bottom-right far. 
getWorldSpaceCorners :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getWorldSpaceCorners a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getWorldSpaceCorners'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 321 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Sets the position of the near clipping plane. 
getNearClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getNearClipDistance a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getNearClipDistance'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 326 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Retrieves the distance from the frustum to the far clipping plane. 
getFarClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getFarClipDistance a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getFarClipDistance'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 331 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Set whether this camera should use the 'rendering distance' on objects to exclude distant objects from the final image. The default behaviour is to use it. 
setUseRenderingDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ use - True to use the rendering distance, false not to. 
  ->  IO ()
 -- ^ 
setUseRenderingDistance a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setUseRenderingDistance'_ a1' a2' >>= \res ->
  return ()
{-# LINE 336 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Get whether this camera should use the 'rendering distance' on objects to exclude distant objects from the final image. 
getUseRenderingDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
getUseRenderingDistance a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getUseRenderingDistance'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 341 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Synchronise core camera settings with another. Copies the position, orientation, clip distances, projection type, FOV, focal length and aspect ratio from another camera. Other settings like query flags, reflection etc are preserved. 
synchroniseBaseSettingsWith :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ cam
  ->  IO ()
 -- ^ 
synchroniseBaseSettingsWith a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  synchroniseBaseSettingsWith'_ a1' a2' >>= \res ->
  return ()
{-# LINE 346 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Get the derived position of this frustum. 
getPositionForViewUpdate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getPositionForViewUpdate a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getPositionForViewUpdate'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 351 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}

-- | Get the derived orientation of this frustum. 
getOrientationForViewUpdate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Quaternion)
 -- ^ 
getOrientationForViewUpdate a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getOrientationForViewUpdate'_ a1' a2' >>= \res ->
  peekQuaternion  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 356 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}


foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_construct"
  new'_ :: ((Ptr CChar) -> ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ()))))

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getSceneManager"
  getSceneManager'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_setPosition"
  setPosition'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> (CFloat -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_setPosition2"
  setPosition2'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getPosition"
  getPosition'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_move"
  move'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_moveRelative"
  moveRelative'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_setDirection"
  setDirection'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> (CFloat -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_setDirection2"
  setDirection2'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getDirection"
  getDirection'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getUp"
  getUp'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getRight"
  getRight'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_lookAt"
  lookAt'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_lookAt2"
  lookAt2'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> (CFloat -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_roll"
  roll'_ :: ((HG3DClassPtr) -> ((RadiansPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_yaw"
  yaw'_ :: ((HG3DClassPtr) -> ((RadiansPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_pitch"
  pitch'_ :: ((HG3DClassPtr) -> ((RadiansPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_rotate"
  rotate'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> ((RadiansPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_rotate2"
  rotate2'_ :: ((HG3DClassPtr) -> ((QuaternionPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_setFixedYawAxis"
  setFixedYawAxis'_ :: ((HG3DClassPtr) -> (CInt -> ((Vec3Ptr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getOrientation"
  getOrientation'_ :: ((HG3DClassPtr) -> ((QuaternionPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_setOrientation"
  setOrientation'_ :: ((HG3DClassPtr) -> ((QuaternionPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getDerivedOrientation"
  getDerivedOrientation'_ :: ((HG3DClassPtr) -> ((QuaternionPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getDerivedPosition"
  getDerivedPosition'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getDerivedDirection"
  getDerivedDirection'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getDerivedUp"
  getDerivedUp'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getDerivedRight"
  getDerivedRight'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getRealOrientation"
  getRealOrientation'_ :: ((HG3DClassPtr) -> ((QuaternionPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getRealPosition"
  getRealPosition'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getRealDirection"
  getRealDirection'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getRealUp"
  getRealUp'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getRealRight"
  getRealRight'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getMovableType"
  getMovableType'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_setAutoTracking"
  setAutoTracking'_ :: ((HG3DClassPtr) -> (CInt -> ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_setLodBias"
  setLodBias'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getLodBias"
  getLodBias'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_setLodCamera"
  setLodCamera'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getLodCamera"
  getLodCamera'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_setWindow"
  setWindow'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> (CFloat -> (CFloat -> (IO ()))))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_resetWindow"
  resetWindow'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_isWindowSet"
  isWindowSet'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getBoundingRadius"
  getBoundingRadius'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getAutoTrackTarget"
  getAutoTrackTarget'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getAutoTrackOffset"
  getAutoTrackOffset'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getViewport"
  getViewport'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_setAutoAspectRatio"
  setAutoAspectRatio'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getAutoAspectRatio"
  getAutoAspectRatio'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_setCullingFrustum"
  setCullingFrustum'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getCullingFrustum"
  getCullingFrustum'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_isVisible3"
  isVisible3'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> ((Ptr CInt) -> ((Ptr CInt) -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getWorldSpaceCorners"
  getWorldSpaceCorners'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getNearClipDistance"
  getNearClipDistance'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getFarClipDistance"
  getFarClipDistance'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_setUseRenderingDistance"
  setUseRenderingDistance'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getUseRenderingDistance"
  getUseRenderingDistance'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_synchroniseBaseSettingsWith"
  synchroniseBaseSettingsWith'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getPositionForViewUpdate"
  getPositionForViewUpdate'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassCamera.chs.h ogre_cam_getOrientationForViewUpdate"
  getOrientationForViewUpdate'_ :: ((HG3DClassPtr) -> ((QuaternionPtr) -> (IO ())))