Welcome to the inaugural issue of the Rust Game Development Workgroup’s monthly (hopefully!) newsletter.
Rust is a systems language pursuing the trifecta: safety, concurrency, and speed. These goals are well-aligned with game development.
We hope to build an inviting ecosystem for anyone wishing to use Rust in their development process! Want to get involved? Join the Rust GameDev working group!
News and Blog Posts
Interested (maybe already invested?) in using Rust for game development? Please set aside a brief moment to answer this short survey about the current state of our GD ecosystem and what the GD working group can do to nurture it. 🌱
While we'd greatly appreciate a modicum of identifying information so we can easily connect with you for further discussions, sharing that information is optional. Only 3 questions in this survey are mandatory and we've saved the most important one for last.
The survey is now being processed for publishing. We’re still accepting responses until the survey has been published and subsequently closed for good.
Also, check out our previous post "Introducing the Rust Game Development Working Group" if you haven't seen it yet [/r/rust, twitter].
nphysics 0.12 release contains several long awaited features:
- The support for linear and non-linear continuous-collision detection (CCD) with colliders on rigid bodies and sensors. There's a brand new page of the user guide about it.
- Rigid body velocity damping: this allows to artificially slow down some bodies. This is essential for, e.g., top-down 2D games where traditional coulomb friction cannot be used.
- Rigid body maximum velocity limit: it is possible to force a rigid body to never get a velocity higher than a threshold.
- The possibility to use custom containers for bodies, colliders, joints, and force generators. This helps overcoming some difficulties related to borrowing, and also help for the integration of nphysics with other solutions. The physics world structures will no longer own those containers.
With ncollide 0.20, it is now possible to compute the time of impact between two shapes undergoing an arbitrary rigid motion. This is known as non-linear time-of-impact computation. This is used by the new CCD integration on nphysics 0.12.
Way of Rhea Trailer and Steam Wishlist Announced
click on the GIF to see the full trailer
Way of Rhea is an upcoming puzzle platformer that takes place in a world where you can only interact with objects that match your current color.
Take a look at this Reddit comment with a quick summary about implementation and tooling.
Veloren is an open-world, open-source multiplayer voxel RPG. The game is in an early stage of development, but is playable.
The 0.3 version was a long time coming, and there has been a ton added to Veloren. Here is a small list of the major changes in this version:
- XP and leveling
- Better combat, movement, and animations
- Enemies, bosses
- Better world generation, more biomes
- Build mode
- Caves, lanterns, lights, dungeons
- Character customization, multiple races
- Inventories (WIP)
- Day/night, better shaders, voxel shadows
- Many performance optimizations
My wife and I wrote this as a fun exercise, and went a lot further with it than originally anticipated. We wanted to try to replicate the original game's behaviour by simply looking at it running in Dosbox and seeing if we could make RUZZT do the same thing. This means the code architecture is likely very different from the original game.
Eventually we did get far enough that it seemed like a waste of time to try to guess how some specific things were implemented, so we used a disassembler to make sure various behaviours worked correctly.
oxygengine-navigation - Navmesh Pathfinding System for ECS Games
Amethyst v0.12 quietly released and now the project moves to two-week release cycle.
New tools for 2D game development: the Sheep spritesheet packer and Amethyst 2D Starter.
Scripting support edges closer.
Learning from Legion: an ECS design discussion.
Atelier Editor underwent some visual planning.
A quote from the announcement:
We've put together a tracking page for our Rust open source work, future ideas/plans, and issues that we've run into and want to improve on.
It is still pretty early, but hope it can be useful or of interest to see what we, a commercial games company, is planning and thinking about Rust.
We are also open to collaborate with other companies or individuals, as well as sponsoring more open source work to improve and support the ecosystem. Feel free to reach out to us here or on firstname.lastname@example.org!
Quite complex big C++ project to build & bind to (@h3r2tic did some magic). Eventually want full native Rust lib but PhysX is feature rich & performant today so nice to be able to use it!
@oliviff tells about theirs experience of developing a hobby game "Tennis Academy" in Rust for six months.
Here's a YouTube video with the current state of the game.
Features of the game:
- 💵money: every item costs money and the money is substracted when buying an item
- 👟tennis courts of all types: hard, clay, concrete and grass
- 🎁more object types: benches, balls, roof tiles
- ⏱️time: the game keeps track of how many days/months/years it's been
- 🌶️main menu
- 🏠build menu
- ⛹️player selection menu
- ↩️assignments: a player can be assigned to a court or a bench
- 🛣️basic pathfinding: a player can find its way to an assigned court or bench
- 📈skill levels: a player playing on a court will get increased tennis skill level
- 🛌needs: a player who plays too much will get tired and need rest
gfx-hal is a low-overhead Vulkanic GPU API in Rust.
Version 0.3 is published that includes:
- MSAA resolves
- events API
- building Vulkan backend on Apple platforms
- "readonly" storage support in DX12 backend
- WASM and compute support in GL backend
- lots of fixes and improvements in all backends
wgpu is a safe, modern and portable GPU API for native platforms and the Web.
It's based on gfx-hal and Rendy.
Our implementation and its Rust wrapper
wgpu-rs have reached version 0.3.
- API is (mostly) updated to the upstream WebGPU working group spec
- internal deadlock protection
- individual tracking of texture array layers and mipmap levels
- more API features:
- indirect draw and dispatch
- stencil masks and reference values
- more examples!
- more state validation!
luminance is a type-safe, type-level and stateless Rust graphics framework.
- luminance-derive - provides several procedural derive macros you can use to easily implement all required traits to work with luminance. Especially, some traits that are unsafe can be implemented in a safe way with that crate.
- luminance-glutin - the windowing crate support for glutin.
Also, two ways to learn luminance were added:
The examples. They are like unit tests: each introduces and focuses on a very specific aspect or feature. You should read them if you are interested in given feature. They’re not well suited to learn from scratch and they are weaker than a structured tutorial but more concise.
The wiki. It contains various chapters, including tutorials and onboarding newcomers. It will not provide you with the best description of a given feature as it focuses more on the overall comprehension and explaining than code directly.
Popular Workgroup Issues in Github
- #23 "[Needed Crate] A pure rust SPIRV generator"
- #25 "The state of math libraries"
- #26 "[Tracker] Better windowing/graphics inter-operation"
- #42 "[Discussion] A plan for crate stewardship"
Requests for Contribution
- gfx-rs's "contributor-friendly" issues;
Just an interesting Rust gamedev link from the past. :)
A Snake's Tale is a puzzle game about snakes in cramped places. Clear a path to get to the hole, eat some eggs along the way, and make sure to press all the buttons.
click on the GIF to see the full release trailer
A few posts about the game and how it was developed:
That's all news for today, thanks for reading!
Want something mentioned in the next newsletter? Send us a pull request.