public BitmapSource GetTile(SymbolID symbolID, GameColor color, int tileSize)
{
var key = new TileKey(symbolID, color, tileSize);
BitmapSource bmp;
if (m_cache.TryGet(key, out bmp))
{
return(bmp);
}
int xOffset = GetTileXOffset(tileSize);
int yOffset = GetTileYOffset(symbolID);
bmp = new CroppedBitmap(this.Atlas, new Int32Rect(xOffset, yOffset, tileSize, tileSize));
if (color != GameColor.None)
{
var rgb = color.ToGameColorRGB();
var wcolor = Color.FromRgb(rgb.R, rgb.G, rgb.B);
bmp = ColorizeBitmap(bmp, wcolor);
}
bmp.Freeze();
m_cache.Add(key, bmp);
return(bmp);
}
public override void Do()
{
this.m_oldFocus = FPGA.FPGA.Instance.Current;
Tile current = FPGA.FPGA.Instance.Current;
Types.Direction direction = Types.ParseDirectionFromString(this.DirectionString);
while (true)
{
TileKey targetKey = V5Navigator.GetDestination(current, direction, 1);
if (!FPGA.FPGA.Instance.Contains(targetKey))
{
throw new ArgumentException("Left FPGA during navigation from " + current + " in direction " + direction);
}
current = FPGA.FPGA.Instance.GetTile(targetKey);
if (!FPGA.FPGA.Instance.Contains(current.TileKey))
{
throw new ArgumentException("Leaving FPGA");
}
if (current.Location.StartsWith(this.TargetPrefix))
{
FPGA.FPGA.Instance.Current = current;
break;
}
}
}
GetUniqueTilesPositions(int[,] bitmap, int tilewidth, int tileheight)
{
int w = bitmap.GetLength(0);
int h = bitmap.GetLength(1);
int l;
Index2 extent = new Index2(tilewidth, tileheight);
ConcurrentQueue <TileKey> ts = new ConcurrentQueue <TileKey>();
ConcurrentDictionary <TileKey, int> remainingVals = new ConcurrentDictionary <TileKey, int>();
Tuple <ConcurrentDictionary <TileKey, int>, ConcurrentDictionary <TileKey, TileKey> > ret = null;
using (MemoryBuffer2D <int> bpbuffer = HardwareAcceleratorManager.GPUAccelerator.Allocate <int>(w, h))
{
bpbuffer.CopyFrom(bitmap, Index2.Zero, Index2.Zero, bpbuffer.Extent);
w /= tilewidth;
h /= tileheight;
l = w * h;
Parallel.For(0, l, ind =>
{
int i1 = ind % w;
int j1 = ind / w;
TileKey k1 = new TileKey(i1, j1, w);
if (!TileIsBlank.Execute(extent, bpbuffer, new Index2(i1 * tilewidth, j1 * tileheight)))
{
remainingVals.TryAdd(k1, ind);
}
});
ret = CheckRepeatedKernel.Execute(remainingVals, bpbuffer, extent.X, extent.Y);
}
return(ret);
}
/// <summary>
/// Computes the base value for placing a tile, that is, before multipliers or modifications.
/// </summary>
/// <param name="tileOrWallType">The tile type or wall.</param>
/// <param name="miningTargetType">Type of tile data, either tile or wall.</param>
/// <returns>Base value in generic units.</returns>
public decimal GetBasePlacingValue(ushort tileOrWallType, TileSubTarget miningTargetType, string group)
{
var key = new TileKey(tileOrWallType, miningTargetType);
//check group overrides first
if (!string.IsNullOrWhiteSpace(group))
{
if (GroupPlacingOverrides.TryGetValue(group, out var groupPlacingOverride))
{
if (groupPlacingOverride.TryGetValue(key, out var groupValueOverride))
{
return(groupValueOverride.Value);
}
}
}
if (PlacingOverrides.TryGetValue(key, out var valueOverride))
{
return(valueOverride.Value);
}
else
{
return(DefaultPlacingValue);
}
}
protected override void DoCommandAction()
{
Tile ul = TileSelectionManager.Instance.GetSelectedTile(".*", FPGATypes.Placement.UpperLeft);
Tile lr = TileSelectionManager.Instance.GetSelectedTile(".*", FPGATypes.Placement.LowerRight);
for (int x = ul.TileKey.X; x <= lr.TileKey.X; x++)
{
for (int y = ul.TileKey.Y; y <= lr.TileKey.Y; y++)
{
TileKey key = new TileKey(x, y);
// click done out of fpga range
if (!FPGA.FPGA.Instance.Contains(key))
{
continue;
}
// add if not added already
if (!TileSelectionManager.Instance.IsSelected(key))
{
TileSelectionManager.Instance.AddToSelection(key, false);
}
}
}
TileSelectionManager.Instance.SelectionChanged();
}
public static IEnumerable <Location> GetDestinations(Tile start, Port port, bool forward)
{
//foreach (Wire wire in start.WireList.GetAllWires().Where(w => (forward ? w.LocalPipIsDriver : !w.LocalPipIsDriver) && w.LocalPip.Equals(port.Name)))
foreach (Wire wire in start.WireList.GetAllWires(port).Where(w => (forward ? w.LocalPipIsDriver : !w.LocalPipIsDriver)))
{
TileKey targetKey = Navigator.GetTargetLocation(start, wire);
if (FPGA.FPGA.Instance.Contains(targetKey))
{
Tile target = FPGA.FPGA.Instance.GetTile(targetKey);
Location loc = new Location(target, new Port(wire.PipOnOtherTile));
yield return(loc);
// return stopovers such as NL1B0 -> NL1E_S0 that are not part of the switch matrix but are part of wire lists
foreach (Wire reverseWire in target.WireList.GetAllWires(wire.PipOnOtherTile).
Where(rw => !rw.PipOnOtherTile.Equals(port.Name) && !rw.LocalPipIsDriver && wire.XIncr + rw.XIncr == 0 && wire.YIncr + rw.YIncr == 0))
{
Location returnLoc = new Location(start, new Port(reverseWire.PipOnOtherTile));
yield return(returnLoc);
}
/*
* // return stopovers such as NL1B0 -> NL1E_S0 that are not part of the switch matrix but are part of wire lists
* foreach (Wire rw in target.WireList.GetAllWires())
* {
* if (!rw.PipOnOtherTile.Equals(port.Name) && !rw.LocalPipIsDriver && rw.LocalPip.Equals(wire.PipOnOtherTile) && wire.XIncr + rw.XIncr == 0 && wire.YIncr + rw.YIncr == 0)
* {
* Location returnLoc = new Location(start, new Port(rw.PipOnOtherTile));
* yield return returnLoc;
* }
* }*/
}
}
}
public List <GridTile> GetTilesAdjacent(TileKey key)
{
List <GridTile> AdjacentTiles = new List <GridTile>();
GridTile _tile;
_tile = GetTile(key + TileKey.north);
if (_tile != null)
{
AdjacentTiles.Add(_tile);
}
_tile = GetTile(key + TileKey.east);
if (_tile != null)
{
AdjacentTiles.Add(_tile);
}
_tile = GetTile(key + TileKey.south);
if (_tile != null)
{
AdjacentTiles.Add(_tile);
}
_tile = GetTile(key + TileKey.west);
if (_tile != null)
{
AdjacentTiles.Add(_tile);
}
return(AdjacentTiles);
}
public static TileKey GetDestination(Tile start, FPGATypes.Direction direction, int stepWidth)
{
TileKey targetKey;
if (direction.Equals(FPGATypes.Direction.North))
{
targetKey = new TileKey(start.TileKey.X, start.TileKey.Y - stepWidth);
return(targetKey);
//return FPGA.FPGA.Instance.GetTile(targetKey);
}
else if (direction.Equals(FPGATypes.Direction.South))
{
targetKey = new TileKey(start.TileKey.X, start.TileKey.Y + stepWidth);
return(targetKey);
//return FPGA.FPGA.Instance.GetTile(targetKey);
}
else if (direction.Equals(FPGATypes.Direction.East))
{
targetKey = new TileKey(start.TileKey.X + stepWidth, start.TileKey.Y);
return(targetKey);
//return FPGA.FPGA.Instance.GetTile(targetKey);
}
else if (direction.Equals(FPGATypes.Direction.West))
{
targetKey = new TileKey(start.TileKey.X - stepWidth, start.TileKey.Y);
return(targetKey);
//return FPGA.FPGA.Instance.GetTile(targetKey);
}
else
{
throw new Exception("Unknown direction: " + direction);
}
}
public static TileKey GetDirection(TileKey from, TileKey to)
{
TileKey _return = to -= from;
// needs to be abs?
_return /= TileKey.Abs(to);
return(_return);
}
public void SetLocalPositionByKey(TileKey key)
{
Vector3 _newPosition = Vector3.zero;
_newPosition.x = key.X;
_newPosition.z = key.Z;
transform.localPosition = _newPosition;
}
public void Init(TileKey key)
{
this.Key = key;
SetLocalPositionByKey(Key);
if (TileRenderers.Length == 0)
{
TileRenderers = GetComponentsInChildren <MeshRenderer>();
}
}
public GridTile GetTile(TileKey key)
{
if (GridTiles.TryGetValue(key, out GridTile _returnTile))
{
return(_returnTile);
}
return(null);
}
public GridTile AddTileAtKey(TileKey key)
{
GridTile _newTile = Instantiate(TilePrefab, transform);
_newTile.Init(key);
GridTiles.Add(key, _newTile);
_newTile.UpdateSurroundingTiles(this);
return(_newTile);
}
public void UpdateStatusStrip(TileKey selectedKey)
{
string statusString = "";
if (FPGA.FPGA.Instance.Contains(selectedKey))
{
Tile selectedTile = FPGA.FPGA.Instance.GetTile(selectedKey);
statusString = selectedTile.Location + " " + selectedKey.ToString();
if (selectedTile.Slices.Count > 0)
{
statusString += " (";
// only display up to to slice
int displayedSlices = Math.Min(2, selectedTile.Slices.Count);
for (int i = 0; i < displayedSlices; i++)
{
statusString += selectedTile.Slices[i].ToString();
if (i != selectedTile.Slices.Count - 1)
{
statusString += ",";
}
}
// add dots for tiles with more than two slices
if (selectedTile.Slices.Count > 2)
{
statusString += "...";
}
statusString += ") ";
}
// 2 element buffer
m_lastClickedTile = m_currentlyClickedTile;
m_currentlyClickedTile = selectedTile;
}
// print selection info
if (StoredPreferences.Instance.PrintSelectionResourceInfo)
{
statusString += "Selection contains ";
statusString += TileSelectionManager.Instance.NumberOfSelectedTiles + " tiles, ";
int clbs = 0;
int brams = 0;
int dsps = 0;
TileSelectionManager.Instance.GetRessourcesInSelection(TileSelectionManager.Instance.GetSelectedTiles(), out clbs, out brams, out dsps);
int others = TileSelectionManager.Instance.NumberOfSelectedTiles - (clbs + brams + dsps);
statusString += clbs + " CLBs, ";
statusString += brams + " BRAMs, and ";
statusString += dsps + " DPS tiles, and ";
statusString += others + " other tiles";
}
m_statusStripLabelSelectedTile.Text = statusString;
}
public GridTile GetTile(int x, int z)
{
TileKey _key = new TileKey(x, z);
if (GridTiles.TryGetValue(_key, out GridTile _returnTile))
{
return(_returnTile);
}
return(null);
}
private static TileKey GetTargetLocation(Tile start, Wire wire)
{
TileKey targetKey = new TileKey(start.TileKey.X + wire.XIncr, start.TileKey.Y + wire.YIncr);
return(targetKey);
/*
* String locationPrefix = Regex.Split(start.Location, @"_X\d+Y\d+")[0];
* String targetLocationString = locationPrefix + "_X" + (start.LocationX + wire.XIncr) + "Y" + (start.LocationY + wire.YIncr);
* return targetLocationString;
*/
}
public static bool DestinationAndWireExists(Tile start, Wire wire)
{
TileKey targetKey = Navigator.GetTargetLocation(start, wire);
if (!FPGA.FPGA.Instance.Contains(targetKey))
{
return(false);
}
Tile target = FPGA.FPGA.Instance.GetTile(targetKey);
return(target.SwitchMatrix.Contains(wire.PipOnOtherTile));
}
public static TileKey Abs(TileKey value)
{
if (value.X < 0)
{
value.X *= -1;
}
if (value.Z < 0)
{
value.Z *= -1;
}
return(value);
}
public static int GetDirectionIndex(TileKey from, TileKey to)
{
TileKey _directionKey = GetDirection(from, to);
TileKey[] Surroundingkeys = Types.SurroundingKeys;
for (int i = 0; i < Surroundingkeys.Length; i++)
{
if (Surroundingkeys[i] == _directionKey)
{
return(i);
}
}
return(-1);
}
public static Tile GetDestinationByWire(Tile start, Wire wire)
{
TileKey targetKey = Navigator.GetTargetLocation(start, wire);
if (FPGA.FPGA.Instance.Contains(targetKey))
{
Tile target = FPGA.FPGA.Instance.GetTile(targetKey);
return(target);
}
else
{
return(FPGA.FPGA.Instance.GetTile(new TileKey(0, 0)));
}
}
private void m_zoomPictBox_MouseDoubleClick(object sender, MouseEventArgs e)
{
TileKey clickedKey = GetClickedKey(e.X, e.Y);
if (FPGA.FPGA.Instance.Contains(clickedKey))
{
OpenTileView cmd = new OpenTileView
{
X = clickedKey.X,
Y = clickedKey.Y
};
CommandExecuter.Instance.Execute(cmd);
}
}
public static Tuple <ConcurrentDictionary <TileKey, int>, ConcurrentDictionary <TileKey, TileKey> > Execute(ConcurrentDictionary <TileKey, int> tiles, ArrayView2D <int> bpBuffer, int tilewidth, int tileheight)
{
int[,] ts = new int[tiles.Count, 3];
int i = 0;
foreach (var kvp in tiles)
{
ts[i, 0] = 0;
ts[i, 1] = kvp.Key.X;
ts[i, 2] = kvp.Key.Y;
i++;
}
int tilesperRow = bpBuffer.Extent.X / tilewidth;
using (MemoryBuffer2D <int> res = HardwareAcceleratorManager.GPUAccelerator.Allocate <int>(ts.GetLength(0), ts.GetLength(1)))
{
res.CopyFrom(ts, Index2.Zero, Index2.Zero, res.Extent);
kernel(new Index2(tiles.Count, tiles.Count), bpBuffer, res, new Index2(tilewidth, tileheight), tilesperRow);
HardwareAcceleratorManager.GPUAccelerator.Synchronize();
res.CopyTo(ts, Index2.Zero, Index2.Zero, res.Extent);
}
ConcurrentDictionary <TileKey, int> ret = new ConcurrentDictionary <TileKey, int>();
ConcurrentDictionary <TileKey, TileKey> ret2 = new ConcurrentDictionary <TileKey, TileKey>();
Parallel.For(0, tiles.Count, x =>
{
if (ts[x, 0] == 0)
{
ret.TryAdd(new TileKey(ts[x, 1], ts[x, 2], tilesperRow), -1);
}
ret2.TryAdd(new TileKey(ts[x, 1], ts[x, 2], tilesperRow), new TileKey((ts[x, 0] - 1) % tilesperRow, (ts[x, 0] - 1) / tilesperRow, tilesperRow));
});
foreach (var kvp in ret2)
{
if (kvp.Value.X >= 0)
{
TileKey aux = kvp.Value;
while (aux.X >= 0)
{
ret2[kvp.Key] = aux;
aux = ret2[aux];
}
}
}
return(new Tuple <ConcurrentDictionary <TileKey, int>, ConcurrentDictionary <TileKey, TileKey> >(ret, ret2));
}
private static TileKey GetTargetLocation(Tile start, Wire wire, bool forward = true)
{
int x = wire.XIncr;
int y = wire.YIncr;
if (!forward)
{
x *= -1;
y *= -1;
}
TileKey targetKey = new TileKey(start.TileKey.X + x, start.TileKey.Y + y);
return(targetKey);
}
protected override void DoCommandAction()
{
Tile ul = TileSelectionManager.Instance.GetUserSelectedTile("", UserSelectionType, FPGATypes.Placement.UpperLeft);
Tile lr = TileSelectionManager.Instance.GetUserSelectedTile("", UserSelectionType, FPGATypes.Placement.LowerRight);
List <Tile> fenceTiles = new List <Tile>();
for (int x = ul.TileKey.X - Size; x <= lr.TileKey.X + Size; x++)
{
for (int y = ul.TileKey.Y - Size; y <= lr.TileKey.Y + Size; y++)
{
TileKey key = new TileKey(x, y);
if (!TileSelectionManager.Instance.IsUserSelected(key, UserSelectionType) && FPGA.FPGA.Instance.Contains(x, y))
{
Tile t = FPGA.FPGA.Instance.GetTile(key);
bool resMatch =
Objects.IdentifierManager.Instance.IsMatch(t.Location, Objects.IdentifierManager.RegexTypes.Interconnect) ||
Objects.IdentifierManager.Instance.IsMatch(t.Location, Objects.IdentifierManager.RegexTypes.CLB) ||
Objects.IdentifierManager.Instance.IsMatch(t.Location, Objects.IdentifierManager.RegexTypes.DSP) ||
Objects.IdentifierManager.Instance.IsMatch(t.Location, Objects.IdentifierManager.RegexTypes.BRAM);
// prevent RUG-Creation by only adding "well known" tiles
if (resMatch)
{
fenceTiles.Add(t);
}
}
}
}
ClearSelection clearCmd = new ClearSelection();
CommandExecuter.Instance.Execute(clearCmd);
foreach (Tile t in fenceTiles)
{
AddToSelectionLoc addCmd = new AddToSelectionLoc();
addCmd.Location = t.Location;
CommandExecuter.Instance.Execute(addCmd);
}
ExpandSelection expandCmd = new ExpandSelection();
CommandExecuter.Instance.Execute(expandCmd);
}
protected override void DoCommandAction()
{
Regex filter = new Regex(Filter);
// run form min to max
int startX = Math.Min(UpperLeftX, LowerRightX);
int endX = Math.Max(UpperLeftX, LowerRightX);
int startY = Math.Min(UpperLeftY, LowerRightY);
int endY = Math.Max(UpperLeftY, LowerRightY);
for (int x = startX; x <= endX; x++)
{
for (int y = startY; y <= endY; y++)
{
// click done out of fpga range
if (!FPGA.FPGA.Instance.Contains(x, y))
{
continue;
}
TileKey key = new TileKey(x, y);
Tile t = FPGA.FPGA.Instance.GetTile(key);
if (!filter.IsMatch(t.Location))
{
continue;
}
//deselect or add the selected tile
if (TileSelectionManager.Instance.IsSelected(x, y))
{
TileSelectionManager.Instance.RemoveFromSelection(key, false);
}
else
{
TileSelectionManager.Instance.AddToSelection(key, false);
}
}
}
TileSelectionManager.Instance.SelectionChanged();
}
public void GenerateGrid()
{
#if UNITY_EDITOR
for (int xindex = 0; xindex < Xtiles; xindex++)
{
for (int zindex = 0; zindex < Ztiles; zindex++)
{
TileKey _newKey = new TileKey(xindex, zindex);
GridTile _newTile = (GridTile)PrefabUtility.InstantiatePrefab(TilePrefab, transform);
_newTile.Init(_newKey);
GridTiles.Add(_newKey, _newTile);
}
}
foreach (KeyValuePair <TileKey, GridTile> item in GridTiles)
{
item.Value.SetSurroundingTiles(this);
}
#endif
}
public void LoadGridFromWorld()
{
foreach (var item in GridTiles)
{
item.Value.ClearSurroundingTiles(this);
}
GridTiles.Clear();
GridTile[] _tileArray = FindObjectsOfType <GridTile>();
// inactive gridtiles should not be included in this fetch
for (int i = _tileArray.Length - 1; i >= 0; i--)
{
GridTile _tile = _tileArray[i];
TileKey _key = GetKeyFromVector(_tile.transform.position);
if (GridTiles.ContainsKey(_key))
{
DestroyImmediate(_tile.gameObject);
Debug.Log(_key + " destroyed");
continue;
}
Vector3 _position = Vector3.zero;
_position.x = Mathf.RoundToInt(_key.X);
_position.z = Mathf.RoundToInt(_key.Z);
_tile.transform.position = _position;
_tile.transform.parent = transform;
_tile.name = _key.X + " " + _key.Z;
_tile.Init(_key);
GridTiles.Add(_key, _tile);
}
foreach (KeyValuePair <TileKey, GridTile> item in GridTiles)
{
item.Value.SetSurroundingTiles(this);
}
Debug.Log(GridTiles.Count);
}
public void DeriveTileKeyAndSliceNumber()
{
Tile tile = FPGA.FPGA.Instance.GetTile(Location);
m_tileKey = tile.TileKey;
// sideeffect with get!
TileKey key = TileKey;
Tile where = FPGA.FPGA.Instance.GetTile(Location);
if (where.HasSlice(SliceName))
{
m_sliceNumber = where.GetSliceNumberByName(SliceName);
}
else
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Warning: Can not find " + SliceName + " on tile " + where.Location);
Console.ResetColor();
m_sliceNumber = 0;
}
}
private FractalTile AllocateTile(TileKey key)
{
double edge;
if (key.LOD < 0)
{
edge = 1.0 * ((long)1 << -key.LOD);
}
else
{
edge = 1.0 / ((long)1 << key.LOD);
}
var pos = new double2(key.X, key.Y);
var minima = new double2(key.X * edge, key.Y * edge);
var maxima = new double2((key.X + 1) * edge, (key.Y + 1) * edge);
var tile = new FractalTile(_fractal, _pool.Get(), minima, maxima, edge < 1e-5);
_tileCache[key] = tile;
return(tile);
}
public override void Do()
{
this.m_oldFocus = FPGA.FPGA.Instance.Current;
Tile current = FPGA.FPGA.Instance.Current;
Types.Direction direction = Types.ParseDirectionFromString(this.DirectionString);
while (true)
{
TileKey targetKey = V5Navigator.GetDestination(current, direction, 1);
if (!FPGA.FPGA.Instance.Contains(targetKey))
throw new ArgumentException("Left FPGA during navigation from " + current + " in direction " + direction);
current = FPGA.FPGA.Instance.GetTile(targetKey);
if (!FPGA.FPGA.Instance.Contains(current.TileKey))
{
throw new ArgumentException("Leaving FPGA");
}
if (System.Text.RegularExpressions.Regex.IsMatch(current.Location, this.Regex))
{
FPGA.FPGA.Instance.Current = current;
break;
}
}
}
