EntityComponentSystemSamples
libm
EntityComponentSystemSamples | libm | |
---|---|---|
23 | 8 | |
6,833 | 498 | |
1.0% | 1.6% | |
4.8 | 5.5 | |
5 days ago | 3 days ago | |
C# | Rust | |
GNU General Public License v3.0 or later | Apache License 2.0 |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
EntityComponentSystemSamples
-
Added Physics to my enemies - Unity DOTS. Pretty happy with the result! Time to tweak
Sure. This is the repo. It contains more than Physics
- Has anyone here ever used the DOTS system in the wild? And how did that go?
-
Compilation error after importing com.unity.entites.
(In general - I'd recommend looking at https://github.com/Unity-Technologies/EntityComponentSystemSamples and use their manifest.json as a base for your project)
-
ECS Utility AI
heres some samples and reads from unity https://github.com/Unity-Technologies/EntityComponentSystemSamples
-
I need a crash course on Unity dots
Check out the links here. The official ressources contain videos, text tutorials and examples.
-
EntityQuery inside a burst compiled job?
The manual is a good starting point. There is also the scripting API for specific syntax, the dots samples by unity and the megacity sample by unity for a full project.
-
How should I get player input when using ECS?
The ECS samples have both. I am using the new input system and it works. The gist is to have a systembase for the callbacks that sets singleton components for the gathered input. Then each system (base or isystem) can query those as normal components. New input system
-
I learned how to use Unity DOTS and unlocked a new kind of pain.
DOTS comprises a number of new features in Unity. Dive into this GitHub as it’s got a number of great resources to get started.
-
Edsger Dijkstra - math and memes
In Unity, the implementation was done by moving functions from the Entity to the Archetype, which then can be accessed via interfaces. Those interfaces can be inherited in classes. I have "running, waiting, scanning" behaviour classes that get applied to those Archetypes, so OOP is still there but different.
-
Spawning multiple entities at once
If you have the same problem that I had. I found the solution from Unity's ECS Samples here the link: https://github.com/Unity-Technologies/EntityComponentSystemSamples it's in Advanced/EntityPrefab long story short you should use DynamicBuffer with struct that includes EntityPrefabReference and then you must load it via adding RequestEntityPrefabLoaded component and only then when we have PrefabLoadResult component we can spawn it.
libm
-
`libm-0.2.6` dependency fails to build for Mac M1
Yes I took a look at build.rs. There's nothing here that stands out to me. Building the project on my Ubuntu machine works btw.
-
Rust f64::tan() twice as slow as Go math.Tan()
The more interesting code is the "kernel" tangent function https://github.com/rust-lang/libm/blob/master/src/math/k_tan.rs . I don't see any numerical analysis of accuracy in either the Rust lib or the MUSL source lib, but from one of the comments it looks like it's intended to be within 1ULP, which is what I'd expect.
-
Slow performance in Rust compared to Go and C# with math, especially f64::tan()
It's nowhere near complete, but: https://github.com/rust-lang/libm
-
Algorithm to compute Trigonometric functions
Inaccurate fast implementations use polynomial approximation. Accurate implementations use high-powered argument reduction and then polynomial approximation. Everything is polynomial approximation.
-
Porting Rust's std to rustix
It looks like https://github.com/rust-lang/libm/pull/249 may be a fix for this.
-
ELI5: How does calculator know and use pi if even super computers can't know all the digits. Does it use like first 100 digits?
In order to be standards-compliant, computer math libraries need to have a lot more digits of pi than should be strictly necessary. Accurately calculating sine in the upper reaches of double precision floats requires computer to have a table of about 100 digits of pi (or rather pi/2 for technically reasons) and 500 digits of 2/pi - here is an example.
-
Cross-platform deterministic physics with Unity DOTS physics and soft floats
So, fixed-point numbers weren't the solution to the problem either. The next thing I came across was the Rapier physics engine. It promises cross-platform determinism all IEEE 754-2008 compliant platforms. Although it's written in Rust, creating C# bindings was fairly easy, and I could use it in Unity after a few hours. But Rapier is still in early stages of development, which means that (at the time of writing this) it lacked many features, like raycasting, which would have been necessary for my project. Also, it's only deterministic on IEEE 754-2008 compliant platforms. But I couldn't really find any information on which processors support it. Even if I did, I still wanted to have deterministic physics on all platforms, not just on "most of them". But I still wondered does how Rapier achieve cross-platform floating point determinism. Supporting only IEEE 754-2008 compliant platforms is one thing, but the mathematical functions I mentioned above (sqrt, trigonometry, etc.) must also be deterministic. I found out that it uses libm, which implements all of these functions in software. It was primarily designed for embedded systems without FPUs, but it turns out it's also pretty useful for making this part of floating point math deterministic. But after all, the basic mathematical operations of floats are still not deterministic. Unless... How about emulating the behavior of floats in software? It should be possible to write a program that works on the byte representation of a float, doing all operations using integer arithmentic... right?
What are some alternatives?
unity-deterministic-physics - Cross-platform deterministic physics simulation in Unity, using DOTS physics and soft floats
ecs-unityintegration - UnityEditor integration for LeoECS Entity Component System framework.
SoftFloat - An implementation of 32 bit floating point arithmetic in C#
SimpleSIMD - Easy to use SIMD accelerated Array and Span methods
compiler-builtins - Porting `compiler-rt` intrinsics to Rust
unity_browser - Open source Unity3d web browser created by Vitaly Chashin https://bitbucket.org/vitaly_chashin/simpleunitybrowser
soft-float-starter-pack - Software implementation of floating point numbers and operations
UniteAustinTechnicalPresentation
rust - Empowering everyone to build reliable and efficient software.
ecs-faq - Frequently asked questions about Entity Component Systems
rustix - Safe Rust bindings to POSIX-ish APIs