public static PointF GetWorldPointF(this IConvertWorldView t, PointF viewLocation)
{
Matrix matrix = t.GetWorldToViewMatrix();
matrix.Invert();
return(matrix.TransformPoint(viewLocation));
}
public ModifiedObjectService(IModifiledObjectInterface @interface, IConvertWorldView convertWorldView)
{
this.@interface = @interface;
_convertWorldView = convertWorldView;
_mouseManager = new MouseMovingBase();
keyMoveXDistance = 0;
keyMoveYDistance = 0;
}
public static Rectangle GetViewRect(this IConvertWorldView t, RectangleF worldRect)
{
PointF pt = worldRect.Location;
PointF ptRB = new PointF(worldRect.Right, worldRect.Bottom);
PointF[] pts = new PointF[] { pt, ptRB };
Matrix matrix = t.GetWorldToViewMatrix();
matrix.TransformPoints(pts);
return(Rectangle.FromLTRB((int)pts[0].X, (int)pts[0].Y, (int)pts[1].X, (int)pts[1].Y).NormalizeRect());
}
public virtual void RenderViewport(Graphics g, IConvertWorldView convertWorldView)
{
switch (Canvas.CanvasState)
{
case CanvasState.NONE:
RenderNoneCanvas(g);
break;
case CanvasState.DRAWABLE:
OnPaint(g, convertWorldView);
break;
}
}
public override void OnPaint(Graphics graphics, IConvertWorldView convertWorldView)
{
InvalidateWorldViewport();
if (WorldViewGroup.CanvasViewport.Width * WorldViewGroup.CanvasViewport.Height == 0)
{
graphics.Clear(Color.FromArgb(207, 207, 207));
return;
}
Color borderColor = Color.FromArgb(194, 194, 194);
var realSize = WorldViewGroup.CanvasViewport.RealSize;
Image worldBitmap = new Bitmap((int)realSize.Width, (int)realSize.Height);
graphics.Clear(Color.FromArgb(207, 207, 207));
RectangleF interserctRect = GetInterserctRect();
PointF renderLocation = new PointF(PaddingLeft, PaddingTop);
renderLocation = CanvasViewport.GetWorldToViewLocation(renderLocation);
renderLocation.X = (renderLocation.X).GreaterOrEqualThan(0);
renderLocation.Y = (renderLocation.Y).GreaterOrEqualThan(0);
if (TileRender != null)
{
Image tileImage = TileRender.GetImage(Graphics.FromImage(worldBitmap), graphics, WorldViewGroup.CanvasViewport);
int cBegin = (int)WorldViewGroup.CanvasViewport.X / TileWidth;
int rBegin = (int)WorldViewGroup.CanvasViewport.Y / TileHeight;
RectangleF rectCrop = new RectangleF(WorldViewGroup.CanvasViewport.X - cBegin * TileWidth - 0.5f,
WorldViewGroup.CanvasViewport.Y - rBegin * TileHeight - 0.5f,
WorldViewGroup.CanvasViewport.Width, WorldViewGroup.CanvasViewport.Height);
graphics.DrawImageFromOtherImage(tileImage, rectCrop,
new RectangleF(renderLocation, interserctRect.Size));
}
WorldViewGroup.OnPaint(Graphics.FromImage(worldBitmap), convertWorldView);
graphics.DrawImageFromOtherImage(worldBitmap, new RectangleF(0, 0, worldBitmap.Width, worldBitmap.Height),
new RectangleF(renderLocation, interserctRect.Size));
PointF firstCorner = new PointF(PaddingLeft, PaddingTop);
PointF lastCorner = new PointF(PaddingLeft + WorldViewGroup.EditorCanvas.Width * WorldViewGroup.CanvasViewport.Scale,
PaddingTop + WorldViewGroup.EditorCanvas.Height * WorldViewGroup.CanvasViewport.Scale);
firstCorner = CanvasViewport.GetWorldToViewLocation(firstCorner);
lastCorner = CanvasViewport.GetWorldToViewLocation(lastCorner);
RectangleF r = RectangleF.FromLTRB(firstCorner.X, firstCorner.Y, lastCorner.X, lastCorner.Y);
graphics.DrawRectangle(new Pen(borderColor, 1), r.X, r.Y, r.Width, r.Height);
}
private void DrawQuadnode(QuadNode node, Graphics viewGraphics, IConvertWorldView convertWorldView)
{
Rectangle locationRect = new Rectangle(node.X, node.Y, node.Width, node.Height);
locationRect = convertWorldView.GetViewRect(locationRect);
viewGraphics.DrawRectangle(new Pen(@interface.QuadtreeBorderColor, 2), locationRect);
if (node.TL != null)
{
DrawQuadnode(node.TL, viewGraphics, convertWorldView);
DrawQuadnode(node.TR, viewGraphics, convertWorldView);
DrawQuadnode(node.BL, viewGraphics, convertWorldView);
DrawQuadnode(node.BR, viewGraphics, convertWorldView);
}
}
public virtual void OnPaint(Graphics g, IConvertWorldView convertWorldView)
{
Image backBuffer = new Bitmap((int)Viewport.Width, (int)Viewport.Height);
Canvas.OnPaint(Graphics.FromImage(backBuffer), Viewport);
var realRect = new RectangleF(PointF.Empty, Viewport.RealSize);
var viewRect = new RectangleF(PointF.Empty, new SizeF(Viewport.Width, Viewport.Height));
g.DrawImageFromOtherImage(backBuffer, viewRect, realRect);
var gridRect = new RectangleF((Viewport.X * Viewport.Scale), (Viewport.Y * Viewport.Scale), Viewport.Width * Viewport.Scale, Viewport.Height * Viewport.Scale);
RenderPixelRuler.OnPaint(g, gridRect, Viewport.Scale, Viewport.Scale);
if (IsRenderGrid && TilesModelParent != null && convertWorldView != null)
{
RenderGrid.OnPaint(g, gridRect, (TilesModelParent.TileWidth * Viewport.Scale),
(TilesModelParent.TileHeight * Viewport.Scale)
);
}
Canvas.OnPaintInView(g, Viewport, convertWorldView);
backBuffer.Dispose();
}
public AddTileService(AddTileInterface @interface, IConvertWorldView convertWorldView)
{
this.@interface = @interface;
_convertWorldView = convertWorldView;
}
public void OnPaintInView(Graphics viewGraphics, CanvasViewport viewViewport, IConvertWorldView convertWorldView)
{
foreach (var index in @interface.TilesIndex)
{
int col = index % @interface.TilesheetColumns;
int row = index / @interface.TilesheetColumns;
Rectangle rect = new Rectangle(col * @interface.TileWidth, row * @interface.TileHeight, @interface.TileWidth, @interface.TileHeight);
Point viewLocation = viewViewport.GetWorldToViewLocation(new Point(col * @interface.TileWidth, row * @interface.TileHeight)).ToPoint();
Size sizeValue = new Size((int)(@interface.TileWidth * viewViewport.Scale), (int)(@interface.TileHeight * viewViewport.Scale));
var viewRect = new Rectangle(viewLocation, sizeValue);
viewGraphics.DrawRectangle(new Pen(@interface.TileObjectColor, 2), viewRect);
}
}
public void OnPaintInView(Graphics viewGraphics, CanvasViewport viewViewport, IConvertWorldView convertWorldView)
{
Objects.ForEach(x => x.OnPaintInView(viewGraphics, viewViewport, convertWorldView));
if (Selected)
{
DrawSelected(viewGraphics, viewViewport, convertWorldView);
}
}
public void OnPaintInView(Graphics viewGraphics, CanvasViewport viewViewport, IConvertWorldView convertWorldView)
{
if ([email protected])
{
return;
}
var tileRenderParent = @interface.TilesModel;
int tileWidth = tileRenderParent.TileWidth;
int tileHeight = tileRenderParent.TileHeight;
int tileRows = tileRenderParent.TileRows;
int tileColumns = tileRenderParent.TileColumns;
int tileSheetColumns = tileRenderParent.TilesheetColumns;
viewGraphics.FillRectangle(new SolidBrush(Color.FromArgb(50, 30, 30, 30)),
viewGraphics.ClipBounds);
int rowIndex = @interface.SelectTileFromWorldLocation.Y / @interface.TileHeight;
int colIndex = @interface.SelectTileFromWorldLocation.X / @interface.TileWidth;
if (rowIndex < 0 || rowIndex >= tileRenderParent.TileRows ||
colIndex < 0 || colIndex >= tileRenderParent.TileColumns
)
{
return;
}
int tileIndex = @interface.TilesModel.Matrix[rowIndex, colIndex];
RectangleF cropedRect = new RectangleF((tileIndex % tileSheetColumns) * tileWidth,
(tileIndex / tileSheetColumns) * tileHeight, tileWidth, tileHeight
);
var viewRect = new Rectangle(@interface.TileWidth * (@interface.SelectTileFromWorldLocation.X / @interface.TileWidth),
@interface.TileHeight * (@interface.SelectTileFromWorldLocation.Y / @interface.TileHeight),
@interface.TileWidth,
@interface.TileHeight);
viewRect = convertWorldView.GetViewRect(viewRect);
viewGraphics.DrawImageFromOtherImage(tileRenderParent.Tilesheet
, cropedRect, viewRect);
}
public void OnPaintInView(Graphics viewGraphics, CanvasViewport viewport, IConvertWorldView convertWorldView)
{
DrawCurrentTile(viewGraphics, viewport);
DrawSelectedTile(viewGraphics, viewport);
}
public void OnPaintInView(Graphics viewGraphics, CanvasViewport viewViewport, IConvertWorldView convertWorldView)
{
if (@interface.FocusedObjectCategory != null)
{
if (@interface.FocusedObjectCategory.TreeViewObject.TreeViewObjectType == Controls.TreeViewControl.TreeViewObjectType.CategoryRectangle)
{
return;
}
RectangleF locationRect = new RectangleF(@interface.FocusedObjectCategoryLocation,
@interface.FocusedObjectCategory.ObjectCategoryImage.Size
);
locationRect = convertWorldView.GetViewRect(locationRect);
viewGraphics.DrawImageFromOtherImage(@interface.FocusedObjectCategory.ObjectCategoryImage,
new RectangleF(Point.Empty, @interface.FocusedObjectCategory.ObjectCategoryImage.Size),
locationRect);
}
}
public static PointF GetViewPointF(this IConvertWorldView t, PointF worldLocation)
{
Matrix matrix = t.GetWorldToViewMatrix();
return(matrix.TransformPoint(worldLocation));
}
public virtual void OnPaint(Graphics graphics, IConvertWorldView convertWorldView)
{
EditorCanvasRender.RenderViewport(graphics, convertWorldView);
}
public void OnPaintInView(Graphics viewGraphics, CanvasViewport viewViewport, IConvertWorldView convertWorldView)
{
foreach (var obj in DrawableObjects)
{
obj.OnPaintInView(viewGraphics, viewViewport, convertWorldView);
}
}
public SelectTileFromWorldService(IConvertWorldView convertWorldView, SelectTileFromWorldServiceInterface @interface)
{
_convertWorldView = convertWorldView;
this.@interface = @interface;
}
public void OnPaintInView(Graphics viewGraphics, CanvasViewport viewViewport, IConvertWorldView convertWorldView)
{
if (@interface.RootNode == null)
{
return;
}
DrawQuadnode(@interface.RootNode, viewGraphics, convertWorldView);
}
public static Point GetWorldPoint(this IConvertWorldView t, PointF viewLocation)
{
PointF p = t.GetWorldPointF(viewLocation);
return(new Point((int)p.X, (int)p.Y));
}
public CreateObjectService(ICreateObject @interface, IConvertWorldView convertWorldView)
{
this.@interface = @interface;
_convertWorldView = convertWorldView;
_mouseMoving = new MouseMovingBase();
}
public void DrawSelected(Graphics g, CanvasViewport viewport, IConvertWorldView convertWorldView)
{
Objects.ForEach(x => x.DrawSelected(g, viewport, convertWorldView));
}
public void OnPaintInView(Graphics viewGraphics, CanvasViewport viewViewport, IConvertWorldView convertWorldView)
{
int selectedTileIndex = @interface.SelectedTileIndex;
if (@interface.SelectedTileIndex == -1)
{
return;
}
int nRows = @interface.TilesModel.TileRows;
int nColumns = @interface.TilesModel.TileColumns;
int tileWidth = @interface.TilesModel.TileWidth;
int tileHeight = @interface.TilesModel.TileHeight;
var worldMatrix = @interface.TilesModel.Matrix;
Point prepareLocation = @interface.TilePrepareAddLocation;
for (int rIndex = 0; rIndex < nRows; rIndex++)
{
for (int cIndex = 0; cIndex < nColumns; cIndex++)
{
if (worldMatrix[rIndex, cIndex] == @interface.SelectedTileIndex)
{
Rectangle locationRect = new Rectangle(cIndex * tileWidth, rIndex * tileHeight, tileWidth, tileHeight);
locationRect = convertWorldView.GetViewRect(locationRect);
viewGraphics.DrawRectangle(new Pen(@interface.SelectedTileInWorldColor, 2),
locationRect);
viewGraphics.FillRectangle(new SolidBrush(Color.FromArgb(50, @interface.SelectedTileInWorldColor.R, @interface.SelectedTileInWorldColor.G, @interface.SelectedTileInWorldColor.B)), locationRect);
}
}
}
if (@interface.CanAddTile)
{
int rIndex = prepareLocation.Y / tileHeight;
int cIndex = prepareLocation.X / tileWidth;
Rectangle locationRect = new Rectangle(cIndex * tileWidth, rIndex * tileHeight, tileWidth, tileHeight);
locationRect = convertWorldView.GetViewRect(locationRect);
viewGraphics.DrawRectangle(new Pen(@interface.SelectedTileInWorldColor, 2),
locationRect);
var cropRect = new Rectangle(tileWidth * (selectedTileIndex % @interface.TilesModel.TilesheetColumns),
tileHeight * (selectedTileIndex / @interface.TilesModel.TilesheetColumns), tileWidth, tileHeight
);
viewGraphics.DrawImageFromOtherImage(@interface.TilesModel.Tilesheet, cropRect, locationRect);
}
}
public void OnPaintInView(Graphics viewGraphics, CanvasViewport viewViewport, IConvertWorldView convertWorldView)
{
if ([email protected])
{
return;
}
Rectangle locationRect = convertWorldView.GetViewRect(@interface.SelectingRect);
viewGraphics.DrawRectangle(new Pen(@interface.SelectingColorBorder, 1), locationRect);
viewGraphics.FillRectangle(new SolidBrush(@interface.SelectingBackColor), locationRect);
}
