New week, new Rust! What are you folks up to?
Flew down to Sydney today for the Rust meetup which was worth the trip. Replaced a bandaid I put on
env_logger with a proper fix while going through the process of updating it in
cargo. I’m working through some feedback on a
tempfile PR and making plans to pick up work on
elastic again for the year too.
I started working on implementing curves (see issue #37), so I can render hair.
I’m sure I can finish the geometry part this week, if there’s time left, I’m going to spend it on the corresponding material (see issue #38).
I didn’t get much done on
uom (type-safe zero-cost dimensional analysis) last week. I’m still dealing with getting tests to pass for non-floating point storage types. Currently running into issues because conversion factors are originally represented as floating point numbers and may lose precision. Likely going to put that on hold this week and try to knock out some easy issues.
This almost look like a real hair. How long does it take to render this one?
How long does it take to render this one?
Unfortunately pretty long. I can only guess because I didn’t time the render process, but I was letting it run during working hours (and over night) so it must be over 8 hours, probably 10 to 12 hours in a 1024x1024 resolution with 1024 pixel samples. That was the C++ version, I can time the Rust version in case I do a re-run after successful implementation …
Still working on LPC82x HAL, still busy with making the pin API safe at compile-time. I’ve made good progress, but the most tricky part is still ahead of me. LPC82x has a switch matrix that allows flexible assignment of hardware functions to various pins, and modelling that in Rust’s type system is non-trivial. I have a plan, but I’m not sure yet that it will work out.
Im still working on flash which is a photo management program with a rust backend and elm frontend.
Last week I almost finnished a pretty major refactoring project which will allow me to sync images between computers in an asyncronous manner.
You linked the flash front-end in the README but it is a private repo in gitlab.
I just filed some three PRs to git-dit to continue it because it practically stalled since 0.4.0.
I also started on implementing a github issue importer which already works, but still has some things which should be improved before I actually use it.
All in all this works towards the idea to move (some of) my projects (especially imag) off of github!
Oh right, thanks for pointing that out. I semi migrated to gitlab a few days ago and must have accidentally made the frontend private
For my project, Ada, I was successful in getting a zero-runtime overhead abstraction plumbed from memmap through my operating system abstraction layer and into my component (low-level) hardware abstraction layer (aka Chal) using static constructor dependency injection. The end result is very nice to use, as well, since the Chal sees the memory mapping as an ordinary slice of memory.
It might seem a bit complex behind that slice, but I expect the performance and loose-coupling benefits to more than make up for the investment. (Stay tuned: the future will be benchmarked…)
This week I’ll be building a model to represent GPIO pins at a higher level than a simple one-to-one mapping, with compile-time enforcement (and with zero run-time overhead, of course). If anyone has seen a good pin-mapping model that would fit this description, I would be grateful for a pointer!
Once I have the system fully plumbed, I’ll begin posting pictures of the hardware every now and again as it gains functionality over time.
A lot of overhaul and fixes on the elm client-side and so with the server-side overhaul on the orm
Responsive search/filter has now been restored.
Infinite scrolling of records now show a loading indicator.
Just started my third attempt to learn Rust, and this time it’s actually “taking”: https://github.com/wspeirs/logstore
Also trying to blog about it as I go: http://blog.metrink.com
Looking forward to the day when I can send LogStore its first log, and then read it back
A follow up progress, I just made the toolbar of Diwata dynamic. It now displays exact additional info on the specifics of what the button does. Not a huge change, but it does have an impact towards the goal of making a user-friendly database interface.
How long does it take to render this one?
In the meantime I have some numbers for lower resolution and less samples:
$ grep resolution assets/scenes/hair/curly-hair.pbrt ... "integer xresolution" [ 512 ] "integer yresolution" [ 512 ] $ grep pixelsamples assets/scenes/hair/curly-hair.pbrt Sampler "sobol" "integer pixelsamples" [ 64 ] # [ 1024 ]
That’s 512x512 pixels with 64 pixel samples:
C++: about 22m
Rust: about 38m
Memory consumption is also very different, which gives me a reason to re-think the current implementation. But first I have to solve some other differences. See images here:
Wow, I was thinking it could have taken longer than that, like hours. Impressive!