public static float[] OuterVertexHeights(BlendTile tile, int shift, int adj_height_l, int adj_height_r)
{
if (shift < 0 || shift >= 6)
{
throw new System.ArgumentOutOfRangeException("shift", "Arguments range is [0-5].");
}
float[] heights = new float[] { 0, 0, 0, 0, 0, 0 };
//calculate height
switch (tile)
{
case BlendTile.Single:
heights[shift] = adj_height_l;
heights[HV.D[1, shift]] = adj_height_l;
break;
case BlendTile.Double:
heights[shift] = adj_height_l;
heights[HV.D[1, shift]] = adj_height_l;
heights[HV.D[2, shift]] = adj_height_l;
break;
case BlendTile.Triple:
heights[shift] = adj_height_l;
heights[HV.D[1, shift]] = adj_height_l;
heights[HV.D[2, shift]] = adj_height_r;
heights[HV.D[3, shift]] = adj_height_r;
break;
}
return(heights);
}
public void Init()
{
_tile = default(BlendTile);
_adj_options = new AdjBlendOption[6];
_raw_adj_options = new ushort[6];
for (int d = 0; d < 6; d++)
{
this[d] = (AdjBlendOption)EditorPrefs.GetInt(PROP_KEY + d, 1);
}
}
private static int ClassifyAdjacentHeight(BlendTile tile)
{
int height = 0;
if (tile != BlendTile.None)
{
height = 1;
}
return(height);
}
public int BlendTileKeyIndex(BlendTile tile)
{
for (int k = 0; k < _blend_tiles.Length; k++)
{
if (_blend_tiles[k] == tile)
{
return(k);
}
}
return(-1);
}
public void GenerateMesh()
{
List <Vector3> vertices = new List <Vector3>();
List <int> triangles = new List <int>();
//add center hexagon
int base_height = 2;
int adj_height_l = 0;
int adj_height_r = 0;
_tile = BlendTile.None;
_shift = 0;
if (rule != null)
{
TileConfiguration config = rule.GetTileConfiguration(adj_tiles);
_tile = config.tile;
_shift = config.shift;
adj_height_l = 1;
adj_height_r = 1;
}
float[] corners = MeshGeneration.OuterVertexHeights(_tile, _shift, adj_height_l, adj_height_r);
Vector3[] surface_vertex = MeshGeneration.CalculateSurfaceVertices(Vector3.zero, base_height, corners);
Vector3[] base_vertex = MeshGeneration.CalculateBaseVertices(Vector3.zero, 0);
MeshGeneration.AddHexagon(surface_vertex, base_vertex, vertices, triangles);
//add adjacent hexagons
for (int d = 0; d < 6; d++)
{
BlendTile adj_tile = ClassifyAdjacentTile(adj_tiles[d]);
int adj_shift = CalculateAdjacentShift(adj_tile, adj_tiles[d], d);
int adj_height = ClassifyAdjacentHeight(adj_tile);
int height = AdjacentHexagonHeight(adj_tiles[d]);
corners = MeshGeneration.OuterVertexHeights(adj_tile, adj_shift, adj_height);
Vector3 center = MeshGeneration.AdjCenters[d];
surface_vertex = MeshGeneration.CalculateSurfaceVertices(center, base_height + height, corners);
base_vertex = MeshGeneration.CalculateBaseVertices(center, 0);
MeshGeneration.AddHexagon(surface_vertex, base_vertex, vertices, triangles);
}
Mesh mesh = new Mesh();
mesh.SetVertices(vertices);
mesh.SetTriangles(triangles, 0);
mesh.RecalculateBounds();
mesh.RecalculateNormals();
mesh.RecalculateTangents();
mesh.UploadMeshData(false);
SetMesh(mesh);
}
public void Init()
{
_shift = 0;
_tile = default(BlendTile);
_adj_tiles = new AdjBlendTile[] {
AdjBlendTile.B, AdjBlendTile.B, AdjBlendTile.B,
AdjBlendTile.B, AdjBlendTile.B, AdjBlendTile.B
};
for (int d = 0; d < 6; d++)
{
this[d] = (AdjBlendTile)EditorPrefs.GetInt(PROP_KEY + d, 1);
}
}
private void Reset()
{
//Create component
_tile = BlendTile.None;
_shift = 0;
adj_tiles = new AdjBlendTile[] {
AdjBlendTile.B,
AdjBlendTile.B,
AdjBlendTile.B,
AdjBlendTile.B,
AdjBlendTile.B,
AdjBlendTile.B
};
GenerateMesh();
}
private void ReadBlendTiles()
{
Map.Tiles.BlendTiles = new List <BlendTile>(Map.Tiles.NumberOfBlendTiles);
//Start at 1! NumberOfBlendTiles is always 1 more than the actual number (?).
for (int i = 1; i < Map.Tiles.NumberOfBlendTiles; i++)
{
var blendTile = new BlendTile();
blendTile.TileIndex = reader.ReadInt16();
blendTile.BlendType = (BlendType)reader.ReadInt64();
long blendData = reader.ReadInt64();
Assert(blendData == BlendTile.BlendData);
Map.Tiles.BlendTiles.Add(blendTile);
}
}
public static int UpperSides(this BlendTile tile)
{
switch (tile)
{
case BlendTile.Single:
return(1);
case BlendTile.Double:
return(2);
case BlendTile.Triple:
return(3);
default:
return(0);
}
}
private static BlendTile ClassifyAdjacentTile(AdjBlendTile adj_tile)
{
BlendTile tile = BlendTile.None;
switch (adj_tile)
{
case AdjBlendTile.BC:
tile = BlendTile.Triple;
break;
case AdjBlendTile.bc:
case AdjBlendTile.LC:
case AdjBlendTile.lc:
tile = BlendTile.Single;
break;
}
return(tile);
}
public void Init()
{
_default_tile = default(BlendTile);
BlendTile[] tiles = (BlendTile[])System.Enum.GetValues(typeof(BlendTile));
int index = 0;
int count = Mathf.Max(tiles.Length - 1);
_rule_lists = new BlendRuleList[count];
_blend_tiles = new BlendTile[count];
for (int k = 0; k < tiles.Length; k++)
{
if (tiles[k] != _default_tile)
{
_blend_tiles[index] = tiles[k];
_rule_lists[index] = new BlendRuleList();
index += 1;
}
}
}
public static bool IsHighPoint(this BlendTile tile, int index)
{
if (index < 0 || index > 5)
{
return(false);
}
switch (tile)
{
case BlendTile.Single:
return(index < 2);
case BlendTile.Double:
return(index < 3);
case BlendTile.Triple:
return(index < 4);
default:
return(false);
}
}
private static int CalculateAdjacentShift(BlendTile tile, AdjBlendTile adj_tile, int d)
{
if (tile == BlendTile.Triple)
{
return(MeshGeneration.D[5, d]);
}
else if (tile == BlendTile.Single)
{
if (adj_tile == AdjBlendTile.bc || adj_tile == AdjBlendTile.lc)
{
return(MeshGeneration.D[4, d]);
}
else
{
return(MeshGeneration.D[3, d]);
}
}
else
{
return(0);
}
}
public static float[] OuterVertexHeights(BlendTile tile, int shift, int adj_height)
{
return(OuterVertexHeights(tile, shift, adj_height, adj_height));
}
