jbox2d VS LiquidFun

“Wrapper” means that the library is just a bit of code that will bridge JBox2D (a Java 2D library) with Processing. It “wraps” the original code in a more appealing package. In other words, it helps you do anything that http://www.jbox2d.org/ can do but in Processing.

I used the jbox2d library: http://www.jbox2d.org/

You can make thicker liquids like honey, and change their colors. You can mix liquids together as well. I'm using Google's LiquidFun to achieve this.

Sadly the marketing department failed utterly, somehow thinking they could sell CFD to... the same kind of kids that spend 200 bucks on loot boxes. I think the absolutely batshit insane potential for dynamic 2D gameplay was barely scratched before they sold the code to Google (creating the LiquidFun project) and went their separate ways. These days the engine has branched into a lot of things, notably a 3D industrial version called ParticleWorks which is a CAD plugin for bringing SPH to mechanical engineering.

This might help: https://google.github.io/liquidfun/

Some years ago I did a project with LiquidFun; https://google.github.io/liquidfun/

It was an interactive art thing for kids; had a TV with a maze of transparent PVC pipes mounted on the front with valves (rotary encoders inside). The kids would open and close the valves, and watch the flow of water be redirected on the TV behind.

yeah, I've played around with a few approaches for running the timestep and for some reason I don't feel like I get the same results as liquidfun.js.

their loop [0] is pretty simple; it's scheduled by `requestAnimationFrame`, advances time by 1/60th of a second, and runs their default of 3 particle iterations. it completes the physics simulation within 3.9–5.5ms, which is easily in time for the 16ms deadline. the rendering is WebGL, which I assume fits easily into that 16ms budget too.

my loop [1] is more complicated; I don't hardcode the timestep to 1/60 seconds, because requestAnimationFrame may be scheduled less frequently than that. so instead I advance time by the time elasped since I was last scheduled. hm, I think there's a mistake there — `lastMs = nowMs` is probably on the wrong side of the physics calculation.

there's an additional technique I use: I put a `Math.min()` over the simulation interval, so that I don't attempt to simulate more than 20ms (this can happen if you get scheduled infrequently due to hot CPU or backgrounding the app) — simulating too much time will make us fail our frame deadline anyway.

furthermore, if we are calculating more than 1/60th of a second, I employ more particle iterations (i.e. 3 particle iterations for every 1/60th of a second that passes). this gave me good results, but turns out it is based on incorrect assumptions (iterations are unrelated to timestep)[3]. moreover, I may be making mistakes in my decision of whether to round this fraction up/down.

if too few particle iterations for a timestep: the particles will bounce. if too many: the particles will look too incompressible[4]. I think that's the "solid-like" structure you're describing.

the main reason I complicated this is because the last one I did[5] made me feel motion-sick. I think if "every 1/60th, or 1/30th, or 1/20th of a second: you simulate a 1/60th of a second of time": the result (if you're not scheduled consistently) is that the world speed keeps changing. I think liquidfun.js's approach should be vulnerable to this, but for some reason it looks fine to me. maybe they get scheduled more consistently than me (even though by my measurements, my physics runs slightly faster, so should be able to achieve similar results).

I think I need to remind myself of what happens if I program the timestep in the simple way that liquidfun.js did. will try that out at some point.

[0] https://github.com/google/liquidfun/blob/master/liquidfun/Bo...

[1] https://github.com/Birch-san/liquidfun-play-2/blob/master/sr...

[2] https://github.com/Birch-san/liquidfun-play-2/blob/master/sr...

[3] http://google.github.io/liquidfun/Programmers-Guide/html/md_...

[4] http://google.github.io/liquidfun/Programmers-Guide/html/md_...

[5] https://birchlabs.co.uk/box2d-wasm-liquidfun/

It should be possible to produce simulations like the ones they produced in JS: http://google.github.io/liquidfun/

He was involved in an open-source project titled LiquidFun, which was released late in 2013 and unfortunately only went through 3 versions, ending developmentin mid 2014. https://github.com/google/liquidfun/releases