module Text.GLTF.Loader.BufferAccessor
  ( GltfBuffer(..),
    -- * Loading GLTF buffers
    loadBuffers,
    -- * Deserializing Accessors
    vertexIndices,
    vertexPositions,
    vertexNormals,
    -- * Binary Get decoders
    -- ** Specific Type decoders
    getIndices,
    getPositions,
    -- ** GLTF Accessor Type decoders
    getScalar,
    getVec2,
    getVec3,
    getVec4,
    getMat2,
    getMat3,
    getMat4,
    -- ** GLTF Component Type decoders
    getByte,
    getUnsignedByte,
    getShort,
    getUnsignedShort,
    getUnsignedInt,
    getFloat
  ) where

import Codec.GlTF.Accessor
import Codec.GlTF.Buffer
import Codec.GlTF.BufferView
import Codec.GlTF.URI
import Codec.GlTF
import Data.Binary.Get
import Data.ByteString.Lazy (fromStrict)
import Foreign.Storable
import Linear
import RIO hiding (min, max)
import qualified RIO.Vector as Vector
import qualified RIO.ByteString as ByteString

newtype GltfBuffer = GltfBuffer { GltfBuffer -> ByteString
unBuffer :: ByteString }
  deriving (GltfBuffer -> GltfBuffer -> Bool
(GltfBuffer -> GltfBuffer -> Bool)
-> (GltfBuffer -> GltfBuffer -> Bool) -> Eq GltfBuffer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GltfBuffer -> GltfBuffer -> Bool
$c/= :: GltfBuffer -> GltfBuffer -> Bool
== :: GltfBuffer -> GltfBuffer -> Bool
$c== :: GltfBuffer -> GltfBuffer -> Bool
Eq, Int -> GltfBuffer -> ShowS
[GltfBuffer] -> ShowS
GltfBuffer -> String
(Int -> GltfBuffer -> ShowS)
-> (GltfBuffer -> String)
-> ([GltfBuffer] -> ShowS)
-> Show GltfBuffer
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GltfBuffer] -> ShowS
$cshowList :: [GltfBuffer] -> ShowS
show :: GltfBuffer -> String
$cshow :: GltfBuffer -> String
showsPrec :: Int -> GltfBuffer -> ShowS
$cshowsPrec :: Int -> GltfBuffer -> ShowS
Show)

data BufferAccessor = BufferAccessor
  { BufferAccessor -> Int
offset :: Int,
    BufferAccessor -> Int
count :: Int,
    BufferAccessor -> GltfBuffer
buffer :: GltfBuffer
  }

loadBuffers :: MonadUnliftIO io => GlTF -> io (Vector GltfBuffer)
loadBuffers :: GlTF -> io (Vector GltfBuffer)
loadBuffers GlTF{$sel:buffers:GlTF :: GlTF -> Maybe (Vector Buffer)
buffers=Maybe (Vector Buffer)
buffers} = do
  let buffers' :: Vector Buffer
buffers' = Vector Buffer -> Maybe (Vector Buffer) -> Vector Buffer
forall a. a -> Maybe a -> a
fromMaybe [] Maybe (Vector Buffer)
buffers

  Vector Buffer
-> (Buffer -> io GltfBuffer) -> io (Vector GltfBuffer)
forall (m :: * -> *) (v :: * -> *) a b.
(Monad m, Vector v a, Vector v b) =>
v a -> (a -> m b) -> m (v b)
Vector.forM Vector Buffer
buffers' ((Buffer -> io GltfBuffer) -> io (Vector GltfBuffer))
-> (Buffer -> io GltfBuffer) -> io (Vector GltfBuffer)
forall a b. (a -> b) -> a -> b
$ \Buffer{Int
Maybe Text
Maybe Value
Maybe Object
Maybe URI
$sel:byteLength:Buffer :: Buffer -> Int
$sel:uri:Buffer :: Buffer -> Maybe URI
$sel:name:Buffer :: Buffer -> Maybe Text
$sel:extensions:Buffer :: Buffer -> Maybe Object
$sel:extras:Buffer :: Buffer -> Maybe Value
extras :: Maybe Value
extensions :: Maybe Object
name :: Maybe Text
uri :: Maybe URI
byteLength :: Int
..} -> do
    ByteString
payload <-
      io ByteString
-> (URI -> io ByteString) -> Maybe URI -> io ByteString
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
      (ByteString -> io ByteString
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
"")
      (\URI
uri' -> do
          Either String ByteString
readRes <- IO (Either String ByteString) -> io (Either String ByteString)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Either String ByteString) -> io (Either String ByteString))
-> IO (Either String ByteString) -> io (Either String ByteString)
forall a b. (a -> b) -> a -> b
$ HasCallStack =>
(String -> IO (Either String ByteString))
-> URI -> IO (Either String ByteString)
(String -> IO (Either String ByteString))
-> URI -> IO (Either String ByteString)
loadURI String -> IO (Either String ByteString)
forall a. HasCallStack => a
undefined URI
uri'
          case Either String ByteString
readRes of
            Left String
err -> String -> io ByteString
forall a. HasCallStack => String -> a
error String
err
            Right ByteString
res -> ByteString -> io ByteString
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
res)
      Maybe URI
uri
    
    GltfBuffer -> io GltfBuffer
forall (m :: * -> *) a. Monad m => a -> m a
return (GltfBuffer -> io GltfBuffer) -> GltfBuffer -> io GltfBuffer
forall a b. (a -> b) -> a -> b
$ ByteString -> GltfBuffer
GltfBuffer ByteString
payload

vertexIndices :: GlTF -> Vector GltfBuffer -> AccessorIx -> [Int]
vertexIndices :: GlTF -> Vector GltfBuffer -> AccessorIx -> [Int]
vertexIndices = Get [Int] -> GlTF -> Vector GltfBuffer -> AccessorIx -> [Int]
forall storable.
Storable storable =>
Get [storable]
-> GlTF -> Vector GltfBuffer -> AccessorIx -> [storable]
readBufferWithGet Get [Int]
getIndices

vertexPositions :: GlTF -> Vector GltfBuffer -> AccessorIx -> [V3 Float]
vertexPositions :: GlTF -> Vector GltfBuffer -> AccessorIx -> [V3 Float]
vertexPositions = Get [V3 Float]
-> GlTF -> Vector GltfBuffer -> AccessorIx -> [V3 Float]
forall storable.
Storable storable =>
Get [storable]
-> GlTF -> Vector GltfBuffer -> AccessorIx -> [storable]
readBufferWithGet Get [V3 Float]
getPositions

vertexNormals :: GlTF -> Vector GltfBuffer -> AccessorIx -> [V3 Float]
vertexNormals :: GlTF -> Vector GltfBuffer -> AccessorIx -> [V3 Float]
vertexNormals = GlTF -> Vector GltfBuffer -> AccessorIx -> [V3 Float]
forall a. HasCallStack => a
undefined

readBufferWithGet
  :: Storable storable
  => Get [storable]
  -> GlTF
  -> Vector GltfBuffer
  -> AccessorIx
  -> [storable]
readBufferWithGet :: Get [storable]
-> GlTF -> Vector GltfBuffer -> AccessorIx -> [storable]
readBufferWithGet Get [storable]
getter GlTF
gltf Vector GltfBuffer
buffers' AccessorIx
accessorId
  = [storable]
-> (BufferAccessor -> [storable])
-> Maybe BufferAccessor
-> [storable]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe []
      (storable -> Get [storable] -> BufferAccessor -> [storable]
forall storable.
Storable storable =>
storable -> Get [storable] -> BufferAccessor -> [storable]
readFromBuffer storable
forall a. HasCallStack => a
undefined Get [storable]
getter)
      (GlTF -> Vector GltfBuffer -> AccessorIx -> Maybe BufferAccessor
bufferAccessor GlTF
gltf Vector GltfBuffer
buffers' AccessorIx
accessorId)

bufferAccessor
  :: GlTF
  -> Vector GltfBuffer
  -> AccessorIx
  -> Maybe BufferAccessor
bufferAccessor :: GlTF -> Vector GltfBuffer -> AccessorIx -> Maybe BufferAccessor
bufferAccessor GlTF{Maybe Value
Maybe Object
Maybe (Vector Text)
Maybe (Vector Animation)
Maybe (Vector Scene)
Maybe (Vector Node)
Maybe (Vector Skin)
Maybe (Vector Mesh)
Maybe (Vector Accessor)
Maybe (Vector Texture)
Maybe (Vector Image)
Maybe (Vector BufferView)
Maybe (Vector Buffer)
Maybe (Vector Material)
Maybe (Vector Sampler)
Maybe (Vector Camera)
Asset
$sel:asset:GlTF :: GlTF -> Asset
$sel:extensionsUsed:GlTF :: GlTF -> Maybe (Vector Text)
$sel:extensionsRequired:GlTF :: GlTF -> Maybe (Vector Text)
$sel:accessors:GlTF :: GlTF -> Maybe (Vector Accessor)
$sel:animations:GlTF :: GlTF -> Maybe (Vector Animation)
$sel:bufferViews:GlTF :: GlTF -> Maybe (Vector BufferView)
$sel:cameras:GlTF :: GlTF -> Maybe (Vector Camera)
$sel:images:GlTF :: GlTF -> Maybe (Vector Image)
$sel:materials:GlTF :: GlTF -> Maybe (Vector Material)
$sel:meshes:GlTF :: GlTF -> Maybe (Vector Mesh)
$sel:nodes:GlTF :: GlTF -> Maybe (Vector Node)
$sel:samplers:GlTF :: GlTF -> Maybe (Vector Sampler)
$sel:scenes:GlTF :: GlTF -> Maybe (Vector Scene)
$sel:skins:GlTF :: GlTF -> Maybe (Vector Skin)
$sel:textures:GlTF :: GlTF -> Maybe (Vector Texture)
$sel:extensions:GlTF :: GlTF -> Maybe Object
$sel:extras:GlTF :: GlTF -> Maybe Value
extras :: Maybe Value
extensions :: Maybe Object
textures :: Maybe (Vector Texture)
skins :: Maybe (Vector Skin)
scenes :: Maybe (Vector Scene)
samplers :: Maybe (Vector Sampler)
nodes :: Maybe (Vector Node)
meshes :: Maybe (Vector Mesh)
materials :: Maybe (Vector Material)
images :: Maybe (Vector Image)
cameras :: Maybe (Vector Camera)
bufferViews :: Maybe (Vector BufferView)
buffers :: Maybe (Vector Buffer)
animations :: Maybe (Vector Animation)
accessors :: Maybe (Vector Accessor)
extensionsRequired :: Maybe (Vector Text)
extensionsUsed :: Maybe (Vector Text)
asset :: Asset
$sel:buffers:GlTF :: GlTF -> Maybe (Vector Buffer)
..} Vector GltfBuffer
buffers' AccessorIx
accessorId = do
  Accessor
accessor <- AccessorIx -> Vector Accessor -> Maybe Accessor
lookupAccessor AccessorIx
accessorId (Vector Accessor -> Maybe Accessor)
-> Maybe (Vector Accessor) -> Maybe Accessor
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe (Vector Accessor)
accessors
  BufferView
bufferView <- Accessor -> Vector BufferView -> Maybe BufferView
lookupBufferViewFromAccessor Accessor
accessor (Vector BufferView -> Maybe BufferView)
-> Maybe (Vector BufferView) -> Maybe BufferView
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe (Vector BufferView)
bufferViews
  GltfBuffer
buffer <- BufferView -> Vector GltfBuffer -> Maybe GltfBuffer
lookupBufferFromBufferView BufferView
bufferView Vector GltfBuffer
buffers'

  let Accessor{$sel:byteOffset:Accessor :: Accessor -> Int
byteOffset=Int
offset, $sel:count:Accessor :: Accessor -> Int
count=Int
count} = Accessor
accessor
      BufferView{$sel:byteOffset:BufferView :: BufferView -> Int
byteOffset=Int
offset'} = BufferView
bufferView

  BufferAccessor -> Maybe BufferAccessor
forall (m :: * -> *) a. Monad m => a -> m a
return (BufferAccessor -> Maybe BufferAccessor)
-> BufferAccessor -> Maybe BufferAccessor
forall a b. (a -> b) -> a -> b
$ BufferAccessor :: Int -> Int -> GltfBuffer -> BufferAccessor
BufferAccessor
    { offset :: Int
offset = Int
offset Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
offset',
      count :: Int
count = Int
count,
      buffer :: GltfBuffer
buffer = GltfBuffer
buffer
    }

lookupBufferViewFromAccessor :: Accessor -> Vector BufferView -> Maybe BufferView
lookupBufferViewFromAccessor :: Accessor -> Vector BufferView -> Maybe BufferView
lookupBufferViewFromAccessor Accessor{Bool
Int
Maybe Text
Maybe Value
Maybe Object
Maybe AccessorSparse
Maybe BufferViewIx
Maybe (Vector Scientific)
ComponentType
AttributeType
$sel:componentType:Accessor :: Accessor -> ComponentType
$sel:normalized:Accessor :: Accessor -> Bool
$sel:type':Accessor :: Accessor -> AttributeType
$sel:bufferView:Accessor :: Accessor -> Maybe BufferViewIx
$sel:min:Accessor :: Accessor -> Maybe (Vector Scientific)
$sel:max:Accessor :: Accessor -> Maybe (Vector Scientific)
$sel:sparse:Accessor :: Accessor -> Maybe AccessorSparse
$sel:name:Accessor :: Accessor -> Maybe Text
$sel:extensions:Accessor :: Accessor -> Maybe Object
$sel:extras:Accessor :: Accessor -> Maybe Value
extras :: Maybe Value
extensions :: Maybe Object
name :: Maybe Text
sparse :: Maybe AccessorSparse
max :: Maybe (Vector Scientific)
min :: Maybe (Vector Scientific)
bufferView :: Maybe BufferViewIx
type' :: AttributeType
count :: Int
byteOffset :: Int
normalized :: Bool
componentType :: ComponentType
$sel:count:Accessor :: Accessor -> Int
$sel:byteOffset:Accessor :: Accessor -> Int
..} Vector BufferView
bufferViews
  = Maybe BufferViewIx
bufferView Maybe BufferViewIx
-> (BufferViewIx -> Maybe BufferView) -> Maybe BufferView
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (BufferViewIx -> Vector BufferView -> Maybe BufferView)
-> Vector BufferView -> BufferViewIx -> Maybe BufferView
forall a b c. (a -> b -> c) -> b -> a -> c
flip BufferViewIx -> Vector BufferView -> Maybe BufferView
lookupBufferView Vector BufferView
bufferViews

lookupBufferFromBufferView :: BufferView -> Vector GltfBuffer -> Maybe GltfBuffer
lookupBufferFromBufferView :: BufferView -> Vector GltfBuffer -> Maybe GltfBuffer
lookupBufferFromBufferView BufferView{Int
Maybe Int
Maybe Text
Maybe Value
Maybe Object
Maybe BufferViewTarget
BufferIx
$sel:buffer:BufferView :: BufferView -> BufferIx
$sel:byteLength:BufferView :: BufferView -> Int
$sel:byteStride:BufferView :: BufferView -> Maybe Int
$sel:target:BufferView :: BufferView -> Maybe BufferViewTarget
$sel:name:BufferView :: BufferView -> Maybe Text
$sel:extensions:BufferView :: BufferView -> Maybe Object
$sel:extras:BufferView :: BufferView -> Maybe Value
extras :: Maybe Value
extensions :: Maybe Object
name :: Maybe Text
target :: Maybe BufferViewTarget
byteStride :: Maybe Int
byteLength :: Int
byteOffset :: Int
buffer :: BufferIx
$sel:byteOffset:BufferView :: BufferView -> Int
..} = BufferIx -> Vector GltfBuffer -> Maybe GltfBuffer
lookupBuffer BufferIx
buffer

lookupAccessor :: AccessorIx -> Vector Accessor -> Maybe Accessor
lookupAccessor :: AccessorIx -> Vector Accessor -> Maybe Accessor
lookupAccessor (AccessorIx Int
accessorId) = (Vector Accessor -> Int -> Maybe Accessor
forall (v :: * -> *) a. Vector v a => v a -> Int -> Maybe a
Vector.!? Int
accessorId)

lookupBufferView :: BufferViewIx -> Vector BufferView -> Maybe BufferView
lookupBufferView :: BufferViewIx -> Vector BufferView -> Maybe BufferView
lookupBufferView (BufferViewIx Int
bufferViewId) = (Vector BufferView -> Int -> Maybe BufferView
forall (v :: * -> *) a. Vector v a => v a -> Int -> Maybe a
Vector.!? Int
bufferViewId)

lookupBuffer :: BufferIx -> Vector GltfBuffer -> Maybe GltfBuffer
lookupBuffer :: BufferIx -> Vector GltfBuffer -> Maybe GltfBuffer
lookupBuffer (BufferIx Int
bufferId) = (Vector GltfBuffer -> Int -> Maybe GltfBuffer
forall (v :: * -> *) a. Vector v a => v a -> Int -> Maybe a
Vector.!? Int
bufferId)

readFromBuffer
  :: Storable storable
  => storable
  -> Get [storable]
  -> BufferAccessor
  -> [storable]
readFromBuffer :: storable -> Get [storable] -> BufferAccessor -> [storable]
readFromBuffer storable
storable Get [storable]
getter BufferAccessor{Int
GltfBuffer
buffer :: GltfBuffer
count :: Int
offset :: Int
buffer :: BufferAccessor -> GltfBuffer
count :: BufferAccessor -> Int
offset :: BufferAccessor -> Int
..}
  = Get [storable] -> ByteString -> [storable]
forall a. Get a -> ByteString -> a
runGet Get [storable]
getter (ByteString -> ByteString
fromStrict ByteString
payload')
  where payload' :: ByteString
payload' = Int -> ByteString -> ByteString
ByteString.take Int
len' (ByteString -> ByteString)
-> (GltfBuffer -> ByteString) -> GltfBuffer -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ByteString -> ByteString
ByteString.drop Int
offset (ByteString -> ByteString)
-> (GltfBuffer -> ByteString) -> GltfBuffer -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GltfBuffer -> ByteString
unBuffer (GltfBuffer -> ByteString) -> GltfBuffer -> ByteString
forall a b. (a -> b) -> a -> b
$ GltfBuffer
buffer
        len' :: Int
len' = Int
count Int -> Int -> Int
forall a. Num a => a -> a -> a
* storable -> Int
forall a. Storable a => a -> Int
sizeOf storable
storable

getIndices :: Get [Int]
getIndices :: Get [Int]
getIndices = Get Int -> Get [Int]
forall a. Get a -> Get [a]
getScalar (Word16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Int) -> Get Word16 -> Get Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word16
getUnsignedShort)

getPositions :: Get [V3 Float]
getPositions :: Get [V3 Float]
getPositions = Get Float -> Get [V3 Float]
forall a. Get a -> Get [V3 a]
getVec3 Get Float
getFloat

getScalar :: Get a -> Get [a]
getScalar :: Get a -> Get [a]
getScalar = Get a -> Get [a]
forall a. Get a -> Get [a]
getList

getVec2 :: Get a -> Get [V2 a]
getVec2 :: Get a -> Get [V2 a]
getVec2 Get a
getter = Get (V2 a) -> Get [V2 a]
forall a. Get a -> Get [a]
getList (Get (V2 a) -> Get [V2 a]) -> Get (V2 a) -> Get [V2 a]
forall a b. (a -> b) -> a -> b
$ a -> a -> V2 a
forall a. a -> a -> V2 a
V2 (a -> a -> V2 a) -> Get a -> Get (a -> V2 a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get a
getter Get (a -> V2 a) -> Get a -> Get (V2 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get a
getter

getVec3 :: Get a -> Get [V3 a]
getVec3 :: Get a -> Get [V3 a]
getVec3 Get a
getter = Get (V3 a) -> Get [V3 a]
forall a. Get a -> Get [a]
getList (Get (V3 a) -> Get [V3 a]) -> Get (V3 a) -> Get [V3 a]
forall a b. (a -> b) -> a -> b
$ a -> a -> a -> V3 a
forall a. a -> a -> a -> V3 a
V3 (a -> a -> a -> V3 a) -> Get a -> Get (a -> a -> V3 a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get a
getter Get (a -> a -> V3 a) -> Get a -> Get (a -> V3 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get a
getter Get (a -> V3 a) -> Get a -> Get (V3 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get a
getter

getVec4 :: Get a -> Get [V4 a]
getVec4 :: Get a -> Get [V4 a]
getVec4 Get a
getter = Get (V4 a) -> Get [V4 a]
forall a. Get a -> Get [a]
getList (Get (V4 a) -> Get [V4 a]) -> Get (V4 a) -> Get [V4 a]
forall a b. (a -> b) -> a -> b
$ a -> a -> a -> a -> V4 a
forall a. a -> a -> a -> a -> V4 a
V4 (a -> a -> a -> a -> V4 a) -> Get a -> Get (a -> a -> a -> V4 a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get a
getter Get (a -> a -> a -> V4 a) -> Get a -> Get (a -> a -> V4 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get a
getter Get (a -> a -> V4 a) -> Get a -> Get (a -> V4 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get a
getter Get (a -> V4 a) -> Get a -> Get (V4 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get a
getter

getMat2 :: Get a -> Get [M22 a]
getMat2 :: Get a -> Get [M22 a]
getMat2 Get a
getter = Get (M22 a) -> Get [M22 a]
forall a. Get a -> Get [a]
getList (Get (M22 a) -> Get [M22 a]) -> Get (M22 a) -> Get [M22 a]
forall a b. (a -> b) -> a -> b
$ do
  a
m1_1 <- Get a
getter
  a
m1_2 <- Get a
getter

  a
m2_1 <- Get a
getter
  a
m2_2 <- Get a
getter

  M22 a -> Get (M22 a)
forall (m :: * -> *) a. Monad m => a -> m a
return (M22 a -> Get (M22 a)) -> M22 a -> Get (M22 a)
forall a b. (a -> b) -> a -> b
$ V2 a -> V2 a -> M22 a
forall a. a -> a -> V2 a
V2
    (a -> a -> V2 a
forall a. a -> a -> V2 a
V2 a
m1_1 a
m2_1)
    (a -> a -> V2 a
forall a. a -> a -> V2 a
V2 a
m1_2 a
m2_2)

getMat3 :: Get a -> Get [M33 a]
getMat3 :: Get a -> Get [M33 a]
getMat3 Get a
getter = Get (M33 a) -> Get [M33 a]
forall a. Get a -> Get [a]
getList (Get (M33 a) -> Get [M33 a]) -> Get (M33 a) -> Get [M33 a]
forall a b. (a -> b) -> a -> b
$ do
  a
m1_1 <- Get a
getter
  a
m1_2 <- Get a
getter
  a
m1_3 <- Get a
getter
  
  a
m2_1 <- Get a
getter
  a
m2_2 <- Get a
getter
  a
m2_3 <- Get a
getter

  a
m3_1 <- Get a
getter
  a
m3_2 <- Get a
getter
  a
m3_3 <- Get a
getter

  M33 a -> Get (M33 a)
forall (m :: * -> *) a. Monad m => a -> m a
return (M33 a -> Get (M33 a)) -> M33 a -> Get (M33 a)
forall a b. (a -> b) -> a -> b
$ V3 a -> V3 a -> V3 a -> M33 a
forall a. a -> a -> a -> V3 a
V3
    (a -> a -> a -> V3 a
forall a. a -> a -> a -> V3 a
V3 a
m1_1 a
m2_1 a
m3_1)
    (a -> a -> a -> V3 a
forall a. a -> a -> a -> V3 a
V3 a
m1_2 a
m2_2 a
m3_2)
    (a -> a -> a -> V3 a
forall a. a -> a -> a -> V3 a
V3 a
m1_3 a
m2_3 a
m3_3)

getMat4 :: Get a -> Get [M44 a]
getMat4 :: Get a -> Get [M44 a]
getMat4 Get a
getter = Get (M44 a) -> Get [M44 a]
forall a. Get a -> Get [a]
getList (Get (M44 a) -> Get [M44 a]) -> Get (M44 a) -> Get [M44 a]
forall a b. (a -> b) -> a -> b
$ do
  a
m1_1 <- Get a
getter
  a
m1_2 <- Get a
getter
  a
m1_3 <- Get a
getter
  a
m1_4 <- Get a
getter
  
  a
m2_1 <- Get a
getter
  a
m2_2 <- Get a
getter
  a
m2_3 <- Get a
getter
  a
m2_4 <- Get a
getter

  a
m3_1 <- Get a
getter
  a
m3_2 <- Get a
getter
  a
m3_3 <- Get a
getter
  a
m3_4 <- Get a
getter

  a
m4_1 <- Get a
getter
  a
m4_2 <- Get a
getter
  a
m4_3 <- Get a
getter
  a
m4_4 <- Get a
getter

  M44 a -> Get (M44 a)
forall (m :: * -> *) a. Monad m => a -> m a
return (M44 a -> Get (M44 a)) -> M44 a -> Get (M44 a)
forall a b. (a -> b) -> a -> b
$ V4 a -> V4 a -> V4 a -> V4 a -> M44 a
forall a. a -> a -> a -> a -> V4 a
V4
    (a -> a -> a -> a -> V4 a
forall a. a -> a -> a -> a -> V4 a
V4 a
m1_1 a
m2_1 a
m3_1 a
m4_1)
    (a -> a -> a -> a -> V4 a
forall a. a -> a -> a -> a -> V4 a
V4 a
m1_2 a
m2_2 a
m3_2 a
m4_2)
    (a -> a -> a -> a -> V4 a
forall a. a -> a -> a -> a -> V4 a
V4 a
m1_3 a
m2_3 a
m3_3 a
m4_3)
    (a -> a -> a -> a -> V4 a
forall a. a -> a -> a -> a -> V4 a
V4 a
m1_4 a
m2_4 a
m3_4 a
m4_4)

getByte :: Get Int8
getByte :: Get Int8
getByte = Get Int8
getInt8

getUnsignedByte :: Get Word8
getUnsignedByte :: Get Word8
getUnsignedByte = Get Word8
getWord8

getShort :: Get Int16
getShort :: Get Int16
getShort = Get Int16
getInt16le

getUnsignedShort :: Get Word16
getUnsignedShort :: Get Word16
getUnsignedShort = Get Word16
getWord16le

getUnsignedInt :: Get Word32
getUnsignedInt :: Get Word32
getUnsignedInt = Get Word32
getWord32le

getFloat :: Get Float
getFloat :: Get Float
getFloat = Get Float
getFloatle

getList :: Get a -> Get [a]
getList :: Get a -> Get [a]
getList Get a
getter = do
  Bool
empty <- Get Bool
isEmpty
  if Bool
empty
    then [a] -> Get [a]
forall (m :: * -> *) a. Monad m => a -> m a
return []
    else (:) (a -> [a] -> [a]) -> Get a -> Get ([a] -> [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get a
getter Get ([a] -> [a]) -> Get [a] -> Get [a]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get a -> Get [a]
forall a. Get a -> Get [a]
getList Get a
getter