{- | Global Tile IDs

https://doc.mapeditor.org/en/latest/reference/global-tile-ids/

-}

module Data.Tiled.GID where

import Data.Aeson (FromJSON(..), ToJSON(..))
import Data.Bits (Bits(..), (.&.))
import Data.Bool (bool)
import Data.Word (Word8, Word32)
import Foreign (Storable(..))
import GHC.Generics (Generic)

newtype GID = GID { GID -> Word32
getGID :: Word32 }
  deriving (GID -> GID -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GID -> GID -> Bool
$c/= :: GID -> GID -> Bool
== :: GID -> GID -> Bool
$c== :: GID -> GID -> Bool
Eq, Int -> GID -> ShowS
[GID] -> ShowS
GID -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GID] -> ShowS
$cshowList :: [GID] -> ShowS
show :: GID -> String
$cshow :: GID -> String
showsPrec :: Int -> GID -> ShowS
$cshowsPrec :: Int -> GID -> ShowS
Show, forall x. Rep GID x -> GID
forall x. GID -> Rep GID x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GID x -> GID
$cfrom :: forall x. GID -> Rep GID x
Generic)
  deriving newtype (Value -> Parser [GID]
Value -> Parser GID
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [GID]
$cparseJSONList :: Value -> Parser [GID]
parseJSON :: Value -> Parser GID
$cparseJSON :: Value -> Parser GID
FromJSON, [GID] -> Encoding
[GID] -> Value
GID -> Encoding
GID -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [GID] -> Encoding
$ctoEncodingList :: [GID] -> Encoding
toJSONList :: [GID] -> Value
$ctoJSONList :: [GID] -> Value
toEncoding :: GID -> Encoding
$ctoEncoding :: GID -> Encoding
toJSON :: GID -> Value
$ctoJSON :: GID -> Value
ToJSON, Ptr GID -> IO GID
Ptr GID -> Int -> IO GID
Ptr GID -> Int -> GID -> IO ()
Ptr GID -> GID -> IO ()
GID -> Int
forall b. Ptr b -> Int -> IO GID
forall b. Ptr b -> Int -> GID -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GID -> GID -> IO ()
$cpoke :: Ptr GID -> GID -> IO ()
peek :: Ptr GID -> IO GID
$cpeek :: Ptr GID -> IO GID
pokeByteOff :: forall b. Ptr b -> Int -> GID -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GID -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GID
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GID
pokeElemOff :: Ptr GID -> Int -> GID -> IO ()
$cpokeElemOff :: Ptr GID -> Int -> GID -> IO ()
peekElemOff :: Ptr GID -> Int -> IO GID
$cpeekElemOff :: Ptr GID -> Int -> IO GID
alignment :: GID -> Int
$calignment :: GID -> Int
sizeOf :: GID -> Int
$csizeOf :: GID -> Int
Storable, Eq GID
GID
Int -> GID
GID -> Bool
GID -> Int
GID -> Maybe Int
GID -> GID
GID -> Int -> Bool
GID -> Int -> GID
GID -> GID -> GID
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: GID -> Int
$cpopCount :: GID -> Int
rotateR :: GID -> Int -> GID
$crotateR :: GID -> Int -> GID
rotateL :: GID -> Int -> GID
$crotateL :: GID -> Int -> GID
unsafeShiftR :: GID -> Int -> GID
$cunsafeShiftR :: GID -> Int -> GID
shiftR :: GID -> Int -> GID
$cshiftR :: GID -> Int -> GID
unsafeShiftL :: GID -> Int -> GID
$cunsafeShiftL :: GID -> Int -> GID
shiftL :: GID -> Int -> GID
$cshiftL :: GID -> Int -> GID
isSigned :: GID -> Bool
$cisSigned :: GID -> Bool
bitSize :: GID -> Int
$cbitSize :: GID -> Int
bitSizeMaybe :: GID -> Maybe Int
$cbitSizeMaybe :: GID -> Maybe Int
testBit :: GID -> Int -> Bool
$ctestBit :: GID -> Int -> Bool
complementBit :: GID -> Int -> GID
$ccomplementBit :: GID -> Int -> GID
clearBit :: GID -> Int -> GID
$cclearBit :: GID -> Int -> GID
setBit :: GID -> Int -> GID
$csetBit :: GID -> Int -> GID
bit :: Int -> GID
$cbit :: Int -> GID
zeroBits :: GID
$czeroBits :: GID
rotate :: GID -> Int -> GID
$crotate :: GID -> Int -> GID
shift :: GID -> Int -> GID
$cshift :: GID -> Int -> GID
complement :: GID -> GID
$ccomplement :: GID -> GID
xor :: GID -> GID -> GID
$cxor :: GID -> GID -> GID
.|. :: GID -> GID -> GID
$c.|. :: GID -> GID -> GID
.&. :: GID -> GID -> GID
$c.&. :: GID -> GID -> GID
Bits)

pattern FLIPPED_HORIZONTALLY_BIT :: Int
pattern $bFLIPPED_HORIZONTALLY_BIT :: Int
$mFLIPPED_HORIZONTALLY_BIT :: forall {r}. Int -> ((# #) -> r) -> ((# #) -> r) -> r
FLIPPED_HORIZONTALLY_BIT = 31

pattern FLIPPED_VERTICALLY_BIT :: Int
pattern $bFLIPPED_VERTICALLY_BIT :: Int
$mFLIPPED_VERTICALLY_BIT :: forall {r}. Int -> ((# #) -> r) -> ((# #) -> r) -> r
FLIPPED_VERTICALLY_BIT = 30

pattern ROTATED_60_BIT :: Int
pattern $bROTATED_60_BIT :: Int
$mROTATED_60_BIT :: forall {r}. Int -> ((# #) -> r) -> ((# #) -> r) -> r
ROTATED_60_BIT = 29

pattern ROTATED_120_BIT :: Int
pattern $bROTATED_120_BIT :: Int
$mROTATED_120_BIT :: forall {r}. Int -> ((# #) -> r) -> ((# #) -> r) -> r
ROTATED_120_BIT = 28

data Flags = Flags
  { Flags -> Bool
flippedHorizontally :: Bool
  , Flags -> Bool
flippedVertically   :: Bool
  , Flags -> Bool
rotated60           :: Bool
  , Flags -> Bool
rotated120          :: Bool
  } deriving (Flags -> Flags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Flags -> Flags -> Bool
$c/= :: Flags -> Flags -> Bool
== :: Flags -> Flags -> Bool
$c== :: Flags -> Flags -> Bool
Eq, Int -> Flags -> ShowS
[Flags] -> ShowS
Flags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Flags] -> ShowS
$cshowList :: [Flags] -> ShowS
show :: Flags -> String
$cshow :: Flags -> String
showsPrec :: Int -> Flags -> ShowS
$cshowsPrec :: Int -> Flags -> ShowS
Show, forall x. Rep Flags x -> Flags
forall x. Flags -> Rep Flags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Flags x -> Flags
$cfrom :: forall x. Flags -> Rep Flags x
Generic)

{-# INLINEABLE flags #-}
flags :: GID -> Flags
flags :: GID -> Flags
flags = Word32 -> Flags
unpack32 forall b c a. (b -> c) -> (a -> b) -> a -> c
. GID -> Word32
getGID

{-# INLINEABLE pack32 #-}
pack32 :: Flags -> Word32
pack32 :: Flags -> Word32
pack32 Flags{Bool
rotated120 :: Bool
rotated60 :: Bool
flippedVertically :: Bool
flippedHorizontally :: Bool
rotated120 :: Flags -> Bool
rotated60 :: Flags -> Bool
flippedVertically :: Flags -> Bool
flippedHorizontally :: Flags -> Bool
..} =
  forall a. a -> a -> Bool -> a
bool Word32
0 (forall a. Bits a => Int -> a
bit Int
FLIPPED_HORIZONTALLY_BIT) Bool
flippedHorizontally forall a. Bits a => a -> a -> a
.|.
  forall a. a -> a -> Bool -> a
bool Word32
0 (forall a. Bits a => Int -> a
bit Int
FLIPPED_VERTICALLY_BIT)   Bool
flippedVertically forall a. Bits a => a -> a -> a
.|.
  forall a. a -> a -> Bool -> a
bool Word32
0 (forall a. Bits a => Int -> a
bit Int
ROTATED_60_BIT)           Bool
rotated60 forall a. Bits a => a -> a -> a
.|.
  forall a. a -> a -> Bool -> a
bool Word32
0 (forall a. Bits a => Int -> a
bit Int
ROTATED_120_BIT)          Bool
rotated120

{-# INLINEABLE unpack32 #-}
unpack32 :: Word32 -> Flags
unpack32 :: Word32 -> Flags
unpack32 Word32
flags32 = Flags
  { flippedHorizontally :: Bool
flippedHorizontally = forall a. Bits a => a -> Int -> Bool
testBit Word32
flags32 Int
FLIPPED_HORIZONTALLY_BIT
  , flippedVertically :: Bool
flippedVertically   = forall a. Bits a => a -> Int -> Bool
testBit Word32
flags32 Int
FLIPPED_VERTICALLY_BIT
  , rotated60 :: Bool
rotated60           = forall a. Bits a => a -> Int -> Bool
testBit Word32
flags32 Int
ROTATED_60_BIT
  , rotated120 :: Bool
rotated120          = forall a. Bits a => a -> Int -> Bool
testBit Word32
flags32 Int
ROTATED_120_BIT
  }

{-# INLINEABLE pack8 #-}
pack8 :: Flags -> Word8
pack8 :: Flags -> Word8
pack8 Flags
flags = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Flags -> Word32
pack32 Flags
flags forall a. Bits a => a -> Int -> a
`shiftR` Int
24)

{-# INLINEABLE unpack8 #-}
unpack8 :: Word8 -> Flags
unpack8 :: Word8 -> Flags
unpack8 Word8
bits8 = Word32 -> Flags
unpack32 (forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
bits8 forall a. Bits a => a -> Int -> a
`shiftL` Int
24)

noFlags :: Flags
noFlags :: Flags
noFlags = Flags
  { flippedHorizontally :: Bool
flippedHorizontally = Bool
False
  , flippedVertically :: Bool
flippedVertically   = Bool
False
  , rotated60 :: Bool
rotated60           = Bool
False
  , rotated120 :: Bool
rotated120          = Bool
False
  }

flagBits :: Word32
flagBits :: Word32
flagBits =
  forall a. Bits a => Int -> a
bit Int
FLIPPED_HORIZONTALLY_BIT forall a. Bits a => a -> a -> a
.|.
  forall a. Bits a => Int -> a
bit Int
FLIPPED_VERTICALLY_BIT forall a. Bits a => a -> a -> a
.|.
  forall a. Bits a => Int -> a
bit Int
ROTATED_60_BIT forall a. Bits a => a -> a -> a
.|.
  forall a. Bits a => Int -> a
bit Int
ROTATED_120_BIT

toLocal :: GID -> Int
toLocal :: GID -> Int
toLocal (GID Word32
bits) = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
bits forall a. Bits a => a -> a -> a
.&. forall a. Bits a => a -> a
complement Word32
flagBits

fromLocal :: Flags -> Int -> GID
fromLocal :: Flags -> Int -> GID
fromLocal Flags
flags Int
localId =
  Word32 -> GID
GID forall a b. (a -> b) -> a -> b
$
    forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
localId forall a. Bits a => a -> a -> a
.|.
    Flags -> Word32
pack32 Flags
flags