{-# LANGUAGE DeriveAnyClass #-}

{-# OPTIONS -Wall #-}

-- | Bindings for types used mainly in @rmodels@
module Raylib.Types.Core.Models
  ( -- * Enumerations
    MaterialMapIndex (..),
    ShaderLocationIndex (..),
    ShaderUniformDataType (..),
    ShaderUniformData (..),
    ShaderUniformDataV (..),
    unpackShaderUniformData,
    unpackShaderUniformDataV,
    ShaderAttributeDataType (..),

    -- * Structures
    Mesh (..),
    Shader (..),
    MaterialMap (..),
    Material (..),
    Transform (..),
    BoneInfo (..),
    Model (..),
    ModelAnimation (..),
    Ray (..),
    RayCollision (..),
    BoundingBox (..),

    -- * Pointer utilities
    p'mesh'vertexCount,
    p'mesh'triangleCount,
    p'mesh'vertices,
    p'mesh'texcoords,
    p'mesh'texcoords2,
    p'mesh'normals,
    p'mesh'tangents,
    p'mesh'colors,
    p'mesh'indices,
    p'mesh'animVertices,
    p'mesh'animNormals,
    p'mesh'boneIds,
    p'mesh'boneWeights,
    p'mesh'vaoId,
    p'mesh'vboId,
    p'shader'id,
    p'shader'locs,
    p'materialMap'texture,
    p'materialMap'color,
    p'materialMap'value,
    p'material'shader,
    p'material'maps,
    p'material'params,
    p'transform'translation,
    p'transform'rotation,
    p'transform'scale,
    p'boneInfo'name,
    p'boneInfo'parent,
    p'model'transform,
    p'model'meshCount,
    p'model'materialCount,
    p'model'meshes,
    p'model'materials,
    p'model'meshMaterial,
    p'model'boneCount,
    p'model'bones,
    p'model'bindPose,
    p'modelAnimation'boneCount,
    p'modelAnimation'frameCount,
    p'modelAnimation'bones,
    p'modelAnimation'framePoses,
    p'modelAnimation'name,
    p'ray'position,
    p'ray'direction,
    p'rayCollision'hit,
    p'rayCollision'distance,
    p'rayCollision'point,
    p'rayCollision'normal,
    p'boundingBox'min,
    p'boundingBox'max,
  )
where

import Control.Monad (forM_, unless)
import Foreign
  ( ForeignPtr,
    Ptr,
    Storable (alignment, peek, poke, sizeOf),
    Word16,
    Word8,
    castForeignPtr,
    castPtr,
    fromBool,
    mallocForeignPtr,
    mallocForeignPtrArray,
    newArray,
    newForeignPtr,
    peekArray,
    plusPtr,
    pokeArray,
    toBool,
    withForeignPtr,
  )
import Foreign.C
  ( CBool,
    CChar,
    CFloat,
    CInt (..),
    CUChar,
    CUInt,
    CUShort,
    castCharToCChar,
    peekCString,
  )
import Raylib.Internal (c'rlGetShaderIdDefault)
import Raylib.Internal.Foreign (Freeable (rlFreeDependents), c'free, freeMaybePtr, newMaybeArray, p'free, peekMaybeArray, peekStaticArray, pokeStaticArray, rightPad, rlFree, rlFreeMaybeArray)
import Raylib.Types.Core (Color, Matrix, Quaternion, Vector2 (Vector2), Vector3 (Vector3), Vector4 (Vector4))
import Raylib.Types.Core.Textures (Texture (texture'id))

---------------------------------------
-- models enums -----------------------
---------------------------------------

data MaterialMapIndex
  = MaterialMapAlbedo
  | MaterialMapMetalness
  | MaterialMapNormal
  | MaterialMapRoughness
  | MaterialMapOcclusion
  | MaterialMapEmission
  | MaterialMapHeight
  | MaterialMapCubemap
  | MaterialMapIrradiance
  | MaterialMapPrefilter
  | MaterialMapBrdf
  deriving (MaterialMapIndex -> MaterialMapIndex -> Bool
(MaterialMapIndex -> MaterialMapIndex -> Bool)
-> (MaterialMapIndex -> MaterialMapIndex -> Bool)
-> Eq MaterialMapIndex
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MaterialMapIndex -> MaterialMapIndex -> Bool
== :: MaterialMapIndex -> MaterialMapIndex -> Bool
$c/= :: MaterialMapIndex -> MaterialMapIndex -> Bool
/= :: MaterialMapIndex -> MaterialMapIndex -> Bool
Eq, Int -> MaterialMapIndex -> ShowS
[MaterialMapIndex] -> ShowS
MaterialMapIndex -> String
(Int -> MaterialMapIndex -> ShowS)
-> (MaterialMapIndex -> String)
-> ([MaterialMapIndex] -> ShowS)
-> Show MaterialMapIndex
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MaterialMapIndex -> ShowS
showsPrec :: Int -> MaterialMapIndex -> ShowS
$cshow :: MaterialMapIndex -> String
show :: MaterialMapIndex -> String
$cshowList :: [MaterialMapIndex] -> ShowS
showList :: [MaterialMapIndex] -> ShowS
Show, Int -> MaterialMapIndex
MaterialMapIndex -> Int
MaterialMapIndex -> [MaterialMapIndex]
MaterialMapIndex -> MaterialMapIndex
MaterialMapIndex -> MaterialMapIndex -> [MaterialMapIndex]
MaterialMapIndex
-> MaterialMapIndex -> MaterialMapIndex -> [MaterialMapIndex]
(MaterialMapIndex -> MaterialMapIndex)
-> (MaterialMapIndex -> MaterialMapIndex)
-> (Int -> MaterialMapIndex)
-> (MaterialMapIndex -> Int)
-> (MaterialMapIndex -> [MaterialMapIndex])
-> (MaterialMapIndex -> MaterialMapIndex -> [MaterialMapIndex])
-> (MaterialMapIndex -> MaterialMapIndex -> [MaterialMapIndex])
-> (MaterialMapIndex
    -> MaterialMapIndex -> MaterialMapIndex -> [MaterialMapIndex])
-> Enum MaterialMapIndex
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: MaterialMapIndex -> MaterialMapIndex
succ :: MaterialMapIndex -> MaterialMapIndex
$cpred :: MaterialMapIndex -> MaterialMapIndex
pred :: MaterialMapIndex -> MaterialMapIndex
$ctoEnum :: Int -> MaterialMapIndex
toEnum :: Int -> MaterialMapIndex
$cfromEnum :: MaterialMapIndex -> Int
fromEnum :: MaterialMapIndex -> Int
$cenumFrom :: MaterialMapIndex -> [MaterialMapIndex]
enumFrom :: MaterialMapIndex -> [MaterialMapIndex]
$cenumFromThen :: MaterialMapIndex -> MaterialMapIndex -> [MaterialMapIndex]
enumFromThen :: MaterialMapIndex -> MaterialMapIndex -> [MaterialMapIndex]
$cenumFromTo :: MaterialMapIndex -> MaterialMapIndex -> [MaterialMapIndex]
enumFromTo :: MaterialMapIndex -> MaterialMapIndex -> [MaterialMapIndex]
$cenumFromThenTo :: MaterialMapIndex
-> MaterialMapIndex -> MaterialMapIndex -> [MaterialMapIndex]
enumFromThenTo :: MaterialMapIndex
-> MaterialMapIndex -> MaterialMapIndex -> [MaterialMapIndex]
Enum)

data ShaderLocationIndex
  = ShaderLocVertexPosition
  | ShaderLocVertexTexcoord01
  | ShaderLocVertexTexcoord02
  | ShaderLocVertexNormal
  | ShaderLocVertexTangent
  | ShaderLocVertexColor
  | ShaderLocMatrixMvp
  | ShaderLocMatrixView
  | ShaderLocMatrixProjection
  | ShaderLocMatrixModel
  | ShaderLocMatrixNormal
  | ShaderLocVectorView
  | ShaderLocColorDiffuse
  | ShaderLocColorSpecular
  | ShaderLocColorAmbient
  | ShaderLocMapAlbedo
  | ShaderLocMapMetalness
  | ShaderLocMapNormal
  | ShaderLocMapRoughness
  | ShaderLocMapOcclusion
  | ShaderLocMapEmission
  | ShaderLocMapHeight
  | ShaderLocMapCubemap
  | ShaderLocMapIrradiance
  | ShaderLocMapPrefilter
  | ShaderLocMapBrdf
  deriving (ShaderLocationIndex -> ShaderLocationIndex -> Bool
(ShaderLocationIndex -> ShaderLocationIndex -> Bool)
-> (ShaderLocationIndex -> ShaderLocationIndex -> Bool)
-> Eq ShaderLocationIndex
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShaderLocationIndex -> ShaderLocationIndex -> Bool
== :: ShaderLocationIndex -> ShaderLocationIndex -> Bool
$c/= :: ShaderLocationIndex -> ShaderLocationIndex -> Bool
/= :: ShaderLocationIndex -> ShaderLocationIndex -> Bool
Eq, Int -> ShaderLocationIndex -> ShowS
[ShaderLocationIndex] -> ShowS
ShaderLocationIndex -> String
(Int -> ShaderLocationIndex -> ShowS)
-> (ShaderLocationIndex -> String)
-> ([ShaderLocationIndex] -> ShowS)
-> Show ShaderLocationIndex
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShaderLocationIndex -> ShowS
showsPrec :: Int -> ShaderLocationIndex -> ShowS
$cshow :: ShaderLocationIndex -> String
show :: ShaderLocationIndex -> String
$cshowList :: [ShaderLocationIndex] -> ShowS
showList :: [ShaderLocationIndex] -> ShowS
Show, Int -> ShaderLocationIndex
ShaderLocationIndex -> Int
ShaderLocationIndex -> [ShaderLocationIndex]
ShaderLocationIndex -> ShaderLocationIndex
ShaderLocationIndex -> ShaderLocationIndex -> [ShaderLocationIndex]
ShaderLocationIndex
-> ShaderLocationIndex
-> ShaderLocationIndex
-> [ShaderLocationIndex]
(ShaderLocationIndex -> ShaderLocationIndex)
-> (ShaderLocationIndex -> ShaderLocationIndex)
-> (Int -> ShaderLocationIndex)
-> (ShaderLocationIndex -> Int)
-> (ShaderLocationIndex -> [ShaderLocationIndex])
-> (ShaderLocationIndex
    -> ShaderLocationIndex -> [ShaderLocationIndex])
-> (ShaderLocationIndex
    -> ShaderLocationIndex -> [ShaderLocationIndex])
-> (ShaderLocationIndex
    -> ShaderLocationIndex
    -> ShaderLocationIndex
    -> [ShaderLocationIndex])
-> Enum ShaderLocationIndex
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ShaderLocationIndex -> ShaderLocationIndex
succ :: ShaderLocationIndex -> ShaderLocationIndex
$cpred :: ShaderLocationIndex -> ShaderLocationIndex
pred :: ShaderLocationIndex -> ShaderLocationIndex
$ctoEnum :: Int -> ShaderLocationIndex
toEnum :: Int -> ShaderLocationIndex
$cfromEnum :: ShaderLocationIndex -> Int
fromEnum :: ShaderLocationIndex -> Int
$cenumFrom :: ShaderLocationIndex -> [ShaderLocationIndex]
enumFrom :: ShaderLocationIndex -> [ShaderLocationIndex]
$cenumFromThen :: ShaderLocationIndex -> ShaderLocationIndex -> [ShaderLocationIndex]
enumFromThen :: ShaderLocationIndex -> ShaderLocationIndex -> [ShaderLocationIndex]
$cenumFromTo :: ShaderLocationIndex -> ShaderLocationIndex -> [ShaderLocationIndex]
enumFromTo :: ShaderLocationIndex -> ShaderLocationIndex -> [ShaderLocationIndex]
$cenumFromThenTo :: ShaderLocationIndex
-> ShaderLocationIndex
-> ShaderLocationIndex
-> [ShaderLocationIndex]
enumFromThenTo :: ShaderLocationIndex
-> ShaderLocationIndex
-> ShaderLocationIndex
-> [ShaderLocationIndex]
Enum)

data ShaderUniformDataType
  = ShaderUniformFloatType
  | ShaderUniformVec2Type
  | ShaderUniformVec3Type
  | ShaderUniformVec4Type
  | ShaderUniformIntType
  | ShaderUniformIVec2Type
  | ShaderUniformIVec3Type
  | ShaderUniformIVec4Type
  | ShaderUniformSampler2DType
  deriving (ShaderUniformDataType -> ShaderUniformDataType -> Bool
(ShaderUniformDataType -> ShaderUniformDataType -> Bool)
-> (ShaderUniformDataType -> ShaderUniformDataType -> Bool)
-> Eq ShaderUniformDataType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShaderUniformDataType -> ShaderUniformDataType -> Bool
== :: ShaderUniformDataType -> ShaderUniformDataType -> Bool
$c/= :: ShaderUniformDataType -> ShaderUniformDataType -> Bool
/= :: ShaderUniformDataType -> ShaderUniformDataType -> Bool
Eq, Int -> ShaderUniformDataType -> ShowS
[ShaderUniformDataType] -> ShowS
ShaderUniformDataType -> String
(Int -> ShaderUniformDataType -> ShowS)
-> (ShaderUniformDataType -> String)
-> ([ShaderUniformDataType] -> ShowS)
-> Show ShaderUniformDataType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShaderUniformDataType -> ShowS
showsPrec :: Int -> ShaderUniformDataType -> ShowS
$cshow :: ShaderUniformDataType -> String
show :: ShaderUniformDataType -> String
$cshowList :: [ShaderUniformDataType] -> ShowS
showList :: [ShaderUniformDataType] -> ShowS
Show, Int -> ShaderUniformDataType
ShaderUniformDataType -> Int
ShaderUniformDataType -> [ShaderUniformDataType]
ShaderUniformDataType -> ShaderUniformDataType
ShaderUniformDataType
-> ShaderUniformDataType -> [ShaderUniformDataType]
ShaderUniformDataType
-> ShaderUniformDataType
-> ShaderUniformDataType
-> [ShaderUniformDataType]
(ShaderUniformDataType -> ShaderUniformDataType)
-> (ShaderUniformDataType -> ShaderUniformDataType)
-> (Int -> ShaderUniformDataType)
-> (ShaderUniformDataType -> Int)
-> (ShaderUniformDataType -> [ShaderUniformDataType])
-> (ShaderUniformDataType
    -> ShaderUniformDataType -> [ShaderUniformDataType])
-> (ShaderUniformDataType
    -> ShaderUniformDataType -> [ShaderUniformDataType])
-> (ShaderUniformDataType
    -> ShaderUniformDataType
    -> ShaderUniformDataType
    -> [ShaderUniformDataType])
-> Enum ShaderUniformDataType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ShaderUniformDataType -> ShaderUniformDataType
succ :: ShaderUniformDataType -> ShaderUniformDataType
$cpred :: ShaderUniformDataType -> ShaderUniformDataType
pred :: ShaderUniformDataType -> ShaderUniformDataType
$ctoEnum :: Int -> ShaderUniformDataType
toEnum :: Int -> ShaderUniformDataType
$cfromEnum :: ShaderUniformDataType -> Int
fromEnum :: ShaderUniformDataType -> Int
$cenumFrom :: ShaderUniformDataType -> [ShaderUniformDataType]
enumFrom :: ShaderUniformDataType -> [ShaderUniformDataType]
$cenumFromThen :: ShaderUniformDataType
-> ShaderUniformDataType -> [ShaderUniformDataType]
enumFromThen :: ShaderUniformDataType
-> ShaderUniformDataType -> [ShaderUniformDataType]
$cenumFromTo :: ShaderUniformDataType
-> ShaderUniformDataType -> [ShaderUniformDataType]
enumFromTo :: ShaderUniformDataType
-> ShaderUniformDataType -> [ShaderUniformDataType]
$cenumFromThenTo :: ShaderUniformDataType
-> ShaderUniformDataType
-> ShaderUniformDataType
-> [ShaderUniformDataType]
enumFromThenTo :: ShaderUniformDataType
-> ShaderUniformDataType
-> ShaderUniformDataType
-> [ShaderUniformDataType]
Enum)

data ShaderUniformData
  = ShaderUniformFloat Float
  | ShaderUniformVec2 Vector2
  | ShaderUniformVec3 Vector3
  | ShaderUniformVec4 Vector4
  | ShaderUniformInt Int
  | ShaderUniformIVec2 (Int, Int)
  | ShaderUniformIVec3 (Int, Int, Int)
  | ShaderUniformIVec4 (Int, Int, Int, Int)
  | ShaderUniformSampler2D Texture
  deriving (ShaderUniformData -> ShaderUniformData -> Bool
(ShaderUniformData -> ShaderUniformData -> Bool)
-> (ShaderUniformData -> ShaderUniformData -> Bool)
-> Eq ShaderUniformData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShaderUniformData -> ShaderUniformData -> Bool
== :: ShaderUniformData -> ShaderUniformData -> Bool
$c/= :: ShaderUniformData -> ShaderUniformData -> Bool
/= :: ShaderUniformData -> ShaderUniformData -> Bool
Eq, Int -> ShaderUniformData -> ShowS
[ShaderUniformData] -> ShowS
ShaderUniformData -> String
(Int -> ShaderUniformData -> ShowS)
-> (ShaderUniformData -> String)
-> ([ShaderUniformData] -> ShowS)
-> Show ShaderUniformData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShaderUniformData -> ShowS
showsPrec :: Int -> ShaderUniformData -> ShowS
$cshow :: ShaderUniformData -> String
show :: ShaderUniformData -> String
$cshowList :: [ShaderUniformData] -> ShowS
showList :: [ShaderUniformData] -> ShowS
Show)

data ShaderUniformDataV
  = ShaderUniformFloatV [Float]
  | ShaderUniformVec2V [Vector2]
  | ShaderUniformVec3V [Vector3]
  | ShaderUniformVec4V [Vector4]
  | ShaderUniformIntV [Int]
  | ShaderUniformIVec2V [(Int, Int)]
  | ShaderUniformIVec3V [(Int, Int, Int)]
  | ShaderUniformIVec4V [(Int, Int, Int, Int)]
  | ShaderUniformSampler2DV [Texture]
  deriving (ShaderUniformDataV -> ShaderUniformDataV -> Bool
(ShaderUniformDataV -> ShaderUniformDataV -> Bool)
-> (ShaderUniformDataV -> ShaderUniformDataV -> Bool)
-> Eq ShaderUniformDataV
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShaderUniformDataV -> ShaderUniformDataV -> Bool
== :: ShaderUniformDataV -> ShaderUniformDataV -> Bool
$c/= :: ShaderUniformDataV -> ShaderUniformDataV -> Bool
/= :: ShaderUniformDataV -> ShaderUniformDataV -> Bool
Eq, Int -> ShaderUniformDataV -> ShowS
[ShaderUniformDataV] -> ShowS
ShaderUniformDataV -> String
(Int -> ShaderUniformDataV -> ShowS)
-> (ShaderUniformDataV -> String)
-> ([ShaderUniformDataV] -> ShowS)
-> Show ShaderUniformDataV
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShaderUniformDataV -> ShowS
showsPrec :: Int -> ShaderUniformDataV -> ShowS
$cshow :: ShaderUniformDataV -> String
show :: ShaderUniformDataV -> String
$cshowList :: [ShaderUniformDataV] -> ShowS
showList :: [ShaderUniformDataV] -> ShowS
Show)

-- | Internal use
unpackShaderUniformData :: ShaderUniformData -> IO (ShaderUniformDataType, ForeignPtr ())
unpackShaderUniformData :: ShaderUniformData -> IO (ShaderUniformDataType, ForeignPtr ())
unpackShaderUniformData ShaderUniformData
u = do
  case ShaderUniformData
u of
    (ShaderUniformFloat Float
f) ->
      do
        ForeignPtr CFloat
fptr <- IO (ForeignPtr CFloat)
forall a. Storable a => IO (ForeignPtr a)
mallocForeignPtr
        ForeignPtr CFloat -> (Ptr CFloat -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CFloat
fptr (\Ptr CFloat
ptr -> Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr CFloat
ptr (Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
f :: CFloat))
        (ShaderUniformDataType, ForeignPtr ())
-> IO (ShaderUniformDataType, ForeignPtr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShaderUniformDataType
ShaderUniformFloatType, ForeignPtr CFloat -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr CFloat
fptr)
    (ShaderUniformVec2 (Vector2 Float
x Float
y)) ->
      do
        ForeignPtr CFloat
fptr <- Int -> IO (ForeignPtr CFloat)
forall a. Storable a => Int -> IO (ForeignPtr a)
mallocForeignPtrArray Int
2
        ForeignPtr CFloat -> (Ptr CFloat -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CFloat
fptr (\Ptr CFloat
ptr -> Ptr CFloat -> [CFloat] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr CFloat
ptr ((Float -> CFloat) -> [Float] -> [CFloat]
forall a b. (a -> b) -> [a] -> [b]
map Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac [Float
x, Float
y] :: [CFloat]))
        (ShaderUniformDataType, ForeignPtr ())
-> IO (ShaderUniformDataType, ForeignPtr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShaderUniformDataType
ShaderUniformVec2Type, ForeignPtr CFloat -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr CFloat
fptr)
    (ShaderUniformVec3 (Vector3 Float
x Float
y Float
z)) ->
      do
        ForeignPtr CFloat
fptr <- Int -> IO (ForeignPtr CFloat)
forall a. Storable a => Int -> IO (ForeignPtr a)
mallocForeignPtrArray Int
3
        ForeignPtr CFloat -> (Ptr CFloat -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CFloat
fptr (\Ptr CFloat
ptr -> Ptr CFloat -> [CFloat] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr CFloat
ptr ((Float -> CFloat) -> [Float] -> [CFloat]
forall a b. (a -> b) -> [a] -> [b]
map Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac [Float
x, Float
y, Float
z] :: [CFloat]))
        (ShaderUniformDataType, ForeignPtr ())
-> IO (ShaderUniformDataType, ForeignPtr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShaderUniformDataType
ShaderUniformVec3Type, ForeignPtr CFloat -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr CFloat
fptr)
    (ShaderUniformVec4 (Vector4 Float
x Float
y Float
z Float
w)) ->
      do
        ForeignPtr CFloat
fptr <- Int -> IO (ForeignPtr CFloat)
forall a. Storable a => Int -> IO (ForeignPtr a)
mallocForeignPtrArray Int
3
        ForeignPtr CFloat -> (Ptr CFloat -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CFloat
fptr (\Ptr CFloat
ptr -> Ptr CFloat -> [CFloat] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr CFloat
ptr ((Float -> CFloat) -> [Float] -> [CFloat]
forall a b. (a -> b) -> [a] -> [b]
map Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac [Float
x, Float
y, Float
z, Float
w] :: [CFloat]))
        (ShaderUniformDataType, ForeignPtr ())
-> IO (ShaderUniformDataType, ForeignPtr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShaderUniformDataType
ShaderUniformVec4Type, ForeignPtr CFloat -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr CFloat
fptr)
    (ShaderUniformInt Int
i) ->
      do
        ForeignPtr CInt
fptr <- IO (ForeignPtr CInt)
forall a. Storable a => IO (ForeignPtr a)
mallocForeignPtr
        ForeignPtr CInt -> (Ptr CInt -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CInt
fptr (\Ptr CInt
ptr -> Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr CInt
ptr (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i :: CInt))
        (ShaderUniformDataType, ForeignPtr ())
-> IO (ShaderUniformDataType, ForeignPtr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShaderUniformDataType
ShaderUniformIntType, ForeignPtr CInt -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr CInt
fptr)
    (ShaderUniformIVec2 (Int
i1, Int
i2)) ->
      do
        ForeignPtr CInt
fptr <- Int -> IO (ForeignPtr CInt)
forall a. Storable a => Int -> IO (ForeignPtr a)
mallocForeignPtrArray Int
2
        ForeignPtr CInt -> (Ptr CInt -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CInt
fptr (\Ptr CInt
ptr -> Ptr CInt -> [CInt] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr CInt
ptr ((Int -> CInt) -> [Int] -> [CInt]
forall a b. (a -> b) -> [a] -> [b]
map Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral [Int
i1, Int
i2] :: [CInt]))
        (ShaderUniformDataType, ForeignPtr ())
-> IO (ShaderUniformDataType, ForeignPtr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShaderUniformDataType
ShaderUniformIVec2Type, ForeignPtr CInt -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr CInt
fptr)
    (ShaderUniformIVec3 (Int
i1, Int
i2, Int
i3)) ->
      do
        ForeignPtr CInt
fptr <- Int -> IO (ForeignPtr CInt)
forall a. Storable a => Int -> IO (ForeignPtr a)
mallocForeignPtrArray Int
3
        ForeignPtr CInt -> (Ptr CInt -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CInt
fptr (\Ptr CInt
ptr -> Ptr CInt -> [CInt] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr CInt
ptr ((Int -> CInt) -> [Int] -> [CInt]
forall a b. (a -> b) -> [a] -> [b]
map Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral [Int
i1, Int
i2, Int
i3] :: [CInt]))
        (ShaderUniformDataType, ForeignPtr ())
-> IO (ShaderUniformDataType, ForeignPtr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShaderUniformDataType
ShaderUniformIVec3Type, ForeignPtr CInt -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr CInt
fptr)
    (ShaderUniformIVec4 (Int
i1, Int
i2, Int
i3, Int
i4)) ->
      do
        ForeignPtr CInt
fptr <- Int -> IO (ForeignPtr CInt)
forall a. Storable a => Int -> IO (ForeignPtr a)
mallocForeignPtrArray Int
4
        ForeignPtr CInt -> (Ptr CInt -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CInt
fptr (\Ptr CInt
ptr -> Ptr CInt -> [CInt] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr CInt
ptr ((Int -> CInt) -> [Int] -> [CInt]
forall a b. (a -> b) -> [a] -> [b]
map Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral [Int
i1, Int
i2, Int
i3, Int
i4] :: [CInt]))
        (ShaderUniformDataType, ForeignPtr ())
-> IO (ShaderUniformDataType, ForeignPtr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShaderUniformDataType
ShaderUniformIVec4Type, ForeignPtr CInt -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr CInt
fptr)
    (ShaderUniformSampler2D Texture
texture) ->
      do
        ForeignPtr CInt
fptr <- IO (ForeignPtr CInt)
forall a. Storable a => IO (ForeignPtr a)
mallocForeignPtr
        ForeignPtr CInt -> (Ptr CInt -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CInt
fptr (\Ptr CInt
ptr -> Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr CInt
ptr (Integer -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> CInt) -> Integer -> CInt
forall a b. (a -> b) -> a -> b
$ Texture -> Integer
texture'id Texture
texture :: CInt))
        (ShaderUniformDataType, ForeignPtr ())
-> IO (ShaderUniformDataType, ForeignPtr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShaderUniformDataType
ShaderUniformSampler2DType, ForeignPtr CInt -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr CInt
fptr)

-- | Internal use
unpackShaderUniformDataV :: ShaderUniformDataV -> IO (ShaderUniformDataType, ForeignPtr (), Int)
unpackShaderUniformDataV :: ShaderUniformDataV
-> IO (ShaderUniformDataType, ForeignPtr (), Int)
unpackShaderUniformDataV ShaderUniformDataV
xs = do
  case ShaderUniformDataV
xs of
    (ShaderUniformFloatV [Float]
fs) ->
      do
        ForeignPtr CFloat
fptr <- Int -> IO (ForeignPtr CFloat)
forall a. Storable a => Int -> IO (ForeignPtr a)
mallocForeignPtrArray ([Float] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Float]
fs)
        ForeignPtr CFloat -> (Ptr CFloat -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CFloat
fptr (\Ptr CFloat
ptr -> Ptr CFloat -> [CFloat] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr CFloat
ptr ((Float -> CFloat) -> [Float] -> [CFloat]
forall a b. (a -> b) -> [a] -> [b]
map Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac [Float]
fs :: [CFloat]))
        (ShaderUniformDataType, ForeignPtr (), Int)
-> IO (ShaderUniformDataType, ForeignPtr (), Int)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShaderUniformDataType
ShaderUniformFloatType, ForeignPtr CFloat -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr CFloat
fptr, [Float] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Float]
fs)
    (ShaderUniformVec2V [Vector2]
vs) ->
      do
        ForeignPtr CFloat
fptr <- Int -> IO (ForeignPtr CFloat)
forall a. Storable a => Int -> IO (ForeignPtr a)
mallocForeignPtrArray (Int
2 Int -> Int -> Int
forall a. Num a => a -> a -> a
* [Vector2] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Vector2]
vs)
        ForeignPtr CFloat -> (Ptr CFloat -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CFloat
fptr (\Ptr CFloat
ptr -> Ptr CFloat -> [CFloat] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr CFloat
ptr ((Float -> CFloat) -> [Float] -> [CFloat]
forall a b. (a -> b) -> [a] -> [b]
map Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac ([Float] -> [CFloat]) -> [Float] -> [CFloat]
forall a b. (a -> b) -> a -> b
$ (Vector2 -> [Float]) -> [Vector2] -> [Float]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\(Vector2 Float
x Float
y) -> [Float
x, Float
y]) [Vector2]
vs :: [CFloat]))
        (ShaderUniformDataType, ForeignPtr (), Int)
-> IO (ShaderUniformDataType, ForeignPtr (), Int)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShaderUniformDataType
ShaderUniformVec2Type, ForeignPtr CFloat -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr CFloat
fptr, [Vector2] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Vector2]
vs)
    (ShaderUniformVec3V [Vector3]
vs) ->
      do
        ForeignPtr CFloat
fptr <- Int -> IO (ForeignPtr CFloat)
forall a. Storable a => Int -> IO (ForeignPtr a)
mallocForeignPtrArray (Int
3 Int -> Int -> Int
forall a. Num a => a -> a -> a
* [Vector3] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Vector3]
vs)
        ForeignPtr CFloat -> (Ptr CFloat -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CFloat
fptr (\Ptr CFloat
ptr -> Ptr CFloat -> [CFloat] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr CFloat
ptr ((Float -> CFloat) -> [Float] -> [CFloat]
forall a b. (a -> b) -> [a] -> [b]
map Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac ([Float] -> [CFloat]) -> [Float] -> [CFloat]
forall a b. (a -> b) -> a -> b
$ (Vector3 -> [Float]) -> [Vector3] -> [Float]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\(Vector3 Float
x Float
y Float
z) -> [Float
x, Float
y, Float
z]) [Vector3]
vs :: [CFloat]))
        (ShaderUniformDataType, ForeignPtr (), Int)
-> IO (ShaderUniformDataType, ForeignPtr (), Int)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShaderUniformDataType
ShaderUniformVec3Type, ForeignPtr CFloat -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr CFloat
fptr, [Vector3] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Vector3]
vs)
    (ShaderUniformVec4V [Vector4]
vs) ->
      do
        ForeignPtr CFloat
fptr <- Int -> IO (ForeignPtr CFloat)
forall a. Storable a => Int -> IO (ForeignPtr a)
mallocForeignPtrArray (Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* [Vector4] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Vector4]
vs)
        ForeignPtr CFloat -> (Ptr CFloat -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CFloat
fptr (\Ptr CFloat
ptr -> Ptr CFloat -> [CFloat] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr CFloat
ptr ((Float -> CFloat) -> [Float] -> [CFloat]
forall a b. (a -> b) -> [a] -> [b]
map Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac ([Float] -> [CFloat]) -> [Float] -> [CFloat]
forall a b. (a -> b) -> a -> b
$ (Vector4 -> [Float]) -> [Vector4] -> [Float]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\(Vector4 Float
x Float
y Float
z Float
w) -> [Float
x, Float
y, Float
z, Float
w]) [Vector4]
vs :: [CFloat]))
        (ShaderUniformDataType, ForeignPtr (), Int)
-> IO (ShaderUniformDataType, ForeignPtr (), Int)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShaderUniformDataType
ShaderUniformVec4Type, ForeignPtr CFloat -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr CFloat
fptr, [Vector4] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Vector4]
vs)
    (ShaderUniformIntV [Int]
is) ->
      do
        ForeignPtr CInt
fptr <- Int -> IO (ForeignPtr CInt)
forall a. Storable a => Int -> IO (ForeignPtr a)
mallocForeignPtrArray ([Int] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Int]
is)
        ForeignPtr CInt -> (Ptr CInt -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CInt
fptr (\Ptr CInt
ptr -> Ptr CInt -> [CInt] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr CInt
ptr ((Int -> CInt) -> [Int] -> [CInt]
forall a b. (a -> b) -> [a] -> [b]
map Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral [Int]
is :: [CInt]))
        (ShaderUniformDataType, ForeignPtr (), Int)
-> IO (ShaderUniformDataType, ForeignPtr (), Int)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShaderUniformDataType
ShaderUniformFloatType, ForeignPtr CInt -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr CInt
fptr, [Int] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Int]
is)
    (ShaderUniformIVec2V [(Int, Int)]
is) ->
      do
        ForeignPtr CInt
fptr <- Int -> IO (ForeignPtr CInt)
forall a. Storable a => Int -> IO (ForeignPtr a)
mallocForeignPtrArray (Int
2 Int -> Int -> Int
forall a. Num a => a -> a -> a
* [(Int, Int)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [(Int, Int)]
is)
        ForeignPtr CInt -> (Ptr CInt -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CInt
fptr (\Ptr CInt
ptr -> Ptr CInt -> [CInt] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr CInt
ptr ((Int -> CInt) -> [Int] -> [CInt]
forall a b. (a -> b) -> [a] -> [b]
map Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Int] -> [CInt]) -> [Int] -> [CInt]
forall a b. (a -> b) -> a -> b
$ ((Int, Int) -> [Int]) -> [(Int, Int)] -> [Int]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\(Int
x, Int
y) -> [Int
x, Int
y]) [(Int, Int)]
is :: [CInt]))
        (ShaderUniformDataType, ForeignPtr (), Int)
-> IO (ShaderUniformDataType, ForeignPtr (), Int)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShaderUniformDataType
ShaderUniformIVec2Type, ForeignPtr CInt -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr CInt
fptr, [(Int, Int)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [(Int, Int)]
is)
    (ShaderUniformIVec3V [(Int, Int, Int)]
is) ->
      do
        ForeignPtr CInt
fptr <- Int -> IO (ForeignPtr CInt)
forall a. Storable a => Int -> IO (ForeignPtr a)
mallocForeignPtrArray (Int
3 Int -> Int -> Int
forall a. Num a => a -> a -> a
* [(Int, Int, Int)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [(Int, Int, Int)]
is)
        ForeignPtr CInt -> (Ptr CInt -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CInt
fptr (\Ptr CInt
ptr -> Ptr CInt -> [CInt] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr CInt
ptr ((Int -> CInt) -> [Int] -> [CInt]
forall a b. (a -> b) -> [a] -> [b]
map Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Int] -> [CInt]) -> [Int] -> [CInt]
forall a b. (a -> b) -> a -> b
$ ((Int, Int, Int) -> [Int]) -> [(Int, Int, Int)] -> [Int]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\(Int
x, Int
y, Int
z) -> [Int
x, Int
y, Int
z]) [(Int, Int, Int)]
is :: [CInt]))
        (ShaderUniformDataType, ForeignPtr (), Int)
-> IO (ShaderUniformDataType, ForeignPtr (), Int)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShaderUniformDataType
ShaderUniformIVec3Type, ForeignPtr CInt -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr CInt
fptr, [(Int, Int, Int)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [(Int, Int, Int)]
is)
    (ShaderUniformIVec4V [(Int, Int, Int, Int)]
is) ->
      do
        ForeignPtr CInt
fptr <- Int -> IO (ForeignPtr CInt)
forall a. Storable a => Int -> IO (ForeignPtr a)
mallocForeignPtrArray (Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* [(Int, Int, Int, Int)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [(Int, Int, Int, Int)]
is)
        ForeignPtr CInt -> (Ptr CInt -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CInt
fptr (\Ptr CInt
ptr -> Ptr CInt -> [CInt] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr CInt
ptr ((Int -> CInt) -> [Int] -> [CInt]
forall a b. (a -> b) -> [a] -> [b]
map Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Int] -> [CInt]) -> [Int] -> [CInt]
forall a b. (a -> b) -> a -> b
$ ((Int, Int, Int, Int) -> [Int]) -> [(Int, Int, Int, Int)] -> [Int]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\(Int
x, Int
y, Int
z, Int
w) -> [Int
x, Int
y, Int
z, Int
w]) [(Int, Int, Int, Int)]
is :: [CInt]))
        (ShaderUniformDataType, ForeignPtr (), Int)
-> IO (ShaderUniformDataType, ForeignPtr (), Int)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShaderUniformDataType
ShaderUniformIVec4Type, ForeignPtr CInt -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr CInt
fptr, [(Int, Int, Int, Int)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [(Int, Int, Int, Int)]
is)
    (ShaderUniformSampler2DV [Texture]
textures) ->
      do
        ForeignPtr CInt
fptr <- IO (ForeignPtr CInt)
forall a. Storable a => IO (ForeignPtr a)
mallocForeignPtr
        ForeignPtr CInt -> (Ptr CInt -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CInt
fptr (\Ptr CInt
ptr -> Ptr CInt -> [CInt] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr CInt
ptr ((Texture -> CInt) -> [Texture] -> [CInt]
forall a b. (a -> b) -> [a] -> [b]
map (Integer -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> CInt) -> (Texture -> Integer) -> Texture -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Texture -> Integer
texture'id) [Texture]
textures :: [CInt]))
        (ShaderUniformDataType, ForeignPtr (), Int)
-> IO (ShaderUniformDataType, ForeignPtr (), Int)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShaderUniformDataType
ShaderUniformSampler2DType, ForeignPtr CInt -> ForeignPtr ()
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr CInt
fptr, [Texture] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Texture]
textures)

-- Unused
data ShaderAttributeDataType
  = ShaderAttribFloat
  | ShaderAttribVec2
  | ShaderAttribVec3
  | ShaderAttribVec4
  deriving (ShaderAttributeDataType -> ShaderAttributeDataType -> Bool
(ShaderAttributeDataType -> ShaderAttributeDataType -> Bool)
-> (ShaderAttributeDataType -> ShaderAttributeDataType -> Bool)
-> Eq ShaderAttributeDataType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShaderAttributeDataType -> ShaderAttributeDataType -> Bool
== :: ShaderAttributeDataType -> ShaderAttributeDataType -> Bool
$c/= :: ShaderAttributeDataType -> ShaderAttributeDataType -> Bool
/= :: ShaderAttributeDataType -> ShaderAttributeDataType -> Bool
Eq, Int -> ShaderAttributeDataType -> ShowS
[ShaderAttributeDataType] -> ShowS
ShaderAttributeDataType -> String
(Int -> ShaderAttributeDataType -> ShowS)
-> (ShaderAttributeDataType -> String)
-> ([ShaderAttributeDataType] -> ShowS)
-> Show ShaderAttributeDataType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShaderAttributeDataType -> ShowS
showsPrec :: Int -> ShaderAttributeDataType -> ShowS
$cshow :: ShaderAttributeDataType -> String
show :: ShaderAttributeDataType -> String
$cshowList :: [ShaderAttributeDataType] -> ShowS
showList :: [ShaderAttributeDataType] -> ShowS
Show, Int -> ShaderAttributeDataType
ShaderAttributeDataType -> Int
ShaderAttributeDataType -> [ShaderAttributeDataType]
ShaderAttributeDataType -> ShaderAttributeDataType
ShaderAttributeDataType
-> ShaderAttributeDataType -> [ShaderAttributeDataType]
ShaderAttributeDataType
-> ShaderAttributeDataType
-> ShaderAttributeDataType
-> [ShaderAttributeDataType]
(ShaderAttributeDataType -> ShaderAttributeDataType)
-> (ShaderAttributeDataType -> ShaderAttributeDataType)
-> (Int -> ShaderAttributeDataType)
-> (ShaderAttributeDataType -> Int)
-> (ShaderAttributeDataType -> [ShaderAttributeDataType])
-> (ShaderAttributeDataType
    -> ShaderAttributeDataType -> [ShaderAttributeDataType])
-> (ShaderAttributeDataType
    -> ShaderAttributeDataType -> [ShaderAttributeDataType])
-> (ShaderAttributeDataType
    -> ShaderAttributeDataType
    -> ShaderAttributeDataType
    -> [ShaderAttributeDataType])
-> Enum ShaderAttributeDataType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ShaderAttributeDataType -> ShaderAttributeDataType
succ :: ShaderAttributeDataType -> ShaderAttributeDataType
$cpred :: ShaderAttributeDataType -> ShaderAttributeDataType
pred :: ShaderAttributeDataType -> ShaderAttributeDataType
$ctoEnum :: Int -> ShaderAttributeDataType
toEnum :: Int -> ShaderAttributeDataType
$cfromEnum :: ShaderAttributeDataType -> Int
fromEnum :: ShaderAttributeDataType -> Int
$cenumFrom :: ShaderAttributeDataType -> [ShaderAttributeDataType]
enumFrom :: ShaderAttributeDataType -> [ShaderAttributeDataType]
$cenumFromThen :: ShaderAttributeDataType
-> ShaderAttributeDataType -> [ShaderAttributeDataType]
enumFromThen :: ShaderAttributeDataType
-> ShaderAttributeDataType -> [ShaderAttributeDataType]
$cenumFromTo :: ShaderAttributeDataType
-> ShaderAttributeDataType -> [ShaderAttributeDataType]
enumFromTo :: ShaderAttributeDataType
-> ShaderAttributeDataType -> [ShaderAttributeDataType]
$cenumFromThenTo :: ShaderAttributeDataType
-> ShaderAttributeDataType
-> ShaderAttributeDataType
-> [ShaderAttributeDataType]
enumFromThenTo :: ShaderAttributeDataType
-> ShaderAttributeDataType
-> ShaderAttributeDataType
-> [ShaderAttributeDataType]
Enum)

---------------------------------------
-- models structures ------------------
---------------------------------------

data Mesh = Mesh
  { Mesh -> Int
mesh'vertexCount :: Int,
    Mesh -> Int
mesh'triangleCount :: Int,
    Mesh -> [Vector3]
mesh'vertices :: [Vector3],
    Mesh -> [Vector2]
mesh'texcoords :: [Vector2],
    Mesh -> Maybe [Vector2]
mesh'texcoords2 :: Maybe [Vector2],
    Mesh -> [Vector3]
mesh'normals :: [Vector3],
    Mesh -> Maybe [Vector4]
mesh'tangents :: Maybe [Vector4],
    Mesh -> Maybe [Color]
mesh'colors :: Maybe [Color],
    Mesh -> Maybe [Word16]
mesh'indices :: Maybe [Word16],
    Mesh -> Maybe [Vector3]
mesh'animVertices :: Maybe [Vector3],
    Mesh -> Maybe [Vector3]
mesh'animNormals :: Maybe [Vector3],
    Mesh -> Maybe [Word8]
mesh'boneIds :: Maybe [Word8],
    Mesh -> Maybe [Float]
mesh'boneWeights :: Maybe [Float],
    Mesh -> Integer
mesh'vaoId :: Integer,
    Mesh -> Maybe [Integer]
mesh'vboId :: Maybe [Integer]
  }
  deriving (Mesh -> Mesh -> Bool
(Mesh -> Mesh -> Bool) -> (Mesh -> Mesh -> Bool) -> Eq Mesh
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Mesh -> Mesh -> Bool
== :: Mesh -> Mesh -> Bool
$c/= :: Mesh -> Mesh -> Bool
/= :: Mesh -> Mesh -> Bool
Eq, Int -> Mesh -> ShowS
[Mesh] -> ShowS
Mesh -> String
(Int -> Mesh -> ShowS)
-> (Mesh -> String) -> ([Mesh] -> ShowS) -> Show Mesh
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Mesh -> ShowS
showsPrec :: Int -> Mesh -> ShowS
$cshow :: Mesh -> String
show :: Mesh -> String
$cshowList :: [Mesh] -> ShowS
showList :: [Mesh] -> ShowS
Show)

instance Storable Mesh where
  sizeOf :: Mesh -> Int
sizeOf Mesh
_ = Int
112
  alignment :: Mesh -> Int
alignment Mesh
_ = Int
8
  peek :: Ptr Mesh -> IO Mesh
peek Ptr Mesh
_p = do
    Int
vertexCount <- CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Int) -> IO CInt -> IO Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr CInt
p'mesh'vertexCount Ptr Mesh
_p)
    Int
triangleCount <- CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Int) -> IO CInt -> IO Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr CInt
p'mesh'triangleCount Ptr Mesh
_p)
    [Vector3]
vertices <- Int -> Ptr Vector3 -> IO [Vector3]
forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
vertexCount (Ptr Vector3 -> IO [Vector3]) -> IO (Ptr Vector3) -> IO [Vector3]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr Vector3) -> IO (Ptr Vector3)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'vertices Ptr Mesh
_p)
    [Vector2]
texcoords <- Int -> Ptr Vector2 -> IO [Vector2]
forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
vertexCount (Ptr Vector2 -> IO [Vector2]) -> IO (Ptr Vector2) -> IO [Vector2]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr Vector2) -> IO (Ptr Vector2)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr Vector2)
p'mesh'texcoords Ptr Mesh
_p)
    Maybe [Vector2]
texcoords2 <- Int -> Ptr Vector2 -> IO (Maybe [Vector2])
forall a. Storable a => Int -> Ptr a -> IO (Maybe [a])
peekMaybeArray Int
vertexCount (Ptr Vector2 -> IO (Maybe [Vector2]))
-> IO (Ptr Vector2) -> IO (Maybe [Vector2])
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr Vector2) -> IO (Ptr Vector2)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr Vector2)
p'mesh'texcoords2 Ptr Mesh
_p)
    [Vector3]
normals <- Int -> Ptr Vector3 -> IO [Vector3]
forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
vertexCount (Ptr Vector3 -> IO [Vector3]) -> IO (Ptr Vector3) -> IO [Vector3]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr Vector3) -> IO (Ptr Vector3)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'normals Ptr Mesh
_p)
    Maybe [Vector4]
tangents <- Int -> Ptr Vector4 -> IO (Maybe [Vector4])
forall a. Storable a => Int -> Ptr a -> IO (Maybe [a])
peekMaybeArray Int
vertexCount (Ptr Vector4 -> IO (Maybe [Vector4]))
-> IO (Ptr Vector4) -> IO (Maybe [Vector4])
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr Vector4) -> IO (Ptr Vector4)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr Vector4)
p'mesh'tangents Ptr Mesh
_p)
    Maybe [Color]
colors <- Int -> Ptr Color -> IO (Maybe [Color])
forall a. Storable a => Int -> Ptr a -> IO (Maybe [a])
peekMaybeArray Int
vertexCount (Ptr Color -> IO (Maybe [Color]))
-> IO (Ptr Color) -> IO (Maybe [Color])
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr Color) -> IO (Ptr Color)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr Color)
p'mesh'colors Ptr Mesh
_p)
    Maybe [Word16]
indices <- ((CUShort -> Word16) -> [CUShort] -> [Word16]
forall a b. (a -> b) -> [a] -> [b]
map CUShort -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([CUShort] -> [Word16]) -> Maybe [CUShort] -> Maybe [Word16]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) (Maybe [CUShort] -> Maybe [Word16])
-> IO (Maybe [CUShort]) -> IO (Maybe [Word16])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> Ptr CUShort -> IO (Maybe [CUShort])
forall a. Storable a => Int -> Ptr a -> IO (Maybe [a])
peekMaybeArray Int
vertexCount (Ptr CUShort -> IO (Maybe [CUShort]))
-> IO (Ptr CUShort) -> IO (Maybe [CUShort])
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr CUShort) -> IO (Ptr CUShort)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr CUShort)
p'mesh'indices Ptr Mesh
_p))
    Maybe [Vector3]
animVertices <- Int -> Ptr Vector3 -> IO (Maybe [Vector3])
forall a. Storable a => Int -> Ptr a -> IO (Maybe [a])
peekMaybeArray Int
vertexCount (Ptr Vector3 -> IO (Maybe [Vector3]))
-> IO (Ptr Vector3) -> IO (Maybe [Vector3])
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr Vector3) -> IO (Ptr Vector3)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'animVertices Ptr Mesh
_p)
    Maybe [Vector3]
animNormals <- Int -> Ptr Vector3 -> IO (Maybe [Vector3])
forall a. Storable a => Int -> Ptr a -> IO (Maybe [a])
peekMaybeArray Int
vertexCount (Ptr Vector3 -> IO (Maybe [Vector3]))
-> IO (Ptr Vector3) -> IO (Maybe [Vector3])
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr Vector3) -> IO (Ptr Vector3)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'animNormals Ptr Mesh
_p)
    Maybe [Word8]
boneIds <- ((CUChar -> Word8) -> [CUChar] -> [Word8]
forall a b. (a -> b) -> [a] -> [b]
map CUChar -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([CUChar] -> [Word8]) -> Maybe [CUChar] -> Maybe [Word8]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) (Maybe [CUChar] -> Maybe [Word8])
-> IO (Maybe [CUChar]) -> IO (Maybe [Word8])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> Ptr CUChar -> IO (Maybe [CUChar])
forall a. Storable a => Int -> Ptr a -> IO (Maybe [a])
peekMaybeArray (Int
vertexCount Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
4) (Ptr CUChar -> IO (Maybe [CUChar]))
-> IO (Ptr CUChar) -> IO (Maybe [CUChar])
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr CUChar) -> IO (Ptr CUChar)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr CUChar)
p'mesh'boneIds Ptr Mesh
_p))
    Maybe [Float]
boneWeights <- ((CFloat -> Float) -> [CFloat] -> [Float]
forall a b. (a -> b) -> [a] -> [b]
map CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac ([CFloat] -> [Float]) -> Maybe [CFloat] -> Maybe [Float]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) (Maybe [CFloat] -> Maybe [Float])
-> IO (Maybe [CFloat]) -> IO (Maybe [Float])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> Ptr CFloat -> IO (Maybe [CFloat])
forall a. Storable a => Int -> Ptr a -> IO (Maybe [a])
peekMaybeArray (Int
vertexCount Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
4) (Ptr CFloat -> IO (Maybe [CFloat]))
-> IO (Ptr CFloat) -> IO (Maybe [CFloat])
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr CFloat) -> IO (Ptr CFloat)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr CFloat)
p'mesh'boneWeights Ptr Mesh
_p))
    Integer
vaoId <- CUInt -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CUInt -> Integer) -> IO CUInt -> IO Integer
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr CUInt
p'mesh'vaoId Ptr Mesh
_p)
    Maybe [Integer]
vboId <- ((CUInt -> Integer) -> [CUInt] -> [Integer]
forall a b. (a -> b) -> [a] -> [b]
map CUInt -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([CUInt] -> [Integer]) -> Maybe [CUInt] -> Maybe [Integer]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) (Maybe [CUInt] -> Maybe [Integer])
-> IO (Maybe [CUInt]) -> IO (Maybe [Integer])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> Ptr CUInt -> IO (Maybe [CUInt])
forall a. Storable a => Int -> Ptr a -> IO (Maybe [a])
peekMaybeArray Int
7 (Ptr CUInt -> IO (Maybe [CUInt]))
-> IO (Ptr CUInt) -> IO (Maybe [CUInt])
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr CUInt) -> IO (Ptr CUInt)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr CUInt)
p'mesh'vboId Ptr Mesh
_p))
    Mesh -> IO Mesh
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Mesh -> IO Mesh) -> Mesh -> IO Mesh
forall a b. (a -> b) -> a -> b
$ Int
-> Int
-> [Vector3]
-> [Vector2]
-> Maybe [Vector2]
-> [Vector3]
-> Maybe [Vector4]
-> Maybe [Color]
-> Maybe [Word16]
-> Maybe [Vector3]
-> Maybe [Vector3]
-> Maybe [Word8]
-> Maybe [Float]
-> Integer
-> Maybe [Integer]
-> Mesh
Mesh Int
vertexCount Int
triangleCount [Vector3]
vertices [Vector2]
texcoords Maybe [Vector2]
texcoords2 [Vector3]
normals Maybe [Vector4]
tangents Maybe [Color]
colors Maybe [Word16]
indices Maybe [Vector3]
animVertices Maybe [Vector3]
animNormals Maybe [Word8]
boneIds Maybe [Float]
boneWeights Integer
vaoId Maybe [Integer]
vboId
  poke :: Ptr Mesh -> Mesh -> IO ()
poke Ptr Mesh
_p (Mesh Int
vertexCount Int
triangleCount [Vector3]
vertices [Vector2]
texcoords Maybe [Vector2]
texcoords2 [Vector3]
normals Maybe [Vector4]
tangents Maybe [Color]
colors Maybe [Word16]
indices Maybe [Vector3]
animVertices Maybe [Vector3]
animNormals Maybe [Word8]
boneIds Maybe [Float]
boneWeights Integer
vaoId Maybe [Integer]
vboId) = do
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Mesh -> Ptr CInt
p'mesh'vertexCount Ptr Mesh
_p) (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
vertexCount)
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Mesh -> Ptr CInt
p'mesh'triangleCount Ptr Mesh
_p) (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
triangleCount)
    Ptr (Ptr Vector3) -> Ptr Vector3 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'vertices Ptr Mesh
_p) (Ptr Vector3 -> IO ()) -> IO (Ptr Vector3) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [Vector3] -> IO (Ptr Vector3)
forall a. Storable a => [a] -> IO (Ptr a)
newArray [Vector3]
vertices
    Ptr (Ptr Vector2) -> Ptr Vector2 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Mesh -> Ptr (Ptr Vector2)
p'mesh'texcoords Ptr Mesh
_p) (Ptr Vector2 -> IO ()) -> IO (Ptr Vector2) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [Vector2] -> IO (Ptr Vector2)
forall a. Storable a => [a] -> IO (Ptr a)
newArray [Vector2]
texcoords
    Ptr (Ptr Vector2) -> Ptr Vector2 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Mesh -> Ptr (Ptr Vector2)
p'mesh'texcoords2 Ptr Mesh
_p) (Ptr Vector2 -> IO ()) -> IO (Ptr Vector2) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe [Vector2] -> IO (Ptr Vector2)
forall a. Storable a => Maybe [a] -> IO (Ptr a)
newMaybeArray Maybe [Vector2]
texcoords2
    Ptr (Ptr Vector3) -> Ptr Vector3 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'normals Ptr Mesh
_p) (Ptr Vector3 -> IO ()) -> IO (Ptr Vector3) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [Vector3] -> IO (Ptr Vector3)
forall a. Storable a => [a] -> IO (Ptr a)
newArray [Vector3]
normals
    Ptr (Ptr Vector4) -> Ptr Vector4 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Mesh -> Ptr (Ptr Vector4)
p'mesh'tangents Ptr Mesh
_p) (Ptr Vector4 -> IO ()) -> IO (Ptr Vector4) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe [Vector4] -> IO (Ptr Vector4)
forall a. Storable a => Maybe [a] -> IO (Ptr a)
newMaybeArray Maybe [Vector4]
tangents
    Ptr (Ptr Color) -> Ptr Color -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Mesh -> Ptr (Ptr Color)
p'mesh'colors Ptr Mesh
_p) (Ptr Color -> IO ()) -> IO (Ptr Color) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe [Color] -> IO (Ptr Color)
forall a. Storable a => Maybe [a] -> IO (Ptr a)
newMaybeArray Maybe [Color]
colors
    Ptr (Ptr CUShort) -> Ptr CUShort -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Mesh -> Ptr (Ptr CUShort)
p'mesh'indices Ptr Mesh
_p) (Ptr CUShort -> IO ()) -> IO (Ptr CUShort) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe [CUShort] -> IO (Ptr CUShort)
forall a. Storable a => Maybe [a] -> IO (Ptr a)
newMaybeArray ((Word16 -> CUShort) -> [Word16] -> [CUShort]
forall a b. (a -> b) -> [a] -> [b]
map Word16 -> CUShort
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Word16] -> [CUShort]) -> Maybe [Word16] -> Maybe [CUShort]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe [Word16]
indices)
    Ptr (Ptr Vector3) -> Ptr Vector3 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'animVertices Ptr Mesh
_p) (Ptr Vector3 -> IO ()) -> IO (Ptr Vector3) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe [Vector3] -> IO (Ptr Vector3)
forall a. Storable a => Maybe [a] -> IO (Ptr a)
newMaybeArray Maybe [Vector3]
animVertices
    Ptr (Ptr Vector3) -> Ptr Vector3 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'animNormals Ptr Mesh
_p) (Ptr Vector3 -> IO ()) -> IO (Ptr Vector3) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe [Vector3] -> IO (Ptr Vector3)
forall a. Storable a => Maybe [a] -> IO (Ptr a)
newMaybeArray Maybe [Vector3]
animNormals
    Ptr (Ptr CUChar) -> Ptr CUChar -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Mesh -> Ptr (Ptr CUChar)
p'mesh'boneIds Ptr Mesh
_p) (Ptr CUChar -> IO ()) -> IO (Ptr CUChar) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe [CUChar] -> IO (Ptr CUChar)
forall a. Storable a => Maybe [a] -> IO (Ptr a)
newMaybeArray ((Word8 -> CUChar) -> [Word8] -> [CUChar]
forall a b. (a -> b) -> [a] -> [b]
map Word8 -> CUChar
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Word8] -> [CUChar]) -> Maybe [Word8] -> Maybe [CUChar]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe [Word8]
boneIds)
    Ptr (Ptr CFloat) -> Ptr CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Mesh -> Ptr (Ptr CFloat)
p'mesh'boneWeights Ptr Mesh
_p) (Ptr CFloat -> IO ()) -> IO (Ptr CFloat) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe [CFloat] -> IO (Ptr CFloat)
forall a. Storable a => Maybe [a] -> IO (Ptr a)
newMaybeArray ((Float -> CFloat) -> [Float] -> [CFloat]
forall a b. (a -> b) -> [a] -> [b]
map Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac ([Float] -> [CFloat]) -> Maybe [Float] -> Maybe [CFloat]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe [Float]
boneWeights)
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Mesh -> Ptr CUInt
p'mesh'vaoId Ptr Mesh
_p) (Integer -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
vaoId)
    Ptr (Ptr CUInt) -> Ptr CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Mesh -> Ptr (Ptr CUInt)
p'mesh'vboId Ptr Mesh
_p) (Ptr CUInt -> IO ()) -> IO (Ptr CUInt) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe [CUInt] -> IO (Ptr CUInt)
forall a. Storable a => Maybe [a] -> IO (Ptr a)
newMaybeArray ((Integer -> CUInt) -> [Integer] -> [CUInt]
forall a b. (a -> b) -> [a] -> [b]
map Integer -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Integer] -> [CUInt]) -> Maybe [Integer] -> Maybe [CUInt]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe [Integer]
vboId)
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

p'mesh'vertexCount :: Ptr Mesh -> Ptr CInt
p'mesh'vertexCount :: Ptr Mesh -> Ptr CInt
p'mesh'vertexCount = (Ptr Mesh -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0)

p'mesh'triangleCount :: Ptr Mesh -> Ptr CInt
p'mesh'triangleCount :: Ptr Mesh -> Ptr CInt
p'mesh'triangleCount = (Ptr Mesh -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4)

-- array (mesh'vertexCount)
p'mesh'vertices :: Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'vertices :: Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'vertices = (Ptr Mesh -> Int -> Ptr (Ptr Vector3)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8)

-- array (mesh'vertexCount)
p'mesh'texcoords :: Ptr Mesh -> Ptr (Ptr Vector2)
p'mesh'texcoords :: Ptr Mesh -> Ptr (Ptr Vector2)
p'mesh'texcoords = (Ptr Mesh -> Int -> Ptr (Ptr Vector2)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16)

-- maybe array (mesh'vertexCount)
p'mesh'texcoords2 :: Ptr Mesh -> Ptr (Ptr Vector2)
p'mesh'texcoords2 :: Ptr Mesh -> Ptr (Ptr Vector2)
p'mesh'texcoords2 = (Ptr Mesh -> Int -> Ptr (Ptr Vector2)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24)

-- array (mesh'vertexCount)
p'mesh'normals :: Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'normals :: Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'normals = (Ptr Mesh -> Int -> Ptr (Ptr Vector3)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32)

-- maybe array (mesh'vertexCount)
p'mesh'tangents :: Ptr Mesh -> Ptr (Ptr Vector4)
p'mesh'tangents :: Ptr Mesh -> Ptr (Ptr Vector4)
p'mesh'tangents = (Ptr Mesh -> Int -> Ptr (Ptr Vector4)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40)

-- maybe array (mesh'vertexCount)
p'mesh'colors :: Ptr Mesh -> Ptr (Ptr Color)
p'mesh'colors :: Ptr Mesh -> Ptr (Ptr Color)
p'mesh'colors = (Ptr Mesh -> Int -> Ptr (Ptr Color)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48)

-- maybe array (mesh'vertexCount)
p'mesh'indices :: Ptr Mesh -> Ptr (Ptr CUShort)
p'mesh'indices :: Ptr Mesh -> Ptr (Ptr CUShort)
p'mesh'indices = (Ptr Mesh -> Int -> Ptr (Ptr CUShort)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56)

-- maybe array (mesh'vertexCount)
p'mesh'animVertices :: Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'animVertices :: Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'animVertices = (Ptr Mesh -> Int -> Ptr (Ptr Vector3)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64)

-- maybe array (mesh'vertexCount)
p'mesh'animNormals :: Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'animNormals :: Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'animNormals = (Ptr Mesh -> Int -> Ptr (Ptr Vector3)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72)

-- maybe array (mesh'vertexCount * 4)
p'mesh'boneIds :: Ptr Mesh -> Ptr (Ptr CUChar)
p'mesh'boneIds :: Ptr Mesh -> Ptr (Ptr CUChar)
p'mesh'boneIds = (Ptr Mesh -> Int -> Ptr (Ptr CUChar)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
80)

-- maybe array (mesh'vertexCount * 4)
p'mesh'boneWeights :: Ptr Mesh -> Ptr (Ptr CFloat)
p'mesh'boneWeights :: Ptr Mesh -> Ptr (Ptr CFloat)
p'mesh'boneWeights = (Ptr Mesh -> Int -> Ptr (Ptr CFloat)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
88)

p'mesh'vaoId :: Ptr Mesh -> Ptr CUInt
p'mesh'vaoId :: Ptr Mesh -> Ptr CUInt
p'mesh'vaoId = (Ptr Mesh -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
96)

-- maybe array (7)
p'mesh'vboId :: Ptr Mesh -> Ptr (Ptr CUInt)
p'mesh'vboId :: Ptr Mesh -> Ptr (Ptr CUInt)
p'mesh'vboId = (Ptr Mesh -> Int -> Ptr (Ptr CUInt)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
104)

instance Freeable Mesh where
  rlFreeDependents :: Mesh -> Ptr Mesh -> IO ()
rlFreeDependents Mesh
_ Ptr Mesh
ptr = do
    Ptr Vector3
verticesPtr <- Ptr (Ptr Vector3) -> IO (Ptr Vector3)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'vertices Ptr Mesh
ptr)
    Ptr () -> IO ()
c'free (Ptr () -> IO ()) -> Ptr () -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr Vector3 -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr Ptr Vector3
verticesPtr
    Ptr Vector2
texcoordsPtr <- Ptr (Ptr Vector2) -> IO (Ptr Vector2)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr Vector2)
p'mesh'texcoords Ptr Mesh
ptr)
    Ptr () -> IO ()
c'free (Ptr () -> IO ()) -> Ptr () -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr Vector2 -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr Ptr Vector2
texcoordsPtr
    Ptr Vector2
texcoords2Ptr <- Ptr (Ptr Vector2) -> IO (Ptr Vector2)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr Vector2)
p'mesh'texcoords2 Ptr Mesh
ptr)
    Ptr () -> IO ()
freeMaybePtr (Ptr () -> IO ()) -> Ptr () -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr Vector2 -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr Ptr Vector2
texcoords2Ptr
    Ptr Vector3
normalsPtr <- Ptr (Ptr Vector3) -> IO (Ptr Vector3)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'normals Ptr Mesh
ptr)
    Ptr () -> IO ()
c'free (Ptr () -> IO ()) -> Ptr () -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr Vector3 -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr Ptr Vector3
normalsPtr
    Ptr Vector4
tangentsPtr <- Ptr (Ptr Vector4) -> IO (Ptr Vector4)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr Vector4)
p'mesh'tangents Ptr Mesh
ptr)
    Ptr () -> IO ()
freeMaybePtr (Ptr () -> IO ()) -> Ptr () -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr Vector4 -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr Ptr Vector4
tangentsPtr
    Ptr Color
colorsPtr <- Ptr (Ptr Color) -> IO (Ptr Color)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr Color)
p'mesh'colors Ptr Mesh
ptr)
    Ptr () -> IO ()
freeMaybePtr (Ptr () -> IO ()) -> Ptr () -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr Color -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr Ptr Color
colorsPtr
    Ptr CUShort
indicesPtr <- Ptr (Ptr CUShort) -> IO (Ptr CUShort)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr CUShort)
p'mesh'indices Ptr Mesh
ptr)
    Ptr () -> IO ()
freeMaybePtr (Ptr () -> IO ()) -> Ptr () -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CUShort -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr Ptr CUShort
indicesPtr
    Ptr Vector3
animVerticesPtr <- Ptr (Ptr Vector3) -> IO (Ptr Vector3)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'animVertices Ptr Mesh
ptr)
    Ptr () -> IO ()
freeMaybePtr (Ptr () -> IO ()) -> Ptr () -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr Vector3 -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr Ptr Vector3
animVerticesPtr
    Ptr Vector3
animNormalsPtr <- Ptr (Ptr Vector3) -> IO (Ptr Vector3)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr Vector3)
p'mesh'animNormals Ptr Mesh
ptr)
    Ptr () -> IO ()
freeMaybePtr (Ptr () -> IO ()) -> Ptr () -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr Vector3 -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr Ptr Vector3
animNormalsPtr
    Ptr CUChar
boneIdsPtr <- Ptr (Ptr CUChar) -> IO (Ptr CUChar)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr CUChar)
p'mesh'boneIds Ptr Mesh
ptr)
    Ptr () -> IO ()
freeMaybePtr (Ptr () -> IO ()) -> Ptr () -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CUChar -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr Ptr CUChar
boneIdsPtr
    Ptr CFloat
boneWeightsPtr <- Ptr (Ptr CFloat) -> IO (Ptr CFloat)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr CFloat)
p'mesh'boneWeights Ptr Mesh
ptr)
    Ptr () -> IO ()
freeMaybePtr (Ptr () -> IO ()) -> Ptr () -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CFloat -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr Ptr CFloat
boneWeightsPtr
    Ptr CUInt
vboIdPtr <- Ptr (Ptr CUInt) -> IO (Ptr CUInt)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Mesh -> Ptr (Ptr CUInt)
p'mesh'vboId Ptr Mesh
ptr)
    Ptr () -> IO ()
c'free (Ptr () -> IO ()) -> Ptr () -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CUInt -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr Ptr CUInt
vboIdPtr

data Shader = Shader
  { Shader -> Integer
shader'id :: Integer,
    Shader -> [Int]
shader'locs :: [Int]
  }
  deriving (Shader -> Shader -> Bool
(Shader -> Shader -> Bool)
-> (Shader -> Shader -> Bool) -> Eq Shader
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Shader -> Shader -> Bool
== :: Shader -> Shader -> Bool
$c/= :: Shader -> Shader -> Bool
/= :: Shader -> Shader -> Bool
Eq, Int -> Shader -> ShowS
[Shader] -> ShowS
Shader -> String
(Int -> Shader -> ShowS)
-> (Shader -> String) -> ([Shader] -> ShowS) -> Show Shader
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Shader -> ShowS
showsPrec :: Int -> Shader -> ShowS
$cshow :: Shader -> String
show :: Shader -> String
$cshowList :: [Shader] -> ShowS
showList :: [Shader] -> ShowS
Show)

instance Storable Shader where
  sizeOf :: Shader -> Int
sizeOf Shader
_ = Int
16
  alignment :: Shader -> Int
alignment Shader
_ = Int
8
  peek :: Ptr Shader -> IO Shader
peek Ptr Shader
_p = do
    Integer
sId <- CUInt -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CUInt -> Integer) -> IO CUInt -> IO Integer
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr Shader -> Ptr CUInt
p'shader'id Ptr Shader
_p)
    [Int]
locs <- (CInt -> Int) -> [CInt] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([CInt] -> [Int]) -> IO [CInt] -> IO [Int]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> Ptr CInt -> IO [CInt]
forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
32 (Ptr CInt -> IO [CInt]) -> IO (Ptr CInt) -> IO [CInt]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr CInt) -> IO (Ptr CInt)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Shader -> Ptr (Ptr CInt)
p'shader'locs Ptr Shader
_p))
    Shader -> IO Shader
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Shader -> IO Shader) -> Shader -> IO Shader
forall a b. (a -> b) -> a -> b
$ Integer -> [Int] -> Shader
Shader Integer
sId [Int]
locs
  poke :: Ptr Shader -> Shader -> IO ()
poke Ptr Shader
_p (Shader Integer
sId [Int]
locs) = do
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Shader -> Ptr CUInt
p'shader'id Ptr Shader
_p) (Integer -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
sId)
    CUInt
defaultShaderId <- IO CUInt
c'rlGetShaderIdDefault
    Ptr CInt
locsArr <- [CInt] -> IO (Ptr CInt)
forall a. Storable a => [a] -> IO (Ptr a)
newArray ((Int -> CInt) -> [Int] -> [CInt]
forall a b. (a -> b) -> [a] -> [b]
map Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral [Int]
locs)
    if Integer
sId Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== CUInt -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral CUInt
defaultShaderId
      then do
        ForeignPtr CInt
locsPtr <- FinalizerPtr CInt -> Ptr CInt -> IO (ForeignPtr CInt)
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr CInt
forall a. FunPtr (Ptr a -> IO ())
p'free Ptr CInt
locsArr
        ForeignPtr CInt -> (Ptr CInt -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr CInt
locsPtr ((Ptr CInt -> IO ()) -> IO ()) -> (Ptr CInt -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr CInt) -> Ptr CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Shader -> Ptr (Ptr CInt)
p'shader'locs Ptr Shader
_p)
      else Ptr (Ptr CInt) -> Ptr CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Shader -> Ptr (Ptr CInt)
p'shader'locs Ptr Shader
_p) Ptr CInt
locsArr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

p'shader'id :: Ptr Shader -> Ptr CUInt
p'shader'id :: Ptr Shader -> Ptr CUInt
p'shader'id = (Ptr Shader -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0)

-- array (32)
p'shader'locs :: Ptr Shader -> Ptr (Ptr CInt)
p'shader'locs :: Ptr Shader -> Ptr (Ptr CInt)
p'shader'locs = (Ptr Shader -> Int -> Ptr (Ptr CInt)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8)

instance Freeable Shader where
  rlFreeDependents :: Shader -> Ptr Shader -> IO ()
rlFreeDependents Shader
val Ptr Shader
ptr = do
    CUInt
defaultShaderId <- IO CUInt
c'rlGetShaderIdDefault
    Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless
      (Shader -> Integer
shader'id Shader
val Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== CUInt -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral CUInt
defaultShaderId)
      ( do
          Ptr CInt
locsPtr <- Ptr (Ptr CInt) -> IO (Ptr CInt)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Shader -> Ptr (Ptr CInt)
p'shader'locs Ptr Shader
ptr)
          Ptr () -> IO ()
c'free (Ptr () -> IO ()) -> Ptr () -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CInt -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr Ptr CInt
locsPtr
      )

data MaterialMap = MaterialMap
  { MaterialMap -> Texture
materialMap'texture :: Texture,
    MaterialMap -> Color
materialMap'color :: Color,
    MaterialMap -> Float
materialMap'value :: Float
  }
  deriving (MaterialMap -> MaterialMap -> Bool
(MaterialMap -> MaterialMap -> Bool)
-> (MaterialMap -> MaterialMap -> Bool) -> Eq MaterialMap
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MaterialMap -> MaterialMap -> Bool
== :: MaterialMap -> MaterialMap -> Bool
$c/= :: MaterialMap -> MaterialMap -> Bool
/= :: MaterialMap -> MaterialMap -> Bool
Eq, Int -> MaterialMap -> ShowS
[MaterialMap] -> ShowS
MaterialMap -> String
(Int -> MaterialMap -> ShowS)
-> (MaterialMap -> String)
-> ([MaterialMap] -> ShowS)
-> Show MaterialMap
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MaterialMap -> ShowS
showsPrec :: Int -> MaterialMap -> ShowS
$cshow :: MaterialMap -> String
show :: MaterialMap -> String
$cshowList :: [MaterialMap] -> ShowS
showList :: [MaterialMap] -> ShowS
Show, MaterialMap -> Ptr MaterialMap -> IO ()
(MaterialMap -> Ptr MaterialMap -> IO ())
-> (MaterialMap -> Ptr MaterialMap -> IO ())
-> Freeable MaterialMap
forall a.
(a -> Ptr a -> IO ()) -> (a -> Ptr a -> IO ()) -> Freeable a
$crlFreeDependents :: MaterialMap -> Ptr MaterialMap -> IO ()
rlFreeDependents :: MaterialMap -> Ptr MaterialMap -> IO ()
$crlFree :: MaterialMap -> Ptr MaterialMap -> IO ()
rlFree :: MaterialMap -> Ptr MaterialMap -> IO ()
Freeable)

instance Storable MaterialMap where
  sizeOf :: MaterialMap -> Int
sizeOf MaterialMap
_ = Int
28
  alignment :: MaterialMap -> Int
alignment MaterialMap
_ = Int
4
  peek :: Ptr MaterialMap -> IO MaterialMap
peek Ptr MaterialMap
_p = do
    Texture
texture <- Ptr Texture -> IO Texture
forall a. Storable a => Ptr a -> IO a
peek (Ptr MaterialMap -> Ptr Texture
p'materialMap'texture Ptr MaterialMap
_p)
    Color
color <- Ptr Color -> IO Color
forall a. Storable a => Ptr a -> IO a
peek (Ptr MaterialMap -> Ptr Color
p'materialMap'color Ptr MaterialMap
_p)
    Float
value <- CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac (CFloat -> Float) -> IO CFloat -> IO Float
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr MaterialMap -> Ptr CFloat
p'materialMap'value Ptr MaterialMap
_p)
    MaterialMap -> IO MaterialMap
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (MaterialMap -> IO MaterialMap) -> MaterialMap -> IO MaterialMap
forall a b. (a -> b) -> a -> b
$ Texture -> Color -> Float -> MaterialMap
MaterialMap Texture
texture Color
color Float
value
  poke :: Ptr MaterialMap -> MaterialMap -> IO ()
poke Ptr MaterialMap
_p (MaterialMap Texture
texture Color
color Float
value) = do
    Ptr Texture -> Texture -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr MaterialMap -> Ptr Texture
p'materialMap'texture Ptr MaterialMap
_p) Texture
texture
    Ptr Color -> Color -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr MaterialMap -> Ptr Color
p'materialMap'color Ptr MaterialMap
_p) Color
color
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr MaterialMap -> Ptr CFloat
p'materialMap'value Ptr MaterialMap
_p) (Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
value)
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

p'materialMap'texture :: Ptr MaterialMap -> Ptr Texture
p'materialMap'texture :: Ptr MaterialMap -> Ptr Texture
p'materialMap'texture = (Ptr MaterialMap -> Int -> Ptr Texture
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0)

p'materialMap'color :: Ptr MaterialMap -> Ptr Color
p'materialMap'color :: Ptr MaterialMap -> Ptr Color
p'materialMap'color = (Ptr MaterialMap -> Int -> Ptr Color
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20)

p'materialMap'value :: Ptr MaterialMap -> Ptr CFloat
p'materialMap'value :: Ptr MaterialMap -> Ptr CFloat
p'materialMap'value = (Ptr MaterialMap -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24)

data Material = Material
  { Material -> Shader
material'shader :: Shader,
    Material -> Maybe [MaterialMap]
material'maps :: Maybe [MaterialMap],
    Material -> [Float]
material'params :: [Float]
  }
  deriving (Material -> Material -> Bool
(Material -> Material -> Bool)
-> (Material -> Material -> Bool) -> Eq Material
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Material -> Material -> Bool
== :: Material -> Material -> Bool
$c/= :: Material -> Material -> Bool
/= :: Material -> Material -> Bool
Eq, Int -> Material -> ShowS
[Material] -> ShowS
Material -> String
(Int -> Material -> ShowS)
-> (Material -> String) -> ([Material] -> ShowS) -> Show Material
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Material -> ShowS
showsPrec :: Int -> Material -> ShowS
$cshow :: Material -> String
show :: Material -> String
$cshowList :: [Material] -> ShowS
showList :: [Material] -> ShowS
Show)

instance Storable Material where
  sizeOf :: Material -> Int
sizeOf Material
_ = Int
40
  alignment :: Material -> Int
alignment Material
_ = Int
8
  peek :: Ptr Material -> IO Material
peek Ptr Material
_p = do
    Shader
shader <- Ptr Shader -> IO Shader
forall a. Storable a => Ptr a -> IO a
peek (Ptr Material -> Ptr Shader
p'material'shader Ptr Material
_p)
    Maybe [MaterialMap]
maps <- Int -> Ptr MaterialMap -> IO (Maybe [MaterialMap])
forall a. Storable a => Int -> Ptr a -> IO (Maybe [a])
peekMaybeArray Int
12 (Ptr MaterialMap -> IO (Maybe [MaterialMap]))
-> IO (Ptr MaterialMap) -> IO (Maybe [MaterialMap])
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr MaterialMap) -> IO (Ptr MaterialMap)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Material -> Ptr (Ptr MaterialMap)
p'material'maps Ptr Material
_p)
    [Float]
params <- (CFloat -> Float) -> [CFloat] -> [Float]
forall a b. (a -> b) -> [a] -> [b]
map CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac ([CFloat] -> [Float]) -> IO [CFloat] -> IO [Float]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Ptr CFloat -> IO [CFloat]
forall a. Storable a => Int -> Ptr a -> IO [a]
peekStaticArray Int
4 (Ptr Material -> Ptr CFloat
p'material'params Ptr Material
_p)
    Material -> IO Material
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Material -> IO Material) -> Material -> IO Material
forall a b. (a -> b) -> a -> b
$ Shader -> Maybe [MaterialMap] -> [Float] -> Material
Material Shader
shader Maybe [MaterialMap]
maps [Float]
params
  poke :: Ptr Material -> Material -> IO ()
poke Ptr Material
_p (Material Shader
shader Maybe [MaterialMap]
maps [Float]
params) = do
    Ptr Shader -> Shader -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Material -> Ptr Shader
p'material'shader Ptr Material
_p) Shader
shader
    Ptr (Ptr MaterialMap) -> Ptr MaterialMap -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Material -> Ptr (Ptr MaterialMap)
p'material'maps Ptr Material
_p) (Ptr MaterialMap -> IO ()) -> IO (Ptr MaterialMap) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe [MaterialMap] -> IO (Ptr MaterialMap)
forall a. Storable a => Maybe [a] -> IO (Ptr a)
newMaybeArray Maybe [MaterialMap]
maps
    Ptr CFloat -> [CFloat] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeStaticArray (Ptr Material -> Ptr CFloat
p'material'params Ptr Material
_p) ((Float -> CFloat) -> [Float] -> [CFloat]
forall a b. (a -> b) -> [a] -> [b]
map Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac [Float]
params)
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

p'material'shader :: Ptr Material -> Ptr Shader
p'material'shader :: Ptr Material -> Ptr Shader
p'material'shader = (Ptr Material -> Int -> Ptr Shader
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0)

-- maybe array (12)
p'material'maps :: Ptr Material -> Ptr (Ptr MaterialMap)
p'material'maps :: Ptr Material -> Ptr (Ptr MaterialMap)
p'material'maps = (Ptr Material -> Int -> Ptr (Ptr MaterialMap)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16)

-- static array (4)
p'material'params :: Ptr Material -> Ptr CFloat
p'material'params :: Ptr Material -> Ptr CFloat
p'material'params = (Ptr Material -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24)

instance Freeable Material where
  rlFreeDependents :: Material -> Ptr Material -> IO ()
rlFreeDependents Material
val Ptr Material
ptr = do
    Shader -> Ptr Shader -> IO ()
forall a. Freeable a => a -> Ptr a -> IO ()
rlFreeDependents (Material -> Shader
material'shader Material
val) (Ptr Material -> Ptr Shader
forall a b. Ptr a -> Ptr b
castPtr Ptr Material
ptr :: Ptr Shader)
    Maybe [MaterialMap] -> Ptr MaterialMap -> IO ()
forall a. (Freeable a, Storable a) => Maybe [a] -> Ptr a -> IO ()
rlFreeMaybeArray (Material -> Maybe [MaterialMap]
material'maps Material
val) (Ptr MaterialMap -> IO ()) -> IO (Ptr MaterialMap) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr MaterialMap) -> IO (Ptr MaterialMap)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Material -> Ptr (Ptr MaterialMap)
p'material'maps Ptr Material
ptr)

data Transform = Transform
  { Transform -> Vector3
transform'translation :: Vector3,
    Transform -> Vector4
transform'rotation :: Quaternion,
    Transform -> Vector3
transform'scale :: Vector3
  }
  deriving (Transform -> Transform -> Bool
(Transform -> Transform -> Bool)
-> (Transform -> Transform -> Bool) -> Eq Transform
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Transform -> Transform -> Bool
== :: Transform -> Transform -> Bool
$c/= :: Transform -> Transform -> Bool
/= :: Transform -> Transform -> Bool
Eq, Int -> Transform -> ShowS
[Transform] -> ShowS
Transform -> String
(Int -> Transform -> ShowS)
-> (Transform -> String)
-> ([Transform] -> ShowS)
-> Show Transform
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Transform -> ShowS
showsPrec :: Int -> Transform -> ShowS
$cshow :: Transform -> String
show :: Transform -> String
$cshowList :: [Transform] -> ShowS
showList :: [Transform] -> ShowS
Show, Transform -> Ptr Transform -> IO ()
(Transform -> Ptr Transform -> IO ())
-> (Transform -> Ptr Transform -> IO ()) -> Freeable Transform
forall a.
(a -> Ptr a -> IO ()) -> (a -> Ptr a -> IO ()) -> Freeable a
$crlFreeDependents :: Transform -> Ptr Transform -> IO ()
rlFreeDependents :: Transform -> Ptr Transform -> IO ()
$crlFree :: Transform -> Ptr Transform -> IO ()
rlFree :: Transform -> Ptr Transform -> IO ()
Freeable)

instance Storable Transform where
  sizeOf :: Transform -> Int
sizeOf Transform
_ = Int
40
  alignment :: Transform -> Int
alignment Transform
_ = Int
4
  peek :: Ptr Transform -> IO Transform
peek Ptr Transform
_p = do
    Vector3
translation <- Ptr Vector3 -> IO Vector3
forall a. Storable a => Ptr a -> IO a
peek (Ptr Transform -> Ptr Vector3
p'transform'translation Ptr Transform
_p)
    Vector4
rotation <- Ptr Vector4 -> IO Vector4
forall a. Storable a => Ptr a -> IO a
peek (Ptr Transform -> Ptr Vector4
p'transform'rotation Ptr Transform
_p)
    Vector3
scale <- Ptr Vector3 -> IO Vector3
forall a. Storable a => Ptr a -> IO a
peek (Ptr Transform -> Ptr Vector3
p'transform'scale Ptr Transform
_p)
    Transform -> IO Transform
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Transform -> IO Transform) -> Transform -> IO Transform
forall a b. (a -> b) -> a -> b
$ Vector3 -> Vector4 -> Vector3 -> Transform
Transform Vector3
translation Vector4
rotation Vector3
scale
  poke :: Ptr Transform -> Transform -> IO ()
poke Ptr Transform
_p (Transform Vector3
translation Vector4
rotation Vector3
scale) = do
    Ptr Vector3 -> Vector3 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Transform -> Ptr Vector3
p'transform'translation Ptr Transform
_p) Vector3
translation
    Ptr Vector4 -> Vector4 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Transform -> Ptr Vector4
p'transform'rotation Ptr Transform
_p) Vector4
rotation
    Ptr Vector3 -> Vector3 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Transform -> Ptr Vector3
p'transform'scale Ptr Transform
_p) Vector3
scale
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

p'transform'translation :: Ptr Transform -> Ptr Vector3
p'transform'translation :: Ptr Transform -> Ptr Vector3
p'transform'translation = (Ptr Transform -> Int -> Ptr Vector3
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0)

p'transform'rotation :: Ptr Transform -> Ptr Quaternion
p'transform'rotation :: Ptr Transform -> Ptr Vector4
p'transform'rotation = (Ptr Transform -> Int -> Ptr Vector4
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12)

p'transform'scale :: Ptr Transform -> Ptr Vector3
p'transform'scale :: Ptr Transform -> Ptr Vector3
p'transform'scale = (Ptr Transform -> Int -> Ptr Vector3
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28)

data BoneInfo = BoneInfo
  { BoneInfo -> String
boneInfo'name :: String,
    BoneInfo -> Int
boneInfo'parent :: Int
  }
  deriving (BoneInfo -> BoneInfo -> Bool
(BoneInfo -> BoneInfo -> Bool)
-> (BoneInfo -> BoneInfo -> Bool) -> Eq BoneInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BoneInfo -> BoneInfo -> Bool
== :: BoneInfo -> BoneInfo -> Bool
$c/= :: BoneInfo -> BoneInfo -> Bool
/= :: BoneInfo -> BoneInfo -> Bool
Eq, Int -> BoneInfo -> ShowS
[BoneInfo] -> ShowS
BoneInfo -> String
(Int -> BoneInfo -> ShowS)
-> (BoneInfo -> String) -> ([BoneInfo] -> ShowS) -> Show BoneInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BoneInfo -> ShowS
showsPrec :: Int -> BoneInfo -> ShowS
$cshow :: BoneInfo -> String
show :: BoneInfo -> String
$cshowList :: [BoneInfo] -> ShowS
showList :: [BoneInfo] -> ShowS
Show, BoneInfo -> Ptr BoneInfo -> IO ()
(BoneInfo -> Ptr BoneInfo -> IO ())
-> (BoneInfo -> Ptr BoneInfo -> IO ()) -> Freeable BoneInfo
forall a.
(a -> Ptr a -> IO ()) -> (a -> Ptr a -> IO ()) -> Freeable a
$crlFreeDependents :: BoneInfo -> Ptr BoneInfo -> IO ()
rlFreeDependents :: BoneInfo -> Ptr BoneInfo -> IO ()
$crlFree :: BoneInfo -> Ptr BoneInfo -> IO ()
rlFree :: BoneInfo -> Ptr BoneInfo -> IO ()
Freeable)

instance Storable BoneInfo where
  sizeOf :: BoneInfo -> Int
sizeOf BoneInfo
_ = Int
36
  alignment :: BoneInfo -> Int
alignment BoneInfo
_ = Int
4
  peek :: Ptr BoneInfo -> IO BoneInfo
peek Ptr BoneInfo
_p = do
    String
name <- CString -> IO String
peekCString (Ptr BoneInfo -> CString
p'boneInfo'name Ptr BoneInfo
_p)
    Int
parent <- CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Int) -> IO CInt -> IO Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr BoneInfo -> Ptr CInt
p'boneInfo'parent Ptr BoneInfo
_p)
    BoneInfo -> IO BoneInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (BoneInfo -> IO BoneInfo) -> BoneInfo -> IO BoneInfo
forall a b. (a -> b) -> a -> b
$ String -> Int -> BoneInfo
BoneInfo String
name Int
parent
  poke :: Ptr BoneInfo -> BoneInfo -> IO ()
poke Ptr BoneInfo
_p (BoneInfo String
name Int
parent) = do
    CString -> [CChar] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeStaticArray (Ptr BoneInfo -> CString
p'boneInfo'name Ptr BoneInfo
_p) (Int -> CChar -> [CChar] -> [CChar]
forall a. Int -> a -> [a] -> [a]
rightPad Int
32 CChar
0 ([CChar] -> [CChar]) -> [CChar] -> [CChar]
forall a b. (a -> b) -> a -> b
$ (Char -> CChar) -> String -> [CChar]
forall a b. (a -> b) -> [a] -> [b]
map Char -> CChar
castCharToCChar String
name)
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BoneInfo -> Ptr CInt
p'boneInfo'parent Ptr BoneInfo
_p) (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
parent)
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- static string (32)
p'boneInfo'name :: Ptr BoneInfo -> Ptr CChar
p'boneInfo'name :: Ptr BoneInfo -> CString
p'boneInfo'name = (Ptr BoneInfo -> Int -> CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0)

p'boneInfo'parent :: Ptr BoneInfo -> Ptr CInt
p'boneInfo'parent :: Ptr BoneInfo -> Ptr CInt
p'boneInfo'parent = (Ptr BoneInfo -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32)

data Model = Model
  { Model -> Matrix
model'transform :: Matrix,
    Model -> [Mesh]
model'meshes :: [Mesh],
    Model -> [Material]
model'materials :: [Material],
    Model -> [Int]
model'meshMaterial :: [Int],
    Model -> Int
model'boneCount :: Int,
    Model -> Maybe [BoneInfo]
model'bones :: Maybe [BoneInfo],
    Model -> Maybe [Transform]
model'bindPose :: Maybe [Transform]
  }
  deriving (Model -> Model -> Bool
(Model -> Model -> Bool) -> (Model -> Model -> Bool) -> Eq Model
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Model -> Model -> Bool
== :: Model -> Model -> Bool
$c/= :: Model -> Model -> Bool
/= :: Model -> Model -> Bool
Eq, Int -> Model -> ShowS
[Model] -> ShowS
Model -> String
(Int -> Model -> ShowS)
-> (Model -> String) -> ([Model] -> ShowS) -> Show Model
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Model -> ShowS
showsPrec :: Int -> Model -> ShowS
$cshow :: Model -> String
show :: Model -> String
$cshowList :: [Model] -> ShowS
showList :: [Model] -> ShowS
Show)

instance Storable Model where
  sizeOf :: Model -> Int
sizeOf Model
_ = Int
120
  alignment :: Model -> Int
alignment Model
_ = Int
4
  peek :: Ptr Model -> IO Model
peek Ptr Model
_p = do
    Matrix
transform <- Ptr Matrix -> IO Matrix
forall a. Storable a => Ptr a -> IO a
peek (Ptr Model -> Ptr Matrix
p'model'transform Ptr Model
_p)
    Int
meshCount <- CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Int) -> IO CInt -> IO Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr Model -> Ptr CInt
p'model'meshCount Ptr Model
_p)
    Int
materialCount <- CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Int) -> IO CInt -> IO Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr Model -> Ptr CInt
p'model'materialCount Ptr Model
_p)
    [Mesh]
meshes <- Int -> Ptr Mesh -> IO [Mesh]
forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
meshCount (Ptr Mesh -> IO [Mesh]) -> IO (Ptr Mesh) -> IO [Mesh]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr Mesh) -> IO (Ptr Mesh)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Model -> Ptr (Ptr Mesh)
p'model'meshes Ptr Model
_p)
    [Material]
materials <- Int -> Ptr Material -> IO [Material]
forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
materialCount (Ptr Material -> IO [Material])
-> IO (Ptr Material) -> IO [Material]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr Material) -> IO (Ptr Material)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Model -> Ptr (Ptr Material)
p'model'materials Ptr Model
_p)
    [Int]
meshMaterial <- (CInt -> Int) -> [CInt] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([CInt] -> [Int]) -> IO [CInt] -> IO [Int]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> Ptr CInt -> IO [CInt]
forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
meshCount (Ptr CInt -> IO [CInt]) -> IO (Ptr CInt) -> IO [CInt]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr CInt) -> IO (Ptr CInt)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Model -> Ptr (Ptr CInt)
p'model'meshMaterial Ptr Model
_p))
    Int
boneCount <- CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Int) -> IO CInt -> IO Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr Model -> Ptr CInt
p'model'boneCount Ptr Model
_p)
    Maybe [BoneInfo]
bones <- Int -> Ptr BoneInfo -> IO (Maybe [BoneInfo])
forall a. Storable a => Int -> Ptr a -> IO (Maybe [a])
peekMaybeArray Int
boneCount (Ptr BoneInfo -> IO (Maybe [BoneInfo]))
-> IO (Ptr BoneInfo) -> IO (Maybe [BoneInfo])
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr BoneInfo) -> IO (Ptr BoneInfo)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Model -> Ptr (Ptr BoneInfo)
p'model'bones Ptr Model
_p)
    Maybe [Transform]
bindPose <- Int -> Ptr Transform -> IO (Maybe [Transform])
forall a. Storable a => Int -> Ptr a -> IO (Maybe [a])
peekMaybeArray Int
boneCount (Ptr Transform -> IO (Maybe [Transform]))
-> IO (Ptr Transform) -> IO (Maybe [Transform])
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr Transform) -> IO (Ptr Transform)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Model -> Ptr (Ptr Transform)
p'model'bindPose Ptr Model
_p)
    Model -> IO Model
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Model -> IO Model) -> Model -> IO Model
forall a b. (a -> b) -> a -> b
$ Matrix
-> [Mesh]
-> [Material]
-> [Int]
-> Int
-> Maybe [BoneInfo]
-> Maybe [Transform]
-> Model
Model Matrix
transform [Mesh]
meshes [Material]
materials [Int]
meshMaterial Int
boneCount Maybe [BoneInfo]
bones Maybe [Transform]
bindPose
  poke :: Ptr Model -> Model -> IO ()
poke Ptr Model
_p (Model Matrix
transform [Mesh]
meshes [Material]
materials [Int]
meshMaterial Int
boneCount Maybe [BoneInfo]
bones Maybe [Transform]
bindPose) = do
    Ptr Matrix -> Matrix -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Model -> Ptr Matrix
p'model'transform Ptr Model
_p) Matrix
transform
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Model -> Ptr CInt
p'model'meshCount Ptr Model
_p) (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Mesh] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Mesh]
meshes))
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Model -> Ptr CInt
p'model'materialCount Ptr Model
_p) (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Material] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Material]
materials))
    Ptr (Ptr Mesh) -> Ptr Mesh -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Model -> Ptr (Ptr Mesh)
p'model'meshes Ptr Model
_p) (Ptr Mesh -> IO ()) -> IO (Ptr Mesh) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [Mesh] -> IO (Ptr Mesh)
forall a. Storable a => [a] -> IO (Ptr a)
newArray [Mesh]
meshes
    Ptr (Ptr Material) -> Ptr Material -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Model -> Ptr (Ptr Material)
p'model'materials Ptr Model
_p) (Ptr Material -> IO ()) -> IO (Ptr Material) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [Material] -> IO (Ptr Material)
forall a. Storable a => [a] -> IO (Ptr a)
newArray [Material]
materials
    Ptr (Ptr CInt) -> Ptr CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Model -> Ptr (Ptr CInt)
p'model'meshMaterial Ptr Model
_p) (Ptr CInt -> IO ()) -> IO (Ptr CInt) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [CInt] -> IO (Ptr CInt)
forall a. Storable a => [a] -> IO (Ptr a)
newArray ((Int -> CInt) -> [Int] -> [CInt]
forall a b. (a -> b) -> [a] -> [b]
map Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral [Int]
meshMaterial)
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Model -> Ptr CInt
p'model'boneCount Ptr Model
_p) (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
boneCount)
    Ptr (Ptr BoneInfo) -> Ptr BoneInfo -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Model -> Ptr (Ptr BoneInfo)
p'model'bones Ptr Model
_p) (Ptr BoneInfo -> IO ()) -> IO (Ptr BoneInfo) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe [BoneInfo] -> IO (Ptr BoneInfo)
forall a. Storable a => Maybe [a] -> IO (Ptr a)
newMaybeArray Maybe [BoneInfo]
bones
    Ptr (Ptr Transform) -> Ptr Transform -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Model -> Ptr (Ptr Transform)
p'model'bindPose Ptr Model
_p) (Ptr Transform -> IO ()) -> IO (Ptr Transform) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe [Transform] -> IO (Ptr Transform)
forall a. Storable a => Maybe [a] -> IO (Ptr a)
newMaybeArray Maybe [Transform]
bindPose
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

p'model'transform :: Ptr Model -> Ptr Matrix
p'model'transform :: Ptr Model -> Ptr Matrix
p'model'transform = (Ptr Model -> Int -> Ptr Matrix
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0)

p'model'meshCount :: Ptr Model -> Ptr CInt
p'model'meshCount :: Ptr Model -> Ptr CInt
p'model'meshCount = (Ptr Model -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64)

p'model'materialCount :: Ptr Model -> Ptr CInt
p'model'materialCount :: Ptr Model -> Ptr CInt
p'model'materialCount = (Ptr Model -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
68)

-- array (model'meshCount)
p'model'meshes :: Ptr Model -> Ptr (Ptr Mesh)
p'model'meshes :: Ptr Model -> Ptr (Ptr Mesh)
p'model'meshes = (Ptr Model -> Int -> Ptr (Ptr Mesh)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72)

-- array (model'materialCount)
p'model'materials :: Ptr Model -> Ptr (Ptr Material)
p'model'materials :: Ptr Model -> Ptr (Ptr Material)
p'model'materials = (Ptr Model -> Int -> Ptr (Ptr Material)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
80)

-- array (model'meshCount)
p'model'meshMaterial :: Ptr Model -> Ptr (Ptr CInt)
p'model'meshMaterial :: Ptr Model -> Ptr (Ptr CInt)
p'model'meshMaterial = (Ptr Model -> Int -> Ptr (Ptr CInt)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
88)

p'model'boneCount :: Ptr Model -> Ptr CInt
p'model'boneCount :: Ptr Model -> Ptr CInt
p'model'boneCount = (Ptr Model -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
96)

-- maybe array (model'boneCount)
p'model'bones :: Ptr Model -> Ptr (Ptr BoneInfo)
p'model'bones :: Ptr Model -> Ptr (Ptr BoneInfo)
p'model'bones = (Ptr Model -> Int -> Ptr (Ptr BoneInfo)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
104)

-- maybe array (model'boneCount)
p'model'bindPose :: Ptr Model -> Ptr (Ptr Transform)
p'model'bindPose :: Ptr Model -> Ptr (Ptr Transform)
p'model'bindPose = (Ptr Model -> Int -> Ptr (Ptr Transform)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
112)

instance Freeable Model where
  rlFreeDependents :: Model -> Ptr Model -> IO ()
rlFreeDependents Model
val Ptr Model
ptr = do
    [Mesh] -> Ptr [Mesh] -> IO ()
forall a. Freeable a => a -> Ptr a -> IO ()
rlFree (Model -> [Mesh]
model'meshes Model
val) (Ptr [Mesh] -> IO ())
-> (Ptr Mesh -> Ptr [Mesh]) -> Ptr Mesh -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr Mesh -> Ptr [Mesh]
forall a b. Ptr a -> Ptr b
castPtr (Ptr Mesh -> IO ()) -> IO (Ptr Mesh) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr Mesh) -> IO (Ptr Mesh)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Model -> Ptr (Ptr Mesh)
p'model'meshes Ptr Model
ptr)
    [Material] -> Ptr [Material] -> IO ()
forall a. Freeable a => a -> Ptr a -> IO ()
rlFree (Model -> [Material]
model'materials Model
val) (Ptr [Material] -> IO ())
-> (Ptr Material -> Ptr [Material]) -> Ptr Material -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr Material -> Ptr [Material]
forall a b. Ptr a -> Ptr b
castPtr (Ptr Material -> IO ()) -> IO (Ptr Material) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr Material) -> IO (Ptr Material)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Model -> Ptr (Ptr Material)
p'model'materials Ptr Model
ptr)
    Ptr () -> IO ()
c'free (Ptr () -> IO ()) -> (Ptr CInt -> Ptr ()) -> Ptr CInt -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr CInt -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr (Ptr CInt -> IO ()) -> IO (Ptr CInt) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr CInt) -> IO (Ptr CInt)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Model -> Ptr (Ptr CInt)
p'model'meshMaterial Ptr Model
ptr)
    Ptr () -> IO ()
freeMaybePtr (Ptr () -> IO ())
-> (Ptr BoneInfo -> Ptr ()) -> Ptr BoneInfo -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr BoneInfo -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr (Ptr BoneInfo -> IO ()) -> IO (Ptr BoneInfo) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr BoneInfo) -> IO (Ptr BoneInfo)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Model -> Ptr (Ptr BoneInfo)
p'model'bones Ptr Model
ptr)
    Ptr () -> IO ()
freeMaybePtr (Ptr () -> IO ())
-> (Ptr Transform -> Ptr ()) -> Ptr Transform -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr Transform -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr (Ptr Transform -> IO ()) -> IO (Ptr Transform) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr Transform) -> IO (Ptr Transform)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Model -> Ptr (Ptr Transform)
p'model'bindPose Ptr Model
ptr)

data ModelAnimation = ModelAnimation
  { ModelAnimation -> Int
modelAnimation'boneCount :: Int,
    ModelAnimation -> Int
modelAnimation'frameCount :: Int,
    ModelAnimation -> [BoneInfo]
modelAnimation'bones :: [BoneInfo],
    ModelAnimation -> [[Transform]]
modelAnimation'framePoses :: [[Transform]],
    ModelAnimation -> String
modelAnimation'name :: String
  }
  deriving (ModelAnimation -> ModelAnimation -> Bool
(ModelAnimation -> ModelAnimation -> Bool)
-> (ModelAnimation -> ModelAnimation -> Bool) -> Eq ModelAnimation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ModelAnimation -> ModelAnimation -> Bool
== :: ModelAnimation -> ModelAnimation -> Bool
$c/= :: ModelAnimation -> ModelAnimation -> Bool
/= :: ModelAnimation -> ModelAnimation -> Bool
Eq, Int -> ModelAnimation -> ShowS
[ModelAnimation] -> ShowS
ModelAnimation -> String
(Int -> ModelAnimation -> ShowS)
-> (ModelAnimation -> String)
-> ([ModelAnimation] -> ShowS)
-> Show ModelAnimation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ModelAnimation -> ShowS
showsPrec :: Int -> ModelAnimation -> ShowS
$cshow :: ModelAnimation -> String
show :: ModelAnimation -> String
$cshowList :: [ModelAnimation] -> ShowS
showList :: [ModelAnimation] -> ShowS
Show)

instance Storable ModelAnimation where
  sizeOf :: ModelAnimation -> Int
sizeOf ModelAnimation
_ = Int
56
  alignment :: ModelAnimation -> Int
alignment ModelAnimation
_ = Int
4
  peek :: Ptr ModelAnimation -> IO ModelAnimation
peek Ptr ModelAnimation
_p = do
    Int
boneCount <- CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Int) -> IO CInt -> IO Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr ModelAnimation -> Ptr CInt
p'modelAnimation'boneCount Ptr ModelAnimation
_p)
    Int
frameCount <- CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Int) -> IO CInt -> IO Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr ModelAnimation -> Ptr CInt
p'modelAnimation'frameCount Ptr ModelAnimation
_p)
    [BoneInfo]
bones <- Int -> Ptr BoneInfo -> IO [BoneInfo]
forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
boneCount (Ptr BoneInfo -> IO [BoneInfo])
-> IO (Ptr BoneInfo) -> IO [BoneInfo]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr BoneInfo) -> IO (Ptr BoneInfo)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ModelAnimation -> Ptr (Ptr BoneInfo)
p'modelAnimation'bones Ptr ModelAnimation
_p)
    Ptr (Ptr Transform)
framePosesPtr <- Ptr (Ptr (Ptr Transform)) -> IO (Ptr (Ptr Transform))
forall a. Storable a => Ptr a -> IO a
peek (Ptr ModelAnimation -> Ptr (Ptr (Ptr Transform))
p'modelAnimation'framePoses Ptr ModelAnimation
_p)
    [Ptr Transform]
framePosesPtrArr <- Int -> Ptr (Ptr Transform) -> IO [Ptr Transform]
forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
frameCount Ptr (Ptr Transform)
framePosesPtr
    [[Transform]]
framePoses <- (Ptr Transform -> IO [Transform])
-> [Ptr Transform] -> IO [[Transform]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (Int -> Ptr Transform -> IO [Transform]
forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
boneCount) [Ptr Transform]
framePosesPtrArr
    String
name <- CString -> IO String
peekCString (Ptr ModelAnimation -> CString
p'modelAnimation'name Ptr ModelAnimation
_p)
    ModelAnimation -> IO ModelAnimation
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ModelAnimation -> IO ModelAnimation)
-> ModelAnimation -> IO ModelAnimation
forall a b. (a -> b) -> a -> b
$ Int
-> Int -> [BoneInfo] -> [[Transform]] -> String -> ModelAnimation
ModelAnimation Int
boneCount Int
frameCount [BoneInfo]
bones [[Transform]]
framePoses String
name
  poke :: Ptr ModelAnimation -> ModelAnimation -> IO ()
poke Ptr ModelAnimation
_p (ModelAnimation Int
boneCount Int
frameCount [BoneInfo]
bones [[Transform]]
framePoses String
name) = do
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ModelAnimation -> Ptr CInt
p'modelAnimation'boneCount Ptr ModelAnimation
_p) (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
boneCount)
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ModelAnimation -> Ptr CInt
p'modelAnimation'frameCount Ptr ModelAnimation
_p) (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
frameCount)
    Ptr (Ptr BoneInfo) -> Ptr BoneInfo -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ModelAnimation -> Ptr (Ptr BoneInfo)
p'modelAnimation'bones Ptr ModelAnimation
_p) (Ptr BoneInfo -> IO ()) -> IO (Ptr BoneInfo) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [BoneInfo] -> IO (Ptr BoneInfo)
forall a. Storable a => [a] -> IO (Ptr a)
newArray [BoneInfo]
bones
    Ptr (Ptr (Ptr Transform)) -> Ptr (Ptr Transform) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ModelAnimation -> Ptr (Ptr (Ptr Transform))
p'modelAnimation'framePoses Ptr ModelAnimation
_p) (Ptr (Ptr Transform) -> IO ()) -> IO (Ptr (Ptr Transform)) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [Ptr Transform] -> IO (Ptr (Ptr Transform))
forall a. Storable a => [a] -> IO (Ptr a)
newArray ([Ptr Transform] -> IO (Ptr (Ptr Transform)))
-> IO [Ptr Transform] -> IO (Ptr (Ptr Transform))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ([Transform] -> IO (Ptr Transform))
-> [[Transform]] -> IO [Ptr Transform]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM [Transform] -> IO (Ptr Transform)
forall a. Storable a => [a] -> IO (Ptr a)
newArray [[Transform]]
framePoses
    CString -> [CChar] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeStaticArray (Ptr ModelAnimation -> CString
p'modelAnimation'name Ptr ModelAnimation
_p) (Int -> CChar -> [CChar] -> [CChar]
forall a. Int -> a -> [a] -> [a]
rightPad Int
32 CChar
0 ([CChar] -> [CChar]) -> [CChar] -> [CChar]
forall a b. (a -> b) -> a -> b
$ (Char -> CChar) -> String -> [CChar]
forall a b. (a -> b) -> [a] -> [b]
map Char -> CChar
castCharToCChar String
name)
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

p'modelAnimation'boneCount :: Ptr ModelAnimation -> Ptr CInt
p'modelAnimation'boneCount :: Ptr ModelAnimation -> Ptr CInt
p'modelAnimation'boneCount = (Ptr ModelAnimation -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0)

p'modelAnimation'frameCount :: Ptr ModelAnimation -> Ptr CInt
p'modelAnimation'frameCount :: Ptr ModelAnimation -> Ptr CInt
p'modelAnimation'frameCount = (Ptr ModelAnimation -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4)

-- array (modelAnimation'boneCount)
p'modelAnimation'bones :: Ptr ModelAnimation -> Ptr (Ptr BoneInfo)
p'modelAnimation'bones :: Ptr ModelAnimation -> Ptr (Ptr BoneInfo)
p'modelAnimation'bones = (Ptr ModelAnimation -> Int -> Ptr (Ptr BoneInfo)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8)

-- array 2d (rows: modelAnimation'frameCount, cols: modelAnimation'boneCount)
p'modelAnimation'framePoses :: Ptr ModelAnimation -> Ptr (Ptr (Ptr Transform))
p'modelAnimation'framePoses :: Ptr ModelAnimation -> Ptr (Ptr (Ptr Transform))
p'modelAnimation'framePoses = (Ptr ModelAnimation -> Int -> Ptr (Ptr (Ptr Transform))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16)

-- static string (32)
p'modelAnimation'name :: Ptr ModelAnimation -> Ptr CChar
p'modelAnimation'name :: Ptr ModelAnimation -> CString
p'modelAnimation'name = (Ptr ModelAnimation -> Int -> CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24)

instance Freeable ModelAnimation where
  rlFreeDependents :: ModelAnimation -> Ptr ModelAnimation -> IO ()
rlFreeDependents ModelAnimation
val Ptr ModelAnimation
ptr = do
    Ptr () -> IO ()
c'free (Ptr () -> IO ())
-> (Ptr BoneInfo -> Ptr ()) -> Ptr BoneInfo -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr BoneInfo -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr (Ptr BoneInfo -> IO ()) -> IO (Ptr BoneInfo) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr (Ptr BoneInfo) -> IO (Ptr BoneInfo)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ModelAnimation -> Ptr (Ptr BoneInfo)
p'modelAnimation'bones Ptr ModelAnimation
ptr)
    Ptr (Ptr Transform)
framePosesPtr <- Ptr (Ptr (Ptr Transform)) -> IO (Ptr (Ptr Transform))
forall a. Storable a => Ptr a -> IO a
peek (Ptr ModelAnimation -> Ptr (Ptr (Ptr Transform))
p'modelAnimation'framePoses Ptr ModelAnimation
ptr)
    [Ptr Transform]
framePosesPtrArr <- Int -> Ptr (Ptr Transform) -> IO [Ptr Transform]
forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray (ModelAnimation -> Int
modelAnimation'frameCount ModelAnimation
val) Ptr (Ptr Transform)
framePosesPtr
    [Ptr Transform] -> (Ptr Transform -> IO ()) -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ [Ptr Transform]
framePosesPtrArr (Ptr () -> IO ()
c'free (Ptr () -> IO ())
-> (Ptr Transform -> Ptr ()) -> Ptr Transform -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr Transform -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr)
    Ptr () -> IO ()
c'free (Ptr () -> IO ()) -> Ptr () -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr Transform) -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr Ptr (Ptr Transform)
framePosesPtr

data Ray = Ray
  { Ray -> Vector3
ray'position :: Vector3,
    Ray -> Vector3
ray'direction :: Vector3
  }
  deriving (Ray -> Ray -> Bool
(Ray -> Ray -> Bool) -> (Ray -> Ray -> Bool) -> Eq Ray
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Ray -> Ray -> Bool
== :: Ray -> Ray -> Bool
$c/= :: Ray -> Ray -> Bool
/= :: Ray -> Ray -> Bool
Eq, Int -> Ray -> ShowS
[Ray] -> ShowS
Ray -> String
(Int -> Ray -> ShowS)
-> (Ray -> String) -> ([Ray] -> ShowS) -> Show Ray
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Ray -> ShowS
showsPrec :: Int -> Ray -> ShowS
$cshow :: Ray -> String
show :: Ray -> String
$cshowList :: [Ray] -> ShowS
showList :: [Ray] -> ShowS
Show, Ray -> Ptr Ray -> IO ()
(Ray -> Ptr Ray -> IO ())
-> (Ray -> Ptr Ray -> IO ()) -> Freeable Ray
forall a.
(a -> Ptr a -> IO ()) -> (a -> Ptr a -> IO ()) -> Freeable a
$crlFreeDependents :: Ray -> Ptr Ray -> IO ()
rlFreeDependents :: Ray -> Ptr Ray -> IO ()
$crlFree :: Ray -> Ptr Ray -> IO ()
rlFree :: Ray -> Ptr Ray -> IO ()
Freeable)

instance Storable Ray where
  sizeOf :: Ray -> Int
sizeOf Ray
_ = Int
24
  alignment :: Ray -> Int
alignment Ray
_ = Int
4
  peek :: Ptr Ray -> IO Ray
peek Ptr Ray
_p = do
    Vector3
position <- Ptr Vector3 -> IO Vector3
forall a. Storable a => Ptr a -> IO a
peek (Ptr Ray -> Ptr Vector3
p'ray'position Ptr Ray
_p)
    Vector3
direction <- Ptr Vector3 -> IO Vector3
forall a. Storable a => Ptr a -> IO a
peek (Ptr Ray -> Ptr Vector3
p'ray'direction Ptr Ray
_p)
    Ray -> IO Ray
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Ray -> IO Ray) -> Ray -> IO Ray
forall a b. (a -> b) -> a -> b
$ Vector3 -> Vector3 -> Ray
Ray Vector3
position Vector3
direction
  poke :: Ptr Ray -> Ray -> IO ()
poke Ptr Ray
_p (Ray Vector3
position Vector3
direction) = do
    Ptr Vector3 -> Vector3 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Ray -> Ptr Vector3
p'ray'position Ptr Ray
_p) Vector3
position
    Ptr Vector3 -> Vector3 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Ray -> Ptr Vector3
p'ray'direction Ptr Ray
_p) Vector3
direction
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

p'ray'position :: Ptr Ray -> Ptr Vector3
p'ray'position :: Ptr Ray -> Ptr Vector3
p'ray'position = (Ptr Ray -> Int -> Ptr Vector3
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0)

p'ray'direction :: Ptr Ray -> Ptr Vector3
p'ray'direction :: Ptr Ray -> Ptr Vector3
p'ray'direction = (Ptr Ray -> Int -> Ptr Vector3
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12)

data RayCollision = RayCollision
  { RayCollision -> Bool
rayCollision'hit :: Bool,
    RayCollision -> Float
rayCollision'distance :: Float,
    RayCollision -> Vector3
rayCollision'point :: Vector3,
    RayCollision -> Vector3
rayCollision'normal :: Vector3
  }
  deriving (RayCollision -> RayCollision -> Bool
(RayCollision -> RayCollision -> Bool)
-> (RayCollision -> RayCollision -> Bool) -> Eq RayCollision
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RayCollision -> RayCollision -> Bool
== :: RayCollision -> RayCollision -> Bool
$c/= :: RayCollision -> RayCollision -> Bool
/= :: RayCollision -> RayCollision -> Bool
Eq, Int -> RayCollision -> ShowS
[RayCollision] -> ShowS
RayCollision -> String
(Int -> RayCollision -> ShowS)
-> (RayCollision -> String)
-> ([RayCollision] -> ShowS)
-> Show RayCollision
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RayCollision -> ShowS
showsPrec :: Int -> RayCollision -> ShowS
$cshow :: RayCollision -> String
show :: RayCollision -> String
$cshowList :: [RayCollision] -> ShowS
showList :: [RayCollision] -> ShowS
Show, RayCollision -> Ptr RayCollision -> IO ()
(RayCollision -> Ptr RayCollision -> IO ())
-> (RayCollision -> Ptr RayCollision -> IO ())
-> Freeable RayCollision
forall a.
(a -> Ptr a -> IO ()) -> (a -> Ptr a -> IO ()) -> Freeable a
$crlFreeDependents :: RayCollision -> Ptr RayCollision -> IO ()
rlFreeDependents :: RayCollision -> Ptr RayCollision -> IO ()
$crlFree :: RayCollision -> Ptr RayCollision -> IO ()
rlFree :: RayCollision -> Ptr RayCollision -> IO ()
Freeable)

instance Storable RayCollision where
  sizeOf :: RayCollision -> Int
sizeOf RayCollision
_ = Int
32
  alignment :: RayCollision -> Int
alignment RayCollision
_ = Int
4
  peek :: Ptr RayCollision -> IO RayCollision
peek Ptr RayCollision
_p = do
    Bool
hit <- CBool -> Bool
forall a. (Eq a, Num a) => a -> Bool
toBool (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr CBool -> IO CBool
forall a. Storable a => Ptr a -> IO a
peek (Ptr RayCollision -> Ptr CBool
p'rayCollision'hit Ptr RayCollision
_p)
    Float
distance <- CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac (CFloat -> Float) -> IO CFloat -> IO Float
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr RayCollision -> Ptr CFloat
p'rayCollision'distance Ptr RayCollision
_p)
    Vector3
point <- Ptr Vector3 -> IO Vector3
forall a. Storable a => Ptr a -> IO a
peek (Ptr RayCollision -> Ptr Vector3
p'rayCollision'point Ptr RayCollision
_p)
    Vector3
normal <- Ptr Vector3 -> IO Vector3
forall a. Storable a => Ptr a -> IO a
peek (Ptr RayCollision -> Ptr Vector3
p'rayCollision'normal Ptr RayCollision
_p)
    RayCollision -> IO RayCollision
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (RayCollision -> IO RayCollision)
-> RayCollision -> IO RayCollision
forall a b. (a -> b) -> a -> b
$ Bool -> Float -> Vector3 -> Vector3 -> RayCollision
RayCollision Bool
hit Float
distance Vector3
point Vector3
normal
  poke :: Ptr RayCollision -> RayCollision -> IO ()
poke Ptr RayCollision
_p (RayCollision Bool
hit Float
distance Vector3
point Vector3
normal) = do
    Ptr CBool -> CBool -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RayCollision -> Ptr CBool
p'rayCollision'hit Ptr RayCollision
_p) (Bool -> CBool
forall a. Num a => Bool -> a
fromBool Bool
hit)
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RayCollision -> Ptr CFloat
p'rayCollision'distance Ptr RayCollision
_p) (Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
distance)
    Ptr Vector3 -> Vector3 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RayCollision -> Ptr Vector3
p'rayCollision'point Ptr RayCollision
_p) Vector3
point
    Ptr Vector3 -> Vector3 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RayCollision -> Ptr Vector3
p'rayCollision'normal Ptr RayCollision
_p) Vector3
normal
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

p'rayCollision'hit :: Ptr RayCollision -> Ptr CBool
p'rayCollision'hit :: Ptr RayCollision -> Ptr CBool
p'rayCollision'hit = (Ptr RayCollision -> Int -> Ptr CBool
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0)

p'rayCollision'distance :: Ptr RayCollision -> Ptr CFloat
p'rayCollision'distance :: Ptr RayCollision -> Ptr CFloat
p'rayCollision'distance = (Ptr RayCollision -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4)

p'rayCollision'point :: Ptr RayCollision -> Ptr Vector3
p'rayCollision'point :: Ptr RayCollision -> Ptr Vector3
p'rayCollision'point = (Ptr RayCollision -> Int -> Ptr Vector3
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8)

p'rayCollision'normal :: Ptr RayCollision -> Ptr Vector3
p'rayCollision'normal :: Ptr RayCollision -> Ptr Vector3
p'rayCollision'normal = (Ptr RayCollision -> Int -> Ptr Vector3
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20)

data BoundingBox = BoundingBox
  { BoundingBox -> Vector3
boundingBox'min :: Vector3,
    BoundingBox -> Vector3
boundingBox'max :: Vector3
  }
  deriving (BoundingBox -> BoundingBox -> Bool
(BoundingBox -> BoundingBox -> Bool)
-> (BoundingBox -> BoundingBox -> Bool) -> Eq BoundingBox
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BoundingBox -> BoundingBox -> Bool
== :: BoundingBox -> BoundingBox -> Bool
$c/= :: BoundingBox -> BoundingBox -> Bool
/= :: BoundingBox -> BoundingBox -> Bool
Eq, Int -> BoundingBox -> ShowS
[BoundingBox] -> ShowS
BoundingBox -> String
(Int -> BoundingBox -> ShowS)
-> (BoundingBox -> String)
-> ([BoundingBox] -> ShowS)
-> Show BoundingBox
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BoundingBox -> ShowS
showsPrec :: Int -> BoundingBox -> ShowS
$cshow :: BoundingBox -> String
show :: BoundingBox -> String
$cshowList :: [BoundingBox] -> ShowS
showList :: [BoundingBox] -> ShowS
Show, BoundingBox -> Ptr BoundingBox -> IO ()
(BoundingBox -> Ptr BoundingBox -> IO ())
-> (BoundingBox -> Ptr BoundingBox -> IO ())
-> Freeable BoundingBox
forall a.
(a -> Ptr a -> IO ()) -> (a -> Ptr a -> IO ()) -> Freeable a
$crlFreeDependents :: BoundingBox -> Ptr BoundingBox -> IO ()
rlFreeDependents :: BoundingBox -> Ptr BoundingBox -> IO ()
$crlFree :: BoundingBox -> Ptr BoundingBox -> IO ()
rlFree :: BoundingBox -> Ptr BoundingBox -> IO ()
Freeable)

instance Storable BoundingBox where
  sizeOf :: BoundingBox -> Int
sizeOf BoundingBox
_ = Int
24
  alignment :: BoundingBox -> Int
alignment BoundingBox
_ = Int
4
  peek :: Ptr BoundingBox -> IO BoundingBox
peek Ptr BoundingBox
_p = do
    Vector3
bMin <- Ptr Vector3 -> IO Vector3
forall a. Storable a => Ptr a -> IO a
peek (Ptr BoundingBox -> Ptr Vector3
p'boundingBox'min Ptr BoundingBox
_p)
    Vector3
bMax <- Ptr Vector3 -> IO Vector3
forall a. Storable a => Ptr a -> IO a
peek (Ptr BoundingBox -> Ptr Vector3
p'boundingBox'max Ptr BoundingBox
_p)
    BoundingBox -> IO BoundingBox
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (BoundingBox -> IO BoundingBox) -> BoundingBox -> IO BoundingBox
forall a b. (a -> b) -> a -> b
$ Vector3 -> Vector3 -> BoundingBox
BoundingBox Vector3
bMin Vector3
bMax
  poke :: Ptr BoundingBox -> BoundingBox -> IO ()
poke Ptr BoundingBox
_p (BoundingBox Vector3
bMin Vector3
bMax) = do
    Ptr Vector3 -> Vector3 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BoundingBox -> Ptr Vector3
p'boundingBox'min Ptr BoundingBox
_p) Vector3
bMin
    Ptr Vector3 -> Vector3 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BoundingBox -> Ptr Vector3
p'boundingBox'max Ptr BoundingBox
_p) Vector3
bMax
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

p'boundingBox'min :: Ptr BoundingBox -> Ptr Vector3
p'boundingBox'min :: Ptr BoundingBox -> Ptr Vector3
p'boundingBox'min = (Ptr BoundingBox -> Int -> Ptr Vector3
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0)

p'boundingBox'max :: Ptr BoundingBox -> Ptr Vector3
p'boundingBox'max :: Ptr BoundingBox -> Ptr Vector3
p'boundingBox'max = (Ptr BoundingBox -> Int -> Ptr Vector3
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12)