public FlowField(PotentialField potentialField)
{
TargetNode = potentialField.TargetNode;
TargetWorldPosition = potentialField.TargetWorldPosition;
GridTransformer = potentialField.GridTransformer;
FlowArray = new Array2D <byte>(potentialField.PotentialArray.Width, potentialField.PotentialArray.Height);
for (int y = 0; y < potentialField.PotentialArray.Height; y++)
{
for (int x = 0; x < potentialField.PotentialArray.Width; x++)
{
var vector = potentialField[x, y];
if (vector.X == 0 && vector.Y == 0)
{
FlowArray[x, y] = 254;
}
else
{
var angle = MathF.Atan2(vector.Y, vector.X);
var index = (byte)((angle + HalfTurn) / FullTurn * StepAmount);
FlowArray[x, y] = index;
}
}
}
}
public void ToGrid_CorrectPosition(Point2 gridSize, Vector2 scale, Vector2 position, Vector2 worldPositionToTransform, Point2 expectedGridPosition)
{
var transformer = new GridTransformer(gridSize, scale, position);
var gridPosition = transformer.ToGrid(worldPositionToTransform);
Assert.AreEqual(expectedGridPosition, gridPosition);
}
public void GetHeading_ZeroPotentials_ZeroVector(Vector2 worldPosition)
{
const int width = 3;
const int height = 3;
var transformer = new GridTransformer(new Point2(width, height), new Vector2(1, 1));
var potentials = new Array2D <float>(width, height);
var potentialField = new PotentialField(transformer, new Point2(), potentials);
CheckHeading(potentialField, worldPosition, new Vector2(0, 0));
}
public Vector2 GetHeading(Vector2 currentPosition)
{
var gridCoords = GridTransformer.ToGrid(currentPosition);
if (gridCoords == TargetNode)
{
return((TargetWorldPosition - currentPosition).Normalized);
}
return(this[gridCoords.X, gridCoords.Y]);
}
public PotentialField(GridTransformer gridTransformer, Point2 targetNodePosition, Array2D <float> potentialArray) : base(gridTransformer)
{
if (potentialArray.Width != gridTransformer.GridSize.X || potentialArray.Height != gridTransformer.GridSize.Y)
{
throw new ArgumentException("The grid dimensions of the transformer have to match the array");
}
PotentialArray = potentialArray;
TargetNode = targetNodePosition;
TargetWorldPosition = gridTransformer.ToWorld(targetNodePosition);
}
public AggregratedPotentialField(GridTransformer gridTransformer, params PotentialFieldBase[] potentialFields) : base(gridTransformer)
{
var firstPotentialField = potentialFields.First();
TargetNode = firstPotentialField.TargetNode;
Width = firstPotentialField.Width;
Height = firstPotentialField.Height;
TargetWorldPosition = potentialFields.First().TargetWorldPosition;
PotentialFields = potentialFields;
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
GridTransformer gridTrans = (GridTransformer)target;
if (GUILayout.Button("Transfrom Line"))
{
gridTrans.TransformLine();
}
}
public PotentialArray(GridTransformer gridTransformer, Array2D <float>[] potentialArrays)
{
if (potentialArrays == null)
{
throw new ArgumentException("potentialArray cannot be null");
}
foreach (var array in potentialArrays)
{
if (array.Width != gridTransformer.GridSize.X || array.Height != gridTransformer.GridSize.Y)
{
throw new ArgumentException("The grid dimensions of the transformer have to match the array");
}
}
GridTransformer = gridTransformer;
Arrays = potentialArrays;
}
/// <summary>
/// Creates a new <see cref="DynamicPotentialField"/>
/// </summary>
/// <param name="pathfindaxManager"></param>
/// <param name="gridTransformer"></param>
/// <param name="interval">The update interval in milliseconds.</param>
public DynamicPotentialField(IPathfindaxManager pathfindaxManager, GridTransformer gridTransformer, float interval) : base(gridTransformer)
{
pathfindaxManager.CreatePotentialFieldUpdater(this, interval);
PotentialArray = new Array2D <float>(gridTransformer.GridSize.X, gridTransformer.GridSize.Y);
}
public void UpdateGridPosition(GridTransformer gridTransformer)
{
var worldPosition = _worldPositionProvider.Invoke();
GridPosition = gridTransformer.ToGrid(worldPosition);
}
public PotentialFieldBase(GridTransformer gridTransformer)
{
GridTransformer = gridTransformer;
}
public PotentialField(GridTransformer gridTransformer, Point2 targetNodePosition) : base(gridTransformer)
{
TargetNode = targetNodePosition;
TargetWorldPosition = gridTransformer.ToWorld(targetNodePosition);
}
public PotentialField(GridTransformer gridTransformer, Point2 targetNodePosition, params Array2D <float>[] potentialArrays)
{
TargetNode = targetNodePosition;
PotentialArray = new PotentialArray(gridTransformer, potentialArrays);
}
//here we go, thats the method called by vvvv each frame
//all data handling should be in here
public void Evaluate(int SpreadMax)
{
double width; FPinWidth.GetValue(0, out width);
double height; FPinHeight.GetValue(0, out height);
// if something changed, recreate Trafo
if (FInputGridFrom.PinIsChanged || FInputGridTo.PinIsChanged || width != FWidth || height != FHeight)
{
// prepare GridTransformer
FTrafo = new GridTransformer();
int i, j;
Point2D p1, p2, p3;
FWidth = (int)width;
FHeight = (int)height;
// check Input ranges
FBufSize = (int)height * (int)width * 2;
if (FInputGridFrom.SliceCount != FBufSize || FInputGridTo.SliceCount != FBufSize)
{
return;
}
// loop through points and create triangles
for (i = 0; i < FHeight - 1; ++i)
{
for (j = 0; j < FWidth - 1; ++j)
{
int index = j + i * FWidth;
// upper triangle
FInputGridFrom.GetValue2D(index, out p1.x, out p1.y);
FInputGridFrom.GetValue2D(index + 1, out p2.x, out p2.y);
FInputGridFrom.GetValue2D(index + FWidth, out p3.x, out p3.y);
Triangle triFrom1 = new Triangle(p1, p2, p3);
FInputGridTo.GetValue2D(index, out p1.x, out p1.y);
FInputGridTo.GetValue2D(index + 1, out p2.x, out p2.y);
FInputGridTo.GetValue2D(index + FWidth, out p3.x, out p3.y);
Triangle triTo1 = new Triangle(p1, p2, p3);
FTrafo.Insert(triFrom1, triTo1);
// lower triangle
FInputGridFrom.GetValue2D(index + 1, out p1.x, out p1.y);
FInputGridFrom.GetValue2D(index + FWidth, out p2.x, out p2.y);
FInputGridFrom.GetValue2D(index + FWidth + 1, out p3.x, out p3.y);
Triangle triFrom2 = new Triangle(p1, p2, p3);
FInputGridTo.GetValue2D(index + 1, out p1.x, out p1.y);
FInputGridTo.GetValue2D(index + FWidth, out p2.x, out p2.y);
FInputGridTo.GetValue2D(index + FWidth + 1, out p3.x, out p3.y);
Triangle triTo2 = new Triangle(p1, p2, p3);
FTrafo.Insert(triFrom2, triTo2);
}
}
}
///////////////////////////////////////////////////////
// do transformation
// prepare data
int sliceCount = FInputPoints.SliceCount;
Point2D pIn, pOut;
List <Point2D> pList = new List <Point2D>();
int[] hitter;
hitter = new int[sliceCount / 2];
int number = (sliceCount / 2);
// loop throug input points and calc Transformation
for (int i = 0; i < sliceCount / 2; ++i)
{
FInputPoints.GetValue2D(i, out pIn.x, out pIn.y);
if (FTrafo.Transform(pIn, out pOut)) // inside ?
{
pList.Add(pOut);
hitter[i] = 1;
}
else
{
hitter[i] = 0;
}
}
// set final slicecount
FOutputPoints.SliceCount = pList.Count * 2;
FOutputHit.SliceCount = number;
// set output
for (int i = 0; i < pList.Count; ++i)
{
FOutputPoints.SetValue2D(i, pList[i].x, pList[i].y);
FOutputHit.SetValue(i, hitter[i]);
}
for (int i = 0; i < number; ++i)
{
FOutputHit.SetValue(i, hitter[i]);
}
}
