

Modeling Physics in Javascript: Gravity and Drag - bpierre
http://burakkanber.com/blog/modeling-physics-javascript-gravity-and-drag/?

======
Simucal
I wrote something like this a couple years ago[1]. I also attempted to support
ball-to-ball collisions. I rarely do any graphics type programming so this was
a fun diversion.

However, the simulation would slow down considerably after adding a few dozen
balls. This was largely due to the quadratic nature of my naive collision
detection. In order to remedy the speed problems I implemented[2] a quadtree I
found online to assist me in culling a lot of my expensive collision checks.
The bounds of the quadtree sections will appear as you begin to add balls.

Unfortunately the quadtree wasn't the performance savior I expected it to be.
I didn't notice a dramatic improvement in the number of balls I could support.
I also introduced a bug with the quadtree version where certain collisions are
missed entirely.

Perhaps I should revisit this simulation and see where I was off.

[1] - <http://jsfiddle.net/simucal/RvA9w/33/>

[2] - <http://jsfiddle.net/simucal/RvA9w/>

~~~
mrhyperpenguin
Instead of quadtrees take a look at spatial hashing[0]. It's more simple than
quadtrees and the performance is similar if not better.

[0] [http://www.gamedev.net/page/resources/_/technical/game-
progr...](http://www.gamedev.net/page/resources/_/technical/game-
programming/spatial-hashing-r2697)

------
mbq
I know it is educational and it does not matter in presence of dissipation,
but it would be nice to mention that Euler method is not only an approximation
but also terribly inaccurate one. It won't produce any stable oscillations or
orbits for instance.

~~~
bkanber
I actually mentioned that in a comment lower on this page. I will be talking
about ODE solvers a couple of articles from now. The Euler method isn't
acceptable for actual simulation but it's the easiest to understand and it
gets the job done for now!

~~~
xxbondsxx
The Velocity Verlet integration method isn't much of a jump in complexity
([http://en.wikipedia.org/wiki/Verlet_integration#Velocity_Ver...](http://en.wikipedia.org/wiki/Verlet_integration#Velocity_Verlet))
and works _great_ for kinematic simulators.

As a cool feature, it maintains the energy of the system, so you can slow
down, stop, and then rewind time and arrive at the same previous
configuration, all by changing the delta T's inside the evaluation.

~~~
bkanber
I'll definitely be talking about this one in my Solvers article!

~~~
baq
be sure to read "numerical recipes in c" chapter 16 first.

fwiw the only thing you need to do to be one of the best references on
numerical integration in js on the net is translate the code to javascript...

------
zackmorris
I've messed around a bit with the Bullet physics library and was wondering if
anyone knows how it works under the hood. It's not brute forcing the
collisions, because it can handle thousands of objects.

Does anyone know how they do the approximation? There is a fudge factor you
can set for say a 10% boundary around an object, where it's almost like it
moves all of the objects and then takes a best guess where they should be
placed for the next physics frame. But I'm curious what their approach is
called, if it's a general solution.

~~~
bkanber
Look into quadtrees, that's a good way to do collision detection in 2d. Or
just partition your world into a fixed grid and only consider collisions with
objects in the same grid square. Quadtrees are just a smarter way of doing
that.

------
typpo
I recently did something somewhat physics related, implementing Kepler's laws
of planetary motion in JS to produce a 3d simulation of the solar system:
<http://www.asterank.com/3d/> ...I plan to generalize it into an open source
educational tool that allows people to build arbitrary space simulations on
top of its physics engine.

Another interesting JS physics experiment that I found while looking into this
stuff is this n-body gravity simulator:
<http://www.spacegoo.com/solar_system/>

~~~
bkanber
Awesome! I couple years ago I made a simple game that uses orbital mechanics
too: <http://burakkanber.com/orbit>

If it will help at all feel free to poke through the source code!

------
mweibel
Very good article and very good explained. I have a hard time really getting
physics but if my teachers would have explained it this way I might actually
have had fun with it :)

~~~
bkanber
Thanks! That's what this series is all about. Physics and math really are fun,
you just need to figure out an application that excites you and also have
someone teach it to you in a manner that keeps you engaged. That's what I'm
trying to do here, so if you're interested you can sign up for the mailing
list and I'll send you emails when new articles are posted!

~~~
mweibel
Yes, did this already :) thanks for making these articles!

------
hrabago
The page won't come up for me. Is it already hurting from being HN'ed with
only 26 upvotes?

~~~
bkanber
Yeah it's a tiny box with Wordpress on it. Fixed!

~~~
slig
Also, it would be great to notified about ALL your blog posts, not only this
series. :-)

~~~
bkanber
Thanks for the support! I wanted to set it up so that I'm not flooding
inboxes-- so you may be better off subscribing to the blog's Atom/RSS feed :)

------
akldfgj
Move the Fiddle to the top of the page, and get much more user interest.

------
viraj_shah
Thanks for putting up the email subscriptions

------
gbrindisi
This might become my favorite blog ever.

~~~
ObnoxiousJul
You really want to play with physics/math with ECMA 262? O_O (hint JS knows
nothing of integers) Floats are way to slow (and faulty when div/mul are
called) compared to int to do anything serious. All 3D engines tricks are
about doing complex math with integers (EDIT: or other tricks
[http://en.wikipedia.org/wiki/Fast_inverse_square_root#Overvi...](http://en.wikipedia.org/wiki/Fast_inverse_square_root#Overview_of_the_code))

~~~
grimboy
Why would you post a link to an example using floats then? I mean sure, part
of the trick involves treating the float as an integer but the number is still
meant to be interpreted as a float.

Your assumptions about speed might be true for something like a Nintendo DS
which doesn't have a floating point unit but a 3DS does, a vectorised one no
less. Also in Javascript integers that can fit into 32 bits are actually
integers nowadays.

All in all, I believe your information is outdated.

~~~
dkersten
Not to mention that most modern games and physics engines all use floating
point numbers these days. We're not in the 90's anymore - gpu's all support
floats natively and are very fast at processing them, cpu floating point units
are as fast as integer units, SIMD (eg SSE) supports fast floats and doubles.
There's really no reason to avoid floats unless you're doing something very
very special (hint: if you're arguing about these things, you're probably
not).

Havok, Bullet, PysX - as far as I know they all use floats.

