module Rattletrap.Type.Attribute.Float where

import Prelude hiding (Float)
import qualified Rattletrap.BitGet as BitGet
import qualified Rattletrap.BitPut as BitPut
import qualified Rattletrap.Schema as Schema
import qualified Rattletrap.Type.F32 as F32
import qualified Rattletrap.Utility.Json as Json

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

instance Json.FromJSON Float where
  parseJSON :: Value -> Parser Float
parseJSON = (F32 -> Float) -> Parser F32 -> Parser Float
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap F32 -> Float
Float (Parser F32 -> Parser Float)
-> (Value -> Parser F32) -> Value -> Parser Float
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Parser F32
forall a. FromJSON a => Value -> Parser a
Json.parseJSON

instance Json.ToJSON Float where
  toJSON :: Float -> Value
toJSON = F32 -> Value
forall a. ToJSON a => a -> Value
Json.toJSON (F32 -> Value) -> (Float -> F32) -> Float -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> F32
value

schema :: Schema.Schema
schema :: Schema
schema = String -> Value -> Schema
Schema.named String
"attribute-float" (Value -> Schema) -> Value -> Schema
forall a b. (a -> b) -> a -> b
$ Schema -> Value
Schema.ref Schema
F32.schema

bitPut :: Float -> BitPut.BitPut
bitPut :: Float -> BitPut
bitPut Float
floatAttribute = F32 -> BitPut
F32.bitPut (Float -> F32
value Float
floatAttribute)

bitGet :: BitGet.BitGet Float
bitGet :: BitGet Float
bitGet = F32 -> Float
Float (F32 -> Float) -> BitGet F32 -> BitGet Float
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> BitGet F32
F32.bitGet