/// <summary>
/// 創造角色的函式(會出現在場上)
/// </summary>
/// <param name="_builder"></param>
/// <returns></returns>
public Figure CreateFigure(FigureBuilder _builder)
{
Figure newFigure = null;
if (_builder.Name.Contains("MeatBall"))
{
newFigure = new MeatBall(_builder);
}
else
{
newFigure = new Figure(_builder);
};
if (figurePool.ContainsKey(_builder.Name))
{
return(figurePool[_builder.Name][0]);
}
else
{
List <Figure> figureList = new List <Figure>();
figureList.Add(newFigure);
figurePool.Add(_builder.Name, figureList);
OnCreateFigure(newFigure);
return(newFigure);
}
}
/// <summary>Construct the builder</summary>
public PathBuilder()
{
data = new List <float>();
segments = new List <sPathSegment>();
figures = new List <sPathFigure>();
fb = new FigureBuilder(this);
}
internal PathBuilder(int expectedFloats, int expectedSegments)
{
data = new List <float>(expectedFloats);
segments = new List <sPathSegment>(expectedSegments);
figures = new List <sPathFigure>(1);
fb = new FigureBuilder(this);
}
/// <summary>
/// Действия по двойному клику на фигурах
/// Обычно, это действие по умолчанию
/// </summary>
/// <param name="location"></param>
/// <param name="modifierKeys"></param>
public void OnDblClick(Point location, Keys modifierKeys)
{
var point = Point.Ceiling(new PointF(location.X / ScaleFactor, location.Y / ScaleFactor));
if (RibbonLineUpdated(point))
{
// добавляем полилинию
var line = new Figure();
var lineGeometry = _selection.Geometry as AddLineGeometry;
if (lineGeometry != null)
{
if (lineGeometry.IsSmoothed)
{
var points = lineGeometry.Path.Path.PathPoints;
var types = lineGeometry.Path.Path.PathTypes;
Helper.CutLastBezierPoints(ref points, ref types);
FigureBuilder.BuildBezierGeometry(line, points, types);
}
else
{
var points = lineGeometry.Points.ToArray();
FigureBuilder.BuildPolyGeometry(line, lineGeometry.IsClosed, points);
}
OnLayerStartChanging();
_layer.Figures.Add(line);
OnLayerChanged();
}
return;
}
}
public Figure2 create(FigureBuilder figureBuilder)
{
figureBuilder.CreateFigure();
figureBuilder.SetColor();
figureBuilder.SetArea();
return(figureBuilder.figure2);
}
/// <summary>
/// Создаём новую фигуру
/// </summary>
/// <param name="location">Позиция мышки</param>
private void CreateFigure(Point location)
{
//создаем новую фигуру
var newFig = CreateFigureRequest();
if (newFig == null)
{
return;
}
var pg = newFig.Geometry as PolygoneGeometry;
if (pg != null)
{
if (!(_selection.Geometry is AddLineGeometry))
{
FigureBuilder.BuildAddLineGeometry(_selection, location, pg.IsClosed);
}
EditorMode = EditorMode.AddLine;
CreateFigureRequest = null;
return;
}
// сразу смещаем на половину размера, чтобы левый верхний угол был в точке мышки
newFig.Transform.Matrix.Translate(location.X + 0.5f, location.Y + 0.5f);
_layer.Figures.Add(newFig);
_selection.Add(newFig);
CreateFigureRequest = null;
OnSelectedFigureChanged();
}
public Figure(FigureBuilder _builder)
{
Behavior = _builder.GameObjectOnScene.GetComponent <FigureBehavior>();
myValue = _builder.Value;
Behavior.name = _builder.Name;
InputType = _builder.Type;
AttackNumber = _builder.AttackNumber;
Initial();
}
public void SelectionFigureTestMethod()
{
//создаем первую фигуру
var fig1 = new Figure();
fig1.Transform.Matrix.Translate(50, 50);
fig1.Transform.Matrix.Scale(100, 100);
FigureBuilder.BuildEllipseGeometry(fig1);
//создаем вторую фигуру
var fig2 = new Figure();
fig2.Transform.Matrix.Translate(150, 150);
fig2.Transform.Matrix.Scale(100, 100);
FigureBuilder.BuildRectangleGeometry(fig2);
//рисуем до выделения
Draw("1_1.png", fig1, fig2);
//создаем selection
var selection = new Selection();
selection.Style.BorderStyle.Width = 1;
selection.Style.BorderStyle.Color = Color.Magenta;
//выделяем фигуры
selection.Add(fig1);
selection.Add(fig2);
//рисуем после выделения
Draw("1_2.png", fig1, fig2, selection);
//вращаем и выделенные фигуры
Matrix m = selection.Transform;
m.RotateAt(45, new PointF(100, 100));
selection.PushTransformToSelectedFigures();
//рисуем после вращения выделенных фигур
Draw("1_3.png", fig1, fig2, selection);
//перемещаем выделенные фигуры
m = selection.Transform;
m.Translate(0, 100);
selection.PushTransformToSelectedFigures();
//рисуем после перемещения выделенных фигур
Draw("1_4.png", fig1, fig2, selection);
//снимаем выделение, отрисовываем результат
selection.Clear();
Draw("1_5.png", fig1, fig2, selection);
}
/// <summary>Clear everything built. This way you can reuse the builder to build multiple paths, saves non-trivial amount of CPU time wasted on GC.</summary>
public void clear()
{
if (fb.isOpen)
{
throw new ApplicationException("You must dispose the current figure before calling PathBuilder.clear()");
}
data.Clear();
segments.Clear();
figures.Clear();
fillMode = eFillMode.Winding;
fb = new FigureBuilder(this);
}
public GLPainter()
{
CurrentFont = PixelFarm.Drawing.GLES2.GLES2Platform.DefaultFont;
UseVertexBufferObjectForRenderVx = true;
//tools
_pathRenderVxBuilder = new FigureBuilder();
_defaultBrush = _currentBrush = new SolidBrush(Color.Black); //default brush
_pathRenderVxBuilder2 = new PathRenderVxBuilder2();
//default
_mySimpleGLBitmapAtlas = new CpuBlit.BitmapAtlas.MySimpleGLBitmapAtlasManager(CpuBlit.BitmapAtlas.TextureKind.Bitmap);
SetBitmapAtlasManager(_mySimpleGLBitmapAtlas);
}
public MeatBall(FigureBuilder _builder) : base(_builder)
{
MeatBallBuilder builder = _builder as MeatBallBuilder;
myBehavior = _builder.GameObjectOnScene.GetComponent <MeatBallBehavior>();
myBehavior.myMeatBallFigure = this;
if (builder == null || !(builder is MeatBallBuilder))
{
SetSet(MeatBallSetFactory.Instance.GetSetObject(MeatBallSetFactory.SetType.Orgin));
}
else
{
SetSet(MeatBallSetFactory.Instance.GetSetObject(builder.Set));
}
}
public void EllipseFigureTestMethod()
{
var oval = new Figure();
oval.Transform.Matrix.Translate(100, 50);
oval.Transform.Matrix.Scale(160, 80);
// настраиваем геометрию на круг
FigureBuilder.BuildEllipseGeometry(oval);
// проверим, что все внутренние классы были подключены
CheckInternalClassesConnection(oval);
oval = SerializeDeserialize(oval);
// пробуем отрисовывать
using (var bmp = new Bitmap(200, 100))
{
using (var canvas = Graphics.FromImage(bmp))
oval.Renderer.Render(canvas, oval);
bmp.Save("EllipseFigure.png");
}
}
public void RectangleFigureTestMethod()
{
var rect = new Figure();
rect.Transform.Matrix.Translate(100, 50);
rect.Transform.Matrix.Scale(160, 80);
// настраиваем геометрию на квадрат
FigureBuilder.BuildRectangleGeometry(rect);
// проверим, что все внутренние классы были подключены
CheckInternalClassesConnection(rect);
rect = SerializeDeserialize(rect);
// пробуем отрисовывать
using (var bmp = new Bitmap(200, 100))
{
using (var canvas = Graphics.FromImage(bmp))
rect.Renderer.Render(canvas, rect);
bmp.Save("RectangleFigure.png");
}
}
public void TextFigureTestMethod()
{
var textfigure = new Figure();
textfigure.Transform.Matrix.Translate(10, 10);
// настраиваем геометрию на текст
FigureBuilder.BuildTextGeometry(textfigure,
"The test for text string rendering complete.");
// проверим, что все внутренние классы были подключены
CheckInternalClassesConnection(textfigure);
textfigure = SerializeDeserialize(textfigure);
// пробуем отрисовывать
using (var bmp = new Bitmap(200, 100))
{
using (var canvas = Graphics.FromImage(bmp))
textfigure.Renderer.Render(canvas, textfigure);
bmp.Save("TextFigure.png");
}
}
/// <summary>
/// Выбор фигур для последующего создания
/// </summary>
private void btnCreateFigure_Click(object sender, EventArgs e)
{
_selectionController.Clear();
Func <Figure> figureCreator = null;
Cursor figureCreatorCursor = CursorFactory.GetCursor(UserCursor.SelectByRibbonRect);
if (sender == tsbPointer)
{
figureCreatorCursor = Cursors.Default;
Cursor = Cursors.Default;
tsbPointer.Enabled = false;
_selectionController.CreateFigureCursor = figureCreatorCursor;
_selectionController.CreateFigureRequest = figureCreator;
return;
}
tsbPointer.Enabled = true;
//
if (sender == btnRectangle || sender == tsbRect)
{
figureCreatorCursor = Cursor = CursorFactory.GetCursor(UserCursor.CreateRect);
figureCreator = () =>
{
var fig = new Figure();
FigureBuilder.BuildRectangleGeometry(fig);
return(fig);
};
}
else if (sender == btnRoundedRectangle)
{
figureCreatorCursor = Cursor = CursorFactory.GetCursor(UserCursor.CreateRect);
figureCreator = () =>
{
var fig = new Figure();
FigureBuilder.BuildRoundedRectangleGeometry(fig, 0.25f);
return(fig);
};
}
//
_selectionController.CreateFigureCursor = figureCreatorCursor;
_selectionController.CreateFigureRequest = figureCreator;
}
/// <summary>
/// Действия по двойному клику на фигурах
/// Обычно, это действие по умолчанию
/// </summary>
/// <param name="location"></param>
/// <param name="modifierKeys"></param>
public void OnDblClick(Point location, Keys modifierKeys)
{
var point = Point.Ceiling(new PointF(location.X / ScaleFactor, location.Y / ScaleFactor));
if (RibbonLineUpdated(point))
{
// добавляем полилинию
var line = new Figure();
var lineGeometry = _selection.Geometry as AddLineGeometry;
if (lineGeometry != null)
{
var points = lineGeometry.Points.ToArray();
FigureBuilder.BuildPolyGeometry(line, lineGeometry.IsClosed, points);
OnLayerStartChanging();
_layer.Figures.Add(line);
OnLayerChanged();
}
return;
}
}
void DrawOutput(Painter painter, Typeface typeface, char selectedChar)
{
#if DEBUG
painter.Clear(Color.White);
//this is a demo.
//
float fontSizeInPts = 300;
_glyphPathBuilder.BuildFromGlyphIndex(typeface.GetGlyphIndex(selectedChar), fontSizeInPts);
var prevColor = painter.StrokeColor;
painter.StrokeColor = Color.Black;
using (Tools.BorrowVxs(out var v1))
{
_glyphPathBuilder.ReadShapes(_tovxs);
_tovxs.WriteOutput(v1); //write content from GlyphTranslator to v1
painter.Fill(v1, KnownColors.Gray);
_tovxs.Reset();
//tess the vxs
FigureBuilder figBuilder = new FigureBuilder();
FigureContainer container = figBuilder.Build(v1);
TessTriangleTechnique tessTechnique = TessTriangleTechnique.DrawElement;
if (container.IsSingleFigure)
{
Figure figure = container._figure;
if (Tess == GlyphDemo_TessTech.SgiTess)
{
//coords of tess triangles
switch (tessTechnique)
{
case TessTriangleTechnique.DrawArray:
{
painter.dbugDrawTessTriangles(figure.GetAreaTess(_tessTool, _tessTool.WindingRuleType, TessTriangleTechnique.DrawArray));
}
break;
case TessTriangleTechnique.DrawElement:
{
float[] tessArea = figure.GetAreaTess(_tessTool, _tessTool.WindingRuleType, TessTriangleTechnique.DrawElement);
ushort[] index = figure.GetAreaIndexList();
painter.dbugDrawTessTriangles(tessArea, index);
}
break;
}
}
else
{
if (ContourAnalysis)
{
ContourAnalyzer analyzer1 = new ContourAnalyzer();
IntermediateOutline outline = analyzer1.CreateIntermediateOutline(v1);
GlyphDebugContourVisualizer dbugVisualizer = new GlyphDebugContourVisualizer();
dbugVisualizer.SetPainter(painter);
dbugVisualizer.Scale = _typeface.CalculateScaleToPixelFromPointSize(fontSizeInPts);
dbugVisualizer.WalkCentroidLine(outline);
}
else
{
//Poly2Tri
List <Poly2Tri.Polygon> polygons = figure.GetTrianglulatedArea(false);
//draw polygon
painter.StrokeColor = Color.Red;
painter.dbugDrawPoly2TriPolygon(polygons);
}
}
}
else
{
MultiFigures multiFig = container._multiFig;
if (Tess == GlyphDemo_TessTech.SgiTess)
{
switch (tessTechnique)
{
case TessTriangleTechnique.DrawArray:
{
painter.dbugDrawTessTriangles(multiFig.GetAreaTess(_tessTool, _tessTool.WindingRuleType, TessTriangleTechnique.DrawArray));
}
break;
case TessTriangleTechnique.DrawElement:
{
float[] tessArea = multiFig.GetAreaTess(_tessTool, _tessTool.WindingRuleType, TessTriangleTechnique.DrawElement);
ushort[] index = multiFig.GetAreaIndexList();
painter.dbugDrawTessTriangles(tessArea, index);
}
break;
}
}
else
{
if (ContourAnalysis)
{
ContourAnalyzer analyzer1 = new ContourAnalyzer();
IntermediateOutline outline = analyzer1.CreateIntermediateOutline(v1);
GlyphDebugContourVisualizer dbugVisualizer = new GlyphDebugContourVisualizer();
dbugVisualizer.SetPainter(painter);
dbugVisualizer.Scale = _typeface.CalculateScaleToPixelFromPointSize(fontSizeInPts);
dbugVisualizer.WalkCentroidLine(outline);
}
else
{
List <Poly2Tri.Polygon> polygons = multiFig.GetTrianglulatedArea(false);
painter.StrokeColor = Color.Red;
painter.dbugDrawPoly2TriPolygon(polygons);
}
}
}
}
painter.StrokeColor = prevColor;
//-------------
//tess
//if (rdoTessSGI.Checked)
//{
// //SGI Tess Lib
// if (!_tessTool.TessPolygon(polygon1, _contourEnds))
// {
// return;
// }
// //1.
// List<ushort> indexList = _tessTool.TessIndexList;
// //2.
// List<TessVertex2d> tempVertexList = _tessTool.TempVertexList;
// //3.
// int vertexCount = indexList.Count;
// //-----------------------------
// int orgVertexCount = polygon1.Length / 2;
// float[] vtx = new float[vertexCount * 2];//***
// int n = 0;
// for (int p = 0; p < vertexCount; ++p)
// {
// ushort index = indexList[p];
// if (index >= orgVertexCount)
// {
// //extra coord (newly created)
// TessVertex2d extraVertex = tempVertexList[index - orgVertexCount];
// vtx[n] = (float)extraVertex.x;
// vtx[n + 1] = (float)extraVertex.y;
// }
// else
// {
// //original corrd
// vtx[n] = (float)polygon1[index * 2];
// vtx[n + 1] = (float)polygon1[(index * 2) + 1];
// }
// n += 2;
// }
// //-----------------------------
// //draw tess result
// int j = vtx.Length;
// for (int i = 0; i < j;)
// {
// var p0 = new PointF(vtx[i], vtx[i + 1]);
// var p1 = new PointF(vtx[i + 2], vtx[i + 3]);
// var p2 = new PointF(vtx[i + 4], vtx[i + 5]);
// _g.DrawLine(Pens.Red, p0, p1);
// _g.DrawLine(Pens.Red, p1, p2);
// _g.DrawLine(Pens.Red, p2, p0);
// i += 6;
// }
//}
//else
//{
// List<Poly2Tri.Polygon> outputPolygons = new List<Poly2Tri.Polygon>();
// Poly2TriExampleHelper.Triangulate(polygon1, contourEndIndices, flipYAxis, outputPolygons);
// foreach (Poly2Tri.Polygon polygon in outputPolygons)
// {
// foreach (Poly2Tri.DelaunayTriangle tri in polygon.Triangles)
// {
// Poly2Tri.TriangulationPoint p0 = tri.P0;
// Poly2Tri.TriangulationPoint p1 = tri.P1;
// Poly2Tri.TriangulationPoint p2 = tri.P2;
// _g.DrawLine(Pens.Red, (float)p0.X, (float)p0.Y, (float)p1.X, (float)p1.Y);
// _g.DrawLine(Pens.Red, (float)p1.X, (float)p1.Y, (float)p2.X, (float)p2.Y);
// _g.DrawLine(Pens.Red, (float)p2.X, (float)p2.Y, (float)p0.X, (float)p0.Y);
// }
// }
//}
#endif
}
public abstract void SetNewFigureBuilder(FigureBuilder builder);
public Controller(View viewToDisplay, FigureBuilder figureCreater)
{
ViewToDisplay = viewToDisplay;
FigureCreater = figureCreater;
}
public void SelectionTest2()
{
//создаем первую фигуру
var fig1 = new Figure();
fig1.Transform.Matrix.Translate(150, 150);
fig1.Transform.Matrix.Scale(30, 30);
FigureBuilder.BuildEllipseGeometry(fig1);
//создаем вторую фигуру
var fig2 = new Figure();
fig2.Transform.Matrix.Translate(200, 200);
fig2.Transform.Matrix.Scale(30, 30);
FigureBuilder.BuildRectangleGeometry(fig2);
//рисуем до выделения
Draw("2_1.png", fig1, fig2);
//создаем selection
var selection = new Selection();
selection.Style.BorderStyle.Width = 1;
selection.Style.BorderStyle.Color = Color.Magenta;
//выделяем фигуры
selection.Add(fig1);
selection.Add(fig2);
//ресайз по X относительно левого края
selection.Scale(2, 1, selection.ToWorldCoordinates(new PointF(0, 0.5f)));
selection.PushTransformToSelectedFigures();
//рисуем
Draw("2_2.png", fig1, fig2, selection);
//ресайз по Y относительно нижнего края
selection.Scale(1, 2, selection.ToWorldCoordinates(new PointF(0.5f, 1)));
selection.PushTransformToSelectedFigures();
//рисуем
Draw("2_3.png", fig1, fig2, selection);
//вращение относительно центра
selection.Rotate(45, selection.ToWorldCoordinates(new PointF(0.5f, 0.5f)));
selection.PushTransformToSelectedFigures();
//рисуем
Draw("2_4.png", fig1, fig2, selection);
//сдвиг
selection.Translate(100, 100);
selection.PushTransformToSelectedFigures();
//рисуем
Draw("2_5.png", fig1, fig2, selection);
//skew по X относительно нижней границы
selection.Skew(0.5f, 0, selection.ToWorldCoordinates(new PointF(0.5f, 1)));
selection.PushTransformToSelectedFigures();
//рисуем
Draw("2_6.png", fig1, fig2, selection);
//результат
selection.Clear();
Draw("2_7.png", fig1, fig2, selection);
}
/// <summary>
/// Обработчик нажатия левой кнопки мышки
/// </summary>
/// <param name="location">Координаты курсора</param>
/// <param name="modifierKeys">Какие клавиши были ещё нажаты в этот момент</param>
public void OnMouseDown(Point location, Keys modifierKeys)
{
_wasMouseMoving = false;
_wasVertexMoving = false;
_isMouseDown = true;
_movedMarker = null;
// запоминаем точку нажатия мышкой
var point = Point.Ceiling(new PointF(location.X / ScaleFactor, location.Y / ScaleFactor));
_firstMouseDown = point;
if (CreateFigureRequest != null)
{
//создаем новую фигуру
EditorMode = EditorMode.CreateFigure;
OnLayerStartChanging();
CreateFigure(point);
_isFigureCreated = true;
return;
}
if (RibbonLineUpdated(point, true))
{
return;
}
if (EditorMode != EditorMode.Select &&
EditorMode != EditorMode.Skew &&
EditorMode != EditorMode.Warp &&
EditorMode != EditorMode.Verticies)
{
Clear(); // очищаем список выбранных
}
//перебираем фигуры, выделяем/снимаем выделение
FindMarkerAt(point, out _movedMarker);
if (_movedMarker == null) // маркера под курсором не встретилось...
{
Figure fig;
if ((EditorMode == EditorMode.Select ||
EditorMode == EditorMode.Skew ||
EditorMode == EditorMode.Warp ||
EditorMode == EditorMode.Verticies) &&
_selection.FindFigureAt(_layer, point, out fig)) // попробуем найти фигуру...
{
// фигура найдена.
// если этой фигуры не было в списке
if (!_selection.Contains(fig))
{
// если не нажата управляющая клавиша Shift
// в режиме изменения вершим может быть выбрана только одна фигура
if (!modifierKeys.HasFlag(Keys.Shift))
{
_selection.Clear(); // очистим список выбранных
}
// то добавим её в список
_selection.Add(fig);
OnSelectedFigureChanged();
}
else
{
if (EditorMode == EditorMode.Verticies && modifierKeys.HasFlag(Keys.Control))
{
OnLayerStartChanging();
// вставка новой вершины при нажатом Ctrl
_selection.InsertVertex(fig, point);
OnLayerChanged();
}
// при нажатой клавише Shift удаляем эту фигуру из списка выбора
// если она не последняя
else
if (_selection.Count > 1 && modifierKeys.HasFlag(Keys.Shift))
{
_selection.Remove(fig);
OnSelectedFigureChanged();
}
}
//строим маркеры
UpdateMarkers();
// что-то выбрано, тогда "тянем"
if (_selection.Count > 0)
{
EditorMode = EditorMode.Drag;
}
}
else
{
// в точке мышки ничего нет
Clear(); // очищаем список выбранных
OnSelectedFigureChanged();
if (CreateFigureRequest == null)
{
// создаём "резиновую" рамку
FigureBuilder.BuildFrameGeometry(_selection, point);
EditorMode = EditorMode.FrameSelect;
}
}
}
else
{
if (EditorMode == EditorMode.Verticies)
{
if (modifierKeys.HasFlag(Keys.Control))
{
if (_movedMarker.MarkerType == MarkerType.Vertex)
{
// удаляем только вершины, а не контрольные точки
OnLayerStartChanging();
_selection.RemoveVertex(((VertexMarker)_movedMarker).Owner,
((VertexMarker)_movedMarker).Index);
OnLayerChanged();
//строим маркеры
UpdateMarkers();
OnSelectedFigureChanged();
}
}
}
else
{
EditorMode = EditorMode.ChangeGeometry;
}
}
}
public override void SetNewFigureBuilder(FigureBuilder builder)
{
FigureCreater = builder;
_logger.Info(LoggerMessage.SET_NEW_FIGURE_BUILDER);
}
public FigureController(View viewToDisplay, FigureBuilder figureCreater) :
base(viewToDisplay, figureCreater)
{
_logger = LogManager.GetCurrentClassLogger();
}
/// <summary>
/// Метод строит маркеры у объекта Selection
/// </summary>
private void BuildMarkers()
{
// стираем предыдущие маркеры
Markers.Clear();
// если ничего не выбрано, выходим
if (Selection.Count == 0)
{
return;
}
switch (_editorMode)
{
case EditorMode.Skew:
//создаём маркеры скоса по горизонтали и по вертикали
if (_selection.Geometry.AllowedOperations.HasFlag(AllowedOperations.Skew)) //если разрешён скос
{
Markers.Add(CreateMarker(MarkerType.SkewX, 0.5f, 0, UserCursor.SkewHorizontal, 1, 1));
Markers.Add(CreateMarker(MarkerType.SkewY, 0, 0.5f, UserCursor.SkewVertical, 1, 1));
Markers.Add(CreateMarker(MarkerType.SkewY, 1, 0.5f, UserCursor.SkewVertical, 0, 0));
Markers.Add(CreateMarker(MarkerType.SkewX, 0.5f, 1, UserCursor.SkewHorizontal, 0, 0));
}
break;
case EditorMode.Verticies:
// создаём маркеры на вершинах фигур
if (_selection.Geometry.AllowedOperations.HasFlag(AllowedOperations.Vertex)) //если разрешено редактирование вершин
{
foreach (var fig in _selection.Where(figure => figure.Geometry is PolygoneGeometry))
{
var polygone = fig.Geometry as PolygoneGeometry;
//get transformed points
if (polygone == null)
{
continue;
}
var points = polygone.GetTransformedPoints(fig);
for (var i = 0; i < points.Length; i++)
{
Markers.Add(CreateMarker(MarkerType.Vertex, points[i], i, fig));
}
}
}
// создаём маркеры градиента
foreach (var fig in _selection.Where(figure => figure.Style.FillStyle is IGradientFill))
{
var gradient = fig.Style.FillStyle as IGradientFill;
//get transformed points
if (gradient == null)
{
continue;
}
var points = gradient.GetGradientPoints(fig);
for (var i = 0; i < points.Length; i++)
{
Markers.Add(CreateMarker(MarkerType.Grafient, points[i], i, fig));
}
}
break;
case EditorMode.Select:
// создаём маркеры масштаба
if (Selection.Geometry.AllowedOperations.HasFlag(AllowedOperations.Scale)) //если разрешено масштабирование
{
Markers.Add(CreateMarker(MarkerType.Scale, 0, 0, UserCursor.SizeNWSE, 1, 1));
Markers.Add(CreateMarker(MarkerType.Scale, 1, 0, UserCursor.SizeNESW, 0, 1));
Markers.Add(CreateMarker(MarkerType.Scale, 1, 1, UserCursor.SizeNWSE, 0, 0));
Markers.Add(CreateMarker(MarkerType.Scale, 0, 1, UserCursor.SizeNESW, 1, 0));
}
// создаём маркеры ресайза по вертикали и горизонтали
if (Selection.Geometry.AllowedOperations.HasFlag(AllowedOperations.Size)) //если разрешено изменение размера
{
Markers.Add(CreateMarker(MarkerType.SizeY, 0.5f, 0, UserCursor.SizeNS, 0.5f, 1));
Markers.Add(CreateMarker(MarkerType.SizeX, 1, 0.5f, UserCursor.SizeWE, 0, 0.5f));
Markers.Add(CreateMarker(MarkerType.SizeY, 0.5f, 1, UserCursor.SizeNS, 0.5f, 0));
Markers.Add(CreateMarker(MarkerType.SizeX, 0, 0.5f, UserCursor.SizeWE, 1, 0.5f));
}
// создаём маркер вращения
if (Selection.Geometry.AllowedOperations.HasFlag(AllowedOperations.Rotate)) //если разрешено вращение
{
var sf = ScaleFactor;
var rotateMarker = CreateMarker(MarkerType.Rotate, 1, 0, UserCursor.Rotate, 0.5f, 0.5f, 15 / sf, -15 / sf);
Markers.Add(rotateMarker);
}
break;
}
// задаём геометрию маркеров по умолчанию
foreach (var marker in Markers)
{
FigureBuilder.BuildMarkerGeometry(marker);
}
}
/// <summary>
/// Метод строит маркеры у объекта Selection
/// </summary>
private void BuildMarkers()
{
// стираем предыдущие маркеры
Markers.Clear();
// если ничего не выбрано, выходим
if (Selection.Count == 0)
{
return;
}
switch (_editorMode)
{
case EditorMode.Warp:
//создаём маркеры искажения по горизонтали и по вертикали
if (_selection.Geometry.AllowedOperations.HasFlag(AllowedOperations.Warp)) //если разрешёно искажение
{
// создаём маркеры искажения
foreach (var fig in RendererDecorator.WhereContainsDecorator(_selection, typeof(WarpRendererDecorator)))
{
var warped = fig.Renderer as WarpRendererDecorator;
//get transformed points
if (warped == null)
{
continue;
}
var points = warped.GetWarpPoints(fig);
for (var i = 0; i < points.Length; i++)
{
Markers.Add(CreateMarker(MarkerType.Warp, points[i], i, fig));
}
}
}
break;
case EditorMode.Skew:
//создаём маркеры скоса по горизонтали и по вертикали
if (_selection.Geometry.AllowedOperations.HasFlag(AllowedOperations.Skew)) //если разрешён скос
{
Markers.Add(CreateMarker(MarkerType.SkewX, 0.5f, 0, UserCursor.SkewHorizontal, 1, 1));
Markers.Add(CreateMarker(MarkerType.SkewY, 0, 0.5f, UserCursor.SkewVertical, 1, 1));
Markers.Add(CreateMarker(MarkerType.SkewY, 1, 0.5f, UserCursor.SkewVertical, 0, 0));
Markers.Add(CreateMarker(MarkerType.SkewX, 0.5f, 1, UserCursor.SkewHorizontal, 0, 0));
}
break;
case EditorMode.Verticies:
// создаём маркеры на вершинах фигур
if (_selection.Geometry.AllowedOperations.HasFlag(AllowedOperations.Vertex)) //если разрешено редактирование вершин
{
foreach (var fig in _selection.Where(figure => figure.Geometry is ITransformedGeometry))
{
var transformed = fig.Geometry as ITransformedGeometry;
//get transformed points
if (transformed == null)
{
continue;
}
var points = transformed.GetTransformedPoints(fig);
var types = transformed.GetTransformedPointTypes(fig);
Markers.Add(CreateMarker(MarkerType.Vertex, points[0], 0, fig));
var nt = 0;
MarkerType mt;
for (var i = 1; i < points.Length; i++)
{
var typ = types[i];
if ((typ & 0x07) == 3)
{
mt = nt % 3 == 2 ? MarkerType.Vertex : MarkerType.ControlBezier;
nt++;
}
else
{
mt = MarkerType.Vertex;
nt = 0;
}
Markers.Add(CreateMarker(mt, points[i], i, fig));
}
}
}
// создаём маркеры градиента
foreach (var fig in _selection.Where(figure => figure.Style.FillStyle is IGradientFill))
{
var gradient = fig.Style.FillStyle as IGradientFill;
//get transformed points
if (gradient == null)
{
continue;
}
var points = gradient.GetGradientPoints(fig);
for (var i = 0; i < points.Length; i++)
{
Markers.Add(CreateMarker(MarkerType.Gradient, points[i], i, fig));
}
}
break;
case EditorMode.Select:
// создаём маркеры масштаба
if (Selection.Geometry.AllowedOperations.HasFlag(AllowedOperations.Scale)) //если разрешено масштабирование
{
Markers.Add(CreateMarker(MarkerType.Scale, 0, 0, UserCursor.SizeNWSE, 1, 1));
Markers.Add(CreateMarker(MarkerType.Scale, 1, 0, UserCursor.SizeNESW, 0, 1));
Markers.Add(CreateMarker(MarkerType.Scale, 1, 1, UserCursor.SizeNWSE, 0, 0));
Markers.Add(CreateMarker(MarkerType.Scale, 0, 1, UserCursor.SizeNESW, 1, 0));
}
// создаём маркеры ресайза по вертикали и горизонтали
if (Selection.Geometry.AllowedOperations.HasFlag(AllowedOperations.Size)) //если разрешено изменение размера
{
Markers.Add(CreateMarker(MarkerType.SizeY, 0.5f, 0, UserCursor.SizeNS, 0.5f, 1));
Markers.Add(CreateMarker(MarkerType.SizeX, 1, 0.5f, UserCursor.SizeWE, 0, 0.5f));
Markers.Add(CreateMarker(MarkerType.SizeY, 0.5f, 1, UserCursor.SizeNS, 0.5f, 0));
Markers.Add(CreateMarker(MarkerType.SizeX, 0, 0.5f, UserCursor.SizeWE, 1, 0.5f));
}
// создаём маркер вращения
if (Selection.Geometry.AllowedOperations.HasFlag(AllowedOperations.Rotate)) //если разрешено вращение
{
var sf = ScaleFactor;
var rotateMarker = CreateMarker(MarkerType.Rotate, 1, 0, UserCursor.Rotate, 0.5f, 0.5f, 15 / sf, -15 / sf);
Markers.Add(rotateMarker);
}
break;
}
// задаём геометрию маркеров по умолчанию
foreach (var marker in Markers)
{
FigureBuilder.BuildMarkerGeometry(marker);
}
}
void DrawOutput(Painter painter, Typeface typeface, char selectedChar)
{
painter.Clear(Color.White);
//this is a demo.
//
float fontSizeInPts = 300;
_glyphPathBuilder.BuildFromGlyphIndex(typeface.GetGlyphIndex(selectedChar), fontSizeInPts);
var prevColor = painter.StrokeColor;
painter.StrokeColor = Color.Black;
using (Tools.BorrowVxs(out var v1))
using (Tools.BorrowCurveFlattener(out var flattener))
{
_glyphPathBuilder.ReadShapes(_tovxs);
//config
if (rdoSimpleIncCurveFlattener.Checked)
{
flattener.ApproximationMethod = CurveApproximationMethod.Inc;
if (int.TryParse(txtIncrementalTessStep.Text, out int stepCount))
{
if (stepCount < 0)
{
//auto calculate inc step count
flattener.IncUseFixedStep = false;
}
else
{
//fix manual inc step count
flattener.IncUseFixedStep = true;
flattener.IncStepCount = stepCount;
}
}
}
else
{
flattener.ApproximationMethod = CurveApproximationMethod.Div;
if (double.TryParse(txtDivAngleTolerenceEpsilon.Text, out double angleTolerance))
{
flattener.AngleTolerance = angleTolerance;
}
if (byte.TryParse(txtDivCurveRecursiveLimit.Text, out byte recursiveLim))
{
flattener.RecursiveLimit = recursiveLim;
}
}
_tovxs.WriteOutput(v1, flattener); //write content from GlyphTranslator to v1
painter.Fill(v1, PixelFarm.Drawing.KnownColors.Gray);
_tovxs.Reset();
//tess the vxs
FigureBuilder figBuilder = new FigureBuilder();
FigureContainer container = figBuilder.Build(v1);
TessTriangleTechnique tessTechnique = TessTriangleTechnique.DrawElement;
if (container.IsSingleFigure)
{
Figure figure = container._figure;
if (rdoTessSGI.Checked)
{
//coords of tess triangles
switch (tessTechnique)
{
case TessTriangleTechnique.DrawArray:
{
DrawTessTriangles(painter, figure.GetAreaTess(_tessTool, _tessTool.WindingRuleType, TessTriangleTechnique.DrawArray));
}
break;
case TessTriangleTechnique.DrawElement:
{
float[] tessArea = figure.GetAreaTess(_tessTool, _tessTool.WindingRuleType, TessTriangleTechnique.DrawElement);
ushort[] index = figure.GetAreaIndexList();
DrawTessTriangles(painter, tessArea, index);
}
break;
}
}
else
{
if (chkShowContourAnalysis.Checked)
{
ContourAnalyzer analyzer1 = new ContourAnalyzer();
IntermediateOutline outline = analyzer1.CreateIntermediateOutline(v1);
var dbugVisualizer = new PixelFarm.GlyphDebugContourVisualizer();
dbugVisualizer.SetPainter(painter);
dbugVisualizer.Scale = _typeface.CalculateScaleToPixelFromPointSize(fontSizeInPts);
dbugVisualizer.WalkCentroidLine(outline);
}
else
{
//Poly2Tri
List <Poly2Tri.Polygon> polygons = figure.GetTrianglulatedArea(false);
//draw polygon
painter.StrokeColor = Color.Red;
DrawPoly2TriPolygon(painter, polygons);
}
}
}
else
{
MultiFigures multiFig = container._multiFig;
if (rdoTessSGI.Checked)
{
switch (tessTechnique)
{
case TessTriangleTechnique.DrawArray:
{
DrawTessTriangles(painter, multiFig.GetAreaTess(_tessTool, _tessTool.WindingRuleType, TessTriangleTechnique.DrawArray));
}
break;
case TessTriangleTechnique.DrawElement:
{
float[] tessArea = multiFig.GetAreaTess(_tessTool, _tessTool.WindingRuleType, TessTriangleTechnique.DrawElement);
ushort[] index = multiFig.GetAreaIndexList();
DrawTessTriangles(painter, tessArea, index);
}
break;
}
}
else
{
if (chkShowContourAnalysis.Checked)
{
ContourAnalyzer analyzer1 = new ContourAnalyzer();
IntermediateOutline outline = analyzer1.CreateIntermediateOutline(v1);
var dbugVisualizer = new PixelFarm.GlyphDebugContourVisualizer();
dbugVisualizer.SetPainter(painter);
dbugVisualizer.Scale = _typeface.CalculateScaleToPixelFromPointSize(fontSizeInPts);
dbugVisualizer.WalkCentroidLine(outline);
}
else
{
List <Poly2Tri.Polygon> polygons = multiFig.GetTrianglulatedArea(false);
painter.StrokeColor = Color.Red;
DrawPoly2TriPolygon(painter, polygons);
}
}
}
}
painter.StrokeColor = prevColor;
//-------------
//tess
//if (rdoTessSGI.Checked)
//{
// //SGI Tess Lib
// if (!_tessTool.TessPolygon(polygon1, _contourEnds))
// {
// return;
// }
// //1.
// List<ushort> indexList = _tessTool.TessIndexList;
// //2.
// List<TessVertex2d> tempVertexList = _tessTool.TempVertexList;
// //3.
// int vertexCount = indexList.Count;
// //-----------------------------
// int orgVertexCount = polygon1.Length / 2;
// float[] vtx = new float[vertexCount * 2];//***
// int n = 0;
// for (int p = 0; p < vertexCount; ++p)
// {
// ushort index = indexList[p];
// if (index >= orgVertexCount)
// {
// //extra coord (newly created)
// TessVertex2d extraVertex = tempVertexList[index - orgVertexCount];
// vtx[n] = (float)extraVertex.x;
// vtx[n + 1] = (float)extraVertex.y;
// }
// else
// {
// //original corrd
// vtx[n] = (float)polygon1[index * 2];
// vtx[n + 1] = (float)polygon1[(index * 2) + 1];
// }
// n += 2;
// }
// //-----------------------------
// //draw tess result
// int j = vtx.Length;
// for (int i = 0; i < j;)
// {
// var p0 = new PointF(vtx[i], vtx[i + 1]);
// var p1 = new PointF(vtx[i + 2], vtx[i + 3]);
// var p2 = new PointF(vtx[i + 4], vtx[i + 5]);
// _g.DrawLine(Pens.Red, p0, p1);
// _g.DrawLine(Pens.Red, p1, p2);
// _g.DrawLine(Pens.Red, p2, p0);
// i += 6;
// }
//}
//else
//{
// List<Poly2Tri.Polygon> outputPolygons = new List<Poly2Tri.Polygon>();
// Poly2TriExampleHelper.Triangulate(polygon1, contourEndIndices, flipYAxis, outputPolygons);
// foreach (Poly2Tri.Polygon polygon in outputPolygons)
// {
// foreach (Poly2Tri.DelaunayTriangle tri in polygon.Triangles)
// {
// Poly2Tri.TriangulationPoint p0 = tri.P0;
// Poly2Tri.TriangulationPoint p1 = tri.P1;
// Poly2Tri.TriangulationPoint p2 = tri.P2;
// _g.DrawLine(Pens.Red, (float)p0.X, (float)p0.Y, (float)p1.X, (float)p1.Y);
// _g.DrawLine(Pens.Red, (float)p1.X, (float)p1.Y, (float)p2.X, (float)p2.Y);
// _g.DrawLine(Pens.Red, (float)p2.X, (float)p2.Y, (float)p0.X, (float)p0.Y);
// }
// }
//}
}
