A library for acquiring a backtrace at runtime
This crate gives small utilities for casting between plain data types.
Colorful and clean backtraces on panic.
Tools for concurrent programming.
egui: an easy-to-use GUI in pure Rust!
A simple logger that can be configured via environment variables, for use
with the logging facade exposed by the
log crate.
A simple 2D graphics library for turning simple 2D shapes and text into textured triangles.
Fx Hash
Embed git information in your code at compile-time.
A handy ECS
Overview
An extension to the include_str!() and include_bytes!() macro for
embedding an entire directory tree into your binary.
Tweak any literal directly from your code, changes to the source appear while running the program.
It works by parsing the file when a change occurs.
Kira
A lightweight logging facade.
Cross-platform file system notification library
Numeric traits for generic mathematics
Overview
Pollster
Data-parallelism library that makes it easy to convert sequential
computations into parallel
Small vectors in various sizes. These store a certain number of elements inline, and fall back
to the heap for larger allocations. This can be a useful optimization for improving cache
locality and reducing allocator traffic for workloads that fit within the inline buffer.
Accurate sleeping. Only use native sleep as far as it can be trusted, then spin.
Winit is a cross-platform window creation and event loop management library.
A 2D affine transform, which can represent translation, rotation, scaling and shear.
A thread-safe reference-counting pointer. ‘Arc’ stands for ‘Atomically
Reference Counted’.
Container that can have elements inserted into it and removed from it.
A wrapper type for an immutably borrowed value from an AtomicRefCell<T>.
A threadsafe analogue to RefCell.
A wrapper type for a mutably borrowed value from an AtomicRefCell<T>.
Controls audio from gameplay code.
Representation of an owned and self-contained backtrace.
A bimap backed by two HashMaps.
Applies a threshold filter to the input image to extract the brightest
regions before blurring them and compositing back onto the original image.
These settings are useful when emulating the 1990s-2000s game look.
Applies a bloom effect to an HDR-enabled 2d or 3d camera.
Records operations for future application to a
WorldA complex number in Cartesian form.
A Duration type to represent a span of time, typically used for system
timeouts.
Lightweight unique ID, or handle, of an entity
Configures a filter effect.
Controls a filter effect.
Implementation of Fisher-Yates algorithm.
This is modified version of https://github.com/adambudziak/shuffle/blob/master/src/fy.rs
A
hash map implemented with quadratic probing and SIMD lookup.
A
hash set implemented as a
HashMap where the value is
().
A 2-dimensional vector.
Index type for
Arena that has a generation attached to it.
A measurement of a monotonically nondecreasing clock.
Opaque and useful only with
Duration.
Describes a keyboard input event.
A value which is initialized on the first access.
Tool for loop rate reporting and control.
A 3x3 column major matrix.
A 4x4 column major matrix.
An integer that is known not to equal zero.
A thread-safe cell which can be written to only once.
A wrapper around floats providing implementations of Eq, Ord, and Hash.
A pinned pointer.
A (half-open) range bounded inclusively below and exclusively above
(start..end).
A single-threaded reference-counting pointer. ‘Rc’ stands for ‘Reference
Counted’.
A mutable memory location with dynamically checked borrow rules
Configures a reverb effect.
A Vec-like container that can store a small number of elements inline.
A piece of audio loaded into memory all at once.
Controls a static sound.
Settings for a static sound.
A Stopwatch is a struct that track elapsed time when started.
Tracks elapsed time. Enters the finished state once duration is reached.
Configures a mixer track.
Controls a mixer track.
A 2-dimensional vector.
A 2-dimensional vector.
A 3-dimensional vector.
A 4-dimensional vector.
A double-ended queue implemented with a growable ring buffer.
A distribution using weighted sampling of discrete items
Represents a window.
An unordered collection of entities, each having any number of distinctly typed components
A trait to emulate dynamic typing.
Used for immutable dereferencing operations, like *v.
Used for mutable dereferencing operations, like in *v = 1;.
Utility methods not meant to be in the main API.
Types (distributions) that can be used to create a random instance of T.
A dynamically typed collection of components
FromParallelIterator implements the creation of a collection
from a
ParallelIterator. By implementing
FromParallelIterator for a given type, you define how it will be
created from an iterator.
A future represents an asynchronous computation obtained by use of
async.
A hashable type.
A trait for hashing an arbitrary stream of bytes.
An iterator that supports “random access” to its data, meaning
that you can split it at arbitrary indices and draw data from
those points.
IntoParallelRefIterator implements the conversion to a
ParallelIterator, providing shared references to the data.
IntoParallelRefMutIterator implements the conversion to a
ParallelIterator, providing mutable references to the data.
Extension trait on iterators, providing random sampling methods.
An
Iterator blanket implementation that provides extra adaptors and
methods.
The multiplication operator *.
Conversion trait to convert an Iterator to a ParallelIterator.
ParallelDrainFull creates a parallel iterator that moves all items
from a collection while retaining the original capacity.
ParallelDrainRange creates a parallel iterator that moves a range of items
from a collection while retaining the original capacity.
ParallelExtend extends an existing collection with items from a
ParallelIterator.
Parallel version of the standard iterator trait.
Parallel extensions for slices.
Parallel extensions for mutable slices.
Parallel extensions for strings.
An automatically-implemented extension trait on
RngCore providing high-level
generic methods for sampling values and other convenience methods.
The core of a random number generator.
Helper trait for creating objects using the correct implementation of
UniformSampler for the sampling type.
Extension trait on slices, providing random mutation and sampling methods.