testdd
cbloom
March 2008
Esc = exit
+/- = change modes (on numpad)
space = pause
# keys = select mode #
Modes are :
0= "cubic interpolator",
1= "cubic maxaccel",
2 = "hybrid cubic"
3= "PD critical",
4= "PD overdamp",
5= "PD transition to linear",
6= "PD blend with linear",
7= "PID"
8 = "PD clamped"
9 = "AI / piecewise quadratic"
This is a lerper/controller test
The square changes color when it hits target
Use space bar to pause to see how it responds to discontinuous target jumps
------------------------------------------------
The pref.txt file :
class MyPref:{
track_time:2
seconds to try to reach target - applies to all modes
overdamp_damping:1.75
damping for mode 3 (1.0 is critical)
mode0_distance_scale : 50
distance scale for converge time extend
lerptransition_distance:16
mode 4 switch distance
lerpblend_distance:60
mode 5 blend distance ; outside this distance it's 100% PD
lerpblend_damping:1.5
mode 5 damping on the PD (1.0 is critical)
lerpblend_lerpspeed:120
mode 5 speed of the lerp part
PID_K:1.0
PID_I:0.0
PID_D:1.0
parameters for the PID
K is overall gain
I is unitless weight of the integrated error
D is unitless derivative weight
(1,0,1) makes it a critically damped PD
cubic_maxaccel :
mode 1 max acceleration
this is actually a distance, it will be divided by track_time^2
}
------------------------------------------------
0= "cubic interpolator",
This method solves a cubic (aka a bezier) to take you from current pos & vel to the target pos & vel.
The cubic is exactly constrained by those 4 conditions.
The cubic will get you there in exactly time T. (T = track_time).
The cubic is remade every frame from current conditions, there is no stored state.
As long as the target is still, T -= dt. (you advance along the curve)
When the target moves, T = track_time. (the curve is reset).
In theory you could do something where if the target barely moves, T only gets a little longer rather
than reseting to the full time.
1= "cubic maxaccel",
Similar to mode 0 but removes all the hackiness and instead uses the max acceleration constraint.
At each time, it finds the cubic curve between the current pos & vel and the target pos & vel.
It then solves for the travel time on that curve that will get there without violating the max accel constraint.
It then takes a dt step along that curve.
If you can get to the target in less than dt without violating max accel, we just go to the target.
2= "hybric cubic"
cubic solved to maxaccel, but takes at most track_time if target is still
3= "PD critical",
PD controller (damped spring) with critical damping.
4= "PD overdamp",
PD controller overdamped to avoid overshoot. In Prefs.
PD's have this problem where if they're fast they overshoot, if they
don't overshoot they're really slow. The linear blend modes use
overdamped PD's so they don't overshoot and then switch or blend to
linear to avoid the really slow tail.
5= "PD transition to linear",
Overdamped PD controller up to lerptransition_distance, where it switched to linear.
Tries to keep velocity magnitude continuous but no gaurantee.
6= "PD blend with linear",
Similar to mode 4, but instead of switching at a distance, inside the transition distance it
blends between the PD and linear interpolation.
7= "PID"
PID is theoretically more tuneable than a PD but hard to work with.
From reading the literature on PID's briefly, they are inherently much
harder to tweak. In fact, there's a bunch of literature on using fuzzy
logic feedback loops to adaptively tune them which sounds just awful.
The parameters for a PID that give you good behavior are data-dependent.
So all the fancy tweakage to make them behave well depends on feeding
them in a certain way, and if you feed the same thing a different input
signal it could behave really badly.
8 = "PD clamped"
PD with a min vel & max accel clamp
min vel makes it move linearly near the end
max accel makes it not accelerate really hard at the start
9 = "AI / piecewise quadratic"
quadratic accel phase
linear maxvel move
quadratic decel phase
sort of like the standard way of making AI steer to a target