Curve3D

public Curve3D();

Creates an owned empty curve resource: Closed=false, BakeInterval=0.2, UpVectorEnabled=true. Add control points before sampling. Stores local data rather than moving Entities or building collisions. Dispose the resource after use.

public float BakeInterval { get; set; }

Positive finite CPU-cache density scale, default 0.2 in local units. Smaller usually produces more samples and memory/CPU work. Not a promise of perfectly equal spacing or exact analytic length: subdivision depth is bounded. The setter does not validate positivity/finiteness for you.

public bool Closed { get; set; }

Adds a last-to-first segment without duplicating a control point in PointCount. Requires at least two meaningful points. Does not enable automatic SampleBaked looping: distance still clamps to endpoints. RemovePoint clears Closed below two points, while PointCount/ClearPoints can retain it.

public int PointCount { get; set; }

Control-point count, not baked-sample count. Growth appends zero positions/handles/tilts; shrinking truncates the end. Changed can occur per appended point rather than one atomic path replacement. Shrinking through PointCount does not automatically clear Closed; validate configuration yourself.

public bool UpVectorEnabled { get; set; }

Enables baked up-vector computation, default true. Used for an up direction along the path and SampleBakedUpVector. Disabling reduces cache data; frame sampling falls back to Vector3.Up, which does not guarantee stability for vertical/degenerate curves. Does not control gravity.

public Reckfell.Collections.Dictionary _Data { get; set; }

Internal data container: points is Vector3[] triplets of in/out/position; tilts is float[] with one value per point. Getter creates a Dictionary snapshot; setter requires matching lengths. An undersized tilts array is not safely validated input. Use point methods for ordinary code and resources for persistence; this is not a stable external format. Dispose the owned Dictionary wrapper after reading.

public void AddPoint(Vector3 position, Vector3? @in = default, Vector3? @out = default, int index = -1);

Adds a control point with local position and relative in/out handles. Default nullable handles become Vector3.Zero. index in [0,PointCount) inserts before that point; negative/out-of-range appends. Shifts subsequent indices, invalidates the cache and emits Changed.

public void ClearPoints();

Removes all control points; the next baked query rebuilds an empty cache. Retains settings including Closed. Do not sample positions/orientation on an empty curve; GetBakedLength returns 0.

public float GetBakeInterval();

Reads BakeInterval. Positive finite CPU-cache density scale, default 0.2 in local units. Smaller usually produces more samples and memory/CPU work. Not a promise of perfectly equal spacing or exact analytic length: subdivision depth is bounded. The setter does not validate positivity/finiteness for you.

public float GetBakedLength();

Lazily updates the CPU cache and returns approximate baked-polyline length in local units. Empty/single-point curves yield 0; Closed includes the closing segment. Path3D scale is not automatically included.

public Vector3[] GetBakedPoints();

Returns an independent C# array of local cached positions, rebuilding first if needed. Array indices are not control-point indices. Samples an approximation rather than original handles.

public float[] GetBakedTilts();

Returns tilt radians aligned with baked positions. Not a list of control-point tilts alone or automatic Entity roll application.

public Vector3[] GetBakedUpVectors();

Returns baked up vectors; empty when UpVectorEnabled=false. Orientation data rather than terrain surface normals. Array edits do not modify the curve.

public float GetClosestOffset(Vector3 toPoint);

Returns local distance along the baked polyline to the closest toPoint projection. Neither perpendicular distance to the curve nor segment t. Can require scanning the entire cache.

public Vector3 GetClosestPoint(Vector3 toPoint);

Projects local toPoint onto the baked polyline by scanning its segments. An approximation, not a physics raycast or guaranteed solution for degenerate segments. Convert world input through Path3D.ToLocal first and the result through ToGlobal if needed.

public int GetPointCount();

Reads the number of control points, including both endpoints of an open curve. Not the segment or baked-sample count.

public Vector3 GetPointIn(int idx);

Reads the incoming handle relative to this point position. Absolute Bezier control position = GetPointPosition(idx)+GetPointIn(idx).

public Vector3 GetPointOut(int idx);

Reads the outgoing handle relative to the point position. Neither the next endpoint nor a world coordinate.

public Vector3 GetPointPosition(int idx);

Reads an existing control point local position. Returns neither its world position nor the nearest baked sample.

public float GetPointTilt(int idx);

Reads the control-point tilt in radians. A roll around path direction, not Entity Euler degrees.

public bool IsClosed();

Reads Closed. Adds a last-to-first segment without duplicating a control point in PointCount. Requires at least two meaningful points. Does not enable automatic SampleBaked looping: distance still clamps to endpoints. RemovePoint clears Closed below two points, while PointCount/ClearPoints can retain it.

public bool IsUpVectorEnabled();

Reads UpVectorEnabled. Enables baked up-vector computation, default true. Used for an up direction along the path and SampleBakedUpVector. Disabling reduces cache data; frame sampling falls back to Vector3.Up, which does not guarantee stability for vertical/degenerate curves. Does not control gravity.

public void RemovePoint(int idx);

Removes an existing index and shifts subsequent ones. If Closed and fewer than two points remain, opens the curve. Unlike shrinking PointCount; invalidates the cache and emits Changed.

public Vector3 Sample(int idx, float t);

Evaluates a segment Bezier position at parameter t, normally 0..1. Not distance or constant speed: even zero handles do not make t=0.25 a quarter of the length. Open segments are 0..PointCount−2; Closed adds last→first. Out-of-segment endpoint indices can return an endpoint, but use a valid index; do not assume t is clamped.

public Vector3 SampleBaked(float offset = 0f, bool cubic = false);

Samples position at finite distance offset along the baked cache. Clamps to 0..GetBakedLength() without looping even when Closed. cubic=true uses cubic cache interpolation, not exact original Bezier sampling, and can differ from linear. Add points first.

public Vector3 SampleBakedUpVector(float offset, bool applyTilt = false);

Samples a local up vector at distance offset; requires UpVectorEnabled and a usable cache. applyTilt defaults to false. Do not use on empty/degenerate curves or treat a diagnosed Vector3.Up fallback as successful sampling.

public Transform3D SampleBakedWithRotation(float offset = 0f, bool cubic = false, bool applyTilt = false);

Returns a local Transform3D: Origin is the baked position and Basis the orientation frame; forward is −Basis.Z. applyTilt includes tilt roll in radians. Meaningful orientation needs at least two nondegenerate points; one point produces diagnostics. Does not automatically assign an Entity transform.

public Vector3 Samplef(float fofs);

Uses the integer part of fofs as segment index and the fraction as t. Not a normalized whole-curve distance. In 1.0.0 Closed Samplef(PointCount) returns the last-segment start rather than the loop endpoint. Use Sample(PointCount−1,1) or SampleBaked(GetBakedLength()) for the closing endpoint.

public void SetBakeInterval(float distance);

Sets BakeInterval. Positive finite CPU-cache density scale, default 0.2 in local units. Smaller usually produces more samples and memory/CPU work. Not a promise of perfectly equal spacing or exact analytic length: subdivision depth is bounded. The setter does not validate positivity/finiteness for you.

public void SetClosed(bool closed);

Sets Closed. Adds a last-to-first segment without duplicating a control point in PointCount. Requires at least two meaningful points. Does not enable automatic SampleBaked looping: distance still clamps to endpoints. RemovePoint clears Closed below two points, while PointCount/ClearPoints can retain it.

public void SetPointCount(int count);

Sets PointCount. Control-point count, not baked-sample count. Growth appends zero positions/handles/tilts; shrinking truncates the end. Changed can occur per appended point rather than one atomic path replacement. Shrinking through PointCount does not automatically clear Closed; validate configuration yourself.

public void SetPointIn(int idx, Vector3 position);

Sets an existing point relative incoming handle. It forms no preceding segment at an open curve first point; Closed uses it for the closing segment. Invalidates the cache.

public void SetPointOut(int idx, Vector3 position);

Sets an existing point relative outgoing handle. It creates no extra segment at an open curve last point; Closed uses it to return to the first. Invalidates the cache.

public void SetPointPosition(int idx, Vector3 position);

Changes an existing point local position while retaining relative handles/tilt. Invalidates the CPU cache and emits Changed. Every owner of a shared resource sees the edit.

public void SetPointTilt(int idx, float tilt);

Sets finite tilt in radians and invalidates the cache. Orientation sampling applies it only with applyTilt=true; position itself does not change.

public void SetUpVectorEnabled(bool enable);

Sets UpVectorEnabled. Enables baked up-vector computation, default true. Used for an up direction along the path and SampleBakedUpVector. Disabling reduces cache data; frame sampling falls back to Vector3.Up, which does not guarantee stability for vertical/degenerate curves. Does not control gravity.

public Vector3[] Tessellate(int maxStages = 5, float toleranceDegrees = 4f);

Returns a local polyline from adaptive subdivision using toleranceDegrees as an angular criterion. maxStages limits depth rather than exact point count. Changes no control points and promises neither equal intervals nor exact length. Closed output returns to the first point.

public Vector3[] TessellateEvenLength(int maxStages = 5, float toleranceLength = 0.2f);

Returns a local polyline from length-based toleranceLength subdivision bounded by maxStages. “Even” guarantees neither perfectly identical spacing nor tolerance after reaching the depth limit. Requires at least two points and changes no source data.