Hey everyone, I hope you and your families are hanging in there during this crazy situation we’re all in at the moment. It seems like the whole world has been turned upside down over the past month or so. It’s hard to predict what the future will bring, or what the long term impacts will be, but I’ve been trying to stay focused as best I can by working on the game!
At some point soon I need to starting putting together trailer videos and other materials for GearBlocks, and for this I want to build some example creations to show off all the parts in the game. So a while back I started building a 4WD off-road buggy with differentials, CV joints, suspension and so on, but that’s when I ran into a problem.
Heavy gears and weird physics
It’s an issue that someone pointed out to me quite a long time ago actually. It’s this: when you have a 4WD vehicle with a long axle connecting the front and rear differentials via gears, at high speed the vehicle wants to rotate in one direction (i.e. steer left or right) much more easily than the other. Its preferred direction depends on the direction of rotation of the long axle. This is a very odd and unnatural behaviour, almost like a kind of gyroscopic effect, and is even more noticeable in the air (during a jump for example). The problem can be reduced slightly by increasing the simulation update rate (and therefore physics accuracy) but this isn’t really practical as it slows performance too much.
It turns out that this weird behaviour is so noticeable because the gears all have really big masses (20kg each). When you have a gear on each end of a long axle (e.g. running front to rear of a 4WD vehicle), it has a large polar moment of inertia. I’m not entirely sure why, but this fact, combined with the high RPM of the axle is what seems to be making the problem so bad. I found that if I give the gears smaller, more appropriate mass values, the unwanted behaviour is significantly reduced.
Why do the gears have such high masses in the first place? Well, it’s a workaround to prevent the gear teeth from slipping from one physics constraint to the next. In the physics simulation, if you have two rigidbodies constrained together, generally speaking the more equal their masses, the better that constraint will solve (with less “stretchiness”). Giving the gears a large mass was a hack to try and balance them with the combined mass of all the parts in the rest of a typical construction.
I’ve always hated this hack, apart from anything else it makes constructions with a lot of gears weigh a huge amount! So I’ve been working on a way to make the gear constraints more resilient, allowing the gears to have more reasonable masses, while still preventing gears slipping.
Searching for an anchor
Previously, when two gears were engaged, for each gear the closest constraint anchor position to the other gear would be found. The problem is, on any particular gear each possible anchor position is quite close to its neighbours, making it easy to slip from one to the next if the constraint doesn’t solve very well (i.e. if it “stretches”). However, I realised there’s a better approach, here’s how it works.
Starting with the simplest case – two gears with an equal number of teeth. As before, for the first gear in an engaged pair, the closest anchor position to the second gear is found. Then, taking the index of the first anchor and negating it will give the anchor index for the second gear, as it can be assumed to match only one possible anchor on that second gear, as shown below.
By directly mapping the first gear’s anchor index onto the second gear makes it almost impossible for the gears to slip. The physics constraint would have to stretch so much that the gears rotate one whole revolution opposite to one another, very unlikely to happen!
To make this work with a pair of gears with an unequal number of teeth is a little trickier. The largest common factor of the two gear’s numbers of teeth has to be considered when mapping the first gear’s anchor index onto the second. This means that there is no longer only one possible anchor on the second gear, for example here’s a situation with three possibilities (a, b, or c).
It means that, of these three possible anchor positions, the closest to the first gear must be found. However, they’re still far enough apart that slipping from one to the next is highly unlikely.
Finally, I had to account for the relative orientation of two gears when they first become engaged. So an anchor index offset is calculated at the point of engagement, that is subsequently applied when mapping an anchor index from one gear to another.
Other gears, and pulleys
Once I had this all working for gear wheels, I then applied the same principle to rack and worm gears. Previously, if for example you crashed a vehicle with rack and pinion steering, it was very common for the rack gear to slip, causing the steering to be offset. You’d have to freeze and unfreeze the construction to fix it. Now this annoyance is much less likely to happen!
I also re-implemented the constraint anchor search code for pulleys to work in a similar way to the gears, bringing the same benefits to the pulleys.
Tuning the masses
I’m now in the process of tuning the gear masses. For stability under high torque loads, I’m finding I still need to give them masses higher than they would naturally have (albeit not as high as before), particularly for the smaller gears. It takes a lot of testing, but hopefully soon I’ll be able to settle on some reasonable masses for the gears that work well in most situations.
All told, this has been a lot of work (that I wasn’t planning to have to do), but I think the results are well worth it!