{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UnboxedTuples #-}

-- | General matrix storage and operations.

module Geomancy.Mat4.Internal
  ( Mat4(..)
  , fromMemory
  , withMemory
  , newMat4
    -- * Order-independent operations
  , identity
  , transpose
  , pointwise
  , scalarMultiply
    -- * List operations in memory order
  , toListMemory
  , toList2dMemory
  , toListTrans
  , toList2dTrans
  , zipWith
  ) where

import Prelude hiding (zipWith)
import GHC.Exts hiding (VecCount(..), toList)

import Control.DeepSeq (NFData(rnf))
import Foreign (Storable(..))
import Foreign.Ptr.Diff (peekDiffOff, pokeDiffOff)
import GHC.IO (IO(..))

import qualified Data.List as List

import Graphics.Gl.Block (Block(..))

data Mat4 = Mat4 ByteArray#

instance NFData Mat4 where
  rnf :: Mat4 -> ()
rnf Mat4{} = ()

{- | Construct 'Mat4' from elements in memory order.
-}
{-# INLINE fromMemory #-}
fromMemory
  :: Float -> Float -> Float -> Float
  -> Float -> Float -> Float -> Float
  -> Float -> Float -> Float -> Float
  -> Float -> Float -> Float -> Float
  -> Mat4
fromMemory :: Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Mat4
fromMemory
  (F# Float#
e0) (F# Float#
e1) (F# Float#
e2) (F# Float#
e3)
  (F# Float#
e4) (F# Float#
e5) (F# Float#
e6) (F# Float#
e7)
  (F# Float#
e8) (F# Float#
e9) (F# Float#
ea) (F# Float#
eb)
  (F# Float#
ec) (F# Float#
ed) (F# Float#
ee) (F# Float#
ef) =
  (State# RealWorld -> Mat4) -> Mat4
forall o. (State# RealWorld -> o) -> o
runRW# \State# RealWorld
world ->
    let
      !(# State# RealWorld
world_, MutableByteArray# RealWorld
arr #) = Int#
-> Int#
-> State# RealWorld
-> (# State# RealWorld, MutableByteArray# RealWorld #)
forall d.
Int# -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
newAlignedPinnedByteArray# Int#
64# Int#
16# State# RealWorld
world

      world0 :: State# RealWorld
world0 = MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
arr Int#
0x0# Float#
e0 State# RealWorld
world_
      world1 :: State# RealWorld
world1 = MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
arr Int#
0x1# Float#
e1 State# RealWorld
world0
      world2 :: State# RealWorld
world2 = MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
arr Int#
0x2# Float#
e2 State# RealWorld
world1
      world3 :: State# RealWorld
world3 = MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
arr Int#
0x3# Float#
e3 State# RealWorld
world2

      world4 :: State# RealWorld
world4 = MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
arr Int#
0x4# Float#
e4 State# RealWorld
world3
      world5 :: State# RealWorld
world5 = MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
arr Int#
0x5# Float#
e5 State# RealWorld
world4
      world6 :: State# RealWorld
world6 = MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
arr Int#
0x6# Float#
e6 State# RealWorld
world5
      world7 :: State# RealWorld
world7 = MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
arr Int#
0x7# Float#
e7 State# RealWorld
world6

      world8 :: State# RealWorld
world8 = MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
arr Int#
0x8# Float#
e8 State# RealWorld
world7
      world9 :: State# RealWorld
world9 = MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
arr Int#
0x9# Float#
e9 State# RealWorld
world8
      worldA :: State# RealWorld
worldA = MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
arr Int#
0xA# Float#
ea State# RealWorld
world9
      worldB :: State# RealWorld
worldB = MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
arr Int#
0xB# Float#
eb State# RealWorld
worldA

      worldC :: State# RealWorld
worldC = MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
arr Int#
0xC# Float#
ec State# RealWorld
worldB
      worldD :: State# RealWorld
worldD = MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
arr Int#
0xD# Float#
ed State# RealWorld
worldC
      worldE :: State# RealWorld
worldE = MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
arr Int#
0xE# Float#
ee State# RealWorld
worldD
      worldF :: State# RealWorld
worldF = MutableByteArray# RealWorld
-> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# RealWorld
arr Int#
0xF# Float#
ef State# RealWorld
worldE

      !(# State# RealWorld
_world', ByteArray#
arr' #) = MutableByteArray# RealWorld
-> State# RealWorld -> (# State# RealWorld, ByteArray# #)
forall d.
MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
unsafeFreezeByteArray# MutableByteArray# RealWorld
arr State# RealWorld
worldF
    in
      ByteArray# -> Mat4
Mat4 ByteArray#
arr'

{- | Reduce 'Mat4' with a function with @memory@ notation for arguments.
-}
{-# INLINE withMemory #-}
withMemory
  :: Mat4
  ->
    ( Float -> Float -> Float -> Float ->
      Float -> Float -> Float -> Float ->
      Float -> Float -> Float -> Float ->
      Float -> Float -> Float -> Float ->
      r
    )
  -> r
withMemory :: forall r.
Mat4
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> r)
-> r
withMemory (Mat4 ByteArray#
arr) Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> r
f =
  Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> r
f
    (Float# -> Float
F# (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr Int#
0x0#))
    (Float# -> Float
F# (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr Int#
0x1#))
    (Float# -> Float
F# (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr Int#
0x2#))
    (Float# -> Float
F# (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr Int#
0x3#))

    (Float# -> Float
F# (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr Int#
0x4#))
    (Float# -> Float
F# (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr Int#
0x5#))
    (Float# -> Float
F# (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr Int#
0x6#))
    (Float# -> Float
F# (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr Int#
0x7#))

    (Float# -> Float
F# (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr Int#
0x8#))
    (Float# -> Float
F# (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr Int#
0x9#))
    (Float# -> Float
F# (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr Int#
0xA#))
    (Float# -> Float
F# (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr Int#
0xB#))

    (Float# -> Float
F# (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr Int#
0xC#))
    (Float# -> Float
F# (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr Int#
0xD#))
    (Float# -> Float
F# (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr Int#
0xE#))
    (Float# -> Float
F# (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr Int#
0xF#))

{- | @I@, the identity matrix.

Neutral element of its monoid, so you can use 'mempty'.
-}
{-# INLINE identity #-}
identity :: Mat4
identity :: Mat4
identity = Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Mat4
fromMemory
  Float
1 Float
0 Float
0 Float
0
  Float
0 Float
1 Float
0 Float
0
  Float
0 Float
0 Float
1 Float
0
  Float
0 Float
0 Float
0 Float
1

-- TODO: simdify
{-# INLINE transpose #-}
transpose :: Mat4 -> Mat4
transpose :: Mat4 -> Mat4
transpose =
  (Mat4
 -> (Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Mat4)
 -> Mat4)
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Mat4)
-> Mat4
-> Mat4
forall a b c. (a -> b -> c) -> b -> a -> c
flip Mat4
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Mat4)
-> Mat4
forall r.
Mat4
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> r)
-> r
withMemory
    \ Float
e0 Float
e1 Float
e2 Float
e3
      Float
e4 Float
e5 Float
e6 Float
e7
      Float
e8 Float
e9 Float
eA Float
eB
      Float
eC Float
eD Float
eE Float
eF ->
    Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Mat4
fromMemory
      Float
e0 Float
e4 Float
e8 Float
eC
      Float
e1 Float
e5 Float
e9 Float
eD
      Float
e2 Float
e6 Float
eA Float
eE
      Float
e3 Float
e7 Float
eB Float
eF

pointwise :: Mat4 -> Mat4 -> (Float -> Float -> Float) -> Mat4
pointwise :: Mat4 -> Mat4 -> (Float -> Float -> Float) -> Mat4
pointwise Mat4
a Mat4
b Float -> Float -> Float
f =
  Mat4
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Mat4)
-> Mat4
forall r.
Mat4
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> r)
-> r
withMemory Mat4
a
    \ Float
a0 Float
a1 Float
a2 Float
a3
      Float
a4 Float
a5 Float
a6 Float
a7
      Float
a8 Float
a9 Float
aA Float
aB
      Float
aC Float
aD Float
aE Float
aF ->
  Mat4
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Mat4)
-> Mat4
forall r.
Mat4
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> r)
-> r
withMemory Mat4
b
    \ Float
b0 Float
b1 Float
b2 Float
b3
      Float
b4 Float
b5 Float
b6 Float
b7
      Float
b8 Float
b9 Float
bA Float
bB
      Float
bC Float
bD Float
bE Float
bF ->
  Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Mat4
fromMemory
    (Float -> Float -> Float
f Float
a0 Float
b0) (Float -> Float -> Float
f Float
a1 Float
b1) (Float -> Float -> Float
f Float
a2 Float
b2) (Float -> Float -> Float
f Float
a3 Float
b3)
    (Float -> Float -> Float
f Float
a4 Float
b4) (Float -> Float -> Float
f Float
a5 Float
b5) (Float -> Float -> Float
f Float
a6 Float
b6) (Float -> Float -> Float
f Float
a7 Float
b7)
    (Float -> Float -> Float
f Float
a8 Float
b8) (Float -> Float -> Float
f Float
a9 Float
b9) (Float -> Float -> Float
f Float
aA Float
bA) (Float -> Float -> Float
f Float
aB Float
bB)
    (Float -> Float -> Float
f Float
aC Float
bC) (Float -> Float -> Float
f Float
aD Float
bD) (Float -> Float -> Float
f Float
aE Float
bE) (Float -> Float -> Float
f Float
aF Float
bF)

{-# INLINE newMat4 #-}
newMat4 :: IO Mat4
newMat4 :: IO Mat4
newMat4 =
  (State# RealWorld -> (# State# RealWorld, Mat4 #)) -> IO Mat4
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO \State# RealWorld
world ->
    let
      !(# State# RealWorld
world_, MutableByteArray# RealWorld
arr_ #) = Int#
-> Int#
-> State# RealWorld
-> (# State# RealWorld, MutableByteArray# RealWorld #)
forall d.
Int# -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
newAlignedPinnedByteArray# Int#
64# Int#
16# State# RealWorld
world
      !(# State# RealWorld
_world', ByteArray#
arr #) = MutableByteArray# RealWorld
-> State# RealWorld -> (# State# RealWorld, ByteArray# #)
forall d.
MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
unsafeFreezeByteArray# MutableByteArray# RealWorld
arr_ State# RealWorld
world_
    in
      (# State# RealWorld
world, ByteArray# -> Mat4
Mat4 ByteArray#
arr #)

{-# INLINE scalarMultiply #-}
scalarMultiply :: Float -> Mat4 -> Mat4
scalarMultiply :: Float -> Mat4 -> Mat4
scalarMultiply Float
x Mat4
m =
  Mat4
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Mat4)
-> Mat4
forall r.
Mat4
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> r)
-> r
withMemory Mat4
m
    \ Float
e0 Float
e1 Float
e2 Float
e3
      Float
e4 Float
e5 Float
e6 Float
e7
      Float
e8 Float
e9 Float
eA Float
eB
      Float
eC Float
eD Float
eE Float
eF ->
      Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Mat4
fromMemory
      (Float
e0 Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
x) (Float
e1 Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
x) (Float
e2 Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
x) (Float
e3 Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
x)
      (Float
e4 Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
x) (Float
e5 Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
x) (Float
e6 Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
x) (Float
e7 Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
x)
      (Float
e8 Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
x) (Float
e9 Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
x) (Float
eA Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
x) (Float
eB Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
x)
      (Float
eC Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
x) (Float
eD Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
x) (Float
eE Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
x) (Float
eF Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
x)

instance Storable Mat4 where
  sizeOf :: Mat4 -> Int
sizeOf Mat4
_mat4 = Int
64

  alignment :: Mat4 -> Int
alignment Mat4
_mat4 = Int
16

  {-# INLINE poke #-}
  poke :: Ptr Mat4 -> Mat4 -> IO ()
poke (Ptr Addr#
addr) (Mat4 ByteArray#
arr) = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO \State# RealWorld
world ->
    let
      world' :: State# RealWorld
world' = ByteArray#
-> Int# -> Addr# -> Int# -> State# RealWorld -> State# RealWorld
forall d.
ByteArray# -> Int# -> Addr# -> Int# -> State# d -> State# d
copyByteArrayToAddr# ByteArray#
arr Int#
0# Addr#
addr Int#
64# State# RealWorld
world
    in
      (# State# RealWorld
world', () #)

  {-# INLINE peek #-}
  peek :: Ptr Mat4 -> IO Mat4
peek (Ptr Addr#
addr) = (State# RealWorld -> (# State# RealWorld, Mat4 #)) -> IO Mat4
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO \State# RealWorld
world ->
    let
      !(# State# RealWorld
world0, MutableByteArray# RealWorld
arr #)  = Int#
-> Int#
-> State# RealWorld
-> (# State# RealWorld, MutableByteArray# RealWorld #)
forall d.
Int# -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
newAlignedPinnedByteArray# Int#
64# Int#
16# State# RealWorld
world
      world1 :: State# RealWorld
world1              = Addr#
-> MutableByteArray# RealWorld
-> Int#
-> Int#
-> State# RealWorld
-> State# RealWorld
forall d.
Addr#
-> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
copyAddrToByteArray# Addr#
addr MutableByteArray# RealWorld
arr Int#
0# Int#
64# State# RealWorld
world0
      !(# State# RealWorld
world', ByteArray#
arr' #) = MutableByteArray# RealWorld
-> State# RealWorld -> (# State# RealWorld, ByteArray# #)
forall d.
MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
unsafeFreezeByteArray# MutableByteArray# RealWorld
arr State# RealWorld
world1
    in
      (# State# RealWorld
world', ByteArray# -> Mat4
Mat4 ByteArray#
arr' #)

instance Block Mat4 where
  type PackedSize Mat4 = 64
  alignment140 :: forall (proxy :: * -> *). proxy Mat4 -> Int
alignment140 proxy Mat4
_  = Int
16
  sizeOf140 :: forall (proxy :: * -> *). proxy Mat4 -> Int
sizeOf140       = proxy Mat4 -> Int
forall b (proxy :: * -> *). Block b => proxy b -> Int
forall (proxy :: * -> *). proxy Mat4 -> Int
sizeOfPacked
  alignment430 :: forall (proxy :: * -> *). proxy Mat4 -> Int
alignment430    = proxy Mat4 -> Int
forall b (proxy :: * -> *). Block b => proxy b -> Int
forall (proxy :: * -> *). proxy Mat4 -> Int
alignment140
  sizeOf430 :: forall (proxy :: * -> *). proxy Mat4 -> Int
sizeOf430       = proxy Mat4 -> Int
forall b (proxy :: * -> *). Block b => proxy b -> Int
forall (proxy :: * -> *). proxy Mat4 -> Int
sizeOf140
  isStruct :: forall (proxy :: * -> *). proxy Mat4 -> Bool
isStruct proxy Mat4
_      = Bool
False
  read140 :: forall (m :: * -> *) a. MonadIO m => Ptr a -> Diff a Mat4 -> m Mat4
read140     = Ptr a -> Diff a Mat4 -> m Mat4
forall (m :: * -> *) b a.
(MonadIO m, Storable b) =>
Ptr a -> Diff a b -> m b
peekDiffOff
  write140 :: forall (m :: * -> *) a.
MonadIO m =>
Ptr a -> Diff a Mat4 -> Mat4 -> m ()
write140    = Ptr a -> Diff a Mat4 -> Mat4 -> m ()
forall (m :: * -> *) b a.
(MonadIO m, Storable b) =>
Ptr a -> Diff a b -> b -> m ()
pokeDiffOff
  read430 :: forall (m :: * -> *) a. MonadIO m => Ptr a -> Diff a Mat4 -> m Mat4
read430     = Ptr a -> Diff a Mat4 -> m Mat4
forall b (m :: * -> *) a.
(Block b, MonadIO m) =>
Ptr a -> Diff a b -> m b
forall (m :: * -> *) a. MonadIO m => Ptr a -> Diff a Mat4 -> m Mat4
read140
  write430 :: forall (m :: * -> *) a.
MonadIO m =>
Ptr a -> Diff a Mat4 -> Mat4 -> m ()
write430    = Ptr a -> Diff a Mat4 -> Mat4 -> m ()
forall b (m :: * -> *) a.
(Block b, MonadIO m) =>
Ptr a -> Diff a b -> b -> m ()
forall (m :: * -> *) a.
MonadIO m =>
Ptr a -> Diff a Mat4 -> Mat4 -> m ()
write140
  readPacked :: forall (m :: * -> *) a. MonadIO m => Ptr a -> Diff a Mat4 -> m Mat4
readPacked  = Ptr a -> Diff a Mat4 -> m Mat4
forall b (m :: * -> *) a.
(Block b, MonadIO m) =>
Ptr a -> Diff a b -> m b
forall (m :: * -> *) a. MonadIO m => Ptr a -> Diff a Mat4 -> m Mat4
read140
  writePacked :: forall (m :: * -> *) a.
MonadIO m =>
Ptr a -> Diff a Mat4 -> Mat4 -> m ()
writePacked = Ptr a -> Diff a Mat4 -> Mat4 -> m ()
forall b (m :: * -> *) a.
(Block b, MonadIO m) =>
Ptr a -> Diff a b -> b -> m ()
forall (m :: * -> *) a.
MonadIO m =>
Ptr a -> Diff a Mat4 -> Mat4 -> m ()
write140
  {-# INLINE alignment140 #-}
  {-# INLINE sizeOf140 #-}
  {-# INLINE alignment430 #-}
  {-# INLINE sizeOf430 #-}
  {-# INLINE isStruct #-}
  {-# INLINE read140 #-}
  {-# INLINE write140 #-}
  {-# INLINE read430 #-}
  {-# INLINE write430 #-}
  {-# INLINE readPacked #-}
  {-# INLINE writePacked #-}

toListMemory :: Mat4 -> [Float]
toListMemory :: Mat4 -> [Float]
toListMemory = (Mat4
 -> (Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> [Float])
 -> [Float])
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> [Float])
-> Mat4
-> [Float]
forall a b c. (a -> b -> c) -> b -> a -> c
flip Mat4
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> [Float])
-> [Float]
forall r.
Mat4
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> r)
-> r
withMemory
    \ Float
e0 Float
e1 Float
e2 Float
e3
      Float
e4 Float
e5 Float
e6 Float
e7
      Float
e8 Float
e9 Float
eA Float
eB
      Float
eC Float
eD Float
eE Float
eF ->
    [ Float
e0, Float
e1, Float
e2, Float
e3
    , Float
e4, Float
e5, Float
e6, Float
e7
    , Float
e8, Float
e9, Float
eA, Float
eB
    , Float
eC, Float
eD, Float
eE, Float
eF
    ]

toList2dMemory :: Mat4 -> [[Float]]
toList2dMemory :: Mat4 -> [[Float]]
toList2dMemory = (Mat4
 -> (Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> [[Float]])
 -> [[Float]])
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> [[Float]])
-> Mat4
-> [[Float]]
forall a b c. (a -> b -> c) -> b -> a -> c
flip Mat4
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> [[Float]])
-> [[Float]]
forall r.
Mat4
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> r)
-> r
withMemory
    \ Float
e0 Float
e1 Float
e2 Float
e3
      Float
e4 Float
e5 Float
e6 Float
e7
      Float
e8 Float
e9 Float
eA Float
eB
      Float
eC Float
eD Float
eE Float
eF ->
    [ [Float
e0, Float
e1, Float
e2, Float
e3]
    , [Float
e4, Float
e5, Float
e6, Float
e7]
    , [Float
e8, Float
e9, Float
eA, Float
eB]
    , [Float
eC, Float
eD, Float
eE, Float
eF]
    ]

toListTrans :: Mat4 -> [Float]
toListTrans :: Mat4 -> [Float]
toListTrans = (Mat4
 -> (Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> [Float])
 -> [Float])
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> [Float])
-> Mat4
-> [Float]
forall a b c. (a -> b -> c) -> b -> a -> c
flip Mat4
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> [Float])
-> [Float]
forall r.
Mat4
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> r)
-> r
withMemory
    \ Float
e0 Float
e1 Float
e2 Float
e3
      Float
e4 Float
e5 Float
e6 Float
e7
      Float
e8 Float
e9 Float
eA Float
eB
      Float
eC Float
eD Float
eE Float
eF ->
    [ Float
e0, Float
e4, Float
e8, Float
eC
    , Float
e1, Float
e5, Float
e9, Float
eD
    , Float
e2, Float
e6, Float
eA, Float
eE
    , Float
e3, Float
e7, Float
eB, Float
eF
    ]

toList2dTrans :: Mat4 -> [[Float]]
toList2dTrans :: Mat4 -> [[Float]]
toList2dTrans = (Mat4
 -> (Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> Float
     -> [[Float]])
 -> [[Float]])
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> [[Float]])
-> Mat4
-> [[Float]]
forall a b c. (a -> b -> c) -> b -> a -> c
flip Mat4
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> [[Float]])
-> [[Float]]
forall r.
Mat4
-> (Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> r)
-> r
withMemory
    \ Float
e0 Float
e1 Float
e2 Float
e3
      Float
e4 Float
e5 Float
e6 Float
e7
      Float
e8 Float
e9 Float
eA Float
eB
      Float
eC Float
eD Float
eE Float
eF ->
    [ [Float
e0, Float
e4, Float
e8, Float
eC]
    , [Float
e1, Float
e5, Float
e9, Float
eD]
    , [Float
e2, Float
e6, Float
eA, Float
eE]
    , [Float
e3, Float
e7, Float
eB, Float
eF]
    ]

zipWith :: (Float -> Float -> c) -> Mat4 -> Mat4 -> [c]
zipWith :: forall c. (Float -> Float -> c) -> Mat4 -> Mat4 -> [c]
zipWith Float -> Float -> c
f Mat4
a Mat4
b = (Float -> Float -> c) -> [Float] -> [Float] -> [c]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
List.zipWith Float -> Float -> c
f (Mat4 -> [Float]
toListMemory Mat4
a) (Mat4 -> [Float]
toListMemory Mat4
b)