public unsafe void SetRenderer(Renderer renderer, uint numParams, Parameter[] parameters)
{
if (disposed)
throw new ObjectDisposedException("Library", "Cannot access a disposed object.");
if (renderer == null)
throw new ArgumentNullException("renderer");
if (parameters == null)
throw new ArgumentNullException("parameters");
ParameterRec[] paramRecs = Array.ConvertAll<Parameter, ParameterRec>(parameters, p => p.Record);
fixed (void* ptr = paramRecs)
{
Error err = FT.FT_Set_Renderer(Reference, renderer.Reference, numParams, (IntPtr)ptr);
if (err != Error.Ok)
throw new FreeTypeException(err);
}
}
public static void DecomposeContour(Renderer renderer, int firstIndex, int lastIndex, PointF[] points)
{
var pointIndex = firstIndex;
var start = points[pointIndex];
var end = points[lastIndex];
var control = start;
if (start.Type == PointType.Cubic)
throw new InvalidFontException("Contours can't start with a cubic control point.");
if (start.Type == PointType.Quadratic)
{
// if first point is a control point, try using the last point
if (end.Type == PointType.OnCurve)
{
start = end;
lastIndex--;
}
else
{
// if they're both control points, start at the middle
start.P = (start.P + end.P) / 2;
}
pointIndex--;
}
// let's draw this contour
renderer.MoveTo(start);
var needClose = true;
while (pointIndex < lastIndex)
{
var point = points[++pointIndex];
switch (point.Type)
{
case PointType.OnCurve:
renderer.LineTo(point);
break;
case PointType.Quadratic:
control = point;
var done = false;
while (pointIndex < lastIndex)
{
var next = points[++pointIndex];
if (next.Type == PointType.OnCurve)
{
renderer.QuadraticCurveTo(control, next);
done = true;
break;
}
if (next.Type != PointType.Quadratic)
throw new InvalidFontException("Bad outline data.");
renderer.QuadraticCurveTo(control, (control.P + next.P) / 2);
control = next;
}
if (!done)
{
// if we hit this point, we're ready to close out the contour
renderer.QuadraticCurveTo(control, start);
needClose = false;
}
break;
case PointType.Cubic:
throw new NotSupportedException();
}
}
if (needClose)
renderer.LineTo(start);
}
internal Glyph(Renderer renderer, PointF[] points, int[] contours, float linearHorizontalAdvance)
{
this.renderer = renderer;
this.points = points;
this.contours = contours;
// find the bounding box
var min = new Vector2(float.MaxValue, float.MaxValue);
var max = new Vector2(float.MinValue, float.MinValue);
var pointCount = points.Length - 4;
for (int i = 0; i < pointCount; i++)
{
min = Vector2.Min(min, points[i].P);
max = Vector2.Max(max, points[i].P);
}
// save the "pure" size of the glyph, in fractional pixels
var size = max - min;
Width = size.X;
Height = size.Y;
// find the "render" size of the glyph, in whole pixels
var shiftX = (int)Math.Floor(min.X);
var shiftY = (int)Math.Floor(min.Y);
RenderWidth = (int)Math.Ceiling(max.X) - shiftX;
RenderHeight = (int)Math.Ceiling(max.Y) - shiftY;
// translate the points so that 0,0 is at the bottom left corner
var offset = new Vector2(-shiftX, -shiftY);
for (int i = 0; i < pointCount; i++)
points[i] = points[i].Offset(offset);
HorizontalMetrics = new GlyphMetrics(new Vector2(min.X, max.Y), points[pointCount + 1].P.X - points[pointCount].P.X, linearHorizontalAdvance);
// TODO: vertical metrics
}