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


-- ClassLight.chs

-- 

module HGamer3D.Bindings.Ogre.ClassLight 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\\ClassLight.chs" #-}
import HGamer3D.Bindings.Ogre.ClassPtr
{-# LINE 41 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
import HGamer3D.Bindings.Ogre.StructHG3DClass
{-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
import HGamer3D.Bindings.Ogre.EnumLightType
{-# LINE 43 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
import HGamer3D.Bindings.Ogre.StructColour
{-# LINE 44 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
import HGamer3D.Bindings.Ogre.StructVec3
{-# LINE 45 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
import HGamer3D.Bindings.Ogre.StructRadians
{-# LINE 46 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Normal constructor. Should not be called directly, but rather the SceneManager::createLight
new :: String  -- ^ name
  ->  IO (HG3DClass)
 -- ^ 
new a1 =
  withCString a1 $ \a1' -> 
  alloca $ \a2' -> 
  new'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 52 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

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

-- | Sets the type of light - see LightTypes for more info. 
setType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  EnumLightType  -- ^ type
  ->  IO ()
 -- ^ 
setType a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = cIntFromEnum a2} in 
  setType'_ a1' a2' >>= \res ->
  return ()
{-# LINE 61 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Returns the light type. 
getType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (EnumLightType)
 -- ^ 
getType a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getType'_ a1' a2' >>= \res ->
  peekEnumUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 66 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Sets the colour of the diffuse light given off by this source. MaterialDiffuse light simulates the typical light emanating from light sources and affects the base colour of objects together with ambient light. 
setDiffuseColour :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ red
  ->  Float  -- ^ green
  ->  Float  -- ^ blue
  ->  IO ()
 -- ^ 
setDiffuseColour a1 a2 a3 a4 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  let {a3' = realToFrac a3} in 
  let {a4' = realToFrac a4} in 
  setDiffuseColour'_ a1' a2' a3' a4' >>= \res ->
  return ()
{-# LINE 73 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Sets the colour of the diffuse light given off by this source. MaterialDiffuse light simulates the typical light emanating from light sources and affects the base colour of objects together with ambient light. 
setDiffuseColour2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Colour  -- ^ colour
  ->  IO ()
 -- ^ 
setDiffuseColour2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withColour a2 $ \a2' -> 
  setDiffuseColour2'_ a1' a2' >>= \res ->
  return ()
{-# LINE 78 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Returns the colour of the diffuse light given off by this light source (see setDiffuseColour for more info). 
getDiffuseColour :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Colour)
 -- ^ 
getDiffuseColour a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getDiffuseColour'_ a1' a2' >>= \res ->
  peekColour  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 83 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Sets the colour of the specular light given off by this source. MaterialSpecular light affects the appearance of shiny highlights on objects, and is also dependent on the 'shininess' Material
setSpecularColour :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ red
  ->  Float  -- ^ green
  ->  Float  -- ^ blue
  ->  IO ()
 -- ^ 
setSpecularColour a1 a2 a3 a4 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  let {a3' = realToFrac a3} in 
  let {a4' = realToFrac a4} in 
  setSpecularColour'_ a1' a2' a3' a4' >>= \res ->
  return ()
{-# LINE 90 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Sets the colour of the specular light given off by this source. MaterialSpecular light affects the appearance of shiny highlights on objects, and is also dependent on the 'shininess' Material
setSpecularColour2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Colour  -- ^ colour
  ->  IO ()
 -- ^ 
setSpecularColour2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withColour a2 $ \a2' -> 
  setSpecularColour2'_ a1' a2' >>= \res ->
  return ()
{-# LINE 95 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Returns the colour of specular light given off by this light source. 
getSpecularColour :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Colour)
 -- ^ 
getSpecularColour a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getSpecularColour'_ a1' a2' >>= \res ->
  peekColour  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 100 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Sets the attenuation parameters of the light source i.e. how it diminishes with distance. Lights normally get fainter the further they are away. Also, each light is given a maximum range beyond which it cannot affect any objects. LightThis follows a standard attenuation approach - see any good 3D text for the details of what they mean since i don't have room here! 
setAttenuation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ range - The absolute upper range of the light in world units 
  ->  Float  -- ^ constant - The constant factor in the attenuation formula: 1.0 means never attenuate, 0.0 is complete attenuation 
  ->  Float  -- ^ linear - The linear factor in the attenuation formula: 1 means attenuate evenly over the distance 
  ->  Float  -- ^ quadratic - The quadratic factor in the attenuation formula: adds a curvature to the attenuation formula. 
  ->  IO ()
 -- ^ 
setAttenuation 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 
  setAttenuation'_ a1' a2' a3' a4' a5' >>= \res ->
  return ()
{-# LINE 108 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Returns the absolute upper range of the light. 
getAttenuationRange :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getAttenuationRange a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getAttenuationRange'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 113 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Returns the constant factor in the attenuation formula. 
getAttenuationConstant :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getAttenuationConstant a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getAttenuationConstant'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 118 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Returns the linear factor in the attenuation formula. 
getAttenuationLinear :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getAttenuationLinear a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getAttenuationLinear'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 123 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Returns the quadric factor in the attenuation formula. 
getAttenuationQuadric :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getAttenuationQuadric a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getAttenuationQuadric'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 128 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Sets the position of the light. Applicable to point lights and spotlights only. This will be overridden if the light is attached to a SceneNode
setPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ x
  ->  Float  -- ^ y
  ->  Float  -- ^ z
  ->  IO ()
 -- ^ 
setPosition a1 a2 a3 a4 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  let {a3' = realToFrac a3} in 
  let {a4' = realToFrac a4} in 
  setPosition'_ a1' a2' a3' a4' >>= \res ->
  return ()
{-# LINE 135 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Sets the position of the light. Applicable to point lights and spotlights only. This will be overridden if the light is attached to a SceneNode
setPosition2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec3  -- ^ vec
  ->  IO ()
 -- ^ 
setPosition2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withVec3 a2 $ \a2' -> 
  setPosition2'_ a1' a2' >>= \res ->
  return ()
{-# LINE 140 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Returns the position of the light. Applicable to point lights and spotlights only. 
getPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getPosition a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getPosition'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 145 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Sets the direction in which a light points. Applicable only to the spotlight and directional light types. This will be overridden if the light is attached to a SceneNode
setDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ x
  ->  Float  -- ^ y
  ->  Float  -- ^ z
  ->  IO ()
 -- ^ 
setDirection a1 a2 a3 a4 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  let {a3' = realToFrac a3} in 
  let {a4' = realToFrac a4} in 
  setDirection'_ a1' a2' a3' a4' >>= \res ->
  return ()
{-# LINE 152 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Sets the direction in which a light points. Applicable only to the spotlight and directional light types. This will be overridden if the light is attached to a SceneNode
setDirection2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec3  -- ^ vec
  ->  IO ()
 -- ^ 
setDirection2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withVec3 a2 $ \a2' -> 
  setDirection2'_ a1' a2' >>= \res ->
  return ()
{-# LINE 157 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Returns the light's direction. Applicable only to the spotlight and directional light types. 
getDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getDirection a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getDirection'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 162 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Sets the range of a spotlight, i.e. the angle of the inner and outer cones and the rate of falloff between them. 
setSpotlightRange :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Radians  -- ^ innerAngle - Angle covered by the bright inner cone  The inner cone applicable only to Direct3D, it'll always treat as zero in OpenGL. 
  ->  Radians  -- ^ outerAngle - Angle covered by the outer cone 
  ->  Float  -- ^ falloff - The rate of falloff between the inner and outer cones. 1.0 means a linear falloff, less means slower falloff, higher means faster falloff. 
  ->  IO ()
 -- ^ 
setSpotlightRange a1 a2 a3 a4 =
  withHG3DClass a1 $ \a1' -> 
  withRadians a2 $ \a2' -> 
  withRadians a3 $ \a3' -> 
  let {a4' = realToFrac a4} in 
  setSpotlightRange'_ a1' a2' a3' a4' >>= \res ->
  return ()
{-# LINE 169 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Returns the angle covered by the spotlights inner cone. 
getSpotlightInnerAngle :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Radians)
 -- ^ 
getSpotlightInnerAngle a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getSpotlightInnerAngle'_ a1' a2' >>= \res ->
  peekRadians  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 174 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Returns the angle covered by the spotlights outer cone. 
getSpotlightOuterAngle :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Radians)
 -- ^ 
getSpotlightOuterAngle a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getSpotlightOuterAngle'_ a1' a2' >>= \res ->
  peekRadians  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 179 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Returns the falloff between the inner and outer cones of the spotlight. 
getSpotlightFalloff :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getSpotlightFalloff a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getSpotlightFalloff'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 184 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Sets the angle covered by the spotlights inner cone. 
setSpotlightInnerAngle :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Radians  -- ^ val
  ->  IO ()
 -- ^ 
setSpotlightInnerAngle a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withRadians a2 $ \a2' -> 
  setSpotlightInnerAngle'_ a1' a2' >>= \res ->
  return ()
{-# LINE 189 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Sets the angle covered by the spotlights outer cone. 
setSpotlightOuterAngle :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Radians  -- ^ val
  ->  IO ()
 -- ^ 
setSpotlightOuterAngle a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withRadians a2 $ \a2' -> 
  setSpotlightOuterAngle'_ a1' a2' >>= \res ->
  return ()
{-# LINE 194 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Sets the falloff between the inner and outer cones of the spotlight. 
setSpotlightFalloff :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ val
  ->  IO ()
 -- ^ 
setSpotlightFalloff a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  setSpotlightFalloff'_ a1' a2' >>= \res ->
  return ()
{-# LINE 199 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Set a scaling factor to indicate the relative power of a light. This factor is only useful in High Dynamic Range (HDR) rendering. You can bind it to a shader variable to take it into account, GpuProgramParameters 
setPowerScale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ power - The power rating of this light, default is 1.0. 
  ->  IO ()
 -- ^ 
setPowerScale a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  setPowerScale'_ a1' a2' >>= \res ->
  return ()
{-# LINE 204 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Set the scaling factor which indicates the relative power of a light. 
getPowerScale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getPowerScale a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getPowerScale'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 209 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.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 214 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Retrieves the position of the light including any transform from nodes it is attached to. 
getDerivedPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ cameraRelativeIfSet - If set to true, returns data in camera-relative units if that's been set up (render use) 
  ->  IO (Vec3)
 -- ^ 
getDerivedPosition a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  alloca $ \a3' -> 
  getDerivedPosition'_ a1' a2' a3' >>= \res ->
  peekVec3  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 220 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Retrieves the direction of the light including any transform from nodes it is attached to. 
getDerivedDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getDerivedDirection a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getDerivedDirection'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 225 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Overridden from MovableObjectAlthough lights themselves are not 'visible', setting a light to invisible means it no longer affects the scene. 
setVisible :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ visible
  ->  IO ()
 -- ^ 
setVisible a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setVisible'_ a1' a2' >>= \res ->
  return ()
{-# LINE 230 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.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 235 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Override to return specific type flag. 
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 240 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Reset the shadow camera setup to the default. ShadowCameraSetup 
resetCustomShadowCameraSetup :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
resetCustomShadowCameraSetup a1 =
  withHG3DClass a1 $ \a1' -> 
  resetCustomShadowCameraSetup'_ a1' >>= \res ->
  return ()
{-# LINE 244 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Sets the maximum distance away from the camera that shadows by this light will be visible. Shadow techniques can be expensive, therefore it is a good idea to limit them to being rendered close to the camera if possible, and to skip the expense of rendering shadows for distance objects. This method allows you to set the distance at which shadows will no longer be rendered. Each shadow technique can interpret this subtely differently. For example, one technique may use this to eliminate casters, another might use it to attenuate the shadows themselves. You should tweak this value to suit your chosen shadow technique and scene setup. 
setShadowFarDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ distance
  ->  IO ()
 -- ^ 
setShadowFarDistance a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  setShadowFarDistance'_ a1' a2' >>= \res ->
  return ()
{-# LINE 249 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Tells the light to use the shadow far distance of the SceneManager
resetShadowFarDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
resetShadowFarDistance a1 =
  withHG3DClass a1 $ \a1' -> 
  resetShadowFarDistance'_ a1' >>= \res ->
  return ()
{-# LINE 253 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Gets the maximum distance away from the camera that shadows by this light will be visible. 
getShadowFarDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getShadowFarDistance a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getShadowFarDistance'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 258 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

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

-- | Set the near clip plane distance to be used by the shadow camera, if this light casts texture shadows. 
setShadowNearClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ nearClip
  ->  IO ()
 -- ^ 
setShadowNearClipDistance a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  setShadowNearClipDistance'_ a1' a2' >>= \res ->
  return ()
{-# LINE 268 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Get the near clip plane distance to be used by the shadow camera, if this light casts texture shadows. May be zero if the light doesn't have it's own near distance set; use _deriveShadowNearDistance for a version guaranteed to give a result. 
getShadowNearClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getShadowNearClipDistance a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getShadowNearClipDistance'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 273 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Set the far clip plane distance to be used by the shadow camera, if this light casts texture shadows. This is different from the 'shadow far distance', which is always measured from the main camera. This distance is the far clip plane of the light camera. 
setShadowFarClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ farClip
  ->  IO ()
 -- ^ 
setShadowFarClipDistance a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  setShadowFarClipDistance'_ a1' a2' >>= \res ->
  return ()
{-# LINE 278 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}

-- | Get the far clip plane distance to be used by the shadow camera, if this light casts texture shadows. May be zero if the light doesn't have it's own far distance set; use _deriveShadowfarDistance for a version guaranteed to give a result. 
getShadowFarClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ 
getShadowFarClipDistance a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getShadowFarClipDistance'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 283 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}


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

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_setType"
  setType'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_getType"
  getType'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_setDiffuseColour"
  setDiffuseColour'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> (CFloat -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_setDiffuseColour2"
  setDiffuseColour2'_ :: ((HG3DClassPtr) -> ((ColourPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_getDiffuseColour"
  getDiffuseColour'_ :: ((HG3DClassPtr) -> ((ColourPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_setSpecularColour"
  setSpecularColour'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> (CFloat -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_setSpecularColour2"
  setSpecularColour2'_ :: ((HG3DClassPtr) -> ((ColourPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_getSpecularColour"
  getSpecularColour'_ :: ((HG3DClassPtr) -> ((ColourPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_setAttenuation"
  setAttenuation'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> (CFloat -> (CFloat -> (IO ()))))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_getAttenuationRange"
  getAttenuationRange'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_getAttenuationConstant"
  getAttenuationConstant'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_getAttenuationLinear"
  getAttenuationLinear'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_getAttenuationQuadric"
  getAttenuationQuadric'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

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

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

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

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

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

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_setSpotlightRange"
  setSpotlightRange'_ :: ((HG3DClassPtr) -> ((RadiansPtr) -> ((RadiansPtr) -> (CFloat -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_getSpotlightInnerAngle"
  getSpotlightInnerAngle'_ :: ((HG3DClassPtr) -> ((RadiansPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_getSpotlightOuterAngle"
  getSpotlightOuterAngle'_ :: ((HG3DClassPtr) -> ((RadiansPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_getSpotlightFalloff"
  getSpotlightFalloff'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_setSpotlightInnerAngle"
  setSpotlightInnerAngle'_ :: ((HG3DClassPtr) -> ((RadiansPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_setSpotlightOuterAngle"
  setSpotlightOuterAngle'_ :: ((HG3DClassPtr) -> ((RadiansPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_setSpotlightFalloff"
  setSpotlightFalloff'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_setPowerScale"
  setPowerScale'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_getPowerScale"
  getPowerScale'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

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

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

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_setVisible"
  setVisible'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

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

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_resetCustomShadowCameraSetup"
  resetCustomShadowCameraSetup'_ :: ((HG3DClassPtr) -> (IO ()))

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_resetShadowFarDistance"
  resetShadowFarDistance'_ :: ((HG3DClassPtr) -> (IO ()))

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

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_setShadowNearClipDistance"
  setShadowNearClipDistance'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_getShadowNearClipDistance"
  getShadowNearClipDistance'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_setShadowFarClipDistance"
  setShadowFarClipDistance'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassLight.chs.h ogre_lgt_getShadowFarClipDistance"
  getShadowFarClipDistance'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))