Nphysics – 2 and 3-dimensional rigid body physics engine in pure Rust

by dbaupp • 13 years ago

78 21 13 years ago

ivan_ah2• 13 years ago

UGRAD mechanics class of the future should be to program a physics simulation engine in the language of your choice.

kyzyl4• 13 years ago

That's what one of my undergrad mechanics classes was. Actually that was just a project in the course, along with all of the usual theory, lectures, assignments etc.

I don't think that's terribly unusual.

ivan_ah2• 13 years ago

Cool! Which school was that? Did they just assume you knew coding to begin with or did they teach the programming aspect also?

Did you keep any lecture notes/code from that project? I'm working on something along those lines[1], but not sure how to do the collisions and contact forces.

The source code of box2D is very useful and I have some other physics engine resources but something with a more physics-lesson flavour could be very handy as inspiration.

[1] https://github.com/ivanistheone/phys.js

bilalhusain• 13 years ago

In case someone is struggling because they didn't read the docs or they are not into game-dev

- you need Rust compiler from the master branch (0.8-pre)

- dependencies needed: libglu1-mesa-dev freeglut3-dev mesa-common-dev libGL-dev libopenal-dev libxrandr-dev libxi-dev libglew1.5-dev libjpeg62-dev libfreetype6-dev libsndfile1-dev; SFML 2.1, CSFML 2.1; build glfw3 with cmake -DBUILD_SHARED_LIBS:BOOL=ON

santaclaus• 13 years ago

How does the code handle the jump from SE(2) to SE(3) in a clean fashion? Pretty much any integrator you cook up will keep your configuration in SE(2), but a discrete integrator of the Newton-Euler equations takes a bit more care.

kyzyl4• 13 years ago

So, I don't know Rust very well and their code is not really documented at all, so this is just a guess. But...

It seem that the default world container assigns an integrator called "BodySmpEulerIntegrator", for which I can't seem to find the source. In any case, with a name like that I would have two predictions:

a) 'Smp' stands for 'simple' in which case this would be a stock/naive/vanilla Euler integrator. If that's indeed true, then I suspect the answer is that it will NOT handle the transition to SE(n>2), as they tend to blow up when the Hamiltonian becomes at all stiff. That is usually the case for your standard 6N+2 dof system in 3D.

b) 'Smp' stands for 'symplectic', which would make the default integrator some form of symplectic euler integrator. To my knowledge any SI should handle a 3D non-timevariant, non-chaotic Hamiltonian. This seems much more likely, given the amount of effort they've put in. Indeed, if you look at the examples that have a 2- and 3-D version, they don't seem to reassign the integrator.

That's a lot of guess-work on my part, though.

unwind• 13 years ago

This would appear to be the source of BodySmpEulerIntegrator, or at least a starting-point (I don't know Rust): https://github.com/sebcrozet/nphysics/blob/916199c0a67219482....

evincarofautumn3• 13 years ago

In a not-that-near future, C++ will die of ugliness

I am so excited for that day. There are some really amazing upcoming languages positioning themselves to replace C++ for new applications. Rust seems to be in the best spot right now; Nimrod is also pretty compelling.

wicknicks• 13 years ago

I'm hoping for a not-that-far future ... Jokes apart, does Rust perform as well as C++?

evincarofautumn3• 13 years ago

Anecdotally yes, within a few percent, depending on what you measure. Safe code tends not to perform as well as unsafe code, but this is also true in C++—most applications just tend to err (and I mean err) on the side of performance.

mden• 13 years ago

Out of curiosity, in what ways is Rust that much less uglier than C++? I've only looked through the docs and the code provided and it seems to be riddled with the same type of "ugliness" inherent to C++ - namely the ugliness symbolized by the need for all of the special characters like * and &. It seems like Rust has some nice syntax for pattern matching, but what else?

nnethercote• 13 years ago

You're only thinking about syntax. Look deeper.

evincarofautumn3• 13 years ago

Syntax is undoubtedly important, but primarily as a means of elegantly expressing the unique semantics of a language. The visible ugliness is the language being explicit about low-level details.

So what else? Rust isn’t a huge innovation in terms of language features, but it does take advantage of relatively recent advances in language design (e.g. typeclasses) and has an excellent combination of defaults. The important ones are memory safety, an ownership model (think unique_ptr/shared_ptr), immutability, and isolated lightweight threads.

z3phyr• 13 years ago

That day might never come. Good things of rust will eventually make their way into newer C++ standards. The industry largely depends on C/C++, and switch to other languages is getting out of the comfort zone.

glennsl• 13 years ago

You might get some of the good stuff, but you won't get its killer feature, robustness, without sacrificing backwards compatibility. And that's not going to happen.

Eventually we have to move on to more robust programming languages where null pointers and pointers to freed memory are not allowed.

Nphysics – 2 and 3-dimensional rigid body physics engine in pure Rust

Related Stories