void UpdateMeshFromSplineGraph()
        {
            Mesh mesh = meshFilter.sharedMesh;

            if (mesh == null)
            {
                mesh = new Mesh();
            }

            if (radialEdgeCount <= 0)
            {
                // TODO: Cleanup case when radialEdgeCount == 0 due to user still editing into inspector field.
                // This should be handled with a delayed int field.
                return;
            }

            var splineGraph = (splineGraphComponent != null)
                ? splineGraphComponent.GetSplineGraph()
                : splineGraphManager.GetSplineGraph();

            // First, go through and compute the number of vertex ring subdivisions required to represent the spline graph based on curvature.
            Int16 vertexIsValidCount = splineGraph.ComputeVertexIsValidCount();
            Int16 edgeIsValidCount   = splineGraph.ComputeEdgeIsValidCount();

            int[] edgeSubdivisionIndex      = new int[splineGraph.edgePoolChildren.count];
            int[] edgeSubdivisionCount      = new int[splineGraph.edgePoolChildren.count];
            int   meshSubdivisionCountTotal = 0;
            int   meshRingCountTotal        = 0;


            for (Int16 edgeIndex = 0; edgeIndex < splineGraph.edgePoolChildren.count; ++edgeIndex)
            {
                DirectedEdge edge = splineGraph.edgePoolChildren.data[edgeIndex];
                if (edge.IsValid() == 0)
                {
                    continue;
                }

                float splineLength     = splineGraph.payload.edgeLengths.data[edgeIndex];
                int   subdivisionCount = math.max(1, (int)math.floor(subdivisionsPerMeter * splineLength + 0.5f));
                int   ringCount        = subdivisionCount + 1;

                edgeSubdivisionIndex[edgeIndex] = meshSubdivisionCountTotal;
                edgeSubdivisionCount[edgeIndex] = subdivisionCount;
                meshSubdivisionCountTotal      += subdivisionCount;
                meshRingCountTotal += ringCount;
            }

            // TODO: Calculate counts.
            int meshVertexCount = meshRingCountTotal * radialEdgeCount;

            Vector3[] vertices  = new Vector3[meshVertexCount];
            Vector2[] uvs       = new Vector2[meshVertexCount];
            Vector3[] normals   = new Vector3[meshVertexCount];
            Color[]   colors    = new Color[meshVertexCount];
            int[]     triangles = new int[meshVertexCount * 6];

            int meshVertexIndex   = 0;
            int meshTriangleIndex = 0;

            for (Int16 edgeIndex = 0; edgeIndex < splineGraph.edgePoolChildren.count; ++edgeIndex)
            {
                DirectedEdge edge = splineGraph.edgePoolChildren.data[edgeIndex];
                if (edge.IsValid() == 0)
                {
                    continue;
                }

                Int16 vertexIndexChild  = splineGraph.edgePoolChildren.data[edgeIndex].vertexIndex;
                Int16 vertexIndexParent = splineGraph.edgePoolParents.data[edgeIndex].vertexIndex;

                SplineMath.Spline spline       = splineGraph.payload.edgeParentToChildSplines.data[edgeIndex];
                float             splineLength = splineGraph.payload.edgeLengths.data[edgeIndex];

                quaternion rotationParent = splineGraph.payload.rotations.data[vertexIndexParent];
                quaternion rotationChild  = splineGraph.payload.rotations.data[vertexIndexChild];

                SplineMath.Spline splineLeash = splineGraph.payload.edgeParentToChildSplinesLeashes.data[edgeIndex];

                // Find neighboring edge (if it exists) for use in CSG style operation against current one to handle intersections in branching region.
                DirectedVertex vertexParent = splineGraph.vertices.data[vertexIndexParent];
                Debug.Assert(vertexParent.IsValid() == 1);

                DirectedVertex vertexChild = splineGraph.vertices.data[vertexIndexChild];
                Debug.Assert(vertexChild.IsValid() == 1);

                int edgeSubdivisionCurrentCount = edgeSubdivisionCount[edgeIndex];
                for (int s = 0; s <= edgeSubdivisionCurrentCount; ++s)
                {
                    float t = (float)s / (float)edgeSubdivisionCurrentCount;
                    // Debug.Log("s = " + s + ", sCount = " + edgeSubdivisionCurrentCount + ", t = " + t);

                    float vNormalized = t;
                    if (s > 0)
                    {
                        // Compute the relative distance we have traveled between our current edge ring and previous.
                        SplineMath.ComputeSplitAtT(out SplineMath.Spline s00, out SplineMath.Spline s01, spline, t);

                        vNormalized = SplineMath.ComputeLengthEstimate(s00, 1e-5f) / splineLength;
                    }

                    float3     positionOnSpline = SplineMath.EvaluatePositionFromT(spline, t);
                    quaternion rotationOnSpline = SplineMath.EvaluateRotationWithRollFromT(spline, rotationParent, rotationChild, t);
                    // float2 leashMaxOS = math.lerp(leashParent, leashChild, t);
                    float2 leashMaxOS = SplineMath.EvaluatePositionFromT(splineLeash, t).xy;

                    // Generate radial ring of triangles
                    if (s < edgeSubdivisionCurrentCount)
                    {
                        for (int v = 0, vLen = radialEdgeCount; v < vLen; ++v)
                        {
                            triangles[meshTriangleIndex + v * 6 + 0] = meshVertexIndex + ((v + 0) % radialEdgeCount) + (0 * radialEdgeCount);
                            triangles[meshTriangleIndex + v * 6 + 1] = meshVertexIndex + ((v + 0) % radialEdgeCount) + (1 * radialEdgeCount);
                            triangles[meshTriangleIndex + v * 6 + 2] = meshVertexIndex + ((v + 1) % radialEdgeCount) + (1 * radialEdgeCount);

                            triangles[meshTriangleIndex + v * 6 + 3] = meshVertexIndex + ((v + 1) % radialEdgeCount) + (1 * radialEdgeCount);
                            triangles[meshTriangleIndex + v * 6 + 4] = meshVertexIndex + ((v + 1) % radialEdgeCount) + (0 * radialEdgeCount);
                            triangles[meshTriangleIndex + v * 6 + 5] = meshVertexIndex + ((v + 0) % radialEdgeCount) + (0 * radialEdgeCount);
                        }

                        meshTriangleIndex += radialEdgeCount * 6;
                    }

                    // Generate radial ring of vertices.
                    // bool ringIntersectsSibling = false;
                    for (int v = 0; v < radialEdgeCount; ++v)
                    {
                        float  thetaNormalized = (float)v / (float)radialEdgeCount;
                        float  theta           = thetaNormalized * 2.0f * math.PI;
                        float2 vertexOffsetOS  = new float2(
                            math.cos(theta),
                            math.sin(theta)
                            ) * leashMaxOS;// * radius;

                        float3 vertexOffsetWS   = math.mul(rotationOnSpline, new float3(vertexOffsetOS, 0.0f));
                        float3 vertexPositionWS = positionOnSpline + vertexOffsetWS;

                        float vertexIntersectionSignedDistanceMin = float.MaxValue;
                        {
                            for (Int16 edgeIndexSibling = vertexParent.childHead; edgeIndexSibling != -1; edgeIndexSibling = splineGraph.edgePoolChildren.data[edgeIndexSibling].next)
                            {
                                DirectedEdge edgeSibling = splineGraph.edgePoolChildren.data[edgeIndexSibling];
                                Debug.Assert(edgeSibling.IsValid() == 1);

                                if (edgeIndexSibling == edgeIndex)
                                {
                                    // Ignore ourselves.
                                    continue;
                                }

                                // Found our sibling edge. Only use the first one, as we only currently support CSG against a single branch.
                                Int16 siblingVertexIndexChild = edgeSibling.vertexIndex;
                                Debug.Assert(siblingVertexIndexChild != -1);

                                Int16 siblingVertexIndexParent = splineGraph.edgePoolParents.data[edgeIndexSibling].vertexIndex;
                                Debug.Assert(siblingVertexIndexParent != -1);

                                SplineMath.Spline splineSibling         = splineGraph.payload.edgeParentToChildSplines.data[edgeIndexSibling];
                                SplineMath.Spline splineLeashSibling    = splineGraph.payload.edgeParentToChildSplinesLeashes.data[edgeIndexSibling];
                                quaternion        siblingRotationParent = splineGraph.payload.rotations.data[siblingVertexIndexParent];
                                quaternion        siblingRotationChild  = splineGraph.payload.rotations.data[siblingVertexIndexChild];

                                SplineMath.FindTFromClosestPointOnSpline(out float siblingClosestT, out float siblingClosestDistance, vertexPositionWS, splineSibling);

                                float3     siblingPositionOnSpline = SplineMath.EvaluatePositionFromT(splineSibling, siblingClosestT);
                                quaternion siblingRotationOnSpline = SplineMath.EvaluateRotationWithRollFromT(splineSibling, siblingRotationParent, siblingRotationChild, siblingClosestT);
                                float2     siblingLeashMaxOS       = SplineMath.EvaluatePositionFromT(splineLeashSibling, siblingClosestT).xy;

                                float vertexIntersectionSignedDistance = math.length(math.mul(math.inverse(siblingRotationOnSpline), vertexPositionWS - siblingPositionOnSpline).xy / siblingLeashMaxOS) - 1.0f;
                                vertexIntersectionSignedDistanceMin = math.min(vertexIntersectionSignedDistanceMin, vertexIntersectionSignedDistance);
                            }

                            for (Int16 edgeIndexSibling = vertexChild.parentHead; edgeIndexSibling != -1; edgeIndexSibling = splineGraph.edgePoolParents.data[edgeIndexSibling].next)
                            {
                                DirectedEdge edgeSibling = splineGraph.edgePoolChildren.data[edgeIndexSibling];
                                Debug.Assert(edgeSibling.IsValid() == 1);

                                if (edgeIndexSibling == edgeIndex)
                                {
                                    // Ignore ourselves.
                                    continue;
                                }

                                // Found our sibling edge. Only use the first one, as we only currently support CSG against a single branch.
                                Int16 siblingVertexIndexParent = edgeSibling.vertexIndex;
                                Debug.Assert(siblingVertexIndexParent != -1);

                                Int16 siblingVertexIndexChild = splineGraph.edgePoolChildren.data[edgeIndexSibling].vertexIndex;
                                Debug.Assert(siblingVertexIndexChild != -1);

                                SplineMath.Spline splineSibling         = splineGraph.payload.edgeParentToChildSplines.data[edgeIndexSibling];
                                SplineMath.Spline splineLeashSibling    = splineGraph.payload.edgeParentToChildSplinesLeashes.data[edgeIndexSibling];
                                quaternion        siblingRotationParent = splineGraph.payload.rotations.data[siblingVertexIndexParent];
                                quaternion        siblingRotationChild  = splineGraph.payload.rotations.data[siblingVertexIndexChild];

                                SplineMath.FindTFromClosestPointOnSpline(out float siblingClosestT, out float siblingClosestDistance, vertexPositionWS, splineSibling);

                                float3     siblingPositionOnSpline = SplineMath.EvaluatePositionFromT(splineSibling, siblingClosestT);
                                quaternion siblingRotationOnSpline = SplineMath.EvaluateRotationWithRollFromT(splineSibling, siblingRotationParent, siblingRotationChild, siblingClosestT);
                                float2     siblingLeashMaxOS       = SplineMath.EvaluatePositionFromT(splineLeashSibling, siblingClosestT).xy;

                                float vertexIntersectionSignedDistance = math.length(math.mul(math.inverse(siblingRotationOnSpline), vertexPositionWS - siblingPositionOnSpline).xy / siblingLeashMaxOS) - 1.0f;
                                vertexIntersectionSignedDistanceMin = math.min(vertexIntersectionSignedDistanceMin, vertexIntersectionSignedDistance);
                            }
                        }

                        vertices[meshVertexIndex] = vertexPositionWS;
                        uvs[meshVertexIndex]      = new float2(
                            thetaNormalized,
                            vNormalized * splineLength * uvScale // TODO: Gotta figure out propogation of UVs.
                            );
                        normals[meshVertexIndex] = math.normalize(vertexOffsetWS);

                        float vertexIntersectionDistanceFade = math.smoothstep(vertexIntersectionSignedDistanceFadeMin, vertexIntersectionSignedDistanceFadeMax, vertexIntersectionSignedDistanceMin);
                        colors[meshVertexIndex] = new Color(vertexIntersectionDistanceFade, vertexIntersectionDistanceFade, vertexIntersectionDistanceFade, vertexIntersectionDistanceFade);

                        ++meshVertexIndex;
                    }
                }
            }

            // Trim arrays to final size.
            Vector3[] verticesTrimmed  = new Vector3[meshVertexIndex];
            Vector2[] uvsTrimmed       = new Vector2[meshVertexIndex];
            Vector3[] normalsTrimmed   = new Vector3[meshVertexIndex];
            Color[]   colorsTrimmed    = new Color[meshVertexIndex];
            int[]     trianglesTrimmed = new int[meshTriangleIndex];

            Array.Copy(vertices, verticesTrimmed, meshVertexIndex);
            Array.Copy(uvs, uvsTrimmed, meshVertexIndex);
            Array.Copy(normals, normalsTrimmed, meshVertexIndex);
            Array.Copy(colors, colorsTrimmed, meshVertexIndex);
            Array.Copy(triangles, trianglesTrimmed, meshTriangleIndex);

            // Finally assign back data (causes GC allocs).
            mesh.Clear();
            mesh.vertices         = verticesTrimmed;
            mesh.uv               = uvsTrimmed;
            mesh.normals          = normalsTrimmed;
            mesh.colors           = colorsTrimmed;
            mesh.triangles        = trianglesTrimmed;
            meshFilter.sharedMesh = mesh;

            MeshCollider meshCollider = meshFilter.gameObject.GetComponent <MeshCollider>();

            if (meshCollider != null)
            {
                meshCollider.sharedMesh = mesh;
            }
        }