Optimise TLAS building.

[Vecvec]

Is your request related to a problem? Please describe.
Currently large TLASes (on the order of hundreds of thousands of instances) can take multiple milliseconds on the CPU. Ideally TLASes should be able to be built each frame as they may have things like players in them which can change each frame.

Currently a TLAS build loops over every TlasInstance, validates it, converts it to a hal RawTlasInstance which gets mapped into the raw bytes by the hal device and then appended each time to the bytes vector. This is not ideal as call times can add up even if most instances are not changing due to them being re-converted.

Describe solutions you've considered
The ideal solution would probably be to upload the instances early and convert them on the GPU because they can have more memory bandwidth (on discrete only) and can do it in parallel. However, shaders would require the wgsl feature which might not be able to be relied on (or exposing the ray tracing feature would be dependent on wgsl).

There are a few things that could probably improve performance before uploading everything to the GPU. It should be possible to not call a dyn function on each instance (either by sending up a layout or by taking an array of instances to convert).

Additional context
A quick benchmark suggests that an average TLAS build + submission (I used a single duplicated BLAS so this is only build speed) takes 60-80 ms with 100,000 instances and scales roughly linearly (9ms for 10,000 and 1ms for 1,000)

cc @JMS55

[JMS55]

The current API requires wgpu to own the input list and scratch buffer, which leaves a lot of performance on the table.

In Bevy, we have https://dev-docs.bevy.org/bevy/render/render_resource/struct.AtomicSparseBufferVec.html which allows sparse updates via a compute shader, falling back to a whole-buffer reupload when more than 15% of things change, reusing the same memory between frames.

I experimented with a version of that for TLAS stuff, but eventually decided on a different path:

All the info I need (really just transforms) is already on the GPU via a separate AtomicSparseBufferVec. Rather then uploading a second buffer for the TLAS instances, which would mostly just be a copy, I instead have a compute shader read the transform buffer, write out the instances to a pre-allocated buffer (it's pretty fast to rewrite the entire buffer every frame since it's entirely GPU-local), and then do an indirect TLAS build command.

Of course, that needs wgpu_hal, which for my project is acceptable.