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


-- ClassFrustum.chs

-- 

module HGamer3D.Bindings.Ogre.ClassFrustum 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\\ClassFrustum.chs" #-}
import HGamer3D.Bindings.Ogre.ClassPtr
{-# LINE 43 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
import HGamer3D.Bindings.Ogre.StructHG3DClass
{-# LINE 44 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
import HGamer3D.Bindings.Ogre.StructRadians
{-# LINE 45 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
import HGamer3D.Bindings.Ogre.StructVec2
{-# LINE 46 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
import HGamer3D.Bindings.Ogre.StructVec3
{-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
import HGamer3D.Bindings.Ogre.EnumFrustumPlane
{-# LINE 48 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
import HGamer3D.Bindings.Ogre.StructSharedPtr
{-# LINE 49 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
import HGamer3D.Bindings.Ogre.EnumProjectionType
{-# LINE 50 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
import HGamer3D.Bindings.Ogre.StructQuaternion
{-# LINE 51 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
import HGamer3D.Bindings.Ogre.EnumOrientationMode
{-# LINE 52 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Named constructor. 
new :: String  -- ^ name
  ->  IO (HG3DClass)
 -- ^ 
new a1 =
  withCString a1 $ \a1' -> 
  alloca $ \a2' -> 
  new'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 58 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

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

-- | Sets the Y-dimension Field Of View (FOV) of the frustum. Field Of View (FOV) is the angle made between the frustum's position, and the edges of the 'screen' onto which the scene is projected. High values (90+ degrees) result in a wide-angle, fish-eye kind of view, low values (30- degrees) in a stretched, telescopic kind of view. Typical values are between 45 and 60 degrees. This value represents the VERTICAL field-of-view. The horizontal field of view is calculated from this depending on the dimensions of the viewport (they will only be the same if the viewport is square). Setting the FOV overrides the value supplied for frustum::setNearClipPlane. 
setFOVy :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Radians  -- ^ fovy
  ->  IO ()
 -- ^ 
setFOVy a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withRadians a2 $ \a2' -> 
  setFOVy'_ a1' a2' >>= \res ->
  return ()
{-# LINE 67 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Retrieves the frustums Y-dimension Field Of View (FOV). 
getFOVy :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Radians)
 -- ^ 
getFOVy a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getFOVy'_ a1' a2' >>= \res ->
  peekRadians  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 72 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Sets the position of the near clipping plane. The position of the near clipping plane is the distance from the frustums position to the screen on which the world is projected. The near plane distance, combined with the field-of-view and the aspect ratio, determines the size of the viewport through which the world is viewed (in world co-ordinates). Note that this world viewport is different to a screen viewport, which has it's dimensions expressed in pixels. The frustums viewport should have the same aspect ratio as the screen viewport it renders into to avoid distortion. 
setNearClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ nearDist
  ->  IO ()
 -- ^ 
setNearClipDistance a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  setNearClipDistance'_ a1' a2' >>= \res ->
  return ()
{-# LINE 77 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

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

-- | Sets the distance to the far clipping plane. The view frustum is a pyramid created from the frustum position and the edges of the viewport. This method sets the distance for the far end of that pyramid. Different applications need different values: e.g. a flight sim needs a much further far clipping plane than a first-person shooter. An important point here is that the larger the ratio between near and far clipping planes, the lower the accuracy of the Z-buffer used to depth-cue pixels. This is because the Z-range is limited to the size of the Z buffer (16 or 32-bit) and the max values must be spread over the gap between near and far clip planes. As it happens, you can affect the accuracy far more by altering the near distance rather than the far distance, but keep this in mind. 
setFarClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ farDist
  ->  IO ()
 -- ^ 
setFarClipDistance a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  setFarClipDistance'_ a1' a2' >>= \res ->
  return ()
{-# LINE 87 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

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

-- | Sets the aspect ratio for the frustum viewport. The ratio between the x and y dimensions of the rectangular area visible through the frustum is known as aspect ratio: aspect = width / height . The default for most fullscreen windows is 1.3333 - this is also assumed by Ogre
setAspectRatio :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ ratio
  ->  IO ()
 -- ^ 
setAspectRatio a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  setAspectRatio'_ a1' a2' >>= \res ->
  return ()
{-# LINE 97 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Retreives the current aspect ratio. 
getAspectRatio :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getAspectRatio a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getAspectRatio'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 102 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Sets frustum offsets, used in stereo rendering. You can set both horizontal and vertical plane offsets of "eye"; in stereo rendering frustum is moved in horizontal plane. To be able to render from two "eyes" you'll need two cameras rendering on two RenderTargets. The frustum offsets is in world coordinates, and default to (0, 0) - no offsets. 
setFrustumOffset :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec2  -- ^ offset - The horizontal and vertical plane offsets. 
  ->  IO ()
 -- ^ 
setFrustumOffset a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withVec2 a2 $ \a2' -> 
  setFrustumOffset'_ a1' a2' >>= \res ->
  return ()
{-# LINE 107 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Sets frustum offsets, used in stereo rendering. You can set both horizontal and vertical plane offsets of "eye"; in stereo rendering frustum is moved in horizontal plane. To be able to render from two "eyes" you'll need two cameras rendering on two RenderTargets. The frustum offsets is in world coordinates, and default to (0, 0) - no offsets. 
setFrustumOffset2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ horizontal - The horizontal plane offset. 
  ->  Float  -- ^ vertical - The vertical plane offset. 
  ->  IO ()
 -- ^ 
setFrustumOffset2 a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  let {a3' = realToFrac a3} in 
  setFrustumOffset2'_ a1' a2' a3' >>= \res ->
  return ()
{-# LINE 113 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Retrieves the frustum offsets. 
getFrustumOffset :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec2)
 -- ^ 
getFrustumOffset a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getFrustumOffset'_ a1' a2' >>= \res ->
  peekVec2  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 118 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Sets frustum focal length (used in stereo rendering). 
setFocalLength :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ focalLength - The distance to the focal plane from the frustum in world coordinates. 
  ->  IO ()
 -- ^ 
setFocalLength a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  setFocalLength'_ a1' a2' >>= \res ->
  return ()
{-# LINE 123 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Returns focal length of frustum. 
getFocalLength :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getFocalLength a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getFocalLength'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 128 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Manually set the extents of the frustum. 
setFrustumExtents :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ left - The position where the side clip planes intersect the near clip plane, in eye space 
  ->  Float  -- ^ right
  ->  Float  -- ^ top
  ->  Float  -- ^ bottom
  ->  IO ()
 -- ^ 
setFrustumExtents 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 
  setFrustumExtents'_ a1' a2' a3' a4' a5' >>= \res ->
  return ()
{-# LINE 136 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Reset the frustum extents to be automatically derived from other params. 
resetFrustumExtents :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
resetFrustumExtents a1 =
  withHG3DClass a1 $ \a1' -> 
  resetFrustumExtents'_ a1' >>= \res ->
  return ()
{-# LINE 140 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Get the extents of the frustum in view space. 
getFrustumExtents :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float, Float, Float, Float)
 -- ^ outleft
getFrustumExtents a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  alloca $ \a3' -> 
  alloca $ \a4' -> 
  alloca $ \a5' -> 
  getFrustumExtents'_ a1' a2' a3' a4' a5' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  peekFloatConv  a3'>>= \a3'' -> 
  peekFloatConv  a4'>>= \a4'' -> 
  peekFloatConv  a5'>>= \a5'' -> 
  return (a2'', a3'', a4'', a5'')
{-# LINE 148 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Returns whether a custom view matrix is in use. 
isCustomViewMatrixEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isCustomViewMatrixEnabled a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isCustomViewMatrixEnabled'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 153 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Returns whether a custom projection matrix is in use. 
isCustomProjectionMatrixEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isCustomProjectionMatrixEnabled a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isCustomProjectionMatrixEnabled'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 158 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Tests whether the given vertex is visible in the FrustumOtherwise, false is returned. 
isVisible3 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec3  -- ^ vert - Vertex to be checked (world space) 
  ->  IO (EnumFrustumPlane, Bool)
 -- ^ culledBy - Optional pointer to an int which will be filled by the plane number which culled the box if the result was false; 
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 165 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Overridden from MovableObject::getTypeFlags
getTypeFlags :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Int)
 -- ^ 
getTypeFlags a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getTypeFlags'_ a1' a2' >>= \res ->
  peekIntConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 170 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.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 175 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.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 180 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Overridden from Renderable
getMaterial :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (SharedPtr)
 -- ^ 
getMaterial a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getMaterial'_ a1' a2' >>= \res ->
  peekSharedPtr  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 185 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

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

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

-- | Sets the type of projection to use (orthographic or perspective). Default is perspective. 
setProjectionType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  EnumProjectionType  -- ^ pt
  ->  IO ()
 -- ^ 
setProjectionType a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = cIntFromEnum a2} in 
  setProjectionType'_ a1' a2' >>= \res ->
  return ()
{-# LINE 201 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Retrieves info on the type of projection used (orthographic or perspective). 
getProjectionType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (EnumProjectionType)
 -- ^ 
getProjectionType a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getProjectionType'_ a1' a2' >>= \res ->
  peekEnumUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 206 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Sets the orthographic window settings, for use with orthographic rendering only. Calling this method will recalculate the aspect ratio, use setOrthoWindowHeight or setOrthoWindowWidth alone if you wish to preserve the aspect ratio but just fit one or other dimension to a particular size. 
setOrthoWindow :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ w - The dimensions of the view window in world units 
  ->  Float  -- ^ h
  ->  IO ()
 -- ^ 
setOrthoWindow a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  let {a3' = realToFrac a3} in 
  setOrthoWindow'_ a1' a2' a3' >>= \res ->
  return ()
{-# LINE 212 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Sets the orthographic window height, for use with orthographic rendering only. The width of the window will be calculated from the aspect ratio. 
setOrthoWindowHeight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ h - The height of the view window in world units 
  ->  IO ()
 -- ^ 
setOrthoWindowHeight a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  setOrthoWindowHeight'_ a1' a2' >>= \res ->
  return ()
{-# LINE 217 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Sets the orthographic window width, for use with orthographic rendering only. The height of the window will be calculated from the aspect ratio. 
setOrthoWindowWidth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ w - The width of the view window in world units 
  ->  IO ()
 -- ^ 
setOrthoWindowWidth a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  setOrthoWindowWidth'_ a1' a2' >>= \res ->
  return ()
{-# LINE 222 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Gets the orthographic window height, for use with orthographic rendering only. 
getOrthoWindowHeight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getOrthoWindowHeight a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getOrthoWindowHeight'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 227 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Gets the orthographic window width, for use with orthographic rendering only. This is calculated from the orthographic height and the aspect ratio 
getOrthoWindowWidth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getOrthoWindowWidth a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getOrthoWindowWidth'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 232 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Disables reflection modification previously turned on with enableReflection 
disableReflection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
disableReflection a1 =
  withHG3DClass a1 $ \a1' -> 
  disableReflection'_ a1' >>= \res ->
  return ()
{-# LINE 236 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Returns whether this frustum is being reflected. 
isReflected :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isReflected a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isReflected'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 241 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Disables any custom near clip plane. 
disableCustomNearClipPlane :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
disableCustomNearClipPlane a1 =
  withHG3DClass a1 $ \a1' -> 
  disableCustomNearClipPlane'_ a1' >>= \res ->
  return ()
{-# LINE 245 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Is a custom near clip plane in use? 
isCustomNearClipPlaneEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isCustomNearClipPlaneEnabled a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isCustomNearClipPlaneEnabled'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 250 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

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

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

-- | Set the orientation mode of the frustum. Default is OR_DEGREE_0 Setting the orientation of a frustum is only supported on iPhone at this time. An exception is thrown on other platforms. 
setOrientationMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  EnumOrientationMode  -- ^ orientationMode
  ->  IO ()
 -- ^ 
setOrientationMode a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = cIntFromEnum a2} in 
  setOrientationMode'_ a1' a2' >>= \res ->
  return ()
{-# LINE 265 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}

-- | Get the orientation mode of the frustum. Getting the orientation of a frustum is only supported on iPhone at this time. An exception is thrown on other platforms. 
getOrientationMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (EnumOrientationMode)
 -- ^ 
getOrientationMode a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getOrientationMode'_ a1' a2' >>= \res ->
  peekEnumUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 270 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}


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

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_setFOVy"
  setFOVy'_ :: ((HG3DClassPtr) -> ((RadiansPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_getFOVy"
  getFOVy'_ :: ((HG3DClassPtr) -> ((RadiansPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_setNearClipDistance"
  setNearClipDistance'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_setFarClipDistance"
  setFarClipDistance'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_setAspectRatio"
  setAspectRatio'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_getAspectRatio"
  getAspectRatio'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_setFrustumOffset"
  setFrustumOffset'_ :: ((HG3DClassPtr) -> ((Vec2Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_setFrustumOffset2"
  setFrustumOffset2'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_getFrustumOffset"
  getFrustumOffset'_ :: ((HG3DClassPtr) -> ((Vec2Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_setFocalLength"
  setFocalLength'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_getFocalLength"
  getFocalLength'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_setFrustumExtents"
  setFrustumExtents'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> (CFloat -> (CFloat -> (IO ()))))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_resetFrustumExtents"
  resetFrustumExtents'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_getFrustumExtents"
  getFrustumExtents'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> ((Ptr CFloat) -> ((Ptr CFloat) -> ((Ptr CFloat) -> (IO ()))))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_isCustomViewMatrixEnabled"
  isCustomViewMatrixEnabled'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_isCustomProjectionMatrixEnabled"
  isCustomProjectionMatrixEnabled'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_getTypeFlags"
  getTypeFlags'_ :: ((HG3DClassPtr) -> ((Ptr CUInt) -> (IO ())))

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

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_getMaterial"
  getMaterial'_ :: ((HG3DClassPtr) -> ((SharedPtrPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_getSquaredViewDepth"
  getSquaredViewDepth'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ()))))

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_setProjectionType"
  setProjectionType'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_getProjectionType"
  getProjectionType'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_setOrthoWindow"
  setOrthoWindow'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_setOrthoWindowHeight"
  setOrthoWindowHeight'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_setOrthoWindowWidth"
  setOrthoWindowWidth'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_getOrthoWindowHeight"
  getOrthoWindowHeight'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_getOrthoWindowWidth"
  getOrthoWindowWidth'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_disableReflection"
  disableReflection'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_isReflected"
  isReflected'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_disableCustomNearClipPlane"
  disableCustomNearClipPlane'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_isCustomNearClipPlaneEnabled"
  isCustomNearClipPlaneEnabled'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

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

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_setOrientationMode"
  setOrientationMode'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs.h ogre_frst_getOrientationMode"
  getOrientationMode'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))