8 ms·
Bevy game engine 0.6
- knobli 5y agoI waited til 5am for this, it's currently 5:25am in Melbourne Australia...
- dralley 5y agoBevy's release notes are consistently the best I've ever seen.
- _cart 5y agoLead Bevy developer here: feel free to ask me anything!
- eb0la 5y agoEvil question: I wonder why do you have version zero.something - this looks good enough for a version 1. What do you like to accomplish? And... What kind of help you'll need to get there??
- djmcnab 5y agoI can't speak for cart here, but from my perspective as a contributor to `bevy`, it's extremely useful having freedom from backwards compatibility concerns to improve our APIs. For example, we want to rework our input handling, asset handling and UI; supporting this current UI solution indefinitely would be frustrating when we hope to make something much better once we can focus on that. As an example of this, we massively changed our rendering APIs for this release, allowing the improvements listed in the blog post to be implemented.
- rl3 5y ago>What do you like to accomplish? The What's Next For Bevy? heading in the release announcement covers this: https://bevyengine.org/news/bevy-0-6/#what-s-next-for-bevy https://bevyengine.org/news/bevy-0-6/#what-s-next-for-bevy
- pcwalton 5y agoWell, lack of skeletal animation is a showstopper. Every 3D game needs that no matter what.
- paledot 5y agoI wondered why the Rust community seemed so averse to 1.0 releases, but Rust for Rustaceans makes the interesting point that there are a lot of cases in the Rust language where adding new features technically qualifies as a breaking change. There doesn't seem to be a lot of room for the minor version number - everything is either a revision or a major release, and people aren't ready to commit to that level of strictness until they're feature-complete.
- fsloth 5y agoLooks really nice! If one was to implement a simple "3d arcball rotator" viewer for 3d formats to get familiar with the engine (i.e. load obj, view) can you suggest which examples would be most relevant (presuming bevy architecture is the only unfamiliar topic here)?
- _cart 5y agoThe input examples and the GLTF loading example are good places to start. https://github.com/bevyengine/bevy/tree/main/examples/input https://github.com/bevyengine/bevy/tree/main/examples/input https://github.com/bevyengine/bevy/blob/main/examples/3d/load_gltf.rs https://github.com/bevyengine/bevy/blob/main/examples/3d/loa...
- pella 5y agoAny public roadmap?
- nchi3 5y agoSuper happy to see 0.6 released, great work! I've been sponsoring for close to a year, but haven't kept up with the Discord in many months. Currently I'm just been checking for updates every couple of weeks, and sometimes checking the state of GitHub issues and milestones. However, is there any better way for me to keep up with progress? If not, has there been any thought about having regular status updates? They don't have to take a lot of your (or someone else's) time, but just a few sentences on what's been decided, what's happened, etc, would be nice! Once every 30 or 60 days would definitely be enough.
- _cart 5y agoGoing forward, we will be doing a curated This Month In Bevy newsletter. We've had templates in draft mode for awhile, but getting 0.6 out the door has taken precedence. I'd like to release our first newsletter this month!
- nchi3 5y agoThat's great to hear! Thank you for all the hard work, I'm looking forward to see Bevy grow, and really hope it'll end up becoming a worthy competitor to Unity/UE/Godot for commercial games some day!
- wrnr 5y agoThanks for your work. What is the support for low-end and mobile devices? I have tried developing with bevy on my old macbook with an Intel Iris graphics card, maybe not ideal but that is what I have and I want to support most hardware. Last time I tried the simple cube example made my fans spin. Is this something that can be alleviated?
- _cart 5y agoWe support low-end devices well (although this is a constant balancing act)! Bevy runs well on iOS currently (and we have WIP Android support ... we're working on re-enabling that asap). Fans spinning is a known issue, but it is generally decoupled from framerates (which tend to be fine). On some machines we are over-engaging cores, even with empty apps that do nothing ... my current theory is that we need to adjust how our task pools are managed.
- skavi 5y agoiPhones have insanely performant GPUs for the form factor. I wouldn’t be surprised if the newer ones get better performance in Bevy than a lot of perfectly usable laptops.
- ffhhj 5y agoCongrats for the release, looks great! Not a criticism, but model projected shadows (not prebaked on lightmaps) are very jagged or really low-res, reminds me of early Unity shadows. I know Unity worked hard to improve them for years and acquired experts on shaders, because users complained and even moved to Unreal for that reason alone. Not sure if there are now well known solutions to get highly defined shadows, but I'm curious on your plans to improve them.
- _cart 5y agoYup shadows are notoriously difficult to make pretty in all situations. Fortunately we do have a number of "shadow quality" improvements in progress: https://bevyengine.org/news/bevy-0-6/#more-renderer-features https://bevyengine.org/news/bevy-0-6/#more-renderer-features. And we'll probably be improving shadows indefinitely from now on. The tech in that space is constantly evolving.
- pcwalton 5y agoI'd like to see irregular Z buffers deployed in a modern graphics engine, as they actually provide pixel-perfect shadows without the need for raytracing hardware. They're pretty experimental, though. Maybe I'll take a stab at implementing them in Bevy sometime :)
- mysterydip 5y agoIf I'm a dev looking at engines to use, would now be the time to jump to Bevy, or is there expected to be significant changes to API and data structures moving forward still?
- _cart 5y agoThings have started to stabilize, but unless you're willing to get your hands dirty and deal with regular breaking changes, I don't yet recommend staking your livelihood on it. That being said, by the end of the year I think we will be _much_ closer to our first stable release, and I expect the number of "serious projects" adopting Bevy to increase throughout the year. Now is the right time to start _evaluating_ Bevy for future projects (and experimenting with it).
- mysterydip 5y agoThanks for the response, I'll check back in a year!
- Animats 5y agoI'm using Rend3 for a Second Life/Open Simulator client. The current system with Rend3 has one thread doing nothing but refreshing the screen, while other lower-priority threads are independently changing the scene based on incoming messages from the network. Is that something the Bevy architecture can handle? Should I consider switching to Bevy?
- _cart 5y agoPipelining allows rendering and app logic to run in parallel. You can adapt to changes from the network when the app logic runs, so in that sense, it seems like a good fit. And you can use bevy_tasks to spawn background tasks (and spawn tasks across different thread pools, if that is required). I think it is worth considering Bevy, but I also think Rend3 is a great piece of software. We discuss rendering with that project's lead constantly :)
- infogulch 5y agoI noticed the short section on changes to Bevy's UI. I expect both GPU rendering and ECS will be important capabilities to consider for new GUI systems, and Bevy does both well. How do you imagine Bevy fitting into the budding Rust GUI story a la https://areweguiyet.com https://areweguiyet.com ? An entrant itself? The backend for one? Would you consider pure GUI applications an important use-case for Bevy now, or perhaps some time in the future?
- alice-i-cecile 5y agoSo, I'm not Cart, but I'm a major contributor. My vision for this is as both an entrant and a logic-backend for GUI. In terms of use cases, I expect that: games > servers > scientific simulation > pure GUI, but all four are something we're trying to be actively mindful of. Accessibility matters, but native-look-and-feel is effectively a non-goal at the engine level; there's a lot of other frameworks that can provide this and cross-platform unification is more important. We're planning to follow Godot and dogfood the UI to build out the editor, so support for pure GUI applications is something that we'll be actively testing.
- cpeterso 5y agoHow do you pronounce Bevy? Long e like “Beevy” or short e like “Bevvy”? What’s the origin of the name?
- Winsaucerer 5y agoI haven’t tried bevy, so this question may sound naive. Does the new renderer support shadows for 2d rendered games? Something I’ve played around with in Godot and can look quite nice. Also, I tried to search for the answer to this: is there any information on ways to make a game build with bevy moddable?
- halpert 5y agoI spent a few days making a (very) basic 2D game engine in Rust for fun. One thing I found is that I didn't find Rust that helpful in preventing bugs due to the nature of game engine code. For instance, I was using a generational array to store components. At some point I had a use-after-free bug in the generational array code that the Rust compiler could never catch. Also, components tend to have circular references to one another, which was very annoying to program in Rust. I'm curious if you've experienced something similar and what your thoughts are now, after many months in the trenches, on Rust's suitability for a game engine.
- jjnoakes 5y agoI want to point out to unfamiliar readers that use-after-free in a rust generational array is a logic bug, where as use-after-free in just about any other non-rust context is undefined behavior. Rust's safety is helping here, not by preventing the bug altogether, but by severely limiting the damage it can cause.
- k__ 5y agoAre there any good learning resources on how to program to get around these "logic bugs"? I had a runtime error with my first Bevy game too, because I forgot to add a resources to my app before I used it.
- deleted 5y ago[deleted]
- cyber_kinetist 5y agoAlthough I'm not _cart, I had a similar experience in making a (hobbyist) 2D game engine both in Rust and C++, and the problem you're facing (similar to the ABA problem) is not a memory safety error but more of a logical bug inherent in naively programmed object pools and is totally language-agnostic. When you create an object pool as Vec<Option<T>> and use a single array index as resource IDs, you risk this scenario: "X has a reference to resource A from object pool, A is destroyed and later reused by the object pool for resource B, now X has a reference to resource B". The problem is that the resource IDs will become invalidated as the object pool reuses its slots. The incremental generational counter is a way to check object lifetimes in object pools at runtime, and this is a solution to a logical error (which can be applied regardless if your language has a borrow checker or not). If you've had weird errors while using generational arrays, chances are that 1) you've exhausted your generational counter and it has overflowed 2) your generational array code is incorrect. The verdict: Rust's lifetimes does not make you safe from non-memory-safety related bugs. It still gives you some really powerful abstractions to fight these bugs (like enums, traits, Option<T> and Result<T, Err> types), but other than that you're on your own. (About circular references between components... doesn't this also get solved by generational indices? With Arc<T> types you're going to have circular dependencies that don't get freed because of reference counting, but with generational indices you're free from that issue since you're manually managing resource lifetimes anyway. And if you're having trouble figuring out how to manage these dependencies, the solution might be to refactor your code. My experience of using generational arrays was that it will naturally move your code-base towards centrally managing resources in a unified fashion, which is rather different than the usual Rust/C++ model of every object having its own independent ownership. After embracing it I tend to have less of those resource management dependency headaches.)
- reitzensteinm 5y agoCongratulations on release! I was wondering if there is any low hanging fruit for WebGL build size improvements. I did a Unity test build for comparison against your rect example, with a cube and a single script that does nothing (so they can't e.g. strip out Mono). Listing sizes uncompressed, 7z Ultra (a decent proxy for Brotli), and wasm-opt + 7z Ultra respectively: Rect example: 13473kb, 1964kb, 1720kb Basic Unity: 9528kb, 2304kb, 2291kb Bevy is still leading, but it's getting uncomfortably close. The uncompressed sizes matter a lot more than any other asset type, as it's all code that has to be compiled, running poorly until the optimized compiler has finished with it. On a Chromebook, my experience is that much code gives you 30-60s of poor FPS before it comes good. I understand this is not necessarily a focus of Bevy, but I do think that you have an opportunity here to build the first game engine without significant downsides on any single platform. Filling the code base with a bunch of feature flags may not be worth it to achieve that goal, though. The modularity of Bevy is super exciting (I've asked you before about WebGL builds on here before and you mentioned this). But Unity ships quite a bit of stuff in a basic build and is probably fairly similar in scope to Bevy with all crates.
- PudgePacket 5y agoThere are a number of techniques available to shrink wasm size in rust, this is the best collection of them I'm aware of https://rustwasm.github.io/docs/book/reference/code-size.html https://rustwasm.github.io/docs/book/reference/code-size.htm.... Please also consider Unity web used to be significantly worse and it took multiples of bevy's lifetime for it to get to where it is now :)
- jeffybefffy519 5y agoNot a game or rust dev, but going thru the quickstart tutorial - Bevvt looks pretty nice. Good job and thanks
- bullen 5y agoPipelined rendering increases motion-to-photon latency.
- gameswithgo 5y agoyes, you desperately want low latency, but also desperately want high throughput. such is life.
- cptroot 5y agoDo you mind explaining why? Near as I can tell it should be the same unless you were already maxing out your CPU to run the game.
- steeleduncan 5y agoInstead of doing all operations required to render the gamestate in a single frame you spread them in parts across multiple frames. This means that the output represents the state of the game some number of frames ago, increasing the time between your control inputs and what you see changing on screen.
- dagmx 5y agoI don't believe that multi frame processing is a required part of a pipelines render. It just means the render stages are customizable, therefore is more flexible. See Unity as an example.
- mtsr 5y agoThis kind of pipelining is really about efficiency. Without it, either only the game logic is busy (utilizing just the CPU, most often) or the renderer is busy (utilizing both CPU and GPU). By starting next frames game logic sooner (concurrently with current frames rendering), one can keep a steadier load on both CPU and GPU with less idle time.
- _cart 5y agoIt can, but with care you can largely resolve this. And you can always disable pipelining if the performance benefits aren't worth it to you. Unity has a great article on this topic here: https://blog.unity.com/technology/fixing-time-deltatime-in-unity-2020-2-for-smoother-gameplay-what-did-it-take https://blog.unity.com/technology/fixing-time-deltatime-in-u...
- twofornone 5y agoLooks like a good reason to finally try out Rust. Does HN have any recommended IDEs?
- petee 5y agoI'm just learning myself, and I found just Visual Studio Code and the Rust extension are great on Windows
- fsloth 5y agoSeconded! It all works incredibly well. Rust with Visual Studio Code and the relevant suggested extensions (CodeLLDB, rust-analyzer) must be least hostile expert system I've ever used (and I've tried a few).
- friedman23 5y agoMake sure to use the Rust Analyzer extension, it's is significantly better than the default Rust extension.
- petee 5y agoI tried for a minute but it just wouldn't work out of the box and I didn't have time to investigate, so I reenabled the default for now. I thought I saw somewhere rust devs themselves recommending Rust Analyzer too
- bobbyskelton41 5y agohttps://github.com/rust-lang/www.rust-lang.org/pull/1620 https://github.com/rust-lang/www.rust-lang.org/pull/1620
- deleted 5y ago[deleted]
- mahulst 5y ago
- mahulst 5y agoAwesome! What a lengthy blog, so many new features. Great job on the new milestone!
- terafo 5y agoWith 3 month release cadence one question becomes more pressing: will it be 1.0 or 0.10?
- alice-i-cecile 5y ago0.10!
- deleted 5y ago[deleted]
- rl3 5y agoCongratulations to cart and the core Bevy contributors! This release was a long time coming, and their efforts are greatly appreciated. If you use this project and you can afford to donate, you definitely should! Having paid close attention to the Bevy Discord this past year, the sheer amount of work that's happened on this release is mind-boggling.
- chmod775 5y agoIt looks great in a lot of respects, but I can't help but notice the aliasing. In the example scene at the top, when in motion, it probably looks like there's a snow storm going on in the foliage and on most of the wall/floor textures. To me good anti-aliasing strategies is the single most important factor when it comes to graphics. I don't really care about things looking realistic or whatever, but I do care about my screen not being full of moving, weird, and distracting grainy patterns. This involves more than just softening the edges around polygons. There's also textures that contain shapes and the borders in textures with transparency to think about (usually foliage). My go-to solution in games with lackluster anti-alias is to just render them at a super-high resolution (4k/8k) and downscale, but that's not great for performance usually. You can compensate a bit because you won't need as much anisotropic filtering and such if you downscale, but even on expensive hardware that's not a solution in all games. To get to the point: In some older games I've seen blurring (possibly due to hardware limitations) of further-away detailed textures reducing aliasing. I'd love to see that technique revived in more modern games, possible with the help of AI to detect patterns/edges on textures that may be susceptible to aliasing, and selectively running those through a filter - basically shifting the work from the artists having to design textures that don't create artifacts to something automatic. In general good AA tends to be a second-class citizen in many modern game engines, partly because of how their renderer is configured by default (looking at you, Unreal). I really wish it wasn't so.
- masklinn 5y ago> My go-to solution in games with lackluster anti-alias is to just render them at a super-high resolution (4k/8k) and downscale, but that's not great for performance usually. By "lackluster anti-alias" do you mean some sort of home-grown MSAA that's garbage? Because you're hand-rolling SSAA/FSAA, can't you just override the AA settings in the graphics driver to force FSAA or something?
- _cart 5y agoThe aliasing you're seeing is "texture aliasing" from a lack of mipmaps. We have an implementation in the works, it just didn't make it into this release. This is a straightforward and well understood problem. Thankfully our mesh edges are already crisp (thanks to MSAA) and we have a number of other anti-aliasing implementations in the works (TAA, SMAA, FXAA), each with their own strengths and tradeoffs.
- serverholic 5y agoBevy is one of the most exciting projects in the rust space IMO.
- jasonjmcghee 5y agoCurious if others are able to see the WebGL2 examples working on iOS. They do not render for me, but WebGL2 definitely works in general, at least on 15.1+ (as per other sites and my own dev work)
- marcusbuffett 5y agoShameless plug, I wrote a snake tutorial for bevy that’s become pretty popular, and just updated it for 0.6. https://mbuffett.com/posts/bevy-snake-tutorial/ https://mbuffett.com/posts/bevy-snake-tutorial/
- alserio 5y agoThank you, I was just asking myself if you are still updating it. Really nice tutorial
- bebop 5y agoI think there is a mistake when calling the setup_camera function in main. You call setup not setup_function, which I think is incorrect. Thanks for writing that up! Great article.
- k__ 5y agoOh no, I just did it right before the 0.6 update. But good tutorial!
- dang 5y agoSome past related threads: Bevy's First Birthday: a year of open source Rust game engine development - https://news.ycombinator.com/item?id=28132114 https://news.ycombinator.com/item?id=28132114 - Aug 2021 (13 comments) Bevy 0.5: data oriented game engine built in Rust - https://news.ycombinator.com/item?id=26716166 https://news.ycombinator.com/item?id=26716166 - April 2021 (65 comments) Bevy: A game engine built in Rust - https://news.ycombinator.com/item?id=26131350 https://news.ycombinator.com/item?id=26131350 - Feb 2021 (117 comments) Bevy 0.4: data oriented game engine built in Rust - https://news.ycombinator.com/item?id=25480321 https://news.ycombinator.com/item?id=25480321 - Dec 2020 (23 comments) Making a Snake Clone with Bevy - https://news.ycombinator.com/item?id=24999073 https://news.ycombinator.com/item?id=24999073 - Nov 2020 (11 comments) Bevy 0.3: game engine built in Rust - https://news.ycombinator.com/item?id=24983956 https://news.ycombinator.com/item?id=24983956 - Nov 2020 (55 comments) Bevy 0.2 - https://news.ycombinator.com/item?id=24530698 https://news.ycombinator.com/item?id=24530698 - Sept 2020 (43 comments) Bevy: A Game Engine in Rust - https://news.ycombinator.com/item?id=24334307 https://news.ycombinator.com/item?id=24334307 - Aug 2020 (42 comments) Bevy: A data-driven game engine and app framework built in Rust - https://news.ycombinator.com/item?id=24123283 https://news.ycombinator.com/item?id=24123283 - Aug 2020 (103 comments)
- Ygg2 5y agoHow do you guys debug bevy? Especially on Windows?