Safe Haskell | None |
---|---|

Language | Haskell2010 |

- initStore :: (Initializable s, InitArgs s ~ ()) => IO s
- runGC :: System w ()
- unEntity :: Entity a -> Int
- data EntityCounter
- initCounter :: IO (Storage EntityCounter)
- nextEntity :: Has w EntityCounter => System w (Entity ())
- newEntity :: (IsRuntime c, Has w c, Has w EntityCounter) => c -> System w (Entity c)
- quantize :: (Fractional (v a), Integral b, RealFrac a, Functor v) => v a -> v a -> v b
- flatten :: (Applicative v, Integral a, Foldable v) => v a -> v a -> Maybe a
- inbounds :: (Num a, Ord a, Applicative v, Foldable v) => v a -> v a -> Bool
- region :: (Enum a, Applicative v, Traversable v) => v a -> v a -> [v a]
- unsafeFlatten :: (Applicative v, Integral a, Foldable v) => v a -> v a -> a
- timeSystem :: System w a -> System w (Double, a)
- timeSystem_ :: System w a -> System w Double

# Utility

initStore :: (Initializable s, InitArgs s ~ ()) => IO s Source #

Initializes a store with (), useful since most stores have () as their initialization argument

# EntityCounter

data EntityCounter Source #

Secretly just an int in a newtype

initCounter :: IO (Storage EntityCounter) Source #

Initialize an EntityCounter

nextEntity :: Has w EntityCounter => System w (Entity ()) Source #

Bumps the EntityCounter and yields its value

newEntity :: (IsRuntime c, Has w c, Has w EntityCounter) => c -> System w (Entity c) Source #

Writes the given components to a new entity, and yields that entity

# Spatial hashing

The following functions are for spatial hashing. The idea is that your spatial hash is defined by two vectors;

- The cell size vector contains real components and dictates
how large each cell in your table is in world space units.
It is used by
`quantize`

to translate a world space coordinate into a table space index vector - The table size vector contains integral components and dictates how
many cells your field consists of in each direction.
It is used by
`flatten`

to translate a table-space index vector into a flat integer

There is currently no dedicated spatial hashing log, but you can use an EnumTable by defining an instance Enum Vec with > fromEnum = flatten size . quantize cell

:: (Fractional (v a), Integral b, RealFrac a, Functor v) | |

=> v a | Quantization cell size |

-> v a | Vector to be quantized |

-> v b |

Quantize turns a world-space coordinate into a table-space coordinate by dividing by the given cell size and rounding towards negative infinity.

flatten :: (Applicative v, Integral a, Foldable v) => v a -> v a -> Maybe a Source #

Turns a table-space vector into an integral index, given some table size vector. Yields Nothing for out-of-bounds queries

inbounds :: (Num a, Ord a, Applicative v, Foldable v) => v a -> v a -> Bool Source #

Tests whether a vector is in the region given by 0 and the size vector (inclusive)

:: (Enum a, Applicative v, Traversable v) | |

=> v a | Lower bound for the region |

-> v a | Higher bound for the region |

-> [v a] |

For two table-space vectors indicating a region's bounds, gives a list of the vectors contained between them. This is useful for querying a spatial hash.

unsafeFlatten :: (Applicative v, Integral a, Foldable v) => v a -> v a -> a Source #

Unsafe version of flatten. Yields garbage for out-of-bounds queries.