public void PointAddition()
{
//var calculator = new CalculatorInt32();
var p1 = new PointInt32(1, 1);
var p2 = new PointInt32(2, 2);
//var p3 = calculator.AddPoints(p1, p2);
var p3 = p1 + p2;
Assert.AreEqual(p3.X, 3);
Assert.AreEqual(p3.Y, 3);
}
public float GetCost(ITileMap map, IMover mover, PointInt32 point, PointInt32 start, PointInt32 target)
{
float dx = target.X - point.X;
float dy = target.Y - point.Y;
return((float)System.Math.Sqrt((double)((dx * dx) + (dy * dy))) * m_Coefficient);
}
protected override void OnRender(ISurface <ColorBgra> dstContent, ISurface <ColorAlpha8> dstMask, PointInt32 renderOffset)
{
base.ThrowIfCancellationRequested();
this.renderer.Render(dstContent, renderOffset);
}
private unsafe void RenderTileWorkItem(PointInt32 tileOffset)
{
IBitmap <ColorPbgra32> bitmap;
bool isCancelled = false;
bool flag = false;
Exception error = null;
isCancelled |= this.IsTileRenderingCancelled(tileOffset);
if (isCancelled)
{
bitmap = null;
}
else
{
RectInt32 tileSourceRect = this.tileMathHelper.GetTileSourceRect(tileOffset);
SizeInt32 tileBufferSize = this.GetTileBufferSize(tileOffset);
bitmap = RetryManager.Eval <IBitmap <ColorPbgra32> >(3, () => BitmapAllocator.Pbgra32.Allocate(tileBufferSize, AllocationOptions.Default), delegate(Exception _) {
CleanupManager.RequestCleanup();
Thread.Sleep(200);
CleanupManager.WaitForPendingCleanup();
}, delegate(AggregateException ex) {
throw new AggregateException($"could not allocate a bitmap of size {tileBufferSize.Width} x {tileBufferSize.Height}", ex).Flatten();
});
if (this.source != null)
{
try
{
isCancelled |= this.IsTileRenderingCancelled(tileOffset);
if (!isCancelled)
{
using (IBitmapLock <ColorPbgra32> @lock = bitmap.Lock <ColorPbgra32>(BitmapLockOptions.ReadWrite))
{
if (this.mipLevel == 0)
{
this.source.CopyPixels(new RectInt32?(tileSourceRect), @lock);
RenderingKernels.ConvertBgra32ToPbgra32((uint *)@lock.Scan0, tileBufferSize.Width, tileBufferSize.Height, @lock.Stride);
flag = true;
}
else
{
BitmapInterpolationMode linear;
if (!this.isHighQuality)
{
linear = BitmapInterpolationMode.Linear;
}
else if (this.mipLevel == 1)
{
linear = BitmapInterpolationMode.Linear;
}
else
{
linear = BitmapInterpolationMode.Fant;
}
IImagingFactory instance = ImagingFactory.Instance;
ICancellationToken cancelToken = CancellationTokenUtil.Create((Func <bool>)(() => (isCancelled | this.IsTileRenderingCancelled(tileOffset))));
int copyHeightLog2 = Math.Max(3, 7 - this.mipLevel);
using (ClippedBitmapSource <ColorBgra32> source2 = new ClippedBitmapSource <ColorBgra32>(this.source, tileSourceRect))
{
using (CancellableBitmapSource <ColorBgra32> source3 = new CancellableBitmapSource <ColorBgra32>(source2, r => this.tileMathHelper.EnumerateTilesClippedToSourceRect(r), null, cancelToken))
{
using (IBitmapSource <ColorPbgra32> source4 = CreateBufferedTileScaler(instance, source3, tileBufferSize.Width, tileBufferSize.Height, linear))
{
using (CancellableBitmapSource <ColorPbgra32> source5 = new CancellableBitmapSource <ColorPbgra32>(source4, r => TileRectSplitter(r, ((int)1) << copyHeightLog2), null, cancelToken))
{
try
{
source5.CopyPixels <ColorPbgra32>(@lock);
flag = true;
}
catch (OperationCanceledException exception2)
{
error = exception2;
isCancelled = true;
}
catch (Exception exception3)
{
error = exception3;
throw;
}
}
}
}
}
}
isCancelled |= this.IsTileRenderingCancelled(tileOffset);
if (isCancelled)
{
flag = false;
}
}
if (!flag)
{
DisposableUtil.Free <IBitmap <ColorPbgra32> >(ref bitmap);
}
}
}
catch (OperationCanceledException exception4)
{
error = exception4;
isCancelled = true;
}
catch (Exception exception5)
{
error = exception5;
isCancelled |= this.IsTileRenderingCancelled(tileOffset);
if (!isCancelled)
{
using (IDrawingContext context = DrawingContext.FromBitmap(bitmap, FactorySource.PerThread))
{
context.Clear(new ColorRgba128Float?((ColorRgba128Float)Colors.White));
string text = exception5.ToString();
using (ISystemFonts fonts = new SystemFonts(true))
{
TextLayout textLayout = UIText.CreateLayout(context, text, fonts.Caption, null, HotkeyRenderMode.Ignore, (double)bitmap.Size.Width, 65535.0);
textLayout.FontSize *= 0.6;
textLayout.WordWrapping = WordWrapping.Wrap;
context.DrawTextLayout(PointDouble.Zero, textLayout, SolidColorBrushCache.Get((ColorRgba128Float)Colors.Black), DrawTextOptions.None);
}
}
flag = true;
}
}
}
}
isCancelled |= this.IsTileRenderingCancelled(tileOffset);
if (isCancelled)
{
DisposableUtil.Free <IBitmap <ColorPbgra32> >(ref bitmap);
}
RenderedTileInfo info = new RenderedTileInfo(bitmap, !isCancelled && (bitmap > null), error);
if (!this.tilesRenderedQueue.TryEnqueue(tileOffset, info))
{
ExceptionUtil.ThrowInternalErrorException("Could not enqueue to this.tilesRenderedQueue");
}
if (Interlocked.Exchange(ref this.isProcessTileRenderedQueueQueued, 1) == 0)
{
this.syncContext.Post(this.processTileRenderedQueueCallback);
}
}
public bool IsTileValid(PointInt32 tileOffset) => this.IsTileValid(tileOffset.X, tileOffset.Y);
private SizeInt32 GetTileBufferSize(PointInt32 tileOffset) => this.GetTileBufferSize(tileOffset.X, tileOffset.Y);
private TileData GetTileData(PointInt32 tileOffset) => this.tileOffsetToTileDataMap.GetOrAdd(tileOffset, to => new TileData(to));
private bool PerformActionImpl()
{
PointInt32 num2;
RectInt32 num3;
if (this.clipData == null)
{
try
{
using (new WaitCursorChanger(this.documentWorkspace))
{
CleanupManager.RequestCleanup();
this.clipData = PdnClipboard.GetDataObject();
}
}
catch (OutOfMemoryException exception)
{
ExceptionDialog.ShowErrorDialog(this.documentWorkspace, PdnResources.GetString("PasteAction.Error.OutOfMemory"), exception);
return(false);
}
catch (Exception exception2)
{
ExceptionDialog.ShowErrorDialog(this.documentWorkspace, PdnResources.GetString("PasteAction.Error.TransferFromClipboard"), exception2);
return(false);
}
}
bool handled = false;
if (this.documentWorkspace.Tool != null)
{
this.documentWorkspace.Tool.PerformPaste(this.clipData, out handled);
}
if (handled)
{
return(true);
}
if (this.maskedSurface == null)
{
try
{
using (new WaitCursorChanger(this.documentWorkspace))
{
this.maskedSurface = ClipboardUtil.TryGetClipboardImage(this.documentWorkspace, this.clipData);
}
}
catch (OutOfMemoryException exception3)
{
ExceptionDialog.ShowErrorDialog(this.documentWorkspace, PdnResources.GetString("PasteAction.Error.OutOfMemory"), exception3);
return(false);
}
catch (Exception exception4)
{
ExceptionDialog.ShowErrorDialog(this.documentWorkspace, PdnResources.GetString("PasteAction.Error.TransferFromClipboard"), exception4);
return(false);
}
}
if (this.maskedSurface == null)
{
MessageBoxUtil.ErrorBox(this.documentWorkspace, PdnResources.GetString("PasteAction.Error.NoImage"));
return(false);
}
RectInt32 cachedGeometryMaskScansBounds = this.maskedSurface.GetCachedGeometryMaskScansBounds();
if ((cachedGeometryMaskScansBounds.Width > this.documentWorkspace.Document.Width) || (cachedGeometryMaskScansBounds.Height > this.documentWorkspace.Document.Height))
{
Surface surface;
try
{
using (new WaitCursorChanger(this.documentWorkspace))
{
surface = CreateThumbnail(this.maskedSurface);
}
}
catch (OutOfMemoryException)
{
surface = null;
}
DialogResult result = ShowExpandCanvasTaskDialog(this.documentWorkspace, surface);
int activeLayerIndex = this.documentWorkspace.ActiveLayerIndex;
ColorBgra background = this.documentWorkspace.ToolSettings.SecondaryColor.Value;
if (result != DialogResult.Cancel)
{
if (result != DialogResult.Yes)
{
if (result != DialogResult.No)
{
throw ExceptionUtil.InvalidEnumArgumentException <DialogResult>(result, "dr");
}
goto Label_031D;
}
using (new PushNullToolMode(this.documentWorkspace))
{
int width = Math.Max(cachedGeometryMaskScansBounds.Width, this.documentWorkspace.Document.Width);
Size newSize = new Size(width, Math.Max(cachedGeometryMaskScansBounds.Height, this.documentWorkspace.Document.Height));
Document document = CanvasSizeAction.ResizeDocument(this.documentWorkspace.Document, newSize, AnchorEdge.TopLeft, background);
if (document == null)
{
return(false);
}
SelectionHistoryMemento memento = new SelectionHistoryMemento(null, null, this.documentWorkspace);
ReplaceDocumentHistoryMemento memento2 = new ReplaceDocumentHistoryMemento(CanvasSizeAction.StaticName, CanvasSizeAction.StaticImage, this.documentWorkspace);
this.documentWorkspace.Document = document;
HistoryMemento[] actions = new HistoryMemento[] { memento, memento2 };
CompoundHistoryMemento memento3 = new CompoundHistoryMemento(CanvasSizeAction.StaticName, CanvasSizeAction.StaticImage, actions);
this.documentWorkspace.History.PushNewMemento(memento3);
this.documentWorkspace.ActiveLayer = (Layer)this.documentWorkspace.Document.Layers[activeLayerIndex];
goto Label_031D;
}
}
return(false);
}
Label_031D:
num3 = this.documentWorkspace.Document.Bounds();
RectDouble visibleDocumentRect = this.documentWorkspace.VisibleDocumentRect;
RectInt32? nullable = visibleDocumentRect.Int32Inset();
RectDouble num5 = nullable.HasValue ? ((RectDouble)nullable.Value) : visibleDocumentRect;
RectInt32 num6 = num5.Int32Bound;
if (num5.Contains(cachedGeometryMaskScansBounds))
{
num2 = new PointInt32(0, 0);
}
else
{
int num12;
int num13;
int num16;
int num17;
if (cachedGeometryMaskScansBounds.X < num5.Left)
{
num12 = -cachedGeometryMaskScansBounds.X + num6.X;
}
else if (cachedGeometryMaskScansBounds.Right > num6.Right)
{
num12 = (-cachedGeometryMaskScansBounds.X + num6.Right) - cachedGeometryMaskScansBounds.Width;
}
else
{
num12 = 0;
}
if (cachedGeometryMaskScansBounds.Y < num5.Top)
{
num13 = -cachedGeometryMaskScansBounds.Y + num6.Y;
}
else if (cachedGeometryMaskScansBounds.Bottom > num6.Bottom)
{
num13 = (-cachedGeometryMaskScansBounds.Y + num6.Bottom) - cachedGeometryMaskScansBounds.Height;
}
else
{
num13 = 0;
}
PointInt32 num14 = new PointInt32(num12, num13);
RectInt32 num15 = new RectInt32(cachedGeometryMaskScansBounds.X + num14.X, cachedGeometryMaskScansBounds.Y + num14.Y, cachedGeometryMaskScansBounds.Width, cachedGeometryMaskScansBounds.Height);
if (num15.X < 0)
{
num16 = num12 - num15.X;
}
else
{
num16 = num12;
}
if (num15.Y < 0)
{
num17 = num13 - num15.Y;
}
else
{
num17 = num13;
}
PointInt32 num18 = new PointInt32(num16, num17);
RectInt32 rect = new RectInt32(cachedGeometryMaskScansBounds.X + num18.X, cachedGeometryMaskScansBounds.Y + num18.Y, cachedGeometryMaskScansBounds.Width, cachedGeometryMaskScansBounds.Height);
if (num3.Contains(rect))
{
num2 = num18;
}
else
{
PointInt32 num20 = num18;
if (rect.Right > num3.Right)
{
int num21 = rect.Right - num3.Right;
int num22 = Math.Min(num21, rect.Left);
num20.X -= num22;
}
if (rect.Bottom > num3.Bottom)
{
int num23 = rect.Bottom - num3.Bottom;
int num24 = Math.Min(num23, rect.Top);
num20.Y -= num24;
}
num2 = num20;
}
}
RectInt32 b = this.documentWorkspace.VisibleDocumentRect.Int32Bound;
RectInt32 a = new RectInt32(cachedGeometryMaskScansBounds.X + num2.X, cachedGeometryMaskScansBounds.Y + num2.Y, cachedGeometryMaskScansBounds.Width, cachedGeometryMaskScansBounds.Height);
bool hasZeroArea = RectInt32.Intersect(a, b).HasZeroArea;
MoveTool.BeginPaste(this.documentWorkspace, PdnResources.GetString("CommonAction.Paste"), PdnResources.GetImageResource("Icons.MenuEditPasteIcon.png"), this.maskedSurface.SurfaceReadOnly, this.maskedSurface.GeometryMask, num2);
if (hasZeroArea)
{
PointInt32 num25 = new PointInt32(b.Left + (b.Width / 2), b.Top + (b.Height / 2));
PointInt32 num26 = new PointInt32(a.Left + (a.Width / 2), a.Top + (a.Height / 2));
SizeInt32 num27 = new SizeInt32(num26.X - num25.X, num26.Y - num25.Y);
PointDouble documentScrollPosition = this.documentWorkspace.DocumentScrollPosition;
PointDouble num29 = new PointDouble(documentScrollPosition.X + num27.Width, documentScrollPosition.Y + num27.Height);
this.documentWorkspace.DocumentScrollPosition = num29;
}
return(true);
}
protected override void OnRenderContent(ISurface <ColorBgra> dstContent, PointInt32 renderOffset)
{
this.brushRenderer.Render(dstContent, renderOffset);
}
private void DrawLine(PointInt32 endPoint)
{
foreach (PointInt32 p in WorldRenderer.DrawLine(_startPoint, endPoint))
{
if (_selection.SelectionVisibility == Visibility.Visible)
{
// if selection is active, and point is not inside, skip point
if (!_selection.Rectangle.Contains(p))
{
continue;
}
}
// center
int x0 = p.X - _properties.Offset.X;
int y0 = p.Y - _properties.Offset.Y;
if (_properties.BrushShape == ToolBrushShape.Square)
{
if (_properties.IsOutline)
{
TilePicker outline = Utility.DeepCopy(_tilePicker);
outline.Wall.IsActive = false;
// eraise a center section
TilePicker eraser = Utility.DeepCopy(_tilePicker);
eraser.IsEraser = true;
eraser.Wall.IsActive = false; // don't erase the wall for the interrior
TilePicker wall = Utility.DeepCopy(_tilePicker);
wall.Tile.IsActive = false;
var interior = new Int32Rect(x0 + _properties.OutlineThickness,
y0 + _properties.OutlineThickness,
_properties.Width - (_properties.OutlineThickness * 2),
_properties.Height - (_properties.OutlineThickness * 2));
// Erase center
FillRectangle(interior, ref eraser);
// Fill center
if (wall.Wall.IsActive)
{
FillRectangle(interior, ref wall);
}
// Draw outline
if (outline.Tile.IsActive)
{
for (int i = 0; i < _properties.OutlineThickness; i++)
{
DrawRectangle(new Int32Rect(x0 + i, y0 + i, _properties.Width - (i * 2) - 1, _properties.Height - (i * 2) - 1), ref outline);
}
}
}
else
{
FillRectangle(new Int32Rect(x0, y0, _properties.Width, _properties.Height), ref _tilePicker);
}
}
else if (_properties.BrushShape == ToolBrushShape.Round)
{
if (_properties.IsOutline)
{
TilePicker outline = Utility.DeepCopy(_tilePicker);
outline.Wall.IsActive = false;
// eraise a center section
TilePicker eraser = Utility.DeepCopy(_tilePicker);
eraser.IsEraser = true;
eraser.Wall.IsActive = false; // don't erase the wall for the interrior
TilePicker wall = Utility.DeepCopy(_tilePicker);
wall.Tile.IsActive = false;
// Draw outline
if (outline.Tile.IsActive)
{
FillEllipse(x0, y0, x0 + _properties.Width, y0 + _properties.Height, ref outline);
}
// Erase center
FillEllipse(x0 + _properties.OutlineThickness,
y0 + _properties.OutlineThickness,
x0 + _properties.Width - _properties.OutlineThickness,
y0 + _properties.Height - _properties.OutlineThickness, ref eraser);
// Fill center
if (wall.Wall.IsActive)
{
FillEllipse(x0 + _properties.OutlineThickness,
y0 + _properties.OutlineThickness,
x0 + _properties.Width - _properties.OutlineThickness,
y0 + _properties.Height - _properties.OutlineThickness, ref wall);
}
eraser = null;
}
else
{
FillEllipse(x0, y0, x0 + _properties.Width, y0 + _properties.Height, ref _tilePicker);
}
}
if (_properties.IsOutline)
{
_renderer.UpdateWorldImage(new Int32Rect(x0, y0, _properties.Width + 1, _properties.Height + 1));
}
}
}
public override void ClipViewPosition(Point p)
{
if (ViewPositionLock != null)
{
p.x = ViewPositionLock.x;
p.y = ViewPositionLock.y;
return;
}
var Walls = this.Map.WallMap;
if (Walls == null)
return;
const double PlayerRadiusMargin = 0.3;
var fPlayerX = p.x;
var fPlayerY = p.y;
var c = new PointInt32
{
X = (int)Math.Floor(p.x),
Y = (int)Math.Floor(p.y)
};
var TILE_SIZE = 1.0;
var PositionInWall =
new Point
{
x = fPlayerX % TILE_SIZE,
y = fPlayerY % TILE_SIZE
};
var TileTop = Walls[c.X, c.Y - 1];
var TileLeft = Walls[c.X - 1, c.Y];
var TileRight = Walls[c.X + 1, c.Y];
var TileBottom = Walls[c.X, c.Y + 1];
var CurrentMapTile = Walls[c.X, c.Y];
if (CurrentMapTile != 0)
{
// we are inside a wall
// push us out of there
#region Dia
var A = PositionInWall.x > PositionInWall.y;
var B = PositionInWall.x > (TILE_SIZE - PositionInWall.y);
var DiaClipLeft = !A && !B;
var DiaClipRight = A && B;
var DiaClipTop = A && !B;
var DiaClipBottom = !A && B;
#endregion
#region Alt
var C = PositionInWall.x > (TILE_SIZE / 2);
var D = PositionInWall.y > (TILE_SIZE / 2);
var AltClipTopLeft = !C && !D;
var AltClipBottomLeft = !C && D;
var AltClipTopRight = C && !D;
var AltClipBottomRight = C && D;
#endregion
var ClipLeft = DiaClipLeft;
if (TileTop != 0) ClipLeft |= AltClipTopLeft;
if (TileBottom != 0) ClipLeft |= AltClipBottomLeft;
var ClipRight = DiaClipRight;
if (TileTop != 0) ClipRight |= AltClipTopRight;
if (TileBottom != 0) ClipRight |= AltClipBottomRight;
var ClipTop = DiaClipTop;
if (TileLeft != 0) ClipTop |= AltClipTopLeft;
if (TileRight != 0) ClipTop |= AltClipTopRight;
var ClipBottom = DiaClipBottom;
if (TileLeft != 0) ClipBottom |= AltClipBottomLeft;
if (TileRight != 0) ClipBottom |= AltClipBottomRight;
if (ClipLeft)
fPlayerX = fPlayerX.Min(c.X * TILE_SIZE - PlayerRadiusMargin);
else if (ClipRight)
fPlayerX = fPlayerX.Max((c.X + 1) * TILE_SIZE + PlayerRadiusMargin);
if (ClipTop)
fPlayerY = fPlayerY.Min(c.Y * TILE_SIZE - PlayerRadiusMargin);
else if (ClipRight)
fPlayerY = fPlayerY.Max((c.Y + 1) * TILE_SIZE + PlayerRadiusMargin);
}
else
{
// fix corners
//
// * L
// F *
if (TileLeft != 0)
fPlayerX = fPlayerX.Max(c.X * TILE_SIZE + PlayerRadiusMargin);
if (TileRight != 0)
fPlayerX = fPlayerX.Min((c.X + 1) * TILE_SIZE - PlayerRadiusMargin);
if (TileTop != 0)
fPlayerY = fPlayerY.Max(c.Y * TILE_SIZE + PlayerRadiusMargin);
if (TileBottom != 0)
fPlayerY = fPlayerY.Min((c.Y + 1) * TILE_SIZE - PlayerRadiusMargin);
}
p.x = fPlayerX;
p.y = fPlayerY;
}
protected override void OnRenderMask(ISurface <ColorAlpha8> dstMask, PointInt32 renderOffset)
{
base.OnRenderMask(dstMask, renderOffset);
dstMask.Multiply(this.opacity);
}
protected override void OnRenderContent(ISurface <ColorBgra> dstContent, PointInt32 renderOffset)
{
dstContent.Clear();
}
protected override GeometryList CreateSelectionGeometry(MagicWandToolChanges changes, AsyncSelectionToolCreateGeometryContext context, CancellationToken cancellationToken)
{
GeometryList list;
Result <BitVector2D> lazyBaseStencil;
IRenderer <ColorBgra> sampleSource = ((MagicWandToolCreateGeometryContext)context).SampleSource;
byte x = (byte)Math.Round((double)(changes.Tolerance * 255.0), MidpointRounding.AwayFromZero);
byte tolerance = ByteUtil.FastScale(x, x);
PointInt32 pt = changes.OriginPointInt32;
if (!sampleSource.Bounds <ColorBgra>().Contains(pt))
{
switch (changes.SelectionCombineMode)
{
case SelectionCombineMode.Replace:
case SelectionCombineMode.Intersect:
return(new GeometryList());
case SelectionCombineMode.Union:
case SelectionCombineMode.Exclude:
case SelectionCombineMode.Xor:
return(changes.BaseGeometry);
}
throw ExceptionUtil.InvalidEnumArgumentException <SelectionCombineMode>(changes.SelectionCombineMode, "changes.SelectionCombineMode");
}
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
Func <bool> isCancellationRequestedFn = () => cancellationToken.IsCancellationRequested;
ColorBgra basis = sampleSource.GetPointSlow(pt);
int width = ((sampleSource.Width + 0x1f) / 0x20) * 0x20;
BitVector2D newStencil = new BitVector2D(width, sampleSource.Height);
BitVector2DStruct newStencilWrapper = new BitVector2DStruct(newStencil);
if (((changes.SelectionCombineMode != SelectionCombineMode.Replace) && sampleSource.Bounds <ColorBgra>().Contains(changes.BaseGeometry.Bounds.Int32Bound)) && changes.BaseGeometry.IsPixelated)
{
lazyBaseStencil = LazyResult.New <BitVector2D>(() => PixelatedGeometryListToBitVector2D(changes.BaseGeometry, newStencil.Width, newStencil.Height, cancellationToken), LazyThreadSafetyMode.ExecutionAndPublication, new SingleUseCriticalSection());
ThreadPool.QueueUserWorkItem(delegate(object _) {
lazyBaseStencil.EnsureEvaluated();
});
}
else
{
lazyBaseStencil = null;
}
FloodMode floodMode = changes.FloodMode;
if (floodMode != FloodMode.Local)
{
if (floodMode != FloodMode.Global)
{
throw ExceptionUtil.InvalidEnumArgumentException <FloodMode>(changes.FloodMode, "changes.FloodMode");
}
}
else
{
RectInt32 num4;
FloodFillAlgorithm.FillStencilFromPoint <BitVector2DStruct>(sampleSource, newStencilWrapper, pt, tolerance, isCancellationRequestedFn, out num4);
goto Label_0293;
}
TileMathHelper tileMathHelper = new TileMathHelper(sampleSource.Width, sampleSource.Height, 7);
Work.ParallelForEach <PointInt32>(WaitType.Pumping, tileMathHelper.EnumerateTileOffsets(), delegate(PointInt32 tileOffset) {
if (!cancellationToken.IsCancellationRequested)
{
RectInt32 clipRect = tileMathHelper.GetTileSourceRect(tileOffset);
FloodFillAlgorithm.FillStencilByColor <BitVector2DStruct>(sampleSource, newStencilWrapper, basis, tolerance, isCancellationRequestedFn, clipRect);
}
}, WorkItemQueuePriority.Normal, null);
Label_0293:
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
if (changes.SelectionCombineMode == SelectionCombineMode.Replace)
{
list = GeometryList.FromStencil <BitVector2DStruct>(newStencilWrapper, cancellationToken);
}
else if (lazyBaseStencil == null)
{
GeometryList rhs = GeometryList.FromStencil <BitVector2DStruct>(newStencilWrapper, cancellationToken);
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
list = GeometryList.Combine(changes.BaseGeometry, changes.SelectionCombineMode.ToGeometryCombineMode(), rhs);
}
else
{
BitVector2D other = lazyBaseStencil.Value;
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
switch (changes.SelectionCombineMode)
{
case SelectionCombineMode.Replace:
throw new InternalErrorException();
case SelectionCombineMode.Union:
newStencil.Or(other);
break;
case SelectionCombineMode.Exclude:
newStencil.Invert();
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
newStencil.And(other);
break;
case SelectionCombineMode.Intersect:
newStencil.And(other);
break;
case SelectionCombineMode.Xor:
newStencil.Xor(other);
break;
default:
throw ExceptionUtil.InvalidEnumArgumentException <SelectionCombineMode>(changes.SelectionCombineMode, "changes.SelectionCombineMode");
}
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
list = GeometryList.FromStencil <BitVector2DStruct>(newStencilWrapper, cancellationToken);
}
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
list.Freeze();
return(list);
}
private PointInt32 ClientPointToViewPoint(PointInt32 pt) => new PointInt32(pt.X, pt.Y + this.ScrollOffset);
public override void ClipViewPosition(Point p)
{
if (ViewPositionLock != null)
{
p.x = ViewPositionLock.x;
p.y = ViewPositionLock.y;
return;
}
var Walls = this.Map.WallMap;
if (Walls == null)
return;
Func<Point, double, bool> RadialBump =
(vp, vr) =>
{
var z = p.GetDistance(vp);
if (z < vr)
{
// pump us out of that sprite
var a = (p - vp).GetRotation();
p.x = vp.x + Math.Cos(a) * vr;
p.y = vp.y + Math.Sin(a) * vr;
return true;
}
else
{
return false;
}
};
#region bump on blocking sprites
if (EnableBlockingSprites)
foreach (var v in BlockingSprites)
{
RadialBump(v.Position, v.Range);
}
#endregion
var fPlayerX = p.x;
var fPlayerY = p.y;
var c = new PointInt32
{
X = (int)Math.Floor(p.x),
Y = (int)Math.Floor(p.y)
};
var TILE_SIZE = 1.0;
var PositionInWall =
new Point
{
x = fPlayerX % TILE_SIZE,
y = fPlayerY % TILE_SIZE
};
var TileTop = Walls[c.X, c.Y - 1];
var TileLeft = Walls[c.X - 1, c.Y];
var TileRight = Walls[c.X + 1, c.Y];
var TileBottom = Walls[c.X, c.Y + 1];
var CurrentMapTile = Walls[c.X, c.Y];
if (CurrentMapTile != 0)
{
// we are inside a wall
// push us out of there
#region Dia
var A = PositionInWall.x > PositionInWall.y;
var B = PositionInWall.x > (TILE_SIZE - PositionInWall.y);
var DiaClipLeft = !A && !B;
var DiaClipRight = A && B;
var DiaClipTop = A && !B;
var DiaClipBottom = !A && B;
#endregion
#region Alt
var C = PositionInWall.x > (TILE_SIZE / 2);
var D = PositionInWall.y > (TILE_SIZE / 2);
var AltClipTopLeft = !C && !D;
var AltClipBottomLeft = !C && D;
var AltClipTopRight = C && !D;
var AltClipBottomRight = C && D;
#endregion
var ClipLeft = DiaClipLeft;
if (TileTop != 0) ClipLeft |= AltClipTopLeft;
if (TileBottom != 0) ClipLeft |= AltClipBottomLeft;
var ClipRight = DiaClipRight;
if (TileTop != 0) ClipRight |= AltClipTopRight;
if (TileBottom != 0) ClipRight |= AltClipBottomRight;
var ClipTop = DiaClipTop;
if (TileLeft != 0) ClipTop |= AltClipTopLeft;
if (TileRight != 0) ClipTop |= AltClipTopRight;
var ClipBottom = DiaClipBottom;
if (TileLeft != 0) ClipBottom |= AltClipBottomLeft;
if (TileRight != 0) ClipBottom |= AltClipBottomRight;
if (ClipLeft)
fPlayerX = fPlayerX.Min(c.X * TILE_SIZE - PlayerRadiusMargin);
else if (ClipRight)
fPlayerX = fPlayerX.Max((c.X + 1) * TILE_SIZE + PlayerRadiusMargin);
if (ClipTop)
fPlayerY = fPlayerY.Min(c.Y * TILE_SIZE - PlayerRadiusMargin);
else if (ClipRight)
fPlayerY = fPlayerY.Max((c.Y + 1) * TILE_SIZE + PlayerRadiusMargin);
}
else
{
// fix corners
//
// * L
// F *
if (TileLeft != 0)
fPlayerX = fPlayerX.Max(c.X * TILE_SIZE + PlayerRadiusMargin);
if (TileRight != 0)
fPlayerX = fPlayerX.Min((c.X + 1) * TILE_SIZE - PlayerRadiusMargin);
if (TileTop != 0)
fPlayerY = fPlayerY.Max(c.Y * TILE_SIZE + PlayerRadiusMargin);
if (TileBottom != 0)
fPlayerY = fPlayerY.Min((c.Y + 1) * TILE_SIZE - PlayerRadiusMargin);
}
p.x = fPlayerX;
p.y = fPlayerY;
BumpCounter++;
var p_top_left = new Point(c.X, c.Y);
var p_top_right = new Point(c.X + 1, c.Y);
var p_bottom_right = new Point(c.X + 1, c.Y + 1);
var p_bottom_left = new Point(c.X, c.Y + 1);
var z_top_left = p.GetDistance(p_top_left);
var z_top_right = p.GetDistance(p_top_right);
var z_bottom_right = p.GetDistance(p_bottom_right);
var z_bottom_left = p.GetDistance(p_bottom_left);
var is_top_left = z_top_left < PlayerRadiusMargin;
var is_top_right = z_top_right < PlayerRadiusMargin;
var is_bottom_right = z_bottom_right < PlayerRadiusMargin;
var is_bottom_left = z_bottom_left < PlayerRadiusMargin;
// this assumes there are always corners.
// if we add larger rooms we need to adjust this here
//WriteLine(BumpCounter + " " + new { is_top_left, is_top_right, is_bottom_right, is_bottom_left });
if (is_top_left)
if (!RadialBump(p_top_left, PlayerRadiusMargin))
WriteLine("fail p_top_left");
if (is_top_right)
if (!RadialBump(p_top_right, PlayerRadiusMargin))
WriteLine("fail p_top_right");
if (is_bottom_right)
if (!RadialBump(p_bottom_right, PlayerRadiusMargin))
WriteLine("fail p_bottom_right");
if (is_bottom_left)
if (!RadialBump(p_bottom_left, PlayerRadiusMargin))
WriteLine("fail bottom_left");
}
public static void FillStencilFromPoint <TBitVector2D>(IRenderer <ColorBgra> sampleSource, TBitVector2D stencilBuffer, PointInt32 startPt, byte tolerance, CancellationToken cancelToken, out RectInt32 bounds) where TBitVector2D : IBitVector2D
{
FillStencilFromPoint <TBitVector2D>(sampleSource, stencilBuffer, startPt, tolerance, CancellationTokenUtil.Create(cancelToken), out bounds);
}
private IRenderer <ColorAlpha8> CreateMaskRenderer()
{
IRenderer <ColorAlpha8> renderer;
byte x = (byte)Math.Round((double)(this.changes.Tolerance * 255.0), MidpointRounding.AwayFromZero);
byte tolerance = ByteUtil.FastScale(x, x);
PointInt32 pt = this.changes.OriginPointInt32;
if (!this.sampleSource.Bounds <ColorBgra>().Contains(pt))
{
return(new FillRendererAlpha8(this.sampleSource.Width, this.sampleSource.Height, ColorAlpha8.Transparent));
}
Func <bool> isCancellationRequestedFn = () => base.IsCancellationRequested;
ColorBgra pointSlow = this.sampleSource.GetPointSlow(pt);
if (base.IsCancellationRequested)
{
return(null);
}
if (this.changes.FloodMode == FloodMode.Global)
{
renderer = new FillStencilByColorRenderer(this.sampleSource, pointSlow, tolerance, isCancellationRequestedFn);
}
else
{
RectInt32 num5;
BitVector2D source = new BitVector2D(this.sampleSource.Width, this.sampleSource.Height);
BitVector2DStruct stencilBuffer = new BitVector2DStruct(source);
source.Clear(true);
if (base.IsCancellationRequested)
{
return(null);
}
foreach (RectInt32 num6 in this.changes.ClippingMask.EnumerateInteriorScans())
{
source.Set(num6, false);
if (base.IsCancellationRequested)
{
return(null);
}
}
BitVector2D other = source.Clone();
if (base.IsCancellationRequested)
{
return(null);
}
FloodFillAlgorithm.FillStencilFromPoint <BitVector2DStruct>(this.sampleSource, stencilBuffer, pt, tolerance, isCancellationRequestedFn, out num5);
if (base.IsCancellationRequested)
{
return(null);
}
source.Xor(other);
if (base.IsCancellationRequested)
{
return(null);
}
renderer = new BitVector2DToAlpha8Renderer <BitVector2DStruct>(stencilBuffer);
}
if (this.changes.Antialiasing)
{
return(new FeatheredMaskRenderer(this.sampleSource, pointSlow, renderer, tolerance, isCancellationRequestedFn));
}
return(renderer);
}
public void PasteBufferIntoWorld(World world, ClipboardBuffer buffer, PointInt32 anchor)
{
for (int x = 0; x < buffer.Size.W; x++)
{
for (int y = 0; y < buffer.Size.H; y++)
{
if (world.IsPointInWorld(x + anchor.X, y + anchor.Y))
{
HistMan.AddTileToBuffer(x + anchor.X, y + anchor.Y, ref world.Tiles[x + anchor.X, y + anchor.Y]);
Tile curTile = (Tile)buffer.Tiles[x, y].Clone();
// Remove overwritten chests data
if (world.Tiles[x + anchor.X, y + anchor.Y].Type == 21)
{
var data = world.GetChestAtTile(x + anchor.X, y + anchor.Y);
if (data != null)
{
world.Chests.Remove(data);
}
}
// Remove overwritten sign data
if (world.Tiles[x + anchor.X, y + anchor.Y].Type == 55 || world.Tiles[x + anchor.X, y + anchor.Y].Type == 85)
{
var data = world.GetSignAtTile(x + anchor.X, y + anchor.Y);
if (data != null)
{
world.Signs.Remove(data);
}
}
// Add new chest data
if (curTile.Type == 21)
{
if (world.GetChestAtTile(x + anchor.X, y + anchor.Y) == null)
{
var data = buffer.GetChestAtTile(x, y);
if (data != null) // allow? chest copying may not work...
{
// Copied chest
var newChest = Utility.DeepCopy(data);
newChest.Location = new PointInt32(x + anchor.X, y + anchor.Y);
world.Chests.Add(newChest);
}
else
{
// Empty chest
world.Chests.Add(new Chest(new PointInt32(x + anchor.X, y + anchor.Y)));
}
}
}
// Add new sign data
if (curTile.Type == 55 || curTile.Type == 85)
{
if (world.GetSignAtTile(x + anchor.X, y + anchor.Y) == null)
{
var data = buffer.GetSignAtTile(x, y);
if (data != null)
{
// Copied sign
var newSign = Utility.DeepCopy(data);
newSign.Location = new PointInt32(x + anchor.X, y + anchor.Y);
world.Signs.Add(newSign);
}
else
{
world.Signs.Add(new Sign("", new PointInt32(x + anchor.X, y + anchor.Y)));
}
}
}
world.Tiles[x + anchor.X, y + anchor.Y] = curTile;
}
}
}
HistMan.AddBufferToHistory();
}
public SnapDescription(SnapObstacle snappedTo, HorizontalSnapEdge horizontalEdge, VerticalSnapEdge verticalEdge, PointInt32 offset) : this(snappedTo, horizontalEdge, verticalEdge, offset.X, offset.Y)
{
}
public bool Contains(PointInt32 e)
{
if (e.X < X)
return false;
if (e.X >= Width)
return false;
if (e.Y < Y)
return false;
if (e.Y >= Height)
return false;
return true;
}
private bool IsTileRenderingCancelled(PointInt32 tileOffset) => this.tilesRenderingCancelledSet.Contains(tileOffset);
public MazeGenerator(int Width, int Height, IFeedback Handler)
{
// port from http://en.wikipedia.org/wiki/Image:Maze.png
this.Width = Width;
this.Height = Height;
clip = new RectInt32 { Width = Width, Height = Height };
int x, y, n, d;
int[] dx = { 0, 0, -1, 1 };
//int[] dy = { -1, 1, Convert.ToInt32(0), Convert.ToInt32(0) };
int[] dy = { -1, 1, 0, 0 };
int[] todo = new int[Width * Height];
int todonum = 0;
/* We want to create a maze on a grid. */
maze = new int[Width][];
/* We start with a grid full of walls. */
for (x = 0; x < Width; x++)
{
maze[x] = new int[Height];
for (y = 0; y < Height; y++)
{
var p = new PointInt32 { X = x, Y = y };
if (clip.IsBorder(p))
{
maze[x][y] = 32;
}
else
{
maze[x][y] = 63;
}
}
}
/* Select any square of the grid, to start with. */
x = ToInt32(1 + random() * (Width - 2));
y = ToInt32(1 + random() * (Height - 2));
/* Mark this square as connected to the maze. */
maze[x][y] &= ~48;
/* Remember the surrounding squares, as we will */
for (d = 0; d < 4; d++)
if ((maze[x + dx[d]][y + dy[d]] & 16) != 0)
{
/* want to connect them to the maze. */
/* alternately, you could use a struct to store the two integers
* this would result in easier to read code, though not as speedy
* of course, if you were worried about speed, you wouldn't be using Java
* you could also use a single integer which represents (x + y * width)
* this would actually be faster than the current approach
* - quin/10-24-06
* Actually, the former wouldn't work in Java- there's no such thing as a
* struct. It's a class or nothing, I'm afraid.
* - Jae Armstrong/23-03-07
*/
todo[todonum++] = ((x + dx[d]) << 16) | (y + dy[d]);
maze[x + dx[d]][y + dy[d]] &= ~16;
}
/* We won't be finished until all is connected. */
while (todonum > 0)
{
if (Handler != null)
Handler.Invoke("todonum = " + todonum);
/* We select one of the squares next to the maze. */
n = ToInt32(random() * todonum);
x = todo[n] >> 16; /* the top 2 bytes of the data */
y = todo[n] & 65535; /* the bottom 2 bytes of the data */
/* We will connect it, so remove it from the queue. */
todonum--;
todo[n] = todo[todonum];
/* Select a direction, which leads to the maze. */
d = ToInt32(random() * 4);
if ((maze[x + dx[d]][y + dy[d]] & 32) != 0)
d = (d + 1) % dx.Length;
if ((maze[x + dx[d]][y + dy[d]] & 32) != 0)
d = (d + 1) % dx.Length;
if ((maze[x + dx[d]][y + dy[d]] & 32) != 0)
d = (d + 1) % dx.Length;
/* Connect this square to the maze. */
maze[x][y] &= ~((1 << d) | 32);
maze[x + dx[d]][y + dy[d]] &= ~(1 << (d ^ 1));
/* Remember the surrounding squares, which aren't */
for (d = 0; d < 4; d++)
if ((maze[x + dx[d]][y + dy[d]] & 16) != 0)
{
/* connected to the maze, and aren't yet queued to be. */
todo[todonum++] = ((x + dx[d]) << 16) | (y + dy[d]);
maze[x + dx[d]][y + dy[d]] &= ~16;
}
/* Repeat until finished. */
}
/* One may want to add an entrance and exit. */
maze[1][1] &= ~1;
maze[Width - 2][Height - 2] &= ~2;
}
public bool ProcessTileRenderedQueue()
{
base.VerifyAccess();
using (this.processTileRenderedQueueRegion.UseEnterScope())
{
if (this.IsDisposed)
{
bool flag = false;
do
{
KeyValuePair <PointInt32, RenderedTileInfo> pair;
while (this.tilesRenderedQueue.TryDequeue(out pair))
{
DisposableUtil.Free <IBitmap <ColorPbgra32> >(ref pair.Value.Buffer);
flag = true;
}
}while (Interlocked.Exchange(ref this.isProcessTileRenderedQueueQueued, 0) == 1);
return(flag);
}
if (Interlocked.Exchange(ref this.isProcessTileRenderedQueueQueued, 0) == 0)
{
return(false);
}
List <PointInt32> collection = new List <PointInt32>();
List <PointInt32> cancelledTileOffsets = null;
bool flag3 = false;
int count = this.tilesRenderedQueue.Count;
for (int i = 0; i < count; i++)
{
KeyValuePair <PointInt32, RenderedTileInfo> pair2;
if (this.tilesRenderedQueue.TryDequeue(out pair2))
{
PointInt32 key = pair2.Key;
RenderedTileInfo info2 = pair2.Value;
IBitmap <ColorPbgra32> buffer = info2.Buffer;
if (this.tilesRenderingCancelledSet.Remove(key) || !info2.Completed)
{
DisposableUtil.Free <IBitmap <ColorPbgra32> >(ref buffer);
if (this.tilesRenderQueue.Contains(key))
{
flag3 = true;
}
else if (info2.Error is OperationCanceledException)
{
if (cancelledTileOffsets == null)
{
cancelledTileOffsets = new List <PointInt32>();
}
cancelledTileOffsets.Add(key);
}
}
else
{
if ((buffer.IsNullReference <IBitmap <ColorPbgra32> >() || buffer.IsDisposed) || !pair2.Value.Completed)
{
throw new PaintDotNet.InternalErrorException();
}
IBitmap <ColorPbgra32> disposeMe = this.tileBuffers[key.Y][key.X];
DisposableUtil.Free <IBitmap <ColorPbgra32> >(ref disposeMe);
this.tileBuffers[key.Y][key.X] = buffer;
this.tileIsValid[key.Y][key.X] = true;
collection.Add(key);
}
if (!this.tilesRenderingSet.Remove(key))
{
throw new PaintDotNet.InternalErrorException();
}
}
}
if (collection.Any <PointInt32>())
{
this.owner.NotifyTileCacheFinishedRendering <List <PointInt32> >(this, collection);
}
if (flag3)
{
this.ProcessTileRenderQueue();
}
if (!this.tilesRenderingSet.Any <PointInt32>())
{
this.owner.NotifyTileCacheIsIdle(this);
}
if (cancelledTileOffsets != null)
{
this.syncContext.Post(delegate(object _) {
this.InvalidateCancelledTiles(cancelledTileOffsets);
});
}
return(collection.Any <PointInt32>());
}
}
public bool IsBorder(PointInt32 e)
{
if (e.X == X)
return true;
if (e.Y == Y)
return true;
if (e.X == X + Width - 1)
return true;
if (e.Y == Y + Height - 1)
return true;
return false;
}
protected abstract void OnRender(ISurface <ColorBgra> dst, PointInt32 renderOffset);
protected override unsafe void OnRender(ISurface <ColorBgra> dstContent, ISurface <ColorAlpha8> dstMask, PointInt32 renderOffset)
{
base.ThrowIfCancellationRequested();
int width = dstContent.Width;
int height = dstContent.Height;
ColorBgra *bgraPtr = (ColorBgra *)dstContent.Scan0;
int num3 = dstContent.Stride - (width * 4);
RectInt32 sourceRect = new RectInt32(renderOffset.X, renderOffset.Y, width, height);
if (this.changes.PixelSource == MoveToolPixelSource.Bitmap)
{
ZeroMaskSampler baseMaskSampler = new ZeroMaskSampler();
this.OnRenderImpl <ZeroMaskSampler>(dstContent, renderOffset, ref baseMaskSampler);
}
else if (this.changes.LeaveCopyBehind)
{
ZeroMaskSampler sampler2 = new ZeroMaskSampler();
this.OnRenderImpl <ZeroMaskSampler>(dstContent, renderOffset, ref sampler2);
}
else
{
using (BaseMaskSampler sampler3 = new BaseMaskSampler(this, sourceRect))
{
this.OnRenderImpl <BaseMaskSampler>(dstContent, renderOffset, ref sampler3);
}
}
}
public Sign(string text, PointInt32 location)
{
_Text = text;
_Location = location;
}
private unsafe void OnRenderImpl <TMaskSampler>(ISurface <ColorBgra> dstContent, PointInt32 renderOffset, ref TMaskSampler baseMaskSampler) where TMaskSampler : IMaskSampler
{
if (Interlocked.Exchange(ref this.isLazyDeltaSelectionMaskFirstTimePrefetched, 1) == 0)
{
this.lazyDeltaSelectionMask.EnsureEvaluated();
}
else if (Interlocked.Exchange(ref this.isLazyFinalSelectionMaskFirstTimePrefetched, 1) == 0)
{
this.lazyFinalSelectionMask.EnsureEvaluated();
}
base.ThrowIfCancellationRequested();
int width = dstContent.Width;
int height = dstContent.Height;
ColorBgra *bgraPtr = (ColorBgra *)dstContent.Scan0;
int stride = dstContent.Stride;
int num4 = stride - (width * 4);
RectInt32 bounds = new RectInt32(renderOffset.X, renderOffset.Y, width, height);
uint num6 = this.changes.BackFillColor.Bgra;
using (ISurface <ColorAlpha8> surface = alpha8Allocator.Allocate(width, height, AllocationOptions.ZeroFillNotRequired))
{
base.ThrowIfCancellationRequested();
this.sourceTx.Render(dstContent, surface, renderOffset);
base.ThrowIfCancellationRequested();
using (ISurface <ColorAlpha8> surface2 = this.lazyFinalSelectionMask.Value.UseTileOrToSurface(bounds))
{
base.ThrowIfCancellationRequested();
ColorBgra *pointAddress = this.activeLayer.Surface.GetPointAddress(renderOffset.X, renderOffset.Y);
int num7 = this.activeLayer.Surface.Stride - (width * 4);
byte * numPtr = (byte *)surface2.Scan0;
int num8 = surface2.Stride - bounds.Width;
byte * numPtr2 = (byte *)surface.Scan0;
int num9 = surface.Stride - bounds.Width;
ColorBgra *bgraPtr3 = bgraPtr + width;
baseMaskSampler.Initialize();
for (int i = 0; i < height; i++)
{
for (ColorBgra *bgraPtr4 = bgraPtr3 - width; bgraPtr4 < bgraPtr3; bgraPtr4++)
{
byte next = baseMaskSampler.GetNext();
byte num12 = numPtr[0];
byte num13 = numPtr2[0];
byte num14 = Math.Min(num13, num12);
if (num14 == 0)
{
byte frac = (byte)(0xff - next);
if (frac == 0)
{
bgraPtr4->Bgra = num6;
}
else
{
ColorBgra bgra = pointAddress[0];
if (frac != 0xff)
{
bgra.A = ByteUtil.FastScale(bgra.A, frac);
}
bgraPtr4->Bgra = bgra.Bgra;
}
}
else if (num14 != 0xff)
{
byte num16 = Math.Min((byte)(0xff - num14), (byte)(0xff - next));
ColorBgra bgra2 = bgraPtr4[0];
ColorBgra bgra3 = pointAddress[0];
ushort d = (ushort)((bgra3.A * num16) + (bgra2.A * num14));
if (d == 0)
{
bgraPtr4->Bgra = num6;
}
else
{
int num18 = UInt16Util.FastDivideBy255((ushort)((bgra3.A * num16) + (bgra2.A * num14)));
uint num19 = UInt32Util.FastDivideByUInt16((uint)(((bgra3.A * num16) * bgra3.B) + ((bgra2.A * num14) * bgra2.B)), d);
uint num20 = UInt32Util.FastDivideByUInt16((uint)(((bgra3.A * num16) * bgra3.G) + ((bgra2.A * num14) * bgra2.G)), d);
uint num21 = UInt32Util.FastDivideByUInt16((uint)(((bgra3.A * num16) * bgra3.R) + ((bgra2.A * num14) * bgra2.R)), d);
bgraPtr4->Bgra = ColorBgra.BgraToUInt32((byte)num19, (byte)num20, (byte)num21, (byte)num18);
}
}
pointAddress++;
numPtr++;
numPtr2++;
}
pointAddress += num7;
baseMaskSampler.MoveToNextRow();
numPtr += num8;
numPtr2 += num9;
bgraPtr3 += stride;
base.ThrowIfCancellationRequested();
}
}
}
}
private void PasteClipboard(PointInt32 anchor)
{
_clipboardMan.PasteBufferIntoWorld(_world, _clipboardMan.Buffer, anchor);
_renderer.UpdateWorldImage(new Int32Rect(anchor.X, anchor.Y, _clipboardMan.Buffer.Size.W, _clipboardMan.Buffer.Size.H));
}
public void Render(ISurface <ColorBgra> dst, PointInt32 renderOffset)
{
this.CreateRenderer().Render(dst, renderOffset);
}
public static unsafe void FillStencilFromPoint <TBitVector2D>(IRenderer <ColorBgra> sampleSource, TBitVector2D stencilBuffer, PointInt32 startPt, byte tolerance, Func <bool> isCancellationRequestedFn, out RectInt32 bounds) where TBitVector2D : IBitVector2D
{
Validate.IsNotNull <IRenderer <ColorBgra> >(sampleSource, "sampleSource");
int width = sampleSource.Width;
int height = sampleSource.Height;
if ((width > stencilBuffer.Width) || (height > stencilBuffer.Height))
{
throw new ArgumentException();
}
if (!sampleSource.CheckPointValue <ColorBgra>(startPt))
{
bounds = RectInt32.Empty;
}
else
{
int num3 = sampleSource.Width;
int num4 = sampleSource.Height;
using (RendererRowCache <ColorBgra> cache = new RendererRowCache <ColorBgra>(sampleSource))
{
int num5 = 0x7fffffff;
int num6 = 0x7fffffff;
int num7 = -2147483648;
int num8 = -2147483648;
Queue <PointInt32> queue = new Queue <PointInt32>(0x10);
queue.Enqueue(startPt);
cache.AddRowRef(startPt.Y - 1);
cache.AddRowRef(startPt.Y);
cache.AddRowRef(startPt.Y + 1);
ColorBgra start = *((ColorBgra *)(((void *)cache.GetRow(startPt.Y)) + (startPt.X * sizeof(ColorBgra))));
while (queue.Any <PointInt32>())
{
if (isCancellationRequestedFn())
{
bounds = RectInt32.Empty;
return;
}
PointInt32 pt = queue.Dequeue();
try
{
if (sampleSource.CheckPointValue <ColorBgra>(pt))
{
ColorBgra *row = (ColorBgra *)cache.GetRow(pt.Y);
int x = pt.X - 1;
int num11 = pt.X;
while (((x >= 0) && !stencilBuffer.Get(x, pt.Y)) && CheckColor(start, row[x], tolerance))
{
stencilBuffer.Set(x, pt.Y, true);
x--;
}
while (((num11 < num3) && !stencilBuffer.Get(num11, pt.Y)) && CheckColor(start, row[num11], tolerance))
{
stencilBuffer.Set(num11, pt.Y, true);
num11++;
}
x++;
num11--;
if (pt.Y > 0)
{
cache.AddRowRef(pt.Y - 2);
cache.AddRowRef(pt.Y - 1);
cache.AddRowRef(pt.Y);
try
{
ColorBgra *bgraPtr2 = (ColorBgra *)cache.GetRow(pt.Y - 1);
int num12 = x;
int num13 = x;
for (int i = x; i <= num11; i++)
{
if (!stencilBuffer.Get(i, pt.Y - 1) && CheckColor(start, bgraPtr2[i], tolerance))
{
num13++;
}
else
{
if ((num13 - num12) > 0)
{
queue.Enqueue(new PointInt32(num12, pt.Y - 1));
cache.AddRowRef(pt.Y - 2);
cache.AddRowRef(pt.Y - 1);
cache.AddRowRef(pt.Y);
}
num13++;
num12 = num13;
}
}
if ((num13 - num12) > 0)
{
queue.Enqueue(new PointInt32(num12, pt.Y - 1));
cache.AddRowRef(pt.Y - 2);
cache.AddRowRef(pt.Y - 1);
cache.AddRowRef(pt.Y);
}
}
finally
{
cache.ReleaseRowRef(pt.Y - 2);
cache.ReleaseRowRef(pt.Y - 1);
cache.ReleaseRowRef(pt.Y);
}
}
if (pt.Y < (num4 - 1))
{
cache.AddRowRef(pt.Y);
cache.AddRowRef(pt.Y + 1);
cache.AddRowRef(pt.Y + 2);
try
{
ColorBgra *bgraPtr3 = (ColorBgra *)cache.GetRow(pt.Y + 1);
int num15 = x;
int num16 = x;
for (int j = x; j <= num11; j++)
{
if (!stencilBuffer.Get(j, pt.Y + 1) && CheckColor(start, bgraPtr3[j], tolerance))
{
num16++;
}
else
{
if ((num16 - num15) > 0)
{
queue.Enqueue(new PointInt32(num15, pt.Y + 1));
cache.AddRowRef(pt.Y);
cache.AddRowRef(pt.Y + 1);
cache.AddRowRef(pt.Y + 2);
}
num16++;
num15 = num16;
}
}
if ((num16 - num15) > 0)
{
queue.Enqueue(new PointInt32(num15, pt.Y + 1));
cache.AddRowRef(pt.Y);
cache.AddRowRef(pt.Y + 1);
cache.AddRowRef(pt.Y + 2);
}
}
finally
{
cache.ReleaseRowRef(pt.Y);
cache.ReleaseRowRef(pt.Y + 1);
cache.ReleaseRowRef(pt.Y + 2);
}
}
num5 = Math.Min(num5, x);
num6 = Math.Min(num6, pt.Y);
num7 = Math.Max(num7, num11);
num8 = Math.Max(num8, pt.Y);
}
continue;
}
finally
{
cache.ReleaseRowRef(pt.Y - 1);
cache.ReleaseRowRef(pt.Y);
cache.ReleaseRowRef(pt.Y + 1);
}
}
bounds = RectInt32.FromEdges(num5, num6, num7, num8);
}
}
}
internal BrushStrokeRenderCache.TileData <GetTileData> b__12_0(PointInt32 to) => new BrushStrokeRenderCache.TileData(to);
protected override void OnRender(ISurface <ColorBgra> dstContent, ISurface <ColorAlpha8> dstMask, PointInt32 renderOffset)
{
base.ThrowIfCancellationRequested();
IRenderer <ColorAlpha8> renderer = this.lazyStencil.CancelableValue <IRenderer <ColorAlpha8> >();
base.ThrowIfCancellationRequested();
if (renderer == null)
{
throw new PaintDotNet.InternalErrorException("stencil == null");
}
base.ThrowIfCancellationRequested();
renderer.Render(dstMask, renderOffset);
base.ThrowIfCancellationRequested();
this.brushRenderer.Render(dstContent, renderOffset);
}
public void Render(ISurface <ColorAlpha8> dst, PointInt32 renderOffset)
{
this.owner.RenderMask(dst, renderOffset, this.cancelToken);
}
public TileData(PointInt32 offset)
{
this.Offset = offset;
}
public override void ClipViewPosition(Point p)
{
if (ViewPositionLock != null)
{
p.x = ViewPositionLock.x;
p.y = ViewPositionLock.y;
return;
}
var Walls = this.Map.WallMap;
if (Walls == null)
return;
#region bump on blocking sprites
foreach (var v in BlockingSprites)
{
var z = Point.distance(p, v.Position);
if (z < v.Range)
{
// pump us out of that sprite
var a = (p - v.Position).GetRotation();
p.x = v.Position.x + Math.Cos(a) * v.Range;
p.y = v.Position.y + Math.Sin(a) * v.Range;
}
}
#endregion
var fPlayerX = p.x;
var fPlayerY = p.y;
var c = new PointInt32
{
X = (int)Math.Floor(p.x),
Y = (int)Math.Floor(p.y)
};
var TILE_SIZE = 1.0;
var PositionInWall =
new Point
{
x = fPlayerX % TILE_SIZE,
y = fPlayerY % TILE_SIZE
};
var TileTop = Walls[c.X, c.Y - 1];
var TileLeft = Walls[c.X - 1, c.Y];
var TileRight = Walls[c.X + 1, c.Y];
var TileBottom = Walls[c.X, c.Y + 1];
var CurrentMapTile = Walls[c.X, c.Y];
if (CurrentMapTile != 0)
{
// we are inside a wall
// push us out of there
#region Dia
var A = PositionInWall.x > PositionInWall.y;
var B = PositionInWall.x > (TILE_SIZE - PositionInWall.y);
var DiaClipLeft = !A && !B;
var DiaClipRight = A && B;
var DiaClipTop = A && !B;
var DiaClipBottom = !A && B;
#endregion
#region Alt
var C = PositionInWall.x > (TILE_SIZE / 2);
var D = PositionInWall.y > (TILE_SIZE / 2);
var AltClipTopLeft = !C && !D;
var AltClipBottomLeft = !C && D;
var AltClipTopRight = C && !D;
var AltClipBottomRight = C && D;
#endregion
var ClipLeft = DiaClipLeft;
if (TileTop != 0) ClipLeft |= AltClipTopLeft;
if (TileBottom != 0) ClipLeft |= AltClipBottomLeft;
var ClipRight = DiaClipRight;
if (TileTop != 0) ClipRight |= AltClipTopRight;
if (TileBottom != 0) ClipRight |= AltClipBottomRight;
var ClipTop = DiaClipTop;
if (TileLeft != 0) ClipTop |= AltClipTopLeft;
if (TileRight != 0) ClipTop |= AltClipTopRight;
var ClipBottom = DiaClipBottom;
if (TileLeft != 0) ClipBottom |= AltClipBottomLeft;
if (TileRight != 0) ClipBottom |= AltClipBottomRight;
if (ClipLeft)
fPlayerX = fPlayerX.Min(c.X * TILE_SIZE - PlayerRadiusMargin);
else if (ClipRight)
fPlayerX = fPlayerX.Max((c.X + 1) * TILE_SIZE + PlayerRadiusMargin);
if (ClipTop)
fPlayerY = fPlayerY.Min(c.Y * TILE_SIZE - PlayerRadiusMargin);
else if (ClipRight)
fPlayerY = fPlayerY.Max((c.Y + 1) * TILE_SIZE + PlayerRadiusMargin);
}
else
{
// fix corners
//
// * L
// F *
if (TileLeft != 0)
fPlayerX = fPlayerX.Max(c.X * TILE_SIZE + PlayerRadiusMargin);
if (TileRight != 0)
fPlayerX = fPlayerX.Min((c.X + 1) * TILE_SIZE - PlayerRadiusMargin);
if (TileTop != 0)
fPlayerY = fPlayerY.Max(c.Y * TILE_SIZE + PlayerRadiusMargin);
if (TileBottom != 0)
fPlayerY = fPlayerY.Min((c.Y + 1) * TILE_SIZE - PlayerRadiusMargin);
}
p.x = fPlayerX;
p.y = fPlayerY;
}