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


-- ClassViewport.chs

-- 

module HGamer3D.Bindings.Ogre.ClassViewport 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\\ClassViewport.chs" #-}
import HGamer3D.Bindings.Ogre.ClassPtr
{-# LINE 41 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
import HGamer3D.Bindings.Ogre.StructHG3DClass
{-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
import HGamer3D.Bindings.Ogre.StructColour
{-# LINE 43 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
import HGamer3D.Bindings.Ogre.EnumOrientationMode
{-# LINE 44 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
import HGamer3D.Bindings.Ogre.StructVec2
{-# LINE 45 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | The usual constructor. 
new :: HG3DClass  -- ^ camera
  ->  HG3DClass  -- ^ target - Pointer to the render target to be the destination for the rendering. 
  ->  Float  -- ^ left
  ->  Float  -- ^ top
  ->  Float  -- ^ width
  ->  Float  -- ^ height - Dimensions of the viewport, expressed as a value between 0 and 1. This allows the dimensions to apply irrespective of changes in the target's size: e.g. to fill the whole area, values of 0,0,1,1 are appropriate. 
  ->  Int  -- ^ ZOrder - Relative Z-order on the target. Lower = further to the front. 
  ->  IO (HG3DClass)
 -- ^ 
new a1 a2 a3 a4 a5 a6 a7 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  let {a3' = realToFrac a3} in 
  let {a4' = realToFrac a4} in 
  let {a5' = realToFrac a5} in 
  let {a6' = realToFrac a6} in 
  let {a7' = fromIntegral a7} in 
  alloca $ \a8' -> 
  new'_ a1' a2' a3' a4' a5' a6' a7' a8' >>= \res ->
  peek  a8'>>= \a8'' -> 
  return (a8'')
{-# LINE 57 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

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

-- | Instructs the viewport to updates its contents. 
update :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
update a1 =
  withHG3DClass a1 $ \a1' -> 
  update'_ a1' >>= \res ->
  return ()
{-# LINE 65 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Instructs the viewport to clear itself, without performing an update. You would not normally call this method when updating the viewport, since the viewport usually clears itself when updating anyway (Viewport::setClearEveryFrame
clear :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Int  -- ^ buffers - Bitmask identifying which buffer elements to clear 
  ->  Colour  -- ^ colour - The colour value to clear to, if FBT_COLOUR is included 
  ->  Float  -- ^ depth - The depth value to clear to, if FBT_DEPTH is included 
  ->  Int  -- ^ stencil - The stencil value to clear to, if FBT_STENCIL is included 
  ->  IO ()
 -- ^ 
clear a1 a2 a3 a4 a5 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromIntegral a2} in 
  withColour a3 $ \a3' -> 
  let {a4' = realToFrac a4} in 
  let {a5' = fromIntegral a5} in 
  clear'_ a1' a2' a3' a4' a5' >>= \res ->
  return ()
{-# LINE 73 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Retrieves a pointer to the render target for this viewport. 
getTarget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ 
getTarget a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getTarget'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 78 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Retrieves a pointer to the camera for this viewport. 
getCamera :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ 
getCamera a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getCamera'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 83 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Sets the camera to use for rendering to this viewport. 
setCamera :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ cam
  ->  IO ()
 -- ^ 
setCamera a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  setCamera'_ a1' a2' >>= \res ->
  return ()
{-# LINE 88 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Gets the Z-Order of this viewport. 
getZOrder :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Int)
 -- ^ 
getZOrder a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getZOrder'_ a1' a2' >>= \res ->
  peekIntConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 93 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Gets one of the relative dimensions of the viewport, a value between 0.0 and 1.0. 
getLeft :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getLeft a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getLeft'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 98 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Gets one of the relative dimensions of the viewport, a value between 0.0 and 1.0. 
getTop :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getTop a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getTop'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 103 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Gets one of the relative dimensions of the viewport, a value between 0.0 and 1.0. 
getWidth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getWidth a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getWidth'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 108 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Gets one of the relative dimensions of the viewport, a value between 0.0 and 1.0. 
getHeight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getHeight a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getHeight'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 113 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Gets one of the actual dimensions of the viewport, a value in pixels. 
getActualLeft :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Int)
 -- ^ 
getActualLeft a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getActualLeft'_ a1' a2' >>= \res ->
  peekIntConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 118 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Gets one of the actual dimensions of the viewport, a value in pixels. 
getActualTop :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Int)
 -- ^ 
getActualTop a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getActualTop'_ a1' a2' >>= \res ->
  peekIntConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 123 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Gets one of the actual dimensions of the viewport, a value in pixels. 
getActualWidth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Int)
 -- ^ 
getActualWidth a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getActualWidth'_ a1' a2' >>= \res ->
  peekIntConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 128 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Gets one of the actual dimensions of the viewport, a value in pixels. 
getActualHeight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Int)
 -- ^ 
getActualHeight a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getActualHeight'_ a1' a2' >>= \res ->
  peekIntConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 133 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Sets the dimensions (after creation). 
setDimensions :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ left
  ->  Float  -- ^ top
  ->  Float  -- ^ width
  ->  Float  -- ^ height - Dimensions relative to the size of the target, represented as real values between 0 and 1. i.e. the full target area is 0, 0, 1, 1. 
  ->  IO ()
 -- ^ 
setDimensions 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 
  setDimensions'_ a1' a2' a3' a4' a5' >>= \res ->
  return ()
{-# LINE 141 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Set the orientation mode of the viewport. 
setOrientationMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  EnumOrientationMode  -- ^ orientationMode
  ->  Bool  -- ^ setDefault
  ->  IO ()
 -- ^ 
setOrientationMode a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = cIntFromEnum a2} in 
  let {a3' = fromBool a3} in 
  setOrientationMode'_ a1' a2' a3' >>= \res ->
  return ()
{-# LINE 147 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Get the orientation mode of the viewport. 
getOrientationMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (EnumOrientationMode)
 -- ^ 
getOrientationMode a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getOrientationMode'_ a1' a2' >>= \res ->
  peekEnumUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 152 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Sets the initial background colour of the viewport (before rendering). 
setBackgroundColour :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Colour  -- ^ colour
  ->  IO ()
 -- ^ 
setBackgroundColour a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withColour a2 $ \a2' -> 
  setBackgroundColour'_ a1' a2' >>= \res ->
  return ()
{-# LINE 157 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Gets the background colour. 
getBackgroundColour :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Colour)
 -- ^ 
getBackgroundColour a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getBackgroundColour'_ a1' a2' >>= \res ->
  peekColour  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 162 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Determines whether to clear the viewport before rendering. You can use this method to set which buffers are cleared (if any) before rendering every frame. 
setClearEveryFrame :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ clear - Whether or not to clear any buffers 
  ->  Int  -- ^ buffers - One or more values from FrameBufferType denoting which buffers to clear, if clear is set to true. Note you should not clear the stencil buffer here unless you know what you're doing. 
  ->  IO ()
 -- ^ 
setClearEveryFrame a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  let {a3' = fromIntegral a3} in 
  setClearEveryFrame'_ a1' a2' a3' >>= \res ->
  return ()
{-# LINE 168 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Determines if the viewport is cleared before every frame. 
getClearEveryFrame :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
getClearEveryFrame a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getClearEveryFrame'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 173 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Gets which buffers are to be cleared each frame. 
getClearBuffers :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Int)
 -- ^ 
getClearBuffers a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getClearBuffers'_ a1' a2' >>= \res ->
  peekIntConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 178 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Sets whether this viewport should be automatically updated if OgreRenderTarget::updateBy default, if you use OgreRoot::startRenderingRenderTarget::update
setAutoUpdated :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ autoupdate - If true, the viewport is updated during the automatic render loop or when RenderTarget::update() is called. If false, the viewport is only updated when its update() method is called explicitly. 
  ->  IO ()
 -- ^ 
setAutoUpdated a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setAutoUpdated'_ a1' a2' >>= \res ->
  return ()
{-# LINE 183 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Gets whether this viewport is automatically updated if OgreRenderTarget::update
isAutoUpdated :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isAutoUpdated a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isAutoUpdated'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 188 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Set the material scheme which the viewport should use. This allows you to tell the system to use a particular material scheme when rendering this viewport, which can involve using different techniques to render your materials. Technique::setSchemeName 
setMaterialScheme :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ schemeName
  ->  IO ()
 -- ^ 
setMaterialScheme a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  setMaterialScheme'_ a1' a2' >>= \res ->
  return ()
{-# LINE 193 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Get the material scheme which the viewport should use. 
getMaterialScheme :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (String)
 -- ^ 
getMaterialScheme a1 =
  withHG3DClass a1 $ \a1' -> 
  alloc64k $ \a2' -> 
  getMaterialScheme'_ a1' a2' >>= \res ->
  peekCString  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 198 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Access to actual dimensions (based on target size). 
getActualDimensions :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Int, Int, Int, Int)
 -- ^ left
getActualDimensions a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  alloca $ \a3' -> 
  alloca $ \a4' -> 
  alloca $ \a5' -> 
  getActualDimensions'_ a1' a2' a3' a4' a5' >>= \res ->
  peekIntConv  a2'>>= \a2'' -> 
  peekIntConv  a3'>>= \a3'' -> 
  peekIntConv  a4'>>= \a4'' -> 
  peekIntConv  a5'>>= \a5'' -> 
  return (a2'', a3'', a4'', a5'')
{-# LINE 206 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Tells this viewport whether it should display Overlay objects. Overlay objects are layers which appear on top of the scene. They are created via SceneManager::createOverlay and every viewport displays these by default. However, you probably don't want this if you're using multiple viewports, because one of them is probably a picture-in-picture which is not supposed to have overlays of it's own. In this case you can turn off overlays on this viewport by calling this method. 
setOverlaysEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ enabled - If true, any overlays are displayed, if false they are not. 
  ->  IO ()
 -- ^ 
setOverlaysEnabled a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setOverlaysEnabled'_ a1' a2' >>= \res ->
  return ()
{-# LINE 211 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Returns whether or not Overlay objects (created in the SceneManager
getOverlaysEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
getOverlaysEnabled a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getOverlaysEnabled'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 216 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Tells this viewport whether it should display skies. Skies are layers which appear on background of the scene. They are created via SceneManager::setSkyBoxSceneManager::setSkyPlaneSceneManager::setSkyDome
setSkiesEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ enabled - If true, any skies are displayed, if false they are not. 
  ->  IO ()
 -- ^ 
setSkiesEnabled a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setSkiesEnabled'_ a1' a2' >>= \res ->
  return ()
{-# LINE 221 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Returns whether or not skies (created in the SceneManager
getSkiesEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
getSkiesEnabled a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getSkiesEnabled'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 226 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Tells this viewport whether it should display shadows. This setting enables you to disable shadow rendering for a given viewport. The global shadow technique set on SceneManager
setShadowsEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ enabled - If true, any shadows are displayed, if false they are not. 
  ->  IO ()
 -- ^ 
setShadowsEnabled a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setShadowsEnabled'_ a1' a2' >>= \res ->
  return ()
{-# LINE 231 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Returns whether or not shadows (defined in the SceneManager
getShadowsEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
getShadowsEnabled a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getShadowsEnabled'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 236 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Sets a per-viewport visibility mask. The visibility mask is a way to exclude objects from rendering for a given viewport. For each object in the frustum, a check is made between this mask and the objects visibility flags (MovableObject::setVisibilityFlags
setVisibilityMask :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Int  -- ^ mask
  ->  IO ()
 -- ^ 
setVisibilityMask a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromIntegral a2} in 
  setVisibilityMask'_ a1' a2' >>= \res ->
  return ()
{-# LINE 241 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Gets a per-viewport visibility mask. Viewport::setVisibilityMask
getVisibilityMask :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Int)
 -- ^ 
getVisibilityMask a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getVisibilityMask'_ a1' a2' >>= \res ->
  peekIntConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 246 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Sets the use of a custom RenderQueueInvocationSequence for rendering this target. RenderQueueInvocationSequence instances are managed through RootRenderTargetRoot
setRenderQueueInvocationSequenceName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ sequenceName
  ->  IO ()
 -- ^ 
setRenderQueueInvocationSequenceName a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  setRenderQueueInvocationSequenceName'_ a1' a2' >>= \res ->
  return ()
{-# LINE 251 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Gets the name of the render queue invocation sequence for this target. 
getRenderQueueInvocationSequenceName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (String)
 -- ^ 
getRenderQueueInvocationSequenceName a1 =
  withHG3DClass a1 $ \a1' -> 
  alloc64k $ \a2' -> 
  getRenderQueueInvocationSequenceName'_ a1' a2' >>= \res ->
  peekCString  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 256 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Convert oriented input point coordinates to screen coordinates. 
pointOrientedToScreen :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec2  -- ^ v
  ->  Int  -- ^ orientationMode
  ->  IO (Vec2)
 -- ^ outv
pointOrientedToScreen a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  withVec2 a2 $ \a2' -> 
  let {a3' = fromIntegral a3} in 
  alloca $ \a4' -> 
  pointOrientedToScreen'_ a1' a2' a3' a4' >>= \res ->
  peekVec2  a4'>>= \a4'' -> 
  return (a4'')
{-# LINE 263 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | 
pointOrientedToScreen2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ orientedX
  ->  Float  -- ^ orientedY
  ->  Int  -- ^ orientationMode
  ->  IO (Float, Float)
 -- ^ screenX
pointOrientedToScreen2 a1 a2 a3 a4 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  let {a3' = realToFrac a3} in 
  let {a4' = fromIntegral a4} in 
  alloca $ \a5' -> 
  alloca $ \a6' -> 
  pointOrientedToScreen2'_ a1' a2' a3' a4' a5' a6' >>= \res ->
  peekFloatConv  a5'>>= \a5'' -> 
  peekFloatConv  a6'>>= \a6'' -> 
  return (a5'', a6'')
{-# LINE 272 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Set the initial orientation mode of viewports. 
setDefaultOrientationMode :: EnumOrientationMode  -- ^ orientationMode
  ->  IO ()
 -- ^ 
setDefaultOrientationMode a1 =
  let {a1' = cIntFromEnum a1} in 
  setDefaultOrientationMode'_ a1' >>= \res ->
  return ()
{-# LINE 276 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}

-- | Get the initial orientation mode of viewports. 
getDefaultOrientationMode :: IO (EnumOrientationMode)
 -- ^ 
getDefaultOrientationMode =
  alloca $ \a1' -> 
  getDefaultOrientationMode'_ a1' >>= \res ->
  peekEnumUtil  a1'>>= \a1'' -> 
  return (a1'')
{-# LINE 280 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}


foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_construct"
  new'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (CFloat -> (CFloat -> (CFloat -> (CFloat -> (CInt -> ((HG3DClassPtr) -> (IO ())))))))))

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_update"
  update'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_clear"
  clear'_ :: ((HG3DClassPtr) -> (CUInt -> ((ColourPtr) -> (CFloat -> (CUShort -> (IO ()))))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getTarget"
  getTarget'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getCamera"
  getCamera'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_setCamera"
  setCamera'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getZOrder"
  getZOrder'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getLeft"
  getLeft'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getTop"
  getTop'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getWidth"
  getWidth'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getHeight"
  getHeight'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getActualLeft"
  getActualLeft'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getActualTop"
  getActualTop'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getActualWidth"
  getActualWidth'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getActualHeight"
  getActualHeight'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_setDimensions"
  setDimensions'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> (CFloat -> (CFloat -> (IO ()))))))

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

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_setBackgroundColour"
  setBackgroundColour'_ :: ((HG3DClassPtr) -> ((ColourPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getBackgroundColour"
  getBackgroundColour'_ :: ((HG3DClassPtr) -> ((ColourPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_setClearEveryFrame"
  setClearEveryFrame'_ :: ((HG3DClassPtr) -> (CInt -> (CUInt -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getClearEveryFrame"
  getClearEveryFrame'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getClearBuffers"
  getClearBuffers'_ :: ((HG3DClassPtr) -> ((Ptr CUInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_setAutoUpdated"
  setAutoUpdated'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_isAutoUpdated"
  isAutoUpdated'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_setMaterialScheme"
  setMaterialScheme'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getMaterialScheme"
  getMaterialScheme'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getActualDimensions"
  getActualDimensions'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> ((Ptr CInt) -> ((Ptr CInt) -> ((Ptr CInt) -> (IO ()))))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_setOverlaysEnabled"
  setOverlaysEnabled'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getOverlaysEnabled"
  getOverlaysEnabled'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_setSkiesEnabled"
  setSkiesEnabled'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getSkiesEnabled"
  getSkiesEnabled'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_setShadowsEnabled"
  setShadowsEnabled'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getShadowsEnabled"
  getShadowsEnabled'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

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

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_setRenderQueueInvocationSequenceName"
  setRenderQueueInvocationSequenceName'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getRenderQueueInvocationSequenceName"
  getRenderQueueInvocationSequenceName'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_pointOrientedToScreen"
  pointOrientedToScreen'_ :: ((HG3DClassPtr) -> ((Vec2Ptr) -> (CInt -> ((Vec2Ptr) -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_pointOrientedToScreen2"
  pointOrientedToScreen2'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> (CInt -> ((Ptr CFloat) -> ((Ptr CFloat) -> (IO ())))))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_setDefaultOrientationMode"
  setDefaultOrientationMode'_ :: (CInt -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassViewport.chs.h ogre_vprt_getDefaultOrientationMode"
  getDefaultOrientationMode'_ :: ((Ptr CInt) -> (IO ()))