-- 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 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\\ClassViewport.chs" #-}
import HGamer3D.Bindings.Ogre.ClassPtr
{-# LINE 43 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
import HGamer3D.Bindings.Ogre.StructHG3DClass
{-# LINE 44 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
import HGamer3D.Bindings.Ogre.StructColour
{-# LINE 45 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
import HGamer3D.Bindings.Ogre.EnumOrientationMode
{-# LINE 46 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
import HGamer3D.Bindings.Ogre.StructVec2
{-# LINE 47 ".\\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 59 ".\\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 63 ".\\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 67 ".\\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 75 ".\\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 80 ".\\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 85 ".\\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 90 ".\\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 95 ".\\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 100 ".\\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 105 ".\\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 110 ".\\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 115 ".\\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 120 ".\\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 125 ".\\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 130 ".\\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 135 ".\\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 143 ".\\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 149 ".\\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 154 ".\\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 159 ".\\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 164 ".\\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 170 ".\\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 175 ".\\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 180 ".\\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 185 ".\\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 190 ".\\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 195 ".\\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 200 ".\\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 208 ".\\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 213 ".\\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 218 ".\\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 223 ".\\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 228 ".\\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 233 ".\\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 238 ".\\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 243 ".\\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 248 ".\\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 253 ".\\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 258 ".\\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 265 ".\\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 274 ".\\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 278 ".\\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 282 ".\\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 ()))