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


-- ClassNode.chs

-- 

module HGamer3D.Bindings.Ogre.ClassNode 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\\ClassNode.chs" #-}
import HGamer3D.Bindings.Ogre.ClassPtr
{-# LINE 43 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
import HGamer3D.Bindings.Ogre.StructHG3DClass
{-# LINE 44 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
import HGamer3D.Bindings.Ogre.StructQuaternion
{-# LINE 45 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
import HGamer3D.Bindings.Ogre.StructVec3
{-# LINE 46 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
import HGamer3D.Bindings.Ogre.EnumNodeTransformSpace
{-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
import HGamer3D.Bindings.Ogre.StructRadians
{-# LINE 48 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

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

-- | Returns the name of the node. 
getName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (String)
 -- ^ 
getName a1 =
  withHG3DClass a1 $ \a1' -> 
  alloc64k $ \a2' -> 
  getName'_ a1' a2' >>= \res ->
  peekCString  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 58 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Gets this node's parent (NULL if this is the root). 
getParent :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ 
getParent a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getParent'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 63 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

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

-- | Sets the orientation of this node via a quaternion. Orientations, unlike other transforms, are not always inherited by child nodes. Whether or not orientations affect the orientation of the child nodes depends on the setInheritOrientation option of the child. In some cases you want a orientating of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative orientation based on the parent's orientation), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own orientation). The default is to inherit as with other transforms. Note that rotations are oriented around the node's origin. 
setOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Quaternion  -- ^ q
  ->  IO ()
 -- ^ 
setOrientation a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withQuaternion a2 $ \a2' -> 
  setOrientation'_ a1' a2' >>= \res ->
  return ()
{-# LINE 73 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Sets the orientation of this node via quaternion parameters. Orientations, unlike other transforms, are not always inherited by child nodes. Whether or not orientations affect the orientation of the child nodes depends on the setInheritOrientation option of the child. In some cases you want a orientating of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative orientation based on the parent's orientation), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own orientation). The default is to inherit as with other transforms. Note that rotations are oriented around the node's origin. 
setOrientation2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ w
  ->  Float  -- ^ x
  ->  Float  -- ^ y
  ->  Float  -- ^ z
  ->  IO ()
 -- ^ 
setOrientation2 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 
  setOrientation2'_ a1' a2' a3' a4' a5' >>= \res ->
  return ()
{-# LINE 81 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Resets the nodes orientation (local axes as world axes, no rotation). Orientations, unlike other transforms, are not always inherited by child nodes. Whether or not orientations affect the orientation of the child nodes depends on the setInheritOrientation option of the child. In some cases you want a orientating of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative orientation based on the parent's orientation), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own orientation). The default is to inherit as with other transforms. Note that rotations are oriented around the node's origin. 
resetOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
resetOrientation a1 =
  withHG3DClass a1 $ \a1' -> 
  resetOrientation'_ a1' >>= \res ->
  return ()
{-# LINE 85 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Sets the position of the node relative to it's parent. 
setPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec3  -- ^ pos
  ->  IO ()
 -- ^ 
setPosition a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withVec3 a2 $ \a2' -> 
  setPosition'_ a1' a2' >>= \res ->
  return ()
{-# LINE 90 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

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

-- | Gets the position of the node relative to it's parent. 
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 102 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Sets the scaling factor applied to this node. Scaling factors, unlike other transforms, are not always inherited by child nodes. Whether or not scalings affect the size of the child nodes depends on the setInheritScale option of the child. In some cases you want a scaling factor of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative size based on the parent's size), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own size). The default is to inherit as with other transforms. Note that like rotations, scalings are oriented around the node's origin. 
setScale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec3  -- ^ scale
  ->  IO ()
 -- ^ 
setScale a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withVec3 a2 $ \a2' -> 
  setScale'_ a1' a2' >>= \res ->
  return ()
{-# LINE 107 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Sets the scaling factor applied to this node. Scaling factors, unlike other transforms, are not always inherited by child nodes. Whether or not scalings affect the size of the child nodes depends on the setInheritScale option of the child. In some cases you want a scaling factor of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative size based on the parent's size), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own size). The default is to inherit as with other transforms. Note that like rotations, scalings are oriented around the node's origin. 
setScale2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ x
  ->  Float  -- ^ y
  ->  Float  -- ^ z
  ->  IO ()
 -- ^ 
setScale2 a1 a2 a3 a4 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  let {a3' = realToFrac a3} in 
  let {a4' = realToFrac a4} in 
  setScale2'_ a1' a2' a3' a4' >>= \res ->
  return ()
{-# LINE 114 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Gets the scaling factor of this node. 
getScale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getScale a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getScale'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 119 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Tells the node whether it should inherit orientation from it's parent node. Orientations, unlike other transforms, are not always inherited by child nodes. Whether or not orientations affect the orientation of the child nodes depends on the setInheritOrientation option of the child. In some cases you want a orientating of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative orientation based on the parent's orientation), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own orientation). The default is to inherit as with other transforms. 
setInheritOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ inherit - If true, this node's orientation will be affected by its parent's orientation. If false, it will not be affected. 
  ->  IO ()
 -- ^ 
setInheritOrientation a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setInheritOrientation'_ a1' a2' >>= \res ->
  return ()
{-# LINE 124 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Returns true if this node is affected by orientation applied to the parent node. Orientations, unlike other transforms, are not always inherited by child nodes. Whether or not orientations affect the orientation of the child nodes depends on the setInheritOrientation option of the child. In some cases you want a orientating of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative orientation based on the parent's orientation), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own orientation). The default is to inherit as with other transforms. 
--See setInheritOrientation for more info. 
getInheritOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
getInheritOrientation a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getInheritOrientation'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 129 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Tells the node whether it should inherit scaling factors from it's parent node. Scaling factors, unlike other transforms, are not always inherited by child nodes. Whether or not scalings affect the size of the child nodes depends on the setInheritScale option of the child. In some cases you want a scaling factor of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative size based on the parent's size), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own size). The default is to inherit as with other transforms. 
setInheritScale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ inherit - If true, this node's scale will be affected by its parent's scale. If false, it will not be affected. 
  ->  IO ()
 -- ^ 
setInheritScale a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setInheritScale'_ a1' a2' >>= \res ->
  return ()
{-# LINE 134 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Returns true if this node is affected by scaling factors applied to the parent node. See setInheritScale for more info. 
getInheritScale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
getInheritScale a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getInheritScale'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 139 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Scales the node, combining it's current scale with the passed in scaling factor. This method applies an extra scaling factor to the node's existing scale, (unlike setScale which overwrites it) combining it's current scale with the new one. E.g. calling this method twice with Vector3(2,2,2) would have the same effect as setScale(Vector3(4,4,4)) if the existing scale was 1. Note that like rotations, scalings are oriented around the node's origin. 
scale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec3  -- ^ scale
  ->  IO ()
 -- ^ 
scale a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withVec3 a2 $ \a2' -> 
  scale'_ a1' a2' >>= \res ->
  return ()
{-# LINE 144 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Scales the node, combining it's current scale with the passed in scaling factor. This method applies an extra scaling factor to the node's existing scale, (unlike setScale which overwrites it) combining it's current scale with the new one. E.g. calling this method twice with Vector3(2,2,2) would have the same effect as setScale(Vector3(4,4,4)) if the existing scale was 1. Note that like rotations, scalings are oriented around the node's origin. 
scale2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ x
  ->  Float  -- ^ y
  ->  Float  -- ^ z
  ->  IO ()
 -- ^ 
scale2 a1 a2 a3 a4 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  let {a3' = realToFrac a3} in 
  let {a4' = realToFrac a4} in 
  scale2'_ a1' a2' a3' a4' >>= \res ->
  return ()
{-# LINE 151 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Moves the node along the Cartesian axes. This method moves the node by the supplied vector along the world Cartesian axes, i.e. along world x,y,z 
translate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec3  -- ^ d - Vector with x,y,z values representing the translation. 
  ->  EnumNodeTransformSpace  -- ^ relativeTo - The space which this transform is relative to. 
  ->  IO ()
 -- ^ 
translate a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  withVec3 a2 $ \a2' -> 
  let {a3' = cIntFromEnum a3} in 
  translate'_ a1' a2' a3' >>= \res ->
  return ()
{-# LINE 157 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Moves the node along the Cartesian axes. This method moves the node by the supplied vector along the world Cartesian axes, i.e. along world x,y,z 
translate2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ x
  ->  Float  -- ^ y
  ->  Float  -- ^ z - Real x, y and z values representing the translation. 
  ->  EnumNodeTransformSpace  -- ^ relativeTo - The space which this transform is relative to. 
  ->  IO ()
 -- ^ 
translate2 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' = cIntFromEnum a5} in 
  translate2'_ a1' a2' a3' a4' a5' >>= \res ->
  return ()
{-# LINE 165 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Rotate the node around the Z-axis. 
roll :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Radians  -- ^ angle
  ->  EnumNodeTransformSpace  -- ^ relativeTo
  ->  IO ()
 -- ^ 
roll a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  withRadians a2 $ \a2' -> 
  let {a3' = cIntFromEnum a3} in 
  roll'_ a1' a2' a3' >>= \res ->
  return ()
{-# LINE 171 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Rotate the node around the X-axis. 
pitch :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Radians  -- ^ angle
  ->  EnumNodeTransformSpace  -- ^ relativeTo
  ->  IO ()
 -- ^ 
pitch a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  withRadians a2 $ \a2' -> 
  let {a3' = cIntFromEnum a3} in 
  pitch'_ a1' a2' a3' >>= \res ->
  return ()
{-# LINE 177 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Rotate the node around the Y-axis. 
yaw :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Radians  -- ^ angle
  ->  EnumNodeTransformSpace  -- ^ relativeTo
  ->  IO ()
 -- ^ 
yaw a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  withRadians a2 $ \a2' -> 
  let {a3' = cIntFromEnum a3} in 
  yaw'_ a1' a2' a3' >>= \res ->
  return ()
{-# LINE 183 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

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

-- | Rotate the node around an aritrary axis using a Quarternion. 
rotate2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Quaternion  -- ^ q
  ->  EnumNodeTransformSpace  -- ^ relativeTo
  ->  IO ()
 -- ^ 
rotate2 a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  withQuaternion a2 $ \a2' -> 
  let {a3' = cIntFromEnum a3} in 
  rotate2'_ a1' a2' a3' >>= \res ->
  return ()
{-# LINE 196 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Creates an unnamed new Node
createChild :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec3  -- ^ translate - Initial translation offset of child relative to parent 
  ->  Quaternion  -- ^ rotate - Initial rotation relative to parent 
  ->  IO (HG3DClass)
 -- ^ 
createChild a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  withVec3 a2 $ \a2' -> 
  withQuaternion a3 $ \a3' -> 
  alloca $ \a4' -> 
  createChild'_ a1' a2' a3' a4' >>= \res ->
  peek  a4'>>= \a4'' -> 
  return (a4'')
{-# LINE 203 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Creates a new named NodeThis creates a child node with a given name, which allows you to look the node up from the parent which holds this collection of nodes. 
createChild2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ name
  ->  Vec3  -- ^ translate - Initial translation offset of child relative to parent 
  ->  Quaternion  -- ^ rotate - Initial rotation relative to parent 
  ->  IO (HG3DClass)
 -- ^ 
createChild2 a1 a2 a3 a4 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  withVec3 a3 $ \a3' -> 
  withQuaternion a4 $ \a4' -> 
  alloca $ \a5' -> 
  createChild2'_ a1' a2' a3' a4' a5' >>= \res ->
  peek  a5'>>= \a5'' -> 
  return (a5'')
{-# LINE 211 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Adds a (precreated) child scene node to this node. If it is attached to another node, it must be detached first. 
addChild :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ child - The Node which is to become a child node of this one 
  ->  IO ()
 -- ^ 
addChild a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  addChild'_ a1' a2' >>= \res ->
  return ()
{-# LINE 216 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Reports the number of child nodes under this one. 
numChildren :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Int)
 -- ^ 
numChildren a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  numChildren'_ a1' a2' >>= \res ->
  peekIntConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 221 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Gets a pointer to a child node. There is an alternate getChild method which returns a named child. 
getChild :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Int  -- ^ index
  ->  IO (HG3DClass)
 -- ^ 
getChild a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromIntegral a2} in 
  alloca $ \a3' -> 
  getChild'_ a1' a2' a3' >>= \res ->
  peek  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 227 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Gets a pointer to a named child node. 
getChild2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ name
  ->  IO (HG3DClass)
 -- ^ 
getChild2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  alloca $ \a3' -> 
  getChild2'_ a1' a2' a3' >>= \res ->
  peek  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 233 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Drops the specified child from this node. Does not delete the node, just detaches it from this parent, potentially to be reattached elsewhere. There is also an alternate version which drops a named child from this node. 
removeChild :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Int  -- ^ index
  ->  IO (HG3DClass)
 -- ^ 
removeChild a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromIntegral a2} in 
  alloca $ \a3' -> 
  removeChild'_ a1' a2' a3' >>= \res ->
  peek  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 239 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Drops the specified child from this node. Does not delete the node, just detaches it from this parent, potentially to be reattached elsewhere. There is also an alternate version which drops a named child from this node. 
removeChild2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ child
  ->  IO (HG3DClass)
 -- ^ 
removeChild2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  alloca $ \a3' -> 
  removeChild2'_ a1' a2' a3' >>= \res ->
  peek  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 245 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Drops the named child from this node. Does not delete the node, just detaches it from this parent, potentially to be reattached elsewhere. 
removeChild3 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ name
  ->  IO (HG3DClass)
 -- ^ 
removeChild3 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  alloca $ \a3' -> 
  removeChild3'_ a1' a2' a3' >>= \res ->
  peek  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 251 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Removes all child Nodes attached to this node. Does not delete the nodes, just detaches them from this parent, potentially to be reattached elsewhere. 
removeAllChildren :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
removeAllChildren a1 =
  withHG3DClass a1 $ \a1' -> 
  removeAllChildren'_ a1' >>= \res ->
  return ()
{-# LINE 255 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Sets the current transform of this node to be the 'initial state' ie that position / orientation / scale to be used as a basis for delta values used in keyframe animation. You never need to call this method unless you plan to animate this node. If you do plan to animate it, call this method once you've loaded the node with it's base state, ie the state on which all keyframes are based. If you never call this method, the initial state is the identity transform, ie do nothing. 
setInitialState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
setInitialState a1 =
  withHG3DClass a1 $ \a1' -> 
  setInitialState'_ a1' >>= \res ->
  return ()
{-# LINE 259 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Resets the position / orientation / scale of this node to it's initial state, see setInitialState for more info. 
resetToInitialState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
resetToInitialState a1 =
  withHG3DClass a1 $ \a1' -> 
  resetToInitialState'_ a1' >>= \res ->
  return ()
{-# LINE 263 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Gets the initial position of this node, see setInitialState for more info. Also resets the cumulative animation weight used for blending. 
getInitialPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getInitialPosition a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getInitialPosition'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 268 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Gets the local position, relative to this node, of the given world-space position 
convertWorldToLocalPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec3  -- ^ worldPos
  ->  IO (Vec3)
 -- ^ 
convertWorldToLocalPosition a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withVec3 a2 $ \a2' -> 
  alloca $ \a3' -> 
  convertWorldToLocalPosition'_ a1' a2' a3' >>= \res ->
  peekVec3  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 274 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Gets the world position of a point in the node local space useful for simple transforms that don't require a child node. 
convertLocalToWorldPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Vec3  -- ^ localPos
  ->  IO (Vec3)
 -- ^ 
convertLocalToWorldPosition a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withVec3 a2 $ \a2' -> 
  alloca $ \a3' -> 
  convertLocalToWorldPosition'_ a1' a2' a3' >>= \res ->
  peekVec3  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 280 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Gets the local orientation, relative to this node, of the given world-space orientation 
convertWorldToLocalOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Quaternion  -- ^ worldOrientation
  ->  IO (Quaternion)
 -- ^ 
convertWorldToLocalOrientation a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withQuaternion a2 $ \a2' -> 
  alloca $ \a3' -> 
  convertWorldToLocalOrientation'_ a1' a2' a3' >>= \res ->
  peekQuaternion  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 286 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Gets the world orientation of an orientation in the node local space useful for simple transforms that don't require a child node. 
convertLocalToWorldOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Quaternion  -- ^ localOrientation
  ->  IO (Quaternion)
 -- ^ 
convertLocalToWorldOrientation a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withQuaternion a2 $ \a2' -> 
  alloca $ \a3' -> 
  convertLocalToWorldOrientation'_ a1' a2' a3' >>= \res ->
  peekQuaternion  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 292 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Gets the initial orientation of this node, see setInitialState for more info. 
getInitialOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Quaternion)
 -- ^ 
getInitialOrientation a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getInitialOrientation'_ a1' a2' >>= \res ->
  peekQuaternion  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 297 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Gets the initial position of this node, see setInitialState for more info. 
getInitialScale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Vec3)
 -- ^ 
getInitialScale a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getInitialScale'_ a1' a2' >>= \res ->
  peekVec3  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 302 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Helper function, get the squared view depth. 
getSquaredViewDepth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ cam
  ->  IO (Float)
 -- ^ 
getSquaredViewDepth a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  alloca $ \a3' -> 
  getSquaredViewDepth'_ a1' a2' a3' >>= \res ->
  peekFloatConv  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 308 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | To be called in the event of transform changes to this node that require it's recalculation. This not only tags the node state as being 'dirty', it also requests it's parent to know about it's dirtiness so it will get an update next time. 
needUpdate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ forceParentUpdate - Even if the node thinks it has already told it's parent, tell it anyway 
  ->  IO ()
 -- ^ 
needUpdate a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  needUpdate'_ a1' a2' >>= \res ->
  return ()
{-# LINE 313 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Called by children to notify their parent that they need an update. 
requestUpdate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ child
  ->  Bool  -- ^ forceParentUpdate - Even if the node thinks it has already told it's parent, tell it anyway 
  ->  IO ()
 -- ^ 
requestUpdate a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  let {a3' = fromBool a3} in 
  requestUpdate'_ a1' a2' a3' >>= \res ->
  return ()
{-# LINE 319 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Called by children to notify their parent that they no longer need an update. 
cancelUpdate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ child
  ->  IO ()
 -- ^ 
cancelUpdate a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  cancelUpdate'_ a1' a2' >>= \res ->
  return ()
{-# LINE 324 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Queue a 'needUpdate' call to a node safely. You can't call needUpdate()Node::Listener
queueNeedUpdate :: HG3DClass  -- ^ n
  ->  IO ()
 -- ^ 
queueNeedUpdate a1 =
  withHG3DClass a1 $ \a1' -> 
  queueNeedUpdate'_ a1' >>= \res ->
  return ()
{-# LINE 328 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}

-- | Process queued 'needUpdate' calls. 
processQueuedUpdates :: IO ()
 -- ^ 
processQueuedUpdates =
  processQueuedUpdates'_ >>= \res ->
  return ()
{-# LINE 332 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}


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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_getName"
  getName'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_getParent"
  getParent'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

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

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_setOrientation2"
  setOrientation2'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> (CFloat -> (CFloat -> (IO ()))))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_resetOrientation"
  resetOrientation'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_setPosition"
  setPosition'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_setPosition2"
  setPosition2'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> (CFloat -> (IO ())))))

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_setScale"
  setScale'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_setScale2"
  setScale2'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> (CFloat -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_getScale"
  getScale'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_setInheritOrientation"
  setInheritOrientation'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_getInheritOrientation"
  getInheritOrientation'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_setInheritScale"
  setInheritScale'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_getInheritScale"
  getInheritScale'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_scale"
  scale'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_scale2"
  scale2'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> (CFloat -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_translate"
  translate'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (CInt -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_translate2"
  translate2'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> (CFloat -> (CInt -> (IO ()))))))

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

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

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

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

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_createChild"
  createChild'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> ((QuaternionPtr) -> ((HG3DClassPtr) -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_createChild2"
  createChild2'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Vec3Ptr) -> ((QuaternionPtr) -> ((HG3DClassPtr) -> (IO ()))))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_addChild"
  addChild'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_numChildren"
  numChildren'_ :: ((HG3DClassPtr) -> ((Ptr CUShort) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_getChild"
  getChild'_ :: ((HG3DClassPtr) -> (CUShort -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_getChild2"
  getChild2'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_removeChild"
  removeChild'_ :: ((HG3DClassPtr) -> (CUShort -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_removeChild2"
  removeChild2'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_removeChild3"
  removeChild3'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_removeAllChildren"
  removeAllChildren'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_setInitialState"
  setInitialState'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_resetToInitialState"
  resetToInitialState'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_getInitialPosition"
  getInitialPosition'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_convertWorldToLocalPosition"
  convertWorldToLocalPosition'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> ((Vec3Ptr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_convertLocalToWorldPosition"
  convertLocalToWorldPosition'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> ((Vec3Ptr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_convertWorldToLocalOrientation"
  convertWorldToLocalOrientation'_ :: ((HG3DClassPtr) -> ((QuaternionPtr) -> ((QuaternionPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_convertLocalToWorldOrientation"
  convertLocalToWorldOrientation'_ :: ((HG3DClassPtr) -> ((QuaternionPtr) -> ((QuaternionPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_getInitialOrientation"
  getInitialOrientation'_ :: ((HG3DClassPtr) -> ((QuaternionPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_getInitialScale"
  getInitialScale'_ :: ((HG3DClassPtr) -> ((Vec3Ptr) -> (IO ())))

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

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_needUpdate"
  needUpdate'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_requestUpdate"
  requestUpdate'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (CInt -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_cancelUpdate"
  cancelUpdate'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_queueNeedUpdate"
  queueNeedUpdate'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\Ogre\\ClassNode.chs.h ogre_nd_processQueuedUpdates"
  processQueuedUpdates'_ :: (IO ())