SurfaceTool

public SurfaceTool();

Creates an owned RefCounted with no vertices; initial primitive is Lines and skin count is 4. Call Begin before adding vertices.

public void AddIndex(int index);

Appends a nonnegative index. The setter does not check index < vertexCount: ensure upper bounds and triangle-count divisibility yourself. Creates no new vertex.

public void AddTriangleFan(Vector3[] vertices, Vector2[] uvs, Color[] colors, Vector2[] uv2S, Vector3[] normals, Reckfell.Collections.Array tangents);

Expands fan (0,1,2), (0,2,3)… into independent Triangles corners without indices. Requires Begin(Triangles) and at least 3 points. Empty optional channels use latched values; short nonempty arrays can retain latched leftovers, so supply a full value per input vertex. Span overload requires every argument.

public void AddTriangleFan(Vector3[] vertices, Vector2[] uvs = null, Color[] colors = null, Vector2[] uv2S = null, Vector3[] normals = null, Reckfell.Collections.Array<Plane> tangents = null);

Expands fan (0,1,2), (0,2,3)… into independent Triangles corners without indices. Requires Begin(Triangles) and at least 3 points. Empty optional channels use latched values; short nonempty arrays can retain latched leftovers, so supply a full value per input vertex. Span overload requires every argument.

public void AddTriangleFan(ReadOnlySpan<Vector3> vertices, ReadOnlySpan<Vector2> uvs, ReadOnlySpan<Color> colors, ReadOnlySpan<Vector2> uv2S, ReadOnlySpan<Vector3> normals, Reckfell.Collections.Array<Plane> tangents);

Expands fan (0,1,2), (0,2,3)… into independent Triangles corners without indices. Requires Begin(Triangles) and at least 3 points. Empty optional channels use latched values; short nonempty arrays can retain latched leftovers, so supply a full value per input vertex. Span overload requires every argument.

public void AddVertex(Vector3 vertex);

Copies position and currently latched attributes into the next corner. Requires Begin; channel presence is fixed after the first vertex. Skin bones/weights must have equal lengths; prefer exactly four preprocessed influences.

public void AppendFrom(Mesh existing, int surface, Transform3D transform);

Appends one source surface, transforming positions by Transform3D and offsetting indices. Normals use the basis directly rather than inverse transpose, requiring separate correction for nonuniform scale. Reflection flips tangent handedness. Prepare compatible primitive/formats and indexed/nonindexed data before combining.

public void Begin(Mesh.PrimitiveType primitive);

Clears state, sets primitive and enables AddVertex. Resets material/custom formats/skin count, so configure them again at the appropriate stage. Does not append a surface to previous geometry.

public void Clear();

Clears geometry, indices, material and formats; begun=false, primitive=Lines, skin count=4. Not equivalent to Begin. Call Begin before another AddVertex. Explicitly set new-surface attributes instead of assuming every latched value is reset to zero.

public ArrayMesh Commit(ArrayMesh existing, uint flags);

Creates an ArrayMesh or appends a new surface to existing, preserving old surfaces. An empty tool returns the mesh without adding one. Uses current material; neither clears the tool nor supplies blend shapes/LODs. Do not separately dispose an existing alias still used by its owner. Rendering was not tested by the CPU suite.

public ArrayMesh Commit(ArrayMesh existing = null, ulong flags = 0);

Creates an ArrayMesh or appends a new surface to existing, preserving old surfaces. An empty tool returns the mesh without adding one. Uses current material; neither clears the tool nor supplies blend shapes/LODs. Do not separately dispose an existing alias still used by its owner. Rendering was not tested by the CPU suite.

public Reckfell.Collections.Array CommitToArrays();

Creates a separate untyped Array of Mesh.ArrayType.Max packed-array slots for active channels. Unused slots are Nil. Neither clears the tool nor creates a GPU surface; dispose the returned Array after use.

public void CreateFrom(Mesh existing, int surface);

Replaces working data with one source Mesh surface, primitive and material; requires accessible arrays and a valid index. Neither begins AddVertex mode nor imports every surface/LOD. A following Begin clears the import.

public void CreateFromArrays(Reckfell.Collections.Array arrays, Mesh.PrimitiveType primitiveType = Mesh.PrimitiveType.Triangles);

Replaces state with coherent Mesh.ArrayType slots; primitiveType defaults to Triangles. Not an arbitrary vertex list. Channel types/counts must match vertexCount. Does not enable begun for subsequent AddVertex.

public void CreateFromBlendShape(Mesh existing, int surface, string blendShape);

Loads one named blend shape from one surface. Positions/normals/tangents come from the shape, remaining channels/indices from the base surface. Creates no complete animation of all shapes; name/index must exist. GPU-backed import was not tested here.

public void Deindex();

Expands indexed corners into a full vertex list and removes the index channel. No-op without indices. Requires valid indices: upper-bound errors are diagnosed after mutation begins.

public int[] GenerateLod(float ndThreshold, int targetIndexCount = 3);

Deprecated index simplifier; source recommends ImporterMesh.GenerateLods. Requires vertex/index arrays, triangle-divisible indices and 0 ≤ targetIndexCount ≤ currentIndexCount. Locks topological borders; neither installs an LOD in a Mesh nor replaces working geometry. Not executed here because it emits deprecation diagnostics.

public void GenerateNormals(bool flip = false);

Recalculates normals for Triangles with corner count divisible by three. Smooth groups use matching positions; uint.MaxValue keeps face normals. flip reverses normals rather than triangle order. Indexed input is temporarily deindexed and reindexed, so vertex count/order can change.

public void GenerateTangents();

Generates tangent xyzw through current Meshoptimizer. Requires Triangles, normals, UVs and a corner count divisible by three; degenerate UVs are not repaired into a meaningful unwrap. Public binding uses no-split mode; verify GPU/normal-map quality separately.

public Aabb GetAabb();

Computes Aabb from all stored positions, including vertices unused by indices. An empty tool is diagnosed with a zero fallback. Not a MeshInstance3D world-space bound.

public SurfaceTool.CustomFormat GetCustomFormat(int channelIndex);

Returns custom-channel 0…3 format; Max means unconfigured. A selected format does not establish SetCustom data.

public Mesh.PrimitiveType GetPrimitiveType();

Returns current primitive; a new/cleared tool has Lines. Does not validate corner counts for that mode.

public SurfaceTool.SkinWeightCount GetSkinWeightCount();

Returns selected influence count rather than last input-array length. Begin/Clear restore Skin4Weights. Skin8Weights before Begin does not establish a working 8-weight surface.

public void Index();

If no indices exist, merges exact full-Vertex duplicates and creates indices. Compares attributes/smooth group rather than position alone; not tolerance welding. Existing indices make this a no-op.

public void OptimizeIndicesForCache();

Reorders triangle indices for vertex-cache use. Requires nonempty valid indices, Triangles, divisibility by three and initialized Meshoptimizer. Promises neither fewer vertices nor speedup on a particular GPU.

public void SetBones(int[] bones);

Sets next-vertex bone indices. Requires SetWeights of matching length; short pairs zero-pad, while current excess handling retains smaller weights. Supply exactly four valid influences in the ordinary Begin workflow.

public void SetBones(ReadOnlySpan<int> bones);

Sets next-vertex bone indices. Requires SetWeights of matching length; short pairs zero-pad, while current excess handling retains smaller weights. Supply exactly four valid influences in the ordinary Begin workflow.

public void SetColor(Color color);

Enables COLOR before the first vertex and sets color for subsequent AddVertex calls. After the first vertex only an already-enabled channel can change. Does not enable vertex-color use in the material.

public void SetCustom(int channelIndex, Color customColor);

Sets next-vertex components through Color without implying color semantics. Requires SetCustomFormat and channel enablement before the first vertex. Format determines components, precision and array encoding.

public void SetCustomFormat(int channelIndex, SurfaceTool.CustomFormat format);

Sets custom-channel 0…3 storage format after Begin and before the first vertex. Does not enable the channel itself: call SetCustom before AddVertex. Do not reinterpret an already-populated channel; Max denotes an unconfigured format.

public void SetMaterial(Material material);

Stores a shared Material for the next Commit. Neither enables COLOR/UV channels nor updates existing surfaces. Begin/Clear resets the reference.

public void SetNormal(Vector3 normal);

Sets the next vertex normal without editing previous vertices. Supply a unit vector; the setter does not normalize automatically. Enable the channel before the first vertex or generate it with GenerateNormals.

public void SetSkinWeightCount(SurfaceTool.SkinWeightCount count);

Accepts the enum only while begun=false. However Begin calls Clear and restores Skin4Weights: setting Skin8Weights before Begin does not provide eight influences. Reproduced without an engine fix; a working 8-weight workflow is not established.

public void SetSmoothGroup(uint index);

Sets the uint group of subsequent vertices for GenerateNormals and exact indexing. Default 0; uint.MaxValue means flat shading. Does not immediately change normals or material.

public void SetTangent(Plane tangent);

Plane is a tangent container: normal → xyz and D → handedness w, normally ±1. Not a geometric surface plane. Enable the channel before the first vertex.

public void SetUV(Vector2 uV);

Sets the next vertex UV; enable the channel before the first AddVertex. Neither unwraps automatically nor scales positions. UVs are normally normalized, but not clamped to 0…1.

public void SetUV2(Vector2 uV2);

Sets the next vertex second UV channel; enable before the first vertex. Neither generates a lightmap unwrap nor bakes lighting.

public void SetWeights(ReadOnlySpan<float> weights);

Sets next-vertex weights; neither selects a skeleton nor automatically normalizes exact/short lists. Requires SetBones with matching length. Prenormalize exactly four influences instead of relying on faulty excess selection.

public void SetWeights(float[] weights);

Sets next-vertex weights; neither selects a skeleton nor automatically normalizes exact/short lists. Requires SetBones with matching length. Prenormalize exactly four influences instead of relying on faulty excess selection.