//-----------------------------------------------------------------------------
public void Execute()
{
for (int i = 0; i < Flowfield.Length; ++i)
{
var cellIndex = FloodQueue[i];
if (cellIndex < 0 || cellIndex >= Flowfield.Length)
{
continue;
}
var flowDirection = Flowfield[cellIndex];
var cellGrid = GridUtilties.Index2Grid(Settings, cellIndex);
var cellDirectionCeiling = new int2((int)math.sign(flowDirection.x), (int)math.sign(flowDirection.z));
var backPropagationCellGrid = cellGrid + cellDirectionCeiling;
var backPropagationCellIndex = GridUtilties.Grid2Index(Settings, backPropagationCellGrid);
if (backPropagationCellIndex < 0)
{
continue;
}
var backPropagationCellDirection = Flowfield[backPropagationCellIndex];
Flowfield[cellIndex] = math_experimental.normalizeSafe(
flowDirection * (1.0f - SmoothAmount) + backPropagationCellDirection * SmoothAmount);
}
}
//-----------------------------------------------------------------------------
public void Execute()
{
BurstQueue queue = new BurstQueue(FloodQueue);
for (int index = 0; index < NumGoals; ++index)
{
var tileIndex = GridUtilties.Grid2Index(Settings, Goals[index]);
if (DistanceMap[tileIndex] < TileSystem.k_ObstacleFloat)
{
DistanceMap[tileIndex] = 0;
queue.Enqueue(tileIndex);
}
}
// Search!
while (queue.Length > 0)
{
var index = queue.Dequeue();
var newDistance = DistanceMap[index] + 1;
var grid = GridUtilties.Index2Grid(Settings, index);
for (GridUtilties.Direction dir = GridUtilties.Direction.N; dir <= GridUtilties.Direction.W; ++dir)
{
var neighborGrid = grid + Offsets[(int)dir];
var neighborIndex = GridUtilties.Grid2Index(Settings, neighborGrid);
if (neighborIndex != -1 && DistanceMap[neighborIndex] < TileSystem.k_ObstacleFloat && newDistance < DistanceMap[neighborIndex])
{
DistanceMap[neighborIndex] = newDistance;
queue.Enqueue(neighborIndex);
}
}
}
}
//-----------------------------------------------------------------------------
public void Execute(int index)
{
int2 gridPos = GridUtilties.Index2Grid(Settings, index);
float weight = DistanceMap[index];
Flowfield[index] = new float3(0);
for (GridUtilties.Direction dir = 0; dir < GridUtilties.Direction.MAX; ++dir)
{
int2 dirOffset = Offsets[(int)dir];
int neigborIdx = GridUtilties.Grid2Index(Settings, gridPos + dirOffset);
if (neigborIdx == -1)
{
continue;
}
float neighborWeight = DistanceMap[neigborIdx];
if (weight <= neighborWeight)
{
continue;
}
weight = neighborWeight;
float3 direction = new float3(dirOffset.x, 0, dirOffset.y);
Flowfield[index] = math.normalize(direction);
}
}
//-----------------------------------------------------------------------------
public static void CreateGrid(GridSettings grid,
NativeArray <float> heightmap,
NativeArray <float3> colormap,
NativeArray <float3> normalmap,
NativeArray <float3> flowMap,
Func <float2, int2, CellData> func)
{
var entityManager = World.Active.GetOrCreateManager <EntityManager>();
var entities = new NativeArray <Entity>(grid.cellCount.x * grid.cellCount.y, Allocator.Temp);
entityManager.CreateEntity(Archetypes.Tile, entities);
var cells = new CellData[entities.Length];
for (int ii = 0; ii < entities.Length; ii++)
{
var coord = GridUtilties.Index2Grid(grid, ii);
float2 per = new float2(coord) / grid.cellCount;
cells[ii] = func(per, coord);
}
float inv255 = 1f / 255f;
for (int ii = 0; ii < entities.Length; ii++)
{
int2 coord = GridUtilties.Index2Grid(grid, ii);
var cd = cells[ii];
colormap[ii] = cd.color;
heightmap[ii] = cd.height;
float[] s = new float[8];
for (int i = 0; i < GridUtilties.Offset.Length; ++i)
{
var index = GridUtilties.Grid2Index(grid, coord + GridUtilties.Offset[i]);
if (index != -1)
{
s[i] = cells[index].height;
}
else
{
s[i] = 0.5f;
}
}
var normal = new float3(
-(s[4] - s[6] + 2 * (s[2] - s[3]) + s[5] - s[7]),
cd.height, //.2f,
-(s[7] - s[6] + 2 * (s[1] - s[0]) + s[5] - s[4]));
normalmap[ii] = math.normalize(normal);
normal.y = 0;
normal = math.normalize(normal);
var flow = normal * cd.cost * inv255;
flowMap[ii] = flow;
Archetypes.SetupTile(entityManager, entities[ii], Main.ActiveInitParams.TileDirectionMesh, Main.ActiveInitParams.TileDirectionMaterial, coord, cd.cost, new float3(), grid);
}
entities.Dispose();
}
static void TestGrid(int2 grid)
{
int min = 0;
int max = grid.x * grid.y - 1;
int edge = grid.x - 1;
// Bounds Checks
Assert.AreEqual(new int2(0, 0), GridUtilties.Index2Grid(grid, min));
Assert.AreEqual(new int2(grid.x - 1, grid.y - 1), GridUtilties.Index2Grid(grid, max));
// Out Of Bounds Checks
Assert.AreEqual(Invalid_Grid, GridUtilties.Index2Grid(grid, min - 1));
Assert.AreEqual(Invalid_Grid, GridUtilties.Index2Grid(grid, max + 1));
// Value Checks
Assert.AreEqual(new int2(grid.x - 1, 0), GridUtilties.Index2Grid(grid, edge));
Assert.AreEqual(new int2(0, 1), GridUtilties.Index2Grid(grid, edge + 1));
Assert.AreEqual(new int2(1, 1), GridUtilties.Index2Grid(grid, edge + 2));
}
//-----------------------------------------------------------------------------
public void Execute(int index)
{
// // don't smooth tiles which are next to obstacles
// if (DistanceMap[index] >= TileSystem.k_ObstacleFloat
// || DistanceMap[index + 1] >= TileSystem.k_ObstacleFloat
// || DistanceMap[index - 1] >= TileSystem.k_ObstacleFloat
// || DistanceMap[index + cellCount] >= TileSystem.k_ObstacleFloat
// || DistanceMap[index - cellCount] >= TileSystem.k_ObstacleFloat
// || DistanceMap[index + cellCount + 1] >= TileSystem.k_ObstacleFloat
// || DistanceMap[index - cellCount - 1] >= TileSystem.k_ObstacleFloat
// || DistanceMap[index + cellCount - 1] >= TileSystem.k_ObstacleFloat
// || DistanceMap[index - cellCount + 1] >= TileSystem.k_ObstacleFloat)
// return;
var cellCount = Settings.cellCount.x;
var minCellCount = cellCount + 1;
if (index < minCellCount || index >= Flowfield.Length - minCellCount)
{
return;
}
int2 gridPos = GridUtilties.Index2Grid(Settings, index);
Flowfield[index] = new float3(0);
float distance = DistanceMap[index];
int neigborIndex = GridUtilties.Grid2Index(Settings, gridPos + Offsets[(int)GridUtilties.Direction.E]);
float ax = (neigborIndex != -1 && DistanceMap[neigborIndex] < TileSystem.k_ObstacleFloat ? DistanceMap[neigborIndex] : distance);
neigborIndex = GridUtilties.Grid2Index(Settings, gridPos + Offsets[(int)GridUtilties.Direction.W]);
float bx = (neigborIndex != -1 && DistanceMap[neigborIndex] < TileSystem.k_ObstacleFloat ? DistanceMap[neigborIndex] : distance);
neigborIndex = GridUtilties.Grid2Index(Settings, gridPos + Offsets[(int)GridUtilties.Direction.N]);
float ay = (neigborIndex != -1 && DistanceMap[neigborIndex] < TileSystem.k_ObstacleFloat ? DistanceMap[neigborIndex] : distance);
neigborIndex = GridUtilties.Grid2Index(Settings, gridPos + Offsets[(int)GridUtilties.Direction.S]);
float by = (neigborIndex != -1 && DistanceMap[neigborIndex] < TileSystem.k_ObstacleFloat ? DistanceMap[neigborIndex] : distance);
Flowfield[index] = math_experimental.normalizeSafe(new float3(ax - bx, 0, ay - by) * math.max((byte.MaxValue - Costs[index]), 1));
}