Spline

Summary

A path a Gob travels along. V3.2: a real curve, followed in floating point. A Spline holds double control points, a curve type (CURVE_LINEAR, CURVE_BEZIER, CURVE_CATMULL_ROM), a speed in pixels per frame and the end logic in its flags. Give it to a Gob with Gob.attachSpline(); HyperView.run() then calls step(gob) once per display frame, which moves the Gob’s exact position fx,fy (doubles) along the curve; the Gob’s integer x,y are those rounded.

Why the old curves were only cosmetic (root cause)

Before 3.2 the constructor copied the points into x[] y[] z[] and, for CURVE_BEZIER, computed control points ctrlX/ctrlY which nothing ever read; CURVE_CATMULL_ROM was only a number stored in curveType. HyperView.run() moved the Gob from point to point with integer deltas dX/dY that computeDeltas() took from Octant.getOctant() (one of 8 directions, ±velocity per axis) — so every curve type travelled the same straight, octant snapped segments. Only the optional path line (PATH_LINE_ENA) was drawn from samples, which is why the curves looked curved on screen but the Gob did not follow them.

How it works now

• Curves: LINEAR = straight segments; BEZIER = one cubic Bezier per segment through the points, handles from the neighbouring points (tangent along P[j+1]−P[j−1], length chord/3, z clamped), or your own with setBezierHandles(); CATMULL_ROM = uniform Catmull-Rom (end points duplicated). setClosed(true) adds a segment back to the first point (seamless loop).
• Arc length: each segment is sampled (samplingResolution, default 128 samples, 4 chords each) into a cumulative length table; getPointAtLength(s) inverts it by binary search. The Gob moves speed pixels per frame ALONG the curve: constant speed whatever the spacing of the points (measured ±0.5% per frame step on the test paths).
• End logic (advance(), overshoot is carried over): WRAP_AT_END d mod length (seamless on a closed Spline, a jump on an open one); BOUNCE_AT_END folds the distance back and reverses; COLLIDE_AT_END stops exactly on the end point, stays attached and is tested by the CollisionManager (combined with WRAP/BOUNCE it keeps moving); STOP_AT_END (or none) stops on the end point and the Gob lets go of the Spline. Priority WRAP > BOUNCE > COLLIDE > STOP.
• Factories createCircle / createEllipse (closed, WRAP_AT_END | SP_ZBUFFER_ENA), createSpiral (open, BOUNCE_AT_END), createHeart (closed, WRAP_AT_END); each has an overload with explicit flags. createCircle/createEllipse used to set the z flag but no end logic.
• Compatibility: the int constructors and the legacy arrays x y z dX dY dZ fX.. rX.. targetX.. curPoint velocity are kept and filled for old readers, but the Gob follows the double curve; changing x[] directly no longer moves the Gob (use setPoints / translate / scale / addPoint). A Spline of length 0 never moves its Gob. One Spline can belong to one Gob only.

Source file: Spline.java. Tests: test/.../SplineTest.java.

Hierarchy

Extends: none

Implements: SplineConstants

Referenced HyperView classes

• HyperView
• Gob
• Octant
• SplineConstants

Media files used

• none referenced

Declaration & members

public class Spline implements SplineConstants

Declared in src/com/multiversesocial/hyperview/Spline.java, lines 1–1234. 77 field(s), 8 constructor(s), 81 method(s). Every member has an anchor you can link to (e.g. Spline.html#<id>).

Fields (77)

Constructors (8)

Methods (81)

Examples

// a curved path, constant speed 4 px/frame, bouncing at the ends
double x[] = {50,170,290,410,530,590};
double y[] = {360,170,360,170,360,250};
Spline s = new Spline(view,4.0,x,y,null,Spline.CURVE_BEZIER,SplineConstants.BOUNCE_AT_END);
s.flags |= SplineConstants.PATH_LINE_ENA;      // draw the curve (optional)
Gob g = new Gob(view,"ea2.gif",46,47,GOB_ON_DISPLAY);
view.addGob(g);
g.attachSpline(s);                              // g now follows the curve; g.getSpline() == s
...
g.detachSpline();                               // lets go where it is

// a closed circle that loops forever, at constant size
Spline c = Spline.createCircle(view,320,240,120,36,5,SplineConstants.WRAP_AT_END);

// the exact position (doubles) and the rounded one
double fx = g.getFloatX(), fy = g.getFloatY();   // g.x == Math.round(fx)

Old callers still work: new Spline(this,1,xLocs0,yLocs0,zLocs0,BOUNCE_AT_END) (ViewMain), new Spline(curView,5,xLocs1,yLocs1,SplineConstants.BOUNCE_AT_END) (MegaMooV), Gob.addSpline(s), new Gob(view,name,w,h,spline,flags).