generational-arena
vec-tree
Our great sponsors
generational-arena | vec-tree | |
---|---|---|
7 | 2 | |
646 | 28 | |
- | - | |
0.0 | 0.0 | |
9 months ago | over 5 years ago | |
Rust | Rust | |
Mozilla Public License 2.0 | Mozilla Public License 2.0 |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
generational-arena
-
Is Rust suitable for representing domain concepts?
In my experience it is often easier to use indexes instead of copying Rc's. If you want to mutate the graph, then look in to slab and generational-arena
-
My thoughts on Rust for game development
Regarding ECS: yes, but in a deflationary sense. The game has entities, stored in something very similar to GenerationalArena, and it has "systems", which are just functions that operate on these entities. The components themselves are just fields of the Entity megastruct. Having an ECS in the narrow sense doesn't really make a lot of sense for this game, because a lot of its rules are dependent on each other, and there's very little chance to extract parallelism. Also, even the current largest levels have less than 10k entities, so simulation performance is not a bottleneck yet.
-
Freeing slice without knowing it’s size
If you cannot inplace construct the slice-dst on heap and your slice is too large to be copied, then I think there are two solutions: - Using Box>, this adds another level of indirection but avoids the copying - Use an arena like slotmap, slab, generational_arena or concurrent_arena to store the Box<[u8]>. It still needs heap allocation, but it allocates in chunks, thus less fragmentation and performs better.
-
Is there an abstract technical name for a map that generates its own keys??
I think this is less of a good fit though: the word "arena" doesn't imply iteration is possible to me. I think arenas also conventionally will reuse previously-released handles (unless you implement akin to a generational arena), so the term might be a bit misleading in that regard.
-
Mutability with Arenas?
Might wanna check out https://github.com/fitzgen/generational-arena / https://github.com/ArnaudValensi/vec-tree/blob/master/tests/tests.rs.
-
A new ProtoBuf generator for Go
This is far from the only arena allocator written in Rust.
From the same author, a zero-unsafe arena allocator: https://github.com/fitzgen/generational-arena
There are many, many arena implementations available with varying characteristics. It's disingenuous to act like Rust requires the author of an arena library to write "unsafe" everywhere.
-
Automatic Struct of Array generation for Rust
If someone wants to adapt it to create computergames, then it would probably be useful to find a way to introduce generational generational indexes
vec-tree
-
Mutability with Arenas?
Might wanna check out https://github.com/fitzgen/generational-arena / https://github.com/ArnaudValensi/vec-tree/blob/master/tests/tests.rs.
-
Using an Arena/ECS style library to describe parent/child relationship amongst children
Hmm looks like this example involves some dependencies to crate versions which have been yanked, and would require some substanial redesign to get working. List crate looks promising, however! https://github.com/ArnaudValensi/vec-tree
What are some alternatives?
bumpalo - A fast bump allocation arena for Rust
entity_system - A naive attempt at getting an Entity Sytem working backed by a generational arena (slotmap) and an AnyMap
goprotobuf - Go support for Google's protocol buffers
fltk-rs - Rust bindings for the FLTK GUI library.
gapid - Graphics API Debugger
go - The Go programming language
TablaM - The practical relational programing language for data-oriented applications
protobuf-go - Go support for Google's protocol buffers
pointer-utils - A collection of small utilities for working with pointer types in Rust.