{-# LINE 1 "src/Box2D/MathTypes.hsc" #-}
-- | Low-level bindings to the value types in @box2d/math_functions.h@.
--
-- These are the small POD math structs that the Box2D API passes and returns
-- by value. Field order matches the C layout; 'Storable' offsets come straight
-- from the header via @hsc2hs@. Fields are 'Float' because C @float@ maps to
-- the Haskell FFI 'Float' with an identical representation.
--
-- In single-precision builds (the default) @b2Pos@ and @b2WorldTransform@ are
-- typedefs for @b2Vec2@ and @b2Transform@, so 'Pos' and 'WorldTransform' are
-- type synonyms here.
module Box2D.MathTypes
  ( Vec2 (..)
  , CosSin (..)
  , Rot (..)
  , Transform (..)
  , Mat22 (..)
  , AABB (..)
  , Plane (..)
  , Pos
  , WorldTransform

    -- * Constants
  , vec2Zero
  , rotIdentity
  , transformIdentity
  ) where

import Foreign



-- | A 2D vector.
data Vec2 = Vec2 Float Float
  deriving (Vec2 -> Vec2 -> Bool
(Vec2 -> Vec2 -> Bool) -> (Vec2 -> Vec2 -> Bool) -> Eq Vec2
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Vec2 -> Vec2 -> Bool
== :: Vec2 -> Vec2 -> Bool
$c/= :: Vec2 -> Vec2 -> Bool
/= :: Vec2 -> Vec2 -> Bool
Eq, Int -> Vec2 -> ShowS
[Vec2] -> ShowS
Vec2 -> String
(Int -> Vec2 -> ShowS)
-> (Vec2 -> String) -> ([Vec2] -> ShowS) -> Show Vec2
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Vec2 -> ShowS
showsPrec :: Int -> Vec2 -> ShowS
$cshow :: Vec2 -> String
show :: Vec2 -> String
$cshowList :: [Vec2] -> ShowS
showList :: [Vec2] -> ShowS
Show)

-- | Cosine and sine pair (@cosine@, @sine@).
data CosSin = CosSin Float Float
  deriving (CosSin -> CosSin -> Bool
(CosSin -> CosSin -> Bool)
-> (CosSin -> CosSin -> Bool) -> Eq CosSin
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CosSin -> CosSin -> Bool
== :: CosSin -> CosSin -> Bool
$c/= :: CosSin -> CosSin -> Bool
/= :: CosSin -> CosSin -> Bool
Eq, Int -> CosSin -> ShowS
[CosSin] -> ShowS
CosSin -> String
(Int -> CosSin -> ShowS)
-> (CosSin -> String) -> ([CosSin] -> ShowS) -> Show CosSin
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CosSin -> ShowS
showsPrec :: Int -> CosSin -> ShowS
$cshow :: CosSin -> String
show :: CosSin -> String
$cshowList :: [CosSin] -> ShowS
showList :: [CosSin] -> ShowS
Show)

-- | A 2D rotation stored as a cosine/sine pair (@c@, @s@).
data Rot = Rot Float Float
  deriving (Rot -> Rot -> Bool
(Rot -> Rot -> Bool) -> (Rot -> Rot -> Bool) -> Eq Rot
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Rot -> Rot -> Bool
== :: Rot -> Rot -> Bool
$c/= :: Rot -> Rot -> Bool
/= :: Rot -> Rot -> Bool
Eq, Int -> Rot -> ShowS
[Rot] -> ShowS
Rot -> String
(Int -> Rot -> ShowS)
-> (Rot -> String) -> ([Rot] -> ShowS) -> Show Rot
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Rot -> ShowS
showsPrec :: Int -> Rot -> ShowS
$cshow :: Rot -> String
show :: Rot -> String
$cshowList :: [Rot] -> ShowS
showList :: [Rot] -> ShowS
Show)

-- | A 2D rigid transform: position @p@ and rotation @q@.
data Transform = Transform Vec2 Rot
  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)

-- | A 2x2 column-major matrix (columns @cx@, @cy@).
data Mat22 = Mat22 Vec2 Vec2
  deriving (Mat22 -> Mat22 -> Bool
(Mat22 -> Mat22 -> Bool) -> (Mat22 -> Mat22 -> Bool) -> Eq Mat22
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Mat22 -> Mat22 -> Bool
== :: Mat22 -> Mat22 -> Bool
$c/= :: Mat22 -> Mat22 -> Bool
/= :: Mat22 -> Mat22 -> Bool
Eq, Int -> Mat22 -> ShowS
[Mat22] -> ShowS
Mat22 -> String
(Int -> Mat22 -> ShowS)
-> (Mat22 -> String) -> ([Mat22] -> ShowS) -> Show Mat22
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Mat22 -> ShowS
showsPrec :: Int -> Mat22 -> ShowS
$cshow :: Mat22 -> String
show :: Mat22 -> String
$cshowList :: [Mat22] -> ShowS
showList :: [Mat22] -> ShowS
Show)

-- | Axis-aligned bounding box (@lowerBound@, @upperBound@).
data AABB = AABB Vec2 Vec2
  deriving (AABB -> AABB -> Bool
(AABB -> AABB -> Bool) -> (AABB -> AABB -> Bool) -> Eq AABB
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AABB -> AABB -> Bool
== :: AABB -> AABB -> Bool
$c/= :: AABB -> AABB -> Bool
/= :: AABB -> AABB -> Bool
Eq, Int -> AABB -> ShowS
[AABB] -> ShowS
AABB -> String
(Int -> AABB -> ShowS)
-> (AABB -> String) -> ([AABB] -> ShowS) -> Show AABB
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AABB -> ShowS
showsPrec :: Int -> AABB -> ShowS
$cshow :: AABB -> String
show :: AABB -> String
$cshowList :: [AABB] -> ShowS
showList :: [AABB] -> ShowS
Show)

-- | A plane: @normal@ and @offset@ where @separation = dot(normal, point) - offset@.
data Plane = Plane Vec2 Float
  deriving (Plane -> Plane -> Bool
(Plane -> Plane -> Bool) -> (Plane -> Plane -> Bool) -> Eq Plane
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Plane -> Plane -> Bool
== :: Plane -> Plane -> Bool
$c/= :: Plane -> Plane -> Bool
/= :: Plane -> Plane -> Bool
Eq, Int -> Plane -> ShowS
[Plane] -> ShowS
Plane -> String
(Int -> Plane -> ShowS)
-> (Plane -> String) -> ([Plane] -> ShowS) -> Show Plane
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Plane -> ShowS
showsPrec :: Int -> Plane -> ShowS
$cshow :: Plane -> String
show :: Plane -> String
$cshowList :: [Plane] -> ShowS
showList :: [Plane] -> ShowS
Show)

-- | World position. In single-precision builds this is 'Vec2'.
type Pos = Vec2

-- | World transform. In single-precision builds this is 'Transform'.
type WorldTransform = Transform

instance Storable Vec2 where
  sizeOf :: Vec2 -> Int
sizeOf Vec2
_ = (Int
8)
{-# LINE 68 "src/Box2D/MathTypes.hsc" #-}
  alignment _ = 4
{-# LINE 69 "src/Box2D/MathTypes.hsc" #-}
  peek p = Vec2 <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p <*> (\hsc_ptr -> peekByteOff hsc_ptr 4) p
{-# LINE 70 "src/Box2D/MathTypes.hsc" #-}
  poke p (Vec2 x y) = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p x
{-# LINE 72 "src/Box2D/MathTypes.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 4) p y
{-# LINE 73 "src/Box2D/MathTypes.hsc" #-}

instance Storable CosSin where
  sizeOf :: CosSin -> Int
sizeOf CosSin
_ = (Int
8)
{-# LINE 76 "src/Box2D/MathTypes.hsc" #-}
  alignment _ = 4
{-# LINE 77 "src/Box2D/MathTypes.hsc" #-}
  peek p = CosSin <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p <*> (\hsc_ptr -> peekByteOff hsc_ptr 4) p
{-# LINE 78 "src/Box2D/MathTypes.hsc" #-}
  poke p (CosSin c s) = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p c
{-# LINE 80 "src/Box2D/MathTypes.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 4) p s
{-# LINE 81 "src/Box2D/MathTypes.hsc" #-}

instance Storable Rot where
  sizeOf :: Rot -> Int
sizeOf Rot
_ = (Int
8)
{-# LINE 84 "src/Box2D/MathTypes.hsc" #-}
  alignment _ = 4
{-# LINE 85 "src/Box2D/MathTypes.hsc" #-}
  peek p = Rot <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p <*> (\hsc_ptr -> peekByteOff hsc_ptr 4) p
{-# LINE 86 "src/Box2D/MathTypes.hsc" #-}
  poke p (Rot c s) = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p c
{-# LINE 88 "src/Box2D/MathTypes.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 4) p s
{-# LINE 89 "src/Box2D/MathTypes.hsc" #-}

instance Storable Transform where
  sizeOf :: Transform -> Int
sizeOf Transform
_ = (Int
16)
{-# LINE 92 "src/Box2D/MathTypes.hsc" #-}
  alignment _ = 4
{-# LINE 93 "src/Box2D/MathTypes.hsc" #-}
  peek p = Transform <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 94 "src/Box2D/MathTypes.hsc" #-}
  poke ptr (Transform p q) = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) ptr p
{-# LINE 96 "src/Box2D/MathTypes.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) ptr q
{-# LINE 97 "src/Box2D/MathTypes.hsc" #-}

instance Storable Mat22 where
  sizeOf :: Mat22 -> Int
sizeOf Mat22
_ = (Int
16)
{-# LINE 100 "src/Box2D/MathTypes.hsc" #-}
  alignment _ = 4
{-# LINE 101 "src/Box2D/MathTypes.hsc" #-}
  peek p = Mat22 <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 102 "src/Box2D/MathTypes.hsc" #-}
  poke p (Mat22 cx cy) = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p cx
{-# LINE 104 "src/Box2D/MathTypes.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p cy
{-# LINE 105 "src/Box2D/MathTypes.hsc" #-}

instance Storable AABB where
  sizeOf :: AABB -> Int
sizeOf AABB
_ = (Int
16)
{-# LINE 108 "src/Box2D/MathTypes.hsc" #-}
  alignment _ = 4
{-# LINE 109 "src/Box2D/MathTypes.hsc" #-}
  peek p = AABB <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 110 "src/Box2D/MathTypes.hsc" #-}
  poke p (AABB lo hi) = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p lo
{-# LINE 112 "src/Box2D/MathTypes.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p hi
{-# LINE 113 "src/Box2D/MathTypes.hsc" #-}

instance Storable Plane where
  sizeOf :: Plane -> Int
sizeOf Plane
_ = (Int
12)
{-# LINE 116 "src/Box2D/MathTypes.hsc" #-}
  alignment _ = 4
{-# LINE 117 "src/Box2D/MathTypes.hsc" #-}
  peek p = Plane <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 118 "src/Box2D/MathTypes.hsc" #-}
  poke p (Plane n o) = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p n
{-# LINE 120 "src/Box2D/MathTypes.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p o
{-# LINE 121 "src/Box2D/MathTypes.hsc" #-}

vec2Zero :: Vec2
vec2Zero :: Vec2
vec2Zero = Float -> Float -> Vec2
Vec2 Float
0 Float
0

-- | The identity rotation (cosine 1, sine 0).
rotIdentity :: Rot
rotIdentity :: Rot
rotIdentity = Float -> Float -> Rot
Rot Float
1 Float
0

transformIdentity :: Transform
transformIdentity :: Transform
transformIdentity = Vec2 -> Rot -> Transform
Transform Vec2
vec2Zero Rot
rotIdentity