New week, new Rust! What are you folks up to?
Finished implementing Ray Tracing: The Next Week in my raytracer shrimpray. Support for volumes of mist/fog/smoke were added.
This render has moving spheres, image textures, perlin textures, glass and dielectric material, lighting, rectangles, fog/smoke, metal and diffuse material.
Parallel processing with the
rayon library is added too. The only changes needed were from
Arc<T> and inheriting the
Send + Sync traits. Using the
into_par_iter() stuff took care of the rest so shrimpray will now use all cores to sample rays.
It was pretty fun and a lot about Rust was learned. I'll leave the third book for some other future.
Writing the test suite of a concurrent and real-time-safe bitmap allocator. Yesterday I finished testing the hole search routine, next I'm going to test allocation transactions, and after that it will be time to test the allocator proper, which should be a formality once the above are taken care of.
After that, I can go back to fun stuff like benchmarking the thing and trying out all those optimizations which I refrained myself from experimenting with in the initial version. And then publish 0.1.
I'm polishing a set of related foundation crates for memory management and dynamic data structures in
no_std environment where no os allocator is available (or You do not want to use it). I've realized the need for these during the process of building a no-alloc library for networking—which I shall not name here, it's not done—where this was desired for stable latency. While it is possible to move all allocation decisions into the final binary, there was no real choice as moving away from a global allocator meant a huge ergonomic sacrifice. All example binaries thus link to
std even though the main library does not need it but this is necessary to keep the examples readable.
I've finished the first draft for my talk at the next hack night in Copenhagen, and just need to go through it a few times to proofread the slides, and decide if I got the order right.
I've also started redoing my website with the static site generator Zola, which is written in Rust. My previous website was just handwritten html, which was not ideal. I do admit I find markdown a bit lacking in configurability though..
Wrote about it in dtypei: Rust/Wasm Exports Introspection v.0.0.1
Also my first Rust crates & first Rust project! Feedback very much appreciated.
Building a command-line diagnostics tool for FlowBetween, and reworking the storage format a bit, as the current design is a bit unwieldy when it comes to extensions as well as a bit inefficient in terms of size. Thinking about rewriting the HTTP user interface in plain hyper.
The aim with the command line tool is to aid in debugging when things go wrong: at the moment some of the trickier bugs with flo_curve's intersection algorithm are the main target. This is something I've been meaning to build for a while: all of FlowBetween's various components communicate via streams of commands and a while back I decided to write the list of edit commands to the animation itself. That's a bit of a godsend when it comes to reproducing rare bugs as I can just replay the exact sequence of actions that were taken to reproduce the bug and debug it or verify that it's gone (FlowBetween is an animation tool so if I replay each edit back on its own frame I can use it to step through its own bugs...)
I've got everything rewritten to use futures 0.3. There are new versions of flo_bindings, desync and flo_stream which have all been updated to use the new version of futures (as I suspected, it was indeed easier to ditch the Sink trait everywhere and replace it with flo_stream's publisher trait than it was to rewrite the old sinks). Desync in particular now has a reworked
future() call that makes it possible to borrow a resource for the lifetime of a future.
Small change to read face normals (even though I do ignore them)
.ply files, so I can render e.g. this:
I've spent this week writing the second chapter of a tutorial showing how to build Pong in Rust
parse_blend_file of the rs-pbrt renderer (see issue #116), btoa now also exports vertex colors (which really are dealt with as triangle colors) from a
.blend file into Arnold's
.ass scene description:
The pole with white, red, and blue colors use those vertex/triangle colors to index into three different materials (simple diffuse materials for now).
I've added a couple of new features to https://lib.rs