wehub-resource-sync
786 lines
27 KiB
C#
786 lines
27 KiB
C#
#nullable enable
|
|
using System.Drawing;
|
|
using System.Drawing.Drawing2D;
|
|
using Lib.Utils;
|
|
using Svg;
|
|
using Svg.Pathing;
|
|
using Svg.Transforms;
|
|
using T3.Core.Utils;
|
|
// ReSharper disable MemberCanBePrivate.Global
|
|
|
|
// ReSharper disable TooWideLocalVariableScope
|
|
// ReSharper disable CheckNamespace
|
|
|
|
namespace Lib.point.io;
|
|
|
|
/**
|
|
* This operator is a compromise: Please also review the additional documentation
|
|
* on the wiki: https://github.com/tixl3d/tixl/wiki/SvgLineFonts
|
|
*/
|
|
[Guid("3d862455-6a7b-4bf6-a159-e4f7cdba6062")]
|
|
internal sealed class LineTextPoints : Instance<LineTextPoints>
|
|
{
|
|
[Output(Guid = "618e9151-cd91-4aa6-9d91-4bb51610cc8b")]
|
|
public readonly Slot<StructuredList?> ResultList = new();
|
|
|
|
[Output(Guid = "15140635-C51D-4674-8FCA-006EBA46496E")]
|
|
public readonly Slot<StructuredList?> StartIndicesAndCounts = new();
|
|
|
|
public LineTextPoints()
|
|
{
|
|
_svgResource = new Resource<SvgDocument>(FilePath, SvgLoader.TryLoad);
|
|
_svgResource.AddDependentSlots(ResultList);
|
|
ResultList.UpdateAction += Update;
|
|
_structuredPoints.TypedElements[_structuredPoints.NumElements - 1] = Point.Separator();
|
|
}
|
|
|
|
private void Update(EvaluationContext context)
|
|
{
|
|
if (!_svgResource.TryGetValue(context, out var svgDoc))
|
|
{
|
|
ResultList.Value = null;
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
var lineFontKey = new LineFontDefinition(Key: FilePath.GetValue(context) ?? string.Empty,
|
|
ReduceCurveThreshold: ReduceCurveThreshold.GetValue(context),
|
|
CornerBalance: CornerWeightBalance.GetValue(context));
|
|
var fontNeedsUpdate = _lineFontKey != lineFontKey;
|
|
|
|
var needsUpdate = fontNeedsUpdate
|
|
|| Text.DirtyFlag.IsDirty
|
|
|| Position.DirtyFlag.IsDirty
|
|
|| Size.DirtyFlag.IsDirty
|
|
|| LineHeight.DirtyFlag.IsDirty
|
|
|| VerticalAlign.DirtyFlag.IsDirty
|
|
|| HorizontalAlign.DirtyFlag.IsDirty
|
|
|| Spacing.DirtyFlag.IsDirty;
|
|
|
|
if (!needsUpdate)
|
|
return;
|
|
|
|
_lineFont = LineFont.Create(svgDoc, _lineFontKey, lineFontKey, this);
|
|
_lineFontKey = lineFontKey;
|
|
|
|
var cursorPos = Vector3.Zero;
|
|
|
|
var text = Text.GetValue(context);
|
|
|
|
if (string.IsNullOrEmpty(text))
|
|
text = " ";
|
|
|
|
var horizontalAlign = HorizontalAlign.GetEnumValue<HorizontalAligns>(context);
|
|
var verticalAlign = VerticalAlign.GetEnumValue<VerticalAligns>(context);
|
|
|
|
var characterSpacing = Spacing.GetValue(context);
|
|
var lineHeightFactor = LineHeight.GetValue(context);
|
|
|
|
var verticalFlip = _lineFont.UnitsPerEm < 0 ? 1 : -1;
|
|
var cursorLineHeight = MathF.Abs(_lineFont.LineHeight) * verticalFlip * lineHeightFactor;
|
|
|
|
var color = Color.GetValue(context);
|
|
var lineWidth = LineWidth.GetValue(context);
|
|
|
|
var position = Position.GetValue(context);
|
|
|
|
var entitySetter = SetFx1To.GetEnumValue<Entities>(context);
|
|
|
|
if (_lineFont == null)
|
|
return;
|
|
|
|
float cursorX = 0;
|
|
float cursorY = 0;
|
|
|
|
var needComputeLineWidths = verticalAlign != VerticalAligns.Top || horizontalAlign != HorizontalAligns.Left;
|
|
|
|
var lineCountInText = 1;
|
|
|
|
if (verticalAlign == VerticalAligns.Middle || verticalAlign == VerticalAligns.Bottom)
|
|
{
|
|
foreach (var c in text)
|
|
{
|
|
if (c == '\n')
|
|
{
|
|
lineCountInText++;
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (verticalAlign)
|
|
{
|
|
case VerticalAligns.Top:
|
|
cursorY -= _lineFont.LineHeight * verticalFlip;
|
|
break;
|
|
|
|
case VerticalAligns.Middle:
|
|
cursorY -= _lineFont.LineHeight * verticalFlip - (lineCountInText - 1) / 2f * cursorLineHeight;
|
|
break;
|
|
|
|
case VerticalAligns.Bottom:
|
|
cursorY -= _lineFont.LineHeight * verticalFlip - (lineCountInText - 1) * cursorLineHeight;
|
|
break;
|
|
}
|
|
|
|
_points.Clear();
|
|
_startIndicesAndCounts.Clear();
|
|
|
|
|
|
var lastCharForKerning = 0;
|
|
var size = Size.GetValue(context) / MathF.Abs(_lineFont.UnitsPerEm) * 2/1080f; // Scaling to match 1080p 72DPI pt font sizes
|
|
|
|
var horizontalLineOffset = 0f;
|
|
var needUpdateCurrentLineWidth = needComputeLineWidths;
|
|
var wordIndex = 0;
|
|
var lineIndex = 0;
|
|
|
|
for (var index = 0; index < text.Length; index++)
|
|
{
|
|
if (needUpdateCurrentLineWidth)
|
|
{
|
|
horizontalLineOffset = GetHorizontalLineOffset(text, index, horizontalAlign, characterSpacing);
|
|
needUpdateCurrentLineWidth = false;
|
|
}
|
|
|
|
var c = text[index];
|
|
|
|
if (c == '\n')
|
|
{
|
|
cursorY -= cursorLineHeight;
|
|
cursorX = 0;
|
|
lastCharForKerning = 0;
|
|
needUpdateCurrentLineWidth = true;
|
|
wordIndex++;
|
|
lineIndex++;
|
|
continue;
|
|
}
|
|
|
|
if (c == ' ')
|
|
{
|
|
wordIndex++;
|
|
}
|
|
|
|
var glyph = _lineFont?.GetGlyphForCharacter(c);
|
|
if (glyph == null)
|
|
{
|
|
lastCharForKerning = 0;
|
|
continue;
|
|
}
|
|
|
|
if (lastCharForKerning != 0)
|
|
{
|
|
int key = lastCharForKerning | c;
|
|
if (_lineFont!.KerningForPairs.TryGetValue(key, out var kerning2))
|
|
{
|
|
cursorX += kerning2;
|
|
}
|
|
}
|
|
|
|
var numPoints = glyph.Points.Length;
|
|
var entityFloat = entitySetter switch
|
|
{
|
|
Entities.None => 0,
|
|
Entities.Characters => index,
|
|
Entities.Words => wordIndex,
|
|
Entities.Lines => lineIndex,
|
|
_ => throw new ArgumentOutOfRangeException()
|
|
};
|
|
|
|
_startIndicesAndCounts.Add(new Int2( _points.Count, numPoints));
|
|
if (numPoints > 0)
|
|
{
|
|
for (var pointIndex = 0; pointIndex < numPoints; pointIndex++)
|
|
{
|
|
var p = glyph.Points[pointIndex];
|
|
var pointPos = p.Position;
|
|
p.Position = new Vector3(
|
|
(cursorX - glyph.VertOriginX + pointPos.X + horizontalLineOffset) * size,
|
|
(cursorY - glyph.VertOriginY + pointPos.Y) * size * verticalFlip,
|
|
0) + position;
|
|
p.Color = color;
|
|
p.Scale *= lineWidth;// keep NaN
|
|
p.F1 = entityFloat;
|
|
p.F2 = 1;
|
|
_points.Add(p);
|
|
}
|
|
}
|
|
|
|
cursorPos.X += glyph.AdvanceX;
|
|
|
|
cursorX += glyph.AdvanceX;
|
|
cursorX += characterSpacing * MathF.Abs(_lineFont?.UnitsPerEm ?? 0) * 0.01f;
|
|
lastCharForKerning = c;
|
|
}
|
|
|
|
var pointCount = _points.Count;
|
|
if (pointCount == 0)
|
|
{
|
|
ResultList.Value = null;
|
|
return;
|
|
}
|
|
|
|
// Copy to points
|
|
if (_structuredPoints.TypedElements.Length != pointCount)
|
|
_structuredPoints = new StructuredList<Point>(_points.Count);
|
|
|
|
for (int index = pointCount - 1; index >= 0; --index)
|
|
{
|
|
_structuredPoints.TypedElements[index] = _points[index];
|
|
}
|
|
|
|
// Copy indices
|
|
if (_structuredIndicesAndCounts.TypedElements.Length != _startIndicesAndCounts.Count)
|
|
_structuredIndicesAndCounts = new StructuredList<Int2>(_startIndicesAndCounts.Count);
|
|
|
|
for (int index = _startIndicesAndCounts.Count - 1; index >= 0; --index)
|
|
{
|
|
_structuredIndicesAndCounts.TypedElements[index] = _startIndicesAndCounts[index];
|
|
}
|
|
|
|
|
|
ResultList.Value = _structuredPoints;
|
|
StartIndicesAndCounts.Value = _structuredIndicesAndCounts;
|
|
}
|
|
|
|
private float GetHorizontalLineOffset(string text, int indexAtLineStart, HorizontalAligns horizontalAligns, float characterSpacing)
|
|
{
|
|
if (_lineFont == null)
|
|
return 0;
|
|
|
|
var widthSum = 0f;
|
|
|
|
for (var index = indexAtLineStart; index < text.Length; index++)
|
|
{
|
|
var c = text[index];
|
|
if (c == '\n')
|
|
{
|
|
break;
|
|
}
|
|
|
|
var glyph = _lineFont?.GetGlyphForCharacter(c);
|
|
if (glyph == null)
|
|
continue;
|
|
|
|
widthSum += glyph.AdvanceX + characterSpacing * MathF.Abs(_lineFont!.UnitsPerEm) * 0.01f;
|
|
}
|
|
|
|
if (horizontalAligns == HorizontalAligns.Center)
|
|
return -widthSum / 2;
|
|
|
|
if (horizontalAligns == HorizontalAligns.Right)
|
|
return -widthSum;
|
|
|
|
return 0;
|
|
}
|
|
|
|
private readonly List<Point> _points = new(1000);
|
|
private StructuredList<Point> _structuredPoints = new(1);
|
|
private readonly List<Int2> _startIndicesAndCounts = new(128);
|
|
private StructuredList<Int2> _structuredIndicesAndCounts = new(1);
|
|
|
|
public enum HorizontalAligns
|
|
{
|
|
Left,
|
|
Center,
|
|
Right,
|
|
}
|
|
|
|
public enum VerticalAligns
|
|
{
|
|
Top,
|
|
Middle,
|
|
Bottom,
|
|
}
|
|
|
|
[Input(Guid = "8EE43C95-869E-4390-A567-CB0BB9C31BDD")]
|
|
public readonly InputSlot<string> Text = new();
|
|
|
|
[Input(Guid = "1077857C-93FA-403A-BBD1-FD5B2B402AE6")]
|
|
public readonly InputSlot<Vector3> Position = new();
|
|
|
|
[Input(Guid = "FB14EABB-B3C8-437C-B083-EBC5E0A46F7B")]
|
|
public readonly InputSlot<float> Size = new();
|
|
|
|
[Input(Guid = "EB22073E-2348-4E76-A096-A4F6F80E2C01")]
|
|
public readonly InputSlot<float> LineHeight = new();
|
|
|
|
[Input(Guid = "EEF1217E-E719-4C32-9A8A-5E7ACBE1A185", MappedType = typeof(VerticalAligns))]
|
|
public readonly InputSlot<int> VerticalAlign = new();
|
|
|
|
[Input(Guid = "4C275222-D85C-4037-8161-536105A6C80F", MappedType = typeof(HorizontalAligns))]
|
|
public readonly InputSlot<int> HorizontalAlign = new();
|
|
|
|
[Input(Guid = "D9CD13D4-C6A3-42DE-9119-5A164CB12C41")]
|
|
public readonly InputSlot<float> Spacing = new();
|
|
|
|
[Input(Guid = "05ACBA8D-1DD1-4D6C-BEFF-E11E466F7253")]
|
|
public readonly InputSlot<string> FilePath = new();
|
|
|
|
[Input(Guid = "77B18D33-A41E-4676-A55C-0DF8E0290D05")]
|
|
public readonly InputSlot<float> ReduceCurveThreshold = new();
|
|
|
|
[Input(Guid = "96F345D9-2E38-4AF6-937D-EE14528727E4")]
|
|
public readonly InputSlot<float> CornerWeightBalance = new();
|
|
|
|
[Input(Guid = "D0B12D48-75A6-4DC5-A634-4D969EC20A29")]
|
|
public readonly InputSlot<Vector4> Color = new();
|
|
|
|
[Input(Guid = "72324D06-1A8E-44F1-A946-9B0E7987908E")]
|
|
public readonly InputSlot<float> LineWidth = new();
|
|
|
|
[Input(Guid = "585A1124-1505-49BB-8E42-9F3E9B51845C", MappedType = typeof(Entities))]
|
|
public readonly InputSlot<int> SetFx1To = new();
|
|
|
|
private enum Entities
|
|
{
|
|
None,
|
|
Characters,
|
|
Words,
|
|
Lines,
|
|
}
|
|
|
|
|
|
|
|
private LineFont? _lineFont;
|
|
private readonly Resource<SvgDocument> _svgResource;
|
|
private LineFontDefinition? _lineFontKey;
|
|
}
|
|
|
|
internal record struct LineFontDefinition(string Key, float ReduceCurveThreshold, float CornerBalance);
|
|
|
|
internal sealed class LineFont
|
|
{
|
|
private const int GlyphTableLength = 256;
|
|
private Glyph[] _glyphTable = []; // Lookup table for fast lookup
|
|
private readonly Dictionary<char, Glyph> _glyphsForCharacters = new(); // Fallback dictionary
|
|
|
|
public Glyph? GetGlyphForCharacter(char c)
|
|
{
|
|
var value = (int)c;
|
|
if (value < GlyphTableLength)
|
|
return _glyphTable[value];
|
|
|
|
Log.Debug($"need dictionary for {c}", this);
|
|
return _glyphsForCharacters.TryGetValue(c, out var glyph) ? glyph : null;
|
|
}
|
|
|
|
public void InitGlyphTable()
|
|
{
|
|
_glyphTable = new Glyph[GlyphTableLength];
|
|
|
|
foreach (var (c, glyph) in _glyphsForCharacters)
|
|
{
|
|
var value = (int)c;
|
|
if (c >= GlyphTableLength)
|
|
continue;
|
|
|
|
_glyphTable[value] = glyph;
|
|
}
|
|
}
|
|
|
|
// ReSharper disable once CollectionNeverUpdated.Global
|
|
public readonly Dictionary<int, float> KerningForPairs = new();
|
|
public float UnitsPerEm = 1000;
|
|
public float Ascent = 800;
|
|
public float Descent = -200;
|
|
public float CapHeight = 500;
|
|
public float XHeight = 300;
|
|
public float LineHeight = 1000; // identical with FontSize
|
|
public float ReduceCurveThreshold = 0.2f;
|
|
public float CornerWeightBalance = 0.5f;
|
|
|
|
|
|
public static LineFont Create(SvgDocument svgDoc, LineFontDefinition? previousKey, LineFontDefinition key, object user)
|
|
{
|
|
if (svgDoc == null)
|
|
throw new ArgumentNullException(nameof(svgDoc));
|
|
|
|
if (previousKey == key)
|
|
{
|
|
return _definitionsForFilePaths[previousKey.Value];
|
|
}
|
|
|
|
if (previousKey.HasValue && _users.TryGetValue(previousKey.Value, out var previousUsers))
|
|
{
|
|
previousUsers.Remove(user);
|
|
|
|
if (previousUsers.Count == 0)
|
|
{
|
|
_users.Remove(previousKey.Value);
|
|
_definitionsForFilePaths.Remove(previousKey.Value);
|
|
}
|
|
}
|
|
|
|
if (_definitionsForFilePaths.TryGetValue(key, out var definition))
|
|
{
|
|
if (_users.TryGetValue(key, out var users))
|
|
{
|
|
users.Add(user);
|
|
}
|
|
else
|
|
{
|
|
_users[key] = [user];
|
|
}
|
|
|
|
return definition;
|
|
}
|
|
|
|
var svgElementCollection = svgDoc.Children;
|
|
var newLineFont = new LineFont()
|
|
{
|
|
ReduceCurveThreshold = key.ReduceCurveThreshold,
|
|
CornerWeightBalance = key.CornerBalance,
|
|
};
|
|
|
|
ParseFontDefinitionsInElements(svgElementCollection, newLineFont);
|
|
|
|
newLineFont.InitGlyphTable();
|
|
|
|
_definitionsForFilePaths[key] = newLineFont;
|
|
return newLineFont;
|
|
}
|
|
|
|
private static void ParseFontDefinitionsInElements(SvgElementCollection svgElementCollection,
|
|
LineFont font)
|
|
{
|
|
foreach (var svgDocChild in svgElementCollection)
|
|
{
|
|
switch (svgDocChild)
|
|
{
|
|
case SvgFont svgFont:
|
|
CollectGlyphsFromSvgFont(svgFont, font);
|
|
break;
|
|
case SvgDefinitionList svgDefinitionList:
|
|
ParseFontDefinitionsInElements(svgDefinitionList.Children, font);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void CollectGlyphsFromSvgFont(SvgFont svgFont, LineFont font)
|
|
{
|
|
var fontFace = svgFont.Children.SingleOrDefault(c => c is SvgFontFace);
|
|
if (fontFace is SvgFontFace svgFontFace)
|
|
{
|
|
font.Descent = svgFontFace.Descent;
|
|
font.Ascent = svgFontFace.Ascent;
|
|
font.XHeight = svgFontFace.XHeight;
|
|
font.UnitsPerEm = svgFontFace.UnitsPerEm;
|
|
}
|
|
|
|
font.LineHeight = svgFont.FontSize != 0 ? svgFont.FontSize : font.UnitsPerEm;
|
|
|
|
foreach (var svgFontChild in svgFont.Children)
|
|
{
|
|
if (svgFontChild is not SvgGlyph svgGlyph)
|
|
continue;
|
|
|
|
var points = GetPointsFromSvgGroup(font, svgGlyph);
|
|
// if (points.Length == 0)
|
|
// continue;
|
|
|
|
if (string.IsNullOrEmpty(svgGlyph.Unicode) || svgGlyph.Unicode.Length != 1)
|
|
{
|
|
Log.Warning("Skipping svg glyph with missing or invalid unicode:" + svgGlyph.GlyphName);
|
|
continue;
|
|
}
|
|
|
|
var uniCode = svgGlyph.Unicode[0];
|
|
var glyphValue = (int)uniCode;
|
|
|
|
// There are some exporters that automatically assign a "icon" range to the Id.
|
|
// If that's the case we fall back to the GlyphName.
|
|
if (glyphValue > 1000 && svgGlyph.GlyphName?.Length == 1)
|
|
{
|
|
uniCode = svgGlyph.GlyphName[0];
|
|
}
|
|
|
|
font._glyphsForCharacters[uniCode] = new Glyph
|
|
{
|
|
Points = points,
|
|
UniCode = "" + uniCode,
|
|
Name = svgGlyph.GlyphName!,
|
|
AdvanceX = svgGlyph.HorizAdvX,
|
|
VertOriginX = svgGlyph.VertOriginX,
|
|
VertOriginY = svgGlyph.VertOriginY,
|
|
BoundsMin = new Vector2(svgGlyph.Bounds.Left, svgGlyph.Bounds.Top),
|
|
BoundsMax = new Vector2(svgGlyph.Bounds.Right, svgGlyph.Bounds.Bottom),
|
|
};
|
|
}
|
|
}
|
|
|
|
private static Point[] GetPointsFromSvgGroup(LineFont font, SvgElement svgGlyph)
|
|
{
|
|
var svgElements = new List<SvgElement> { svgGlyph };
|
|
var pathElements = GraphicsPathEntry.CreateFromSvgElements(svgElements, true);
|
|
|
|
// Flatten and sum total point count including separators
|
|
|
|
|
|
_tempPoints.Clear();
|
|
foreach (var pathElement in pathElements)
|
|
{
|
|
try
|
|
{
|
|
pathElement.GraphicsPath?.Flatten(null, font.ReduceCurveThreshold);
|
|
_ = pathElement.GraphicsPath?.PathPoints.Length; // Access path points to see if result is valid.
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Debug("Can't flatten element" + e.Message);
|
|
continue;
|
|
}
|
|
|
|
var path = pathElement.GraphicsPath;
|
|
if (path == null)
|
|
continue;
|
|
|
|
var pathPointCount = path.PathPoints.Length;
|
|
|
|
var loopStartIndex = _tempPoints.Count;
|
|
var lastPos = new Vector3(-9999f, 0f, 0f);
|
|
|
|
for (var pathPointIndex = 0; pathPointIndex < pathPointCount; pathPointIndex++)
|
|
{
|
|
var point = path.PathPoints[pathPointIndex];
|
|
|
|
var position = (new Vector3(point.X, 1 - point.Y, 0));
|
|
var length = (lastPos - position).LengthSquared();
|
|
lastPos = position;
|
|
var tooClose = length < 0.000001f;
|
|
if (tooClose)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
_tempPoints.Add(new Point
|
|
{
|
|
Position = position,
|
|
F1 = 1,
|
|
Orientation = Quaternion.Identity,
|
|
Color = Vector4.One,
|
|
Scale = Vector3.One,
|
|
F2 = 1,
|
|
});
|
|
}
|
|
|
|
// Close loop?
|
|
if (pathElement.NeedsClosing)
|
|
{
|
|
_tempPoints.Add(_tempPoints[loopStartIndex]);
|
|
}
|
|
|
|
_tempPoints.Add(Point.Separator());
|
|
}
|
|
|
|
var points = _tempPoints.ToArray();
|
|
var flip = font.UnitsPerEm < 0 ? 1 : -1;
|
|
// Calc point orientation
|
|
{
|
|
var p0 = Vector3.Zero;
|
|
var p0Valid = false;
|
|
var p1 = Vector3.Zero;
|
|
var p1Valid = false;
|
|
var p2 = Vector3.Zero;
|
|
var p2Valid = false;
|
|
for (var pointIndex = 0; pointIndex <= points.Length + 2; pointIndex++)
|
|
{
|
|
p0Valid = pointIndex >= 0 && pointIndex < points.Length && !float.IsNaN(points[pointIndex].F1);
|
|
if (p0Valid)
|
|
p0 = points[pointIndex].Position;
|
|
|
|
if (p1Valid)
|
|
{
|
|
if (p0Valid && p2Valid)
|
|
{
|
|
var v1 = Vector3.Normalize(p0-p1) - Vector3.Normalize(p2-p1);
|
|
var v2 = Vector3.Normalize(p0 - p2);
|
|
var v = Vector3.Lerp(v1, v2, font.CornerWeightBalance);
|
|
|
|
var angle = -MathF.Atan2(v.X, v.Y);
|
|
points[pointIndex-1].Orientation= Quaternion.CreateFromAxisAngle(Vector3.UnitZ, angle * flip);
|
|
}
|
|
else if (p2Valid)
|
|
{
|
|
var v = p1 - p2;
|
|
var p =points[pointIndex-1];
|
|
var angle = -MathF.Atan2(v.X, v.Y) ;
|
|
points[pointIndex-1].Orientation= Quaternion.CreateFromAxisAngle(Vector3.UnitZ, angle * flip );
|
|
}
|
|
else if (p0Valid)
|
|
{
|
|
var v = p0 - p1;
|
|
var p =points[pointIndex-1];
|
|
var angle = -MathF.Atan2(v.X, v.Y) ;
|
|
points[pointIndex-1].Orientation= Quaternion.CreateFromAxisAngle(Vector3.UnitZ, angle * flip );
|
|
}
|
|
}
|
|
|
|
p2Valid = p1Valid;
|
|
p2 = p1;
|
|
p1Valid = p0Valid;
|
|
p1 = p0;
|
|
}
|
|
}
|
|
|
|
return points;
|
|
}
|
|
|
|
private static readonly Dictionary<LineFontDefinition, LineFont> _definitionsForFilePaths = new();
|
|
private static readonly Dictionary<LineFontDefinition, HashSet<object>> _users = new();
|
|
|
|
private static readonly List<Point> _tempPoints = new(100); // Reuse to avoid GC
|
|
|
|
internal sealed class Glyph
|
|
{
|
|
//public char Char;
|
|
public float AdvanceX = 10;
|
|
public Point[] Points = [];
|
|
public string UniCode = string.Empty;
|
|
public string Name = string.Empty;
|
|
public float VertOriginX;
|
|
public float VertOriginY;
|
|
public Vector2 BoundsMin;
|
|
public Vector2 BoundsMax;
|
|
}
|
|
}
|
|
|
|
internal sealed class GraphicsPathEntry
|
|
{
|
|
public GraphicsPath? GraphicsPath;
|
|
public bool NeedsClosing;
|
|
|
|
public static List<GraphicsPathEntry> CreateFromSvgElements(IEnumerable<SvgElement> nodes, bool importAsLines)
|
|
{
|
|
var paths = new List<GraphicsPathEntry>();
|
|
|
|
_svgRenderer ??= SvgRenderer.FromImage(new Bitmap(1, 1));
|
|
|
|
foreach (var node in nodes)
|
|
{
|
|
switch (node)
|
|
{
|
|
case SvgPath svgPath:
|
|
{
|
|
var fullPath = svgPath.Path(_svgRenderer);
|
|
SplitGraphicsPathIntoSubPaths(fullPath, paths);
|
|
break;
|
|
}
|
|
|
|
case SvgGlyph svgGlyph:
|
|
{
|
|
var fullPath = svgGlyph.Path(_svgRenderer);
|
|
SplitGraphicsPathIntoSubPaths(fullPath, paths);
|
|
break;
|
|
}
|
|
|
|
case SvgGroup:
|
|
break;
|
|
|
|
case SvgPathBasedElement element:
|
|
{
|
|
if (element is SvgRectangle { Transforms: not null } rect)
|
|
{
|
|
foreach (var t in rect.Transforms)
|
|
{
|
|
if (t is not SvgTranslate tr)
|
|
continue;
|
|
|
|
rect.X += tr.X;
|
|
rect.Y += tr.Y;
|
|
}
|
|
}
|
|
|
|
var needsClosing = element is SvgRectangle or SvgCircle or SvgEllipse;
|
|
|
|
var graphicsPath = element.Path(_svgRenderer);
|
|
|
|
paths.Add(new GraphicsPathEntry
|
|
{
|
|
GraphicsPath = graphicsPath,
|
|
NeedsClosing = needsClosing && importAsLines
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return paths;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Splits a GraphicsPath into sub-paths at each StartPoint marker.
|
|
/// This avoids manual segment iteration with AddToPath, letting the SVG library
|
|
/// handle path construction internally via SvgPath.Path(renderer).
|
|
/// </summary>
|
|
private static void SplitGraphicsPathIntoSubPaths(GraphicsPath? fullPath, List<GraphicsPathEntry> paths)
|
|
{
|
|
if (fullPath == null || fullPath.PointCount == 0)
|
|
return;
|
|
|
|
var points = fullPath.PathPoints;
|
|
var types = fullPath.PathTypes;
|
|
|
|
GraphicsPath? currentSubPath = null;
|
|
var subPathStart = PointF.Empty;
|
|
|
|
for (var i = 0; i < points.Length; i++)
|
|
{
|
|
var pathType = types[i];
|
|
var pointType = (PathPointType)(pathType & 0x07);
|
|
var isStartPoint = pointType == PathPointType.Start;
|
|
var isCloseSubPath = (pathType & (byte)PathPointType.CloseSubpath) != 0;
|
|
|
|
if (isStartPoint)
|
|
{
|
|
if (currentSubPath != null && currentSubPath.PointCount > 0)
|
|
{
|
|
paths.Add(new GraphicsPathEntry
|
|
{
|
|
GraphicsPath = currentSubPath,
|
|
NeedsClosing = false
|
|
});
|
|
}
|
|
currentSubPath = new GraphicsPath();
|
|
subPathStart = points[i];
|
|
}
|
|
|
|
currentSubPath ??= new GraphicsPath();
|
|
|
|
if (pointType == PathPointType.Line)
|
|
{
|
|
var prev = i > 0 ? points[i - 1] : subPathStart;
|
|
currentSubPath.AddLine(prev, points[i]);
|
|
}
|
|
else if (pointType == PathPointType.Bezier3 && i + 2 < points.Length)
|
|
{
|
|
var prev = i > 0 ? points[i - 1] : subPathStart;
|
|
currentSubPath.AddBezier(prev, points[i], points[i + 1], points[i + 2]);
|
|
i += 2;
|
|
}
|
|
|
|
if (isCloseSubPath && currentSubPath.PointCount > 0)
|
|
{
|
|
currentSubPath.CloseFigure();
|
|
paths.Add(new GraphicsPathEntry
|
|
{
|
|
GraphicsPath = currentSubPath,
|
|
NeedsClosing = false
|
|
});
|
|
currentSubPath = null;
|
|
}
|
|
}
|
|
|
|
if (currentSubPath != null && currentSubPath.PointCount > 0)
|
|
{
|
|
paths.Add(new GraphicsPathEntry
|
|
{
|
|
GraphicsPath = currentSubPath,
|
|
NeedsClosing = false
|
|
});
|
|
}
|
|
}
|
|
|
|
private static ISvgRenderer? _svgRenderer;
|
|
} |