PathFollow3D

public PathFollow3D();

Creates an Entity3D follower with Loop/CubicInterp/TiltEnabled=true, RotationMode=Xyz and UseModelFront=false. Requires a direct in-tree Path3D parent with a usable Curve3D. Advance Progress yourself; this changes transforms without physical collision solving.

public bool CubicInterp { get; set; }

Cubic interpolation of the baked cache, true by default. Neither exact Bezier sampling nor a physics setting; sparse-cache positions can differ from linear distance sampling. Setter changes the flag without immediately recalculating transform. Configure before changing Progress; in 3D reassigning identical Progress also does not refresh transform.

public float HOffset { get; set; }

Offset along final path-frame local X after RotationMode/UseModelFront/tilt. UseModelFront flips X and therefore this offset direction. Applied before restoring the follower own Scale; Path3D scale still affects world position.

public bool Loop { get; set; }

On Progress assignment, wraps distance by path length; false clamps to 0..length. A nonzero length multiple is retained at the endpoint rather than necessarily zero. Joins neither endpoints nor tangents of open geometry and starts no motion. Toggling the flag does not normalize an already stored distance.

public float Progress { get; set; }

Local-unit distance along the parent Path baked curve, not seconds. Advance Progress by speed×delta yourself; no automatic motion occurs. With an active path the setter applies Loop/clamp. A value assigned before tree entry can remain out of range: initialize after attaching Path/Curve. Parent scale changes world speed.

public float ProgressRatio { get; set; }

Fraction of current baked length: setter passes ratio×length to Progress. Requires a direct Path parent inside the tree, a Curve and nonzero length. Values outside 0..1 follow Loop/clamp rather than separate clamping. Getter returns 0 without a usable path, not proof of arrival at the start. A length change preserves distance rather than the old ratio.

public PathFollow3D.RotationModeEnum RotationMode { get; set; }

Corrects the basis: None resets rotation on update, Y retains only Euler Y, Xy removes Z roll, Xyz retains all axes; calculations use YXZ order. Oriented rebuilds from the tangent with Y-up rather than retaining input roll. TiltEnabled applies AFTER correction and can restore tilt with Y/Xy. For Oriented heed the Curve.UpVectorEnabled warning; degenerate/vertical cases were not accepted here.

public bool TiltEnabled { get; set; }

Applies Curve3D tilt radians after RotationMode and UseModelFront. Thus Y-only does not guarantee no roll when tilt is enabled. Skipped for RotationMode=None. Does not create curve tilt data.

public bool UseModelFront { get; set; }

With orientation enabled, uses model +Z rather than −Z front by flipping basis X/Z. Also changes HOffset direction. Changes neither Curve geometry nor length and has no effect with RotationMode=None.

public float VOffset { get; set; }

Offset along final path-frame local Y, not necessarily world-up. Curve tilt rotates it too; supply finite local-unit values.

public static Transform3D CorrectPosture(Transform3D transform, PathFollow3D.RotationModeEnum rotationMode);

Statically corrects an input Transform3D Basis by RotationMode while preserving Origin. None sets identity Basis; Y/Xy/Xyz rebuild from normalized YXZ Euler; Oriented builds tangent Y-up from −Basis.Z. Samples no curve and applies neither UseModelFront nor tilt; arbitrary input Basis scale is not a promised preserved contract. Returns a value without editing an Entity.

public bool GetCubicInterpolation();

Reads CubicInterp. Cubic interpolation of the baked cache, true by default. Neither exact Bezier sampling nor a physics setting; sparse-cache positions can differ from linear distance sampling. Setter changes the flag without immediately recalculating transform. Configure before changing Progress; in 3D reassigning identical Progress also does not refresh transform.

public float GetHOffset();

Reads HOffset. Offset along final path-frame local X after RotationMode/UseModelFront/tilt. UseModelFront flips X and therefore this offset direction. Applied before restoring the follower own Scale; Path3D scale still affects world position.

public float GetProgress();

Reads Progress. Local-unit distance along the parent Path baked curve, not seconds. Advance Progress by speed×delta yourself; no automatic motion occurs. With an active path the setter applies Loop/clamp. A value assigned before tree entry can remain out of range: initialize after attaching Path/Curve. Parent scale changes world speed.

public float GetProgressRatio();

Reads ProgressRatio. Fraction of current baked length: setter passes ratio×length to Progress. Requires a direct Path parent inside the tree, a Curve and nonzero length. Values outside 0..1 follow Loop/clamp rather than separate clamping. Getter returns 0 without a usable path, not proof of arrival at the start. A length change preserves distance rather than the old ratio.

public PathFollow3D.RotationModeEnum GetRotationMode();

Reads RotationMode. Corrects the basis: None resets rotation on update, Y retains only Euler Y, Xy removes Z roll, Xyz retains all axes; calculations use YXZ order. Oriented rebuilds from the tangent with Y-up rather than retaining input roll. TiltEnabled applies AFTER correction and can restore tilt with Y/Xy. For Oriented heed the Curve.UpVectorEnabled warning; degenerate/vertical cases were not accepted here.

public float GetVOffset();

Reads VOffset. Offset along final path-frame local Y, not necessarily world-up. Curve tilt rotates it too; supply finite local-unit values.

public bool HasLoop();

Reads Loop. On Progress assignment, wraps distance by path length; false clamps to 0..length. A nonzero length multiple is retained at the endpoint rather than necessarily zero. Joins neither endpoints nor tangents of open geometry and starts no motion. Toggling the flag does not normalize an already stored distance.

public bool IsTiltEnabled();

Reads TiltEnabled. Applies Curve3D tilt radians after RotationMode and UseModelFront. Thus Y-only does not guarantee no roll when tilt is enabled. Skipped for RotationMode=None. Does not create curve tilt data.

public bool IsUsingModelFront();

Reads UseModelFront. With orientation enabled, uses model +Z rather than −Z front by flipping basis X/Z. Also changes HOffset direction. Changes neither Curve geometry nor length and has no effect with RotationMode=None.

public void SetCubicInterpolation(bool enabled);

Sets CubicInterp. Cubic interpolation of the baked cache, true by default. Neither exact Bezier sampling nor a physics setting; sparse-cache positions can differ from linear distance sampling. Setter changes the flag without immediately recalculating transform. Configure before changing Progress; in 3D reassigning identical Progress also does not refresh transform.

public void SetHOffset(float hOffset);

Sets HOffset. Offset along final path-frame local X after RotationMode/UseModelFront/tilt. UseModelFront flips X and therefore this offset direction. Applied before restoring the follower own Scale; Path3D scale still affects world position.

public void SetLoop(bool loop);

Sets Loop. On Progress assignment, wraps distance by path length; false clamps to 0..length. A nonzero length multiple is retained at the endpoint rather than necessarily zero. Joins neither endpoints nor tangents of open geometry and starts no motion. Toggling the flag does not normalize an already stored distance.

public void SetProgress(float progress);

Sets finite local distance and updates the transform with an active Path3D. In 1.0.0 an identical stored value returns BEFORE normalization: reassigning it neither fixes out-of-tree Progress nor forces a transform refresh. Initialize after path readiness and validate bounds.

public void SetProgressRatio(float ratio);

Sets ProgressRatio. Fraction of current baked length: setter passes ratio×length to Progress. Requires a direct Path parent inside the tree, a Curve and nonzero length. Values outside 0..1 follow Loop/clamp rather than separate clamping. Getter returns 0 without a usable path, not proof of arrival at the start. A length change preserves distance rather than the old ratio.

public void SetRotationMode(PathFollow3D.RotationModeEnum rotationMode);

Sets RotationMode. Corrects the basis: None resets rotation on update, Y retains only Euler Y, Xy removes Z roll, Xyz retains all axes; calculations use YXZ order. Oriented rebuilds from the tangent with Y-up rather than retaining input roll. TiltEnabled applies AFTER correction and can restore tilt with Y/Xy. For Oriented heed the Curve.UpVectorEnabled warning; degenerate/vertical cases were not accepted here.

public void SetTiltEnabled(bool enabled);

Sets TiltEnabled. Applies Curve3D tilt radians after RotationMode and UseModelFront. Thus Y-only does not guarantee no roll when tilt is enabled. Skipped for RotationMode=None. Does not create curve tilt data.

public void SetUseModelFront(bool enabled);

Sets UseModelFront. With orientation enabled, uses model +Z rather than −Z front by flipping basis X/Z. Also changes HOffset direction. Changes neither Curve geometry nor length and has no effect with RotationMode=None.

public void SetVOffset(float vOffset);

Sets VOffset. Offset along final path-frame local Y, not necessarily world-up. Curve tilt rotates it too; supply finite local-unit values.