bevy

I wouldn't call that code idiomatic either: it is cleaned up from the automatic translation, but it still a far cry from what Rust written by hand would look like pub static mut g_color_table: [crate::src::qcommon::q_shared::vec4_t; 8] = [ [0f32, 0f32, 0f32, 1f32], [1f32, 0f32, 0f32, 1f32], [0f32, 1f32, 0f32, 1f32], [1f32, 1f32, 0f32, 1f32], [0f32, 0f32, 1f32, 1f32], [0f32, 1f32, 1f32, 1f32], [1f32, 0f32, 1f32, 1f32], [1f32, 1f32, 1f32, 1f32], ]; would maybe look like pub static mut g_color_table: [[f32; 4]; 8] = [ [0, 0, 0, 1], [1, 0, 0, 1], [0, 1, 0, 1], [1, 1, 0, 1], [0, 0, 1, 1], [0, 1, 1, 1], [1, 0, 1, 1], [1, 1, 1, 1], ]; but it still looks weird to me (a static mut would be uncommon in a design, and not having a new-type to rep

I cannot agree enough. For example, in the bevy[0] discord alone, there's a remarkable about of advice, plugin recommendations, and technical help that's essentially just lost in noise. It's a real shame; I can't help but wonder how much effort is repeated, or how much beginners needlessly struggle because they couldn't effectively find information. [0] https://github.com/bevyengine/bevy

I wrote an implementation based on this a few weeks back. It works really nicely and I can render some 2M line segments at 60fps. One thing you should do is try to limit very short and small segments, as GPUs don’t like rendering 1px triangles. Still, I’ve been lead to understand that the instanced rendering done in this article is suboptimal on most GPUs. A better way to do it is apparently to put the points into a (non-vertex) buffer and do (batched) drawcalls for large numbers of vertices with a kind of manual instancing. Basically looking up what amounts to instance data using gl_VertexInput/6 and vertex data using gl_VertexIndex%6 (or 4 instead of 6 for indexes rendering). Unfortunately I haven’t had the time to implement and test this yet. If like me you’re also rendering lines with perspective, you want to also look at Freya Holmer

It's not the default, but Rust absolutely allows dynamic linking [1]. For example, Bevy encourages building the engine as a dynamic library during development to improve iteration turnaround times for the app code [2]. [1] https://doc.rust-lang.org/reference/linkage.html [2] https://github.com/bevyengine/bevy/issues/791

Yep, marker components is a much more feasible pattern now, and I tend to prefer tiny, granular components when writing Bevy apps as a result. The only drawback to this design is that you can't add / remove components instantly[0], and instead need to wait for the next "hard sync point" at the end of the stage. 0: https://github.com/bevyengine/bevy/issues/1613

We ended up cutting some of the technical ECS details from the blog post to make it more easily-digestible. The description in this pull request is effectively a stand-alone blog post describing things like the Archetype Graph: https://github.com/bevyengine/bevy/pull/1525

I'd just like to mention that the release notes are one of the best I've read. Same goes for PR descriptions like for the ECS v2 PR [1]. That's more text than half of open source libraries have documentation. [1] https://github.com/bevyengine/bevy/pull/1525

There are some in the blog post, with more details in the corresponding PR: https://github.com/bevyengine/bevy/pull/1525 Ctrl+F for "Benchmarks" to find the right section :) Eventually it would be nice to update the cross-engine ecs_bench_suite fully to reflect the changes.

All this hype around ECS started when Minecraft, Factorio and They Are Billions proved that the paradigm works, though that is just a small percentage of games that can benefit from ECS. The rest should use the classic OOP model. I really don't see how a game like Dota, CSGO or your average Battle Royale will be better with ECS. I agree with the article. There are libraries enabling ECS for you if you are not looking for an engine like Unity: C++: https://github.com/skypjack/entt (Non-Java Minecraft uses this) Java: https://github.com/libgdx/ashley Rust: https://github.com/bevyengine/bevy (it's still work in progress, not battle-tested and a moving target)

Can anyone speak to their experience using Bevy on the web with WASM (related [1])? Are there other non-JavaScript game engines you’d recommend? [1] https://github.com/bevyengine/bevy/issues/88

PBR is on the todo list. https://github.com/bevyengine/bevy/issues/179