Use require.js by default, if you need help, I can convert all your code.

you know the drill

Is there any complete api doc available? I mean complete list of available classes/methods/properties?

I'm guessing I would need to create a simulation and then write a custom renderer that applied resulting values to the DOM elements I'm wanting to apply physics to. But got stuck.

If I knew how to simulate a box of known dimensions and apply gravity to it I feel like I could figure out the rest of it.

I've built the master version and when I've tried using it I got this error:

Uncaught TypeError: Object #<Object> has no method 'Layer' newton.js:363

Would be great to know this info, before starting building something on it.

There seems to be no way to do this except destroying one of the particles used by the constraint.

Please forgive me if there's an obvious reason why I shouldn't be doing this, but I'd like to remove things from my simulation periodically beyond just particles. For instance, if I create a body that has associated edges, particles and constraints, I'd like to be able to remove the entire thing from the simulation at a certain point.

I was able to accomplish this for my purposes by adding an isDestroyed to Edge and adding a cull pass into the simulator for the edge list. I can submit a PR with that change if that's valuable.

In general, I'd just like to start a discussion as to the right approach for removal of complex bodies from the simulator.

I want to use newton.js in a large project, but I have a couple questions: are there any docs besides the guide? Even a list of classes to explore? Secondly, how do I render bodies without using a builtin renderer (to use textures, etc.)?

BoxConstraint isn't defined, for example. (perhaps it's just been updated since last publish).

If you could publish latest as 0.0.6 or something, that'd be much appreciated. I've been having a ton of fun with this library, thanks for writing it!

I tried to applyForce (which gave me an error), setVelocity and manual set of velocity. Nothing works. How should I do it?

https://gist.github.com/andricicezar/9515262#file-ball-html

On the README you say to download using bower with bower install newton however that's not this library.

The newton package on bower.io is this one: https://github.com/jpsilvashy/newton

The pixi renderer is simple and a huge improvement over canvas.

CoffeePhysics has a crazy fast renderer as a result of using custom vertex shaders instead of individual draw operations:

https://github.com/soulwire/Coffee-Physics/blob/master/source/demos/renderer/WebGLRenderer.coffee

It may or may not be worth implementing such a thing in newton.

Apologies if this is the wrong place - it's the closest I could find to a project related to your post "Physics for the lazy".

The line:
ctx.globalCompositeOperation='overlay';
...makes the demo insanely slow in FF.

The Firebug profiler shows that, with this line, the line:
ctx.stroke();
...uses about 99.99% of the cpu time.

The demo runs at a normal speed without the 'overlay' setting.

System: FF29.0.1, Win 7, Nvidia GeForce GT 650M

https://gist.github.com/andricicezar/9510779#file-newton-test-html

In this test particles aren't rendered. Can you help me and tell me why?

Thanx :)

Code from this tutorial: https://github.com/hunterloftis/newton/blob/master/examples/bodies/index.html

The bug is visible in the first image where the 2 boxes are 45º degree and are sliding on the lattice, obviously not very realistic. In the second image you can see that one box is sliding correctly.

Code

        var canvas = $('<canvas id="display" width="1280" height="450"></canvas>')
        this.$el.append(canvas)
        var renderer = Newton.GLRenderer(canvas[0]),
              sim = Newton.Simulator(undefined, renderer.callback, 60, 10),
              gravity = Newton.LinearGravity(0, 0.002, 0),
              container = Newton.BoxConstraint(0, 0, 1280, 450),
              squishy = Newton.Squishy(525, 250, 70, 16),
              boxes = createBoxes(20, 20, 25, 10),
              fabric = Newton.Fabric(700, 0, 1250, 50, 40, 22),
              lattice = Newton.Lattice(0, 200, 50, 10, true, true),
              anchor = squishy.particles[0];

          anchor.pin(525, 0);

          sim
            .add(gravity)
            // .add(squishy, 'squishy')
            .add(boxes, 'boxes')
            // .add(fabric, 'fabric')
            .add(lattice, 'boxes')
            .add(container)
            // .link('squishy', 'boxes fabric')
            // .link('boxes', 'boxes squishy fabric')
            // .link('fabric', 'boxes squishy')
            .start();

          $('#display').on('mousemove', function(e) {
            var offset = $(this).offset();
            var x = e.pageX - offset.left;
            var y = e.pageY - offset.top;

            anchor.pin(x, y);
          });


          function createBoxes(x, y, size, amount) {
            var boxes = [];
            while (amount--) {
              boxes.push(Newton.Box(x + amount * size * 3, y, size));
            }
            return boxes;
          }

... although it's called internally by Simulation.Layer() when creating layers.

I think supporting node require will vastly increase audience of newton (aka simple multiplayer game examples).

It would be nice to be able to measure performance before/after changes semi-objectively (eg, without noise from browser implementations and render steps). A suite of node tests with timers could help here.

The examples tend to be render-limited rather than simulation-limited.

Their overall speed could be improved by converting the default renderer to WebGL from Canvas.

How would one add an effect of inertia on a particle ?

let's say i would like to improve the example from the guide (copy/pasted here)

var mousePin = null;

renderer.on('pointerdown', function(point) {
    var particle = sim.findNearest(point, 30);
    if (particle) mousePin = sim.add(Newton.PinConstraint(particle, point));
});

renderer.on('pointerup', function(point) {
   if (!mousePin) return;
   sim.remove(mousePin);
   mousePin = null;
});

And i would like the particle to continue its movement upon mouse release, and slowly stop until its completely static.

Since forces are applied globally on all particles, the way to go would be to make an inertia constraint to target a specific particle.
Am i right ?