Run "ormolu" on all source files.

1 files changed, 379 insertions, 173 deletions

diff --git a/Graphics/Glyph/Mat4.hs b/Graphics/Glyph/Mat4.hs
index 6581126..9ef922f 100644
--- a/Graphics/Glyph/Mat4.hs
+++ b/Graphics/Glyph/Mat4.hs
@@ -1,224 +1,430 @@
-{-# LANGUAGE MultiParamTypeClasses, FlexibleContexts #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+
 module Graphics.Glyph.Mat4 where
 
 import Control.Monad
-
 import Foreign.Marshal.Alloc
 import Foreign.Marshal.Array
 import Foreign.Ptr
 import Foreign.Storable
-
-import Graphics.Rendering.OpenGL
 import Graphics.GL.Compatibility30
--- import Graphics.Rendering.OpenGL.Raw.Core31
+import Graphics.Rendering.OpenGL
 
-data Mat4 a = Matrix (a,a,a,a,
-                      a,a,a,a,
-                      a,a,a,a,
-                      a,a,a,a) | IdentityMatrix
+-- import Graphics.Rendering.OpenGL.Raw.Core31
 
-data Mat3 a = Matrix3 ( a,a,a,
-                        a,a,a,
-                        a,a,a ) | IdentityMatrix3
+data Mat4 a
+  = Matrix
+      ( a,
+        a,
+        a,
+        a,
+        a,
+        a,
+        a,
+        a,
+        a,
+        a,
+        a,
+        a,
+        a,
+        a,
+        a,
+        a
+      )
+  | IdentityMatrix
+
+data Mat3 a
+  = Matrix3
+      ( a,
+        a,
+        a,
+        a,
+        a,
+        a,
+        a,
+        a,
+        a
+      )
+  | IdentityMatrix3
 
 class StorableMatrix t a where
-    fromList :: [t] -> a t
-    toPtr :: a t -> (Ptr t -> IO b) -> IO b
-    fromPtr :: Ptr t -> (a t -> IO b) -> IO b
+  fromList :: [t] -> a t
+  toPtr :: a t -> (Ptr t -> IO b) -> IO b
+  fromPtr :: Ptr t -> (a t -> IO b) -> IO b
 
 instance (Storable t) => StorableMatrix t Mat4 where
-    fromList (m1:m2:m3:m4:m5:m6:m7:m8:m9:m10:m11:m12:m13:m14:m15:m16:_) =
-        Matrix (m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15,m16)
+  fromList (m1 : m2 : m3 : m4 : m5 : m6 : m7 : m8 : m9 : m10 : m11 : m12 : m13 : m14 : m15 : m16 : _) =
+    Matrix (m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16)
 
-    toPtr (Matrix (m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15,m16)) fun =
-        allocaArray 16 $ \ptr -> do
-            pokeArray ptr [m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15,m16]
-            fun ptr
+  toPtr (Matrix (m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16)) fun =
+    allocaArray 16 $ \ptr -> do
+      pokeArray ptr [m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16]
+      fun ptr
 
-    fromPtr ptr f = peekArray 16 ptr >>= f . fromList
+  fromPtr ptr f = peekArray 16 ptr >>= f . fromList
 
 instance (Storable t) => StorableMatrix t Mat3 where
-    fromList (m1:m2:m3:m4:m5:m6:m7:m8:m9:_) =
-        Matrix3 (m1,m2,m3,m4,m5,m6,m7,m8,m9)
+  fromList (m1 : m2 : m3 : m4 : m5 : m6 : m7 : m8 : m9 : _) =
+    Matrix3 (m1, m2, m3, m4, m5, m6, m7, m8, m9)
 
-    toPtr (Matrix3 (m1,m2,m3,m4,m5,m6,m7,m8,m9)) fun =
-        allocaArray 9 $ \ptr -> do
-            pokeArray ptr [m1,m2,m3,m4,m5,m6,m7,m8,m9]
-            fun ptr
+  toPtr (Matrix3 (m1, m2, m3, m4, m5, m6, m7, m8, m9)) fun =
+    allocaArray 9 $ \ptr -> do
+      pokeArray ptr [m1, m2, m3, m4, m5, m6, m7, m8, m9]
+      fun ptr
 
-    fromPtr ptr f = peekArray 9 ptr >>= f . fromList
+  fromPtr ptr f = peekArray 9 ptr >>= f . fromList
 
 instance Uniform (Mat4 GLfloat) where
-    uniform (UniformLocation loc)  = makeStateVar getter setter
-                    where setter mat = toPtr mat $ \ptr ->
-                                    glUniformMatrix4fv loc 1 (fromIntegral GL_FALSE) ptr
-                          getter :: IO (Mat4 GLfloat)
-                          getter = do
-                                pid <- liftM fromIntegral getCurrentProgram
-                                ( allocaArray 16 $ \buf -> do
-                                    glGetUniformfv pid loc buf
-                                    fromPtr buf return )
+  uniform (UniformLocation loc) = makeStateVar getter setter
+    where
+      setter mat = toPtr mat $ \ptr ->
+        glUniformMatrix4fv loc 1 (fromIntegral GL_FALSE) ptr
+      getter :: IO (Mat4 GLfloat)
+      getter = do
+        pid <- liftM fromIntegral getCurrentProgram
+        ( allocaArray 16 $ \buf -> do
+            glGetUniformfv pid loc buf
+            fromPtr buf return
+          )
 
 instance Uniform (Mat3 GLfloat) where
-    uniform (UniformLocation loc)  = makeStateVar getter setter
-                    where setter mat = toPtr mat $ \ptr ->
-                                    glUniformMatrix3fv loc 1 (fromIntegral GL_FALSE) ptr
-                          getter :: IO (Mat3 GLfloat)
-                          getter = do
-                                pid <- liftM fromIntegral getCurrentProgram
-                                ( allocaArray 9 $ \buf -> do
-                                    glGetUniformfv pid loc buf
-                                    fromPtr buf return )
+  uniform (UniformLocation loc) = makeStateVar getter setter
+    where
+      setter mat = toPtr mat $ \ptr ->
+        glUniformMatrix3fv loc 1 (fromIntegral GL_FALSE) ptr
+      getter :: IO (Mat3 GLfloat)
+      getter = do
+        pid <- liftM fromIntegral getCurrentProgram
+        ( allocaArray 9 $ \buf -> do
+            glGetUniformfv pid loc buf
+            fromPtr buf return
+          )
 
 getCurrentProgram :: IO GLint
 getCurrentProgram = alloca $ \ptr -> glGetIntegerv GL_CURRENT_PROGRAM ptr >> peek ptr
 
 instance (Show a) => Show (Mat4 a) where
-    show IdentityMatrix =
-        "[ 1 0 0 0\n" ++
-        "  0 1 0 0\n" ++
-        "  0 0 1 0\n" ++
-        "  0 0 0 1 ]\n"
-    show (Matrix (m00,m01,m02,m03,m10,m11,m12,m13,m20,m21,m22,m23,m30,m31,m32,m33)) =
-        "["++! m00 ++ " " ++! m01 ++ " " ++! m02 ++ " " ++! m03 ++ "\n" ++
-        " "++! m10 ++ " " ++! m11 ++ " " ++! m12 ++ " " ++! m13 ++ "\n" ++
-        " "++! m20 ++ " " ++! m21 ++ " " ++! m22 ++ " " ++! m23 ++ "\n" ++
-        " "++! m30 ++ " " ++! m31 ++ " " ++! m32 ++ " " ++! m33 ++ "]"
-     where (++!) a = (a++) . show
-        
-
-    
-
-translateMat4 :: (Num a) => Mat4 a -> (a,a,a,a) -> Mat4 a
-translateMat4 IdentityMatrix x = translateMat4 (Matrix (1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1)) x
-translateMat4  (Matrix (m00,m01,m02,m03,
-                        m10,m11,m12,m13,
-                        m20,m21,m22,m23,
-                        m30,m31,m32,m33)) (v0,v1,v2,v3) =
-                Matrix (m00,m01,m02,m03+v0,
-                        m10,m11,m12,m13+v1,
-                        m20,m21,m22,m23+v2,
-                        m30,m31,m32,m33+v3)
-
-applyMatrix :: (Num a) => Mat4 a -> (a,a,a,a) -> (a,a,a,a)
-applyMatrix  (Matrix (m00,m01,m02,m03,
-              m10,m11,m12,m13,
-              m20,m21,m22,m23,
-              m30,m31,m32,m33)) (v0,v1,v2,v3) =
-                ( v0 * m00 + v1 * m01 + v2 * m02 + v3 * m03,
-                  v0 * m10 + v1 * m11 + v2 * m12 + v3 * m13,
-                  v0 * m20 + v1 * m21 + v2 * m22 + v3 * m23,
-                  v0 * m30 + v1 * m31 + v2 * m32 + v3 * m33 )
-
+  show IdentityMatrix =
+    "[ 1 0 0 0\n"
+      ++ "  0 1 0 0\n"
+      ++ "  0 0 1 0\n"
+      ++ "  0 0 0 1 ]\n"
+  show (Matrix (m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33)) =
+    "[" ++! m00 ++ " " ++! m01 ++ " " ++! m02 ++ " " ++! m03 ++ "\n"
+      ++ " " ++! m10
+      ++ " " ++! m11
+      ++ " " ++! m12
+      ++ " " ++! m13
+      ++ "\n"
+      ++ " " ++! m20
+      ++ " " ++! m21
+      ++ " " ++! m22
+      ++ " " ++! m23
+      ++ "\n"
+      ++ " " ++! m30
+      ++ " " ++! m31
+      ++ " " ++! m32
+      ++ " " ++! m33
+      ++ "]"
+    where
+      (++!) a = (a ++) . show
+
+translateMat4 :: (Num a) => Mat4 a -> (a, a, a, a) -> Mat4 a
+translateMat4 IdentityMatrix x = translateMat4 (Matrix (1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)) x
+translateMat4
+  ( Matrix
+      ( m00,
+        m01,
+        m02,
+        m03,
+        m10,
+        m11,
+        m12,
+        m13,
+        m20,
+        m21,
+        m22,
+        m23,
+        m30,
+        m31,
+        m32,
+        m33
+        )
+    )
+  (v0, v1, v2, v3) =
+    Matrix
+      ( m00,
+        m01,
+        m02,
+        m03 + v0,
+        m10,
+        m11,
+        m12,
+        m13 + v1,
+        m20,
+        m21,
+        m22,
+        m23 + v2,
+        m30,
+        m31,
+        m32,
+        m33 + v3
+      )
+
+applyMatrix :: (Num a) => Mat4 a -> (a, a, a, a) -> (a, a, a, a)
+applyMatrix
+  ( Matrix
+      ( m00,
+        m01,
+        m02,
+        m03,
+        m10,
+        m11,
+        m12,
+        m13,
+        m20,
+        m21,
+        m22,
+        m23,
+        m30,
+        m31,
+        m32,
+        m33
+        )
+    )
+  (v0, v1, v2, v3) =
+    ( v0 * m00 + v1 * m01 + v2 * m02 + v3 * m03,
+      v0 * m10 + v1 * m11 + v2 * m12 + v3 * m13,
+      v0 * m20 + v1 * m21 + v2 * m22 + v3 * m23,
+      v0 * m30 + v1 * m31 + v2 * m32 + v3 * m33
+    )
 applyMatrix IdentityMatrix v = v
 
-scaleMatrix :: (Num a) => Mat4 a -> (a,a,a) -> Mat4 a
-scaleMatrix IdentityMatrix (a,b,c) = Matrix ( a,0,0,0,
-                               0,b,0,0,
-                               0,0,c,0,
-                               0,0,0,1)
-
-scaleMatrix (Matrix (m00,m01,m02,m03,m10,m11,m12,m13,m20,m21,m22,m23,m30,m31,m32,m33)) (a,b,c)
-                    = Matrix ( m00*a,m01,m02,m03,
-                               m10,m11*b,m12,m13,
-                               m20,m21,m22*c,m23,
-                               m30,m31,m32,m33)
+scaleMatrix :: (Num a) => Mat4 a -> (a, a, a) -> Mat4 a
+scaleMatrix IdentityMatrix (a, b, c) =
+  Matrix
+    ( a,
+      0,
+      0,
+      0,
+      0,
+      b,
+      0,
+      0,
+      0,
+      0,
+      c,
+      0,
+      0,
+      0,
+      0,
+      1
+    )
+scaleMatrix (Matrix (m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33)) (a, b, c) =
+  Matrix
+    ( m00 * a,
+      m01,
+      m02,
+      m03,
+      m10,
+      m11 * b,
+      m12,
+      m13,
+      m20,
+      m21,
+      m22 * c,
+      m23,
+      m30,
+      m31,
+      m32,
+      m33
+    )
 
 applyMatrixToList :: (Num a) => Mat4 a -> [a] -> [a]
 applyMatrixToList IdentityMatrix t = t
-applyMatrixToList mat (a:b:c:xs) =
-    let (a',b',c',_) = applyMatrix mat (a,b,c,1) in
-    (a':b':c':applyMatrixToList mat xs)
-
+applyMatrixToList mat (a : b : c : xs) =
+  let (a', b', c', _) = applyMatrix mat (a, b, c, 1)
+   in (a' : b' : c' : applyMatrixToList mat xs)
 applyMatrixToList _ _ = []
 
 mulMatrix4 :: (Num a) => Mat4 a -> Mat4 a -> Mat4 a
 mulMatrix4 IdentityMatrix a = a
 mulMatrix4 a IdentityMatrix = a
 mulMatrix4
-    (Matrix (a00,a01,a02,a03,
-              a10,a11,a12,a13,
-              a20,a21,a22,a23,
-              a30,a31,a32,a33 ))
-    (Matrix (b00,b01,b02,b03,
-              b10,b11,b12,b13,
-              b20,b21,b22,b23,
-              b30,b31,b32,b33 )) =
-                Matrix  (b00*a00+b10*a01+b20*a02+b30*a03,
-                         b01*a00+b11*a01+b21*a02+b31*a03,
-                         b02*a00+b12*a01+b22*a02+b32*a03,
-                         b03*a00+b13*a01+b23*a02+b33*a03,
-
-                         b00*a10+b10*a11+b20*a12+b30*a13,
-                         b01*a10+b11*a11+b21*a12+b31*a13,
-                         b02*a10+b12*a11+b22*a12+b32*a13,
-                         b03*a10+b13*a11+b23*a12+b33*a13,
-
-                         b00*a20+b10*a21+b20*a22+b30*a23,
-                         b01*a20+b11*a21+b21*a22+b31*a23,
-                         b02*a20+b12*a21+b22*a22+b32*a23,
-                         b03*a20+b13*a21+b23*a22+b33*a23,
-
-                         b00*a30+b10*a31+b20*a32+b30*a33,
-                         b01*a30+b11*a31+b21*a32+b31*a33,
-                         b02*a30+b12*a31+b22*a32+b32*a33,
-                         b03*a30+b13*a31+b23*a32+b33*a33 )
+  ( Matrix
+      ( a00,
+        a01,
+        a02,
+        a03,
+        a10,
+        a11,
+        a12,
+        a13,
+        a20,
+        a21,
+        a22,
+        a23,
+        a30,
+        a31,
+        a32,
+        a33
+        )
+    )
+  ( Matrix
+      ( b00,
+        b01,
+        b02,
+        b03,
+        b10,
+        b11,
+        b12,
+        b13,
+        b20,
+        b21,
+        b22,
+        b23,
+        b30,
+        b31,
+        b32,
+        b33
+        )
+    ) =
+    Matrix
+      ( b00 * a00 + b10 * a01 + b20 * a02 + b30 * a03,
+        b01 * a00 + b11 * a01 + b21 * a02 + b31 * a03,
+        b02 * a00 + b12 * a01 + b22 * a02 + b32 * a03,
+        b03 * a00 + b13 * a01 + b23 * a02 + b33 * a03,
+        b00 * a10 + b10 * a11 + b20 * a12 + b30 * a13,
+        b01 * a10 + b11 * a11 + b21 * a12 + b31 * a13,
+        b02 * a10 + b12 * a11 + b22 * a12 + b32 * a13,
+        b03 * a10 + b13 * a11 + b23 * a12 + b33 * a13,
+        b00 * a20 + b10 * a21 + b20 * a22 + b30 * a23,
+        b01 * a20 + b11 * a21 + b21 * a22 + b31 * a23,
+        b02 * a20 + b12 * a21 + b22 * a22 + b32 * a23,
+        b03 * a20 + b13 * a21 + b23 * a22 + b33 * a23,
+        b00 * a30 + b10 * a31 + b20 * a32 + b30 * a33,
+        b01 * a30 + b11 * a31 + b21 * a32 + b31 * a33,
+        b02 * a30 + b12 * a31 + b22 * a32 + b32 * a33,
+        b03 * a30 + b13 * a31 + b23 * a32 + b33 * a33
+      )
 
 (|*|) :: (Num a) => Mat4 a -> Mat4 a -> Mat4 a
 (|*|) = mulMatrix4
 
 transpose4 :: Mat4 a -> Mat4 a
-transpose4 (Matrix
-                (m00,m01,m02,m03,
-                 m10,m11,m12,m13,
-                 m20,m21,m22,m23,
-                 m30,m31,m32,m33 ))  = (Matrix (m00, m10, m20, m30,
-                                                m01, m11, m21, m31,
-                                                m02, m12, m22, m32,
-                                                m03, m13, m23, m33))
+transpose4
+  ( Matrix
+      ( m00,
+        m01,
+        m02,
+        m03,
+        m10,
+        m11,
+        m12,
+        m13,
+        m20,
+        m21,
+        m22,
+        m23,
+        m30,
+        m31,
+        m32,
+        m33
+        )
+    ) =
+    ( Matrix
+        ( m00,
+          m10,
+          m20,
+          m30,
+          m01,
+          m11,
+          m21,
+          m31,
+          m02,
+          m12,
+          m22,
+          m32,
+          m03,
+          m13,
+          m23,
+          m33
+        )
+    )
+
 scale4 :: (Num a) => a -> Mat4 a -> Mat4 a
-scale4 n (Matrix (m11,m12,m13,m14,m21,m22,m23,m24,m31,m32,m33,m34,m41,m42,m43,m44)) =
-    Matrix (m11*n,m12*n,m13*n,m14*n,m21*n,m22*n,m23*n,m24*n,m31*n,m32*n,m33*n,m34*n,m41*n,m42*n,m43*n,m44*n)
+scale4 n (Matrix (m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44)) =
+  Matrix (m11 * n, m12 * n, m13 * n, m14 * n, m21 * n, m22 * n, m23 * n, m24 * n, m31 * n, m32 * n, m33 * n, m34 * n, m41 * n, m42 * n, m43 * n, m44 * n)
 
 det4 :: (Num a) => Mat4 a -> a
-det4 (Matrix (m11,m12,m13,m14,m21,m22,m23,m24,m31,m32,m33,m34,m41,m42,m43,m44)) =
-          m11*m22*m33*m44 + m11*m23*m34*m42 + m11*m24*m32*m43
-        + m12*m21*m34*m43 + m12*m23*m31*m44 + m12*m24*m33*m41
-        + m13*m21*m32*m44 + m13*m22*m34*m41 + m13*m24*m31*m42
-        + m14*m21*m33*m42 + m14*m22*m31*m43 + m14*m23*m32*m41
-        - m11*m22*m34*m43 - m11*m23*m32*m44 - m11*m24*m33*m42
-        - m12*m21*m33*m44 - m12*m23*m34*m41 - m12*m24*m31*m43
-        - m13*m21*m34*m42 - m13*m22*m31*m44 - m13*m24*m32*m41
-        - m14*m21*m32*m43 - m14*m22*m33*m41 - m14*m23*m31*m42
-
-inv4 :: (Floating a,Eq a) => Mat4 a -> Maybe (Mat4 a)
-inv4 mat@(Matrix (m11,m12,m13,m14,m21,m22,m23,m24,m31,m32,m33,m34,m41,m42,m43,m44)) =
-        let b11 = m22*m33*m44 + m23*m34*m42 + m24*m32*m43 - m22*m34*m43 - m23*m32*m44 - m24*m33*m42
-            b12 = m12*m34*m43 + m13*m32*m44 + m14*m33*m42 - m12*m33*m44 - m13*m34*m42 - m14*m32*m43
-            b13 = m12*m23*m44 + m13*m24*m42 + m14*m22*m43 - m12*m24*m43 - m13*m22*m44 - m14*m23*m42
-            b14 = m12*m24*m33 + m13*m22*m34 + m14*m23*m32 - m12*m23*m34 - m13*m24*m32 - m14*m22*m33
-            b21 = m21*m34*m43 + m23*m31*m44 + m24*m33*m41 - m21*m33*m44 - m23*m34*m41 - m24*m31*m43
-            b22 = m11*m33*m44 + m13*m34*m41 + m14*m31*m43 - m11*m34*m43 - m13*m31*m44 - m14*m33*m41
-            b23 = m11*m24*m43 + m13*m21*m44 + m14*m23*m41 - m11*m23*m44 - m13*m24*m41 - m14*m21*m43
-            b24 = m11*m23*m34 + m13*m24*m31 + m14*m21*m33 - m11*m24*m33 - m13*m21*m34 - m14*m23*m31
-            b31 = m21*m32*m44 + m22*m34*m41 + m24*m31*m42 - m21*m34*m42 - m22*m31*m44 - m24*m32*m41
-            b32 = m11*m34*m42 + m12*m31*m44 + m14*m32*m41 - m11*m32*m44 - m12*m34*m41 - m14*m31*m42
-            b33 = m11*m22*m44 + m12*m24*m41 + m14*m21*m42 - m11*m24*m42 - m12*m21*m44 - m14*m22*m41
-            b34 = m11*m24*m32 + m12*m21*m34 + m14*m22*m31 - m11*m22*m34 - m12*m24*m31 - m14*m21*m32
-            b41 = m21*m33*m42 + m22*m31*m43 + m23*m32*m41 - m21*m32*m43 - m22*m33*m41 - m23*m31*m42
-            b42 = m11*m32*m43 + m12*m33*m41 + m13*m31*m42 - m11*m33*m42 - m12*m31*m43 - m13*m32*m41
-            b43 = m11*m23*m42 + m12*m21*m43 + m13*m22*m41 - m11*m22*m43 - m12*m23*m41 - m13*m21*m42
-            b44 = m11*m22*m33 + m12*m23*m31 + m13*m21*m32 - m11*m23*m32 - m12*m21*m33 - m13*m22*m31 in
-            case det4 mat of
-                0 -> Nothing
-                det -> Just $ (1 / det) `scale4` Matrix (b11,b12,b13,b14,b21,b22,b23,b24,b31,b32,b33,b34,b41,b42,b43,b44)
+det4 (Matrix (m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44)) =
+  m11 * m22 * m33 * m44 + m11 * m23 * m34 * m42 + m11 * m24 * m32 * m43
+    + m12 * m21 * m34 * m43
+    + m12 * m23 * m31 * m44
+    + m12 * m24 * m33 * m41
+    + m13 * m21 * m32 * m44
+    + m13 * m22 * m34 * m41
+    + m13 * m24 * m31 * m42
+    + m14 * m21 * m33 * m42
+    + m14 * m22 * m31 * m43
+    + m14 * m23 * m32 * m41
+    - m11 * m22 * m34 * m43
+    - m11 * m23 * m32 * m44
+    - m11 * m24 * m33 * m42
+    - m12 * m21 * m33 * m44
+    - m12 * m23 * m34 * m41
+    - m12 * m24 * m31 * m43
+    - m13 * m21 * m34 * m42
+    - m13 * m22 * m31 * m44
+    - m13 * m24 * m32 * m41
+    - m14 * m21 * m32 * m43
+    - m14 * m22 * m33 * m41
+    - m14 * m23 * m31 * m42
+
+inv4 :: (Floating a, Eq a) => Mat4 a -> Maybe (Mat4 a)
+inv4 mat@(Matrix (m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44)) =
+  let b11 = m22 * m33 * m44 + m23 * m34 * m42 + m24 * m32 * m43 - m22 * m34 * m43 - m23 * m32 * m44 - m24 * m33 * m42
+      b12 = m12 * m34 * m43 + m13 * m32 * m44 + m14 * m33 * m42 - m12 * m33 * m44 - m13 * m34 * m42 - m14 * m32 * m43
+      b13 = m12 * m23 * m44 + m13 * m24 * m42 + m14 * m22 * m43 - m12 * m24 * m43 - m13 * m22 * m44 - m14 * m23 * m42
+      b14 = m12 * m24 * m33 + m13 * m22 * m34 + m14 * m23 * m32 - m12 * m23 * m34 - m13 * m24 * m32 - m14 * m22 * m33
+      b21 = m21 * m34 * m43 + m23 * m31 * m44 + m24 * m33 * m41 - m21 * m33 * m44 - m23 * m34 * m41 - m24 * m31 * m43
+      b22 = m11 * m33 * m44 + m13 * m34 * m41 + m14 * m31 * m43 - m11 * m34 * m43 - m13 * m31 * m44 - m14 * m33 * m41
+      b23 = m11 * m24 * m43 + m13 * m21 * m44 + m14 * m23 * m41 - m11 * m23 * m44 - m13 * m24 * m41 - m14 * m21 * m43
+      b24 = m11 * m23 * m34 + m13 * m24 * m31 + m14 * m21 * m33 - m11 * m24 * m33 - m13 * m21 * m34 - m14 * m23 * m31
+      b31 = m21 * m32 * m44 + m22 * m34 * m41 + m24 * m31 * m42 - m21 * m34 * m42 - m22 * m31 * m44 - m24 * m32 * m41
+      b32 = m11 * m34 * m42 + m12 * m31 * m44 + m14 * m32 * m41 - m11 * m32 * m44 - m12 * m34 * m41 - m14 * m31 * m42
+      b33 = m11 * m22 * m44 + m12 * m24 * m41 + m14 * m21 * m42 - m11 * m24 * m42 - m12 * m21 * m44 - m14 * m22 * m41
+      b34 = m11 * m24 * m32 + m12 * m21 * m34 + m14 * m22 * m31 - m11 * m22 * m34 - m12 * m24 * m31 - m14 * m21 * m32
+      b41 = m21 * m33 * m42 + m22 * m31 * m43 + m23 * m32 * m41 - m21 * m32 * m43 - m22 * m33 * m41 - m23 * m31 * m42
+      b42 = m11 * m32 * m43 + m12 * m33 * m41 + m13 * m31 * m42 - m11 * m33 * m42 - m12 * m31 * m43 - m13 * m32 * m41
+      b43 = m11 * m23 * m42 + m12 * m21 * m43 + m13 * m22 * m41 - m11 * m22 * m43 - m12 * m23 * m41 - m13 * m21 * m42
+      b44 = m11 * m22 * m33 + m12 * m23 * m31 + m13 * m21 * m32 - m11 * m23 * m32 - m12 * m21 * m33 - m13 * m22 * m31
+   in case det4 mat of
+        0 -> Nothing
+        det -> Just $ (1 / det) `scale4` Matrix (b11, b12, b13, b14, b21, b22, b23, b24, b31, b32, b33, b34, b41, b42, b43, b44)
 
 trunc4 :: Mat4 a -> Mat3 a
-trunc4 (Matrix
-        (m11,m12,m13,_,
-         m21,m22,m23,_,
-         m31,m32,m33,_,
-          _ , _ , _ ,_)) = Matrix3 (m11,m12,m13,m21,m22,m23,m31,m32,m33)
-
-toNormalMatrix :: (Floating a,Eq a) => Mat4 a -> Maybe (Mat3 a)
+trunc4
+  ( Matrix
+      ( m11,
+        m12,
+        m13,
+        _,
+        m21,
+        m22,
+        m23,
+        _,
+        m31,
+        m32,
+        m33,
+        _,
+        _,
+        _,
+        _,
+        _
+        )
+    ) = Matrix3 (m11, m12, m13, m21, m22, m23, m31, m32, m33)
+
+toNormalMatrix :: (Floating a, Eq a) => Mat4 a -> Maybe (Mat3 a)
 toNormalMatrix mat = inv4 mat >>= return . trunc4 . transpose4