internal override void RuleMatrixOnGUI(RuleTile ruleTile, Rect rect, RuleTile.TilingRule tilingRule)
{
var hexTile = (HexagonalRuleTile)ruleTile;
bool flatTop = hexTile.m_FlatTop;
Handles.color = EditorGUIUtility.isProSkin ? new Color(1f, 1f, 1f, 0.2f) : new Color(0f, 0f, 0f, 0.2f);
float w = rect.width / 3f;
float h = rect.height / 3f;
// Grid
if (flatTop)
{
for (int x = 0; x <= 3; x++)
{
float left = rect.xMin + x * w;
float offset = x % 3 > 0 ? 0 : h / 2;
Handles.DrawLine(new Vector3(left, rect.yMin + offset), new Vector3(left, rect.yMax - offset));
if (x < 3)
{
bool noOffset = x % 2 > 0;
for (int y = 0; y < (noOffset ? 4 : 3); y++)
{
float top = rect.yMin + y * h + (noOffset ? 0 : h / 2);
Handles.DrawLine(new Vector3(left, top), new Vector3(left + w, top));
}
}
}
}
else
{
for (int y = 0; y <= 3; y++)
{
float top = rect.yMin + y * h;
float offset = y % 3 > 0 ? 0 : w / 2;
Handles.DrawLine(new Vector3(rect.xMin + offset, top), new Vector3(rect.xMax - offset, top));
if (y < 3)
{
bool noOffset = y % 2 > 0;
for (int x = 0; x < (noOffset ? 4 : 3); x++)
{
float left = rect.xMin + x * w + (noOffset ? 0 : w / 2);
Handles.DrawLine(new Vector3(left, top), new Vector3(left, top + h));
}
}
}
}
// Icons
Handles.color = Color.white;
for (int index = 0; index < hexTile.neighborCount; ++index)
{
Vector2 position = flatTop ? s_FlatTopPositions[index] : s_PointedTopPositions[index];
int arrowIndex = flatTop ? s_FlatTopArrows[index] : s_PointedTopArrows[index];
Rect r = new Rect(rect.xMin + position.x * w, rect.yMin + position.y * h, w - 1, h - 1);
RuleOnGUI(r, arrowIndex, tilingRule.m_Neighbors[index]);
RuleNeighborUpdate(r, tilingRule, index);
}
// Center
{
Rect r = new Rect(rect.xMin + w, rect.yMin + h, w - 1, h - 1);
RuleTransformOnGUI(r, tilingRule.m_RuleTransform);
RuleTransformUpdate(r, tilingRule);
}
}
private void RuleOverrideInspectorOnGUI(Rect rect, RuleTile.TilingRule originalRule)
{
RuleTile.TilingRule overrideRule = overrideTile[originalRule];
float y = rect.yMin;
EditorGUI.BeginChangeCheck();
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Enabled");
bool enabled = EditorGUI.Toggle(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), overrideRule != null);
y += k_SingleLineHeight;
if (EditorGUI.EndChangeCheck())
{
if (enabled)
{
overrideTile[originalRule] = originalRule;
}
else
{
overrideTile[originalRule] = null;
}
overrideRule = overrideTile[originalRule];
}
if (overrideRule == null)
{
return;
}
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Game Object");
overrideRule.m_GameObject = (GameObject)EditorGUI.ObjectField(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), "", overrideRule.m_GameObject, typeof(GameObject), false);
y += k_SingleLineHeight;
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Collider");
overrideRule.m_ColliderType = (Tile.ColliderType)EditorGUI.EnumPopup(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), overrideRule.m_ColliderType);
y += k_SingleLineHeight;
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Output");
overrideRule.m_Output = (RuleTile.TilingRule.OutputSprite)EditorGUI.EnumPopup(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), overrideRule.m_Output);
y += k_SingleLineHeight;
if (overrideRule.m_Output == RuleTile.TilingRule.OutputSprite.Animation)
{
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Speed");
overrideRule.m_AnimationSpeed = EditorGUI.FloatField(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), overrideRule.m_AnimationSpeed);
y += k_SingleLineHeight;
}
if (overrideRule.m_Output == RuleTile.TilingRule.OutputSprite.Random)
{
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Noise");
overrideRule.m_PerlinScale = EditorGUI.Slider(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), overrideRule.m_PerlinScale, 0.001f, 0.999f);
y += k_SingleLineHeight;
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Shuffle");
overrideRule.m_RandomTransform = (RuleTile.TilingRule.Transform)EditorGUI.EnumPopup(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), overrideRule.m_RandomTransform);
y += k_SingleLineHeight;
}
if (overrideRule.m_Output != RuleTile.TilingRule.OutputSprite.Single)
{
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Size");
EditorGUI.BeginChangeCheck();
int newLength = EditorGUI.DelayedIntField(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), overrideRule.m_Sprites.Length);
if (EditorGUI.EndChangeCheck())
{
Array.Resize(ref overrideRule.m_Sprites, Math.Max(newLength, 1));
}
y += k_SingleLineHeight;
for (int i = 0; i < overrideRule.m_Sprites.Length; i++)
{
overrideRule.m_Sprites[i] = EditorGUI.ObjectField(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), overrideRule.m_Sprites[i], typeof(Sprite), false) as Sprite;
y += k_SingleLineHeight;
}
}
}
protected virtual void DoRuleMatrixOnGUI(RuleTile tile, Rect rect, RuleTile.TilingRule tilingRule)
{
RuleMatrixOnGUI(tile, rect, tilingRule);
}
public override void RuleMatrixOnGUI(RuleTile ruleTile, Rect rect, BoundsInt bounds, RuleTile.TilingRule tilingRule)
{
Handles.color = EditorGUIUtility.isProSkin ? new Color(1f, 1f, 1f, 0.2f) : new Color(0f, 0f, 0f, 0.2f);
float w = rect.width / bounds.size.x;
float h = rect.height / bounds.size.y;
// Grid
float d = rect.width / (bounds.size.x + bounds.size.y);
for (int y = 0; y <= bounds.size.y; y++)
{
float left = rect.xMin + d * y;
float top = rect.yMin + d * y;
float right = rect.xMax - d * (bounds.size.y - y);
float bottom = rect.yMax - d * (bounds.size.y - y);
Handles.DrawLine(new Vector3(left, bottom), new Vector3(right, top));
}
for (int x = 0; x <= bounds.size.x; x++)
{
float left = rect.xMin + d * x;
float top = rect.yMax - d * x;
float right = rect.xMax - d * (bounds.size.x - x);
float bottom = rect.yMin + d * (bounds.size.x - x);
Handles.DrawLine(new Vector3(left, bottom), new Vector3(right, top));
}
Handles.color = Color.white;
var neighbors = tilingRule.GetNeighbors();
// Icons
float iconSize = (rect.width - d) / (bounds.size.x + bounds.size.y - 1);
float iconScale = Mathf.Pow(2, 0.5f);
for (int y = bounds.yMin; y < bounds.yMax; y++)
{
for (int x = bounds.xMin; x < bounds.xMax; x++)
{
Vector3Int pos = new Vector3Int(x, y, 0);
Vector3Int offset = new Vector3Int(pos.x - bounds.xMin, pos.y - bounds.yMin, 0);
Rect r = new Rect(
rect.xMin + rect.size.x - iconSize * (offset.y - offset.x + 0.5f + bounds.size.x),
rect.yMin + rect.size.y - iconSize * (offset.y + offset.x + 1.5f),
iconSize, iconSize
);
Vector2 center = r.center;
r.size *= iconScale;
r.center = center;
if (x != 0 || y != 0)
{
if (neighbors.ContainsKey(pos))
{
RuleOnGUI(r, pos, neighbors[pos]);
RuleTooltipOnGUI(r, neighbors[pos]);
}
if (RuleNeighborUpdate(r, tilingRule, neighbors, pos))
{
tile.UpdateNeighborPositions();
}
}
else
{
RuleTransformOnGUI(r, tilingRule.m_RuleTransform);
if (RuleTransformUpdate(r, tilingRule))
{
tile.UpdateNeighborPositions();
}
}
}
}
}
private static void RuleMatrixOnGUI(Rect rect, RuleTile.TilingRule tilingRule)
{
Handles.color = EditorGUIUtility.isProSkin ? new Color(1f, 1f, 1f, 0.2f) : new Color(0f, 0f, 0f, 0.2f);
int index = 0;
float w = rect.width / 3f;
float h = rect.height / 3f;
for (int y = 0; y <= 3; y++)
{
float top = rect.yMin + y * h;
Handles.DrawLine(new Vector3(rect.xMin, top), new Vector3(rect.xMax, top));
}
for (int x = 0; x <= 3; x++)
{
float left = rect.xMin + x * w;
Handles.DrawLine(new Vector3(left, rect.yMin), new Vector3(left, rect.yMax));
}
Handles.color = Color.white;
for (int y = 0; y <= 2; y++)
{
for (int x = 0; x <= 2; x++)
{
Rect r = new Rect(rect.xMin + x * w, rect.yMin + y * h, w - 1, h - 1);
if (x != 1 || y != 1)
{
switch (tilingRule.m_Neighbors[index])
{
case RuleTile.TilingRule.Neighbor.This:
GUI.DrawTexture(r, arrows[y * 3 + x]);
break;
case RuleTile.TilingRule.Neighbor.NotThis:
GUI.DrawTexture(r, arrows[9]);
break;
}
if (Event.current.type == EventType.MouseDown && r.Contains(Event.current.mousePosition))
{
tilingRule.m_Neighbors[index] = (RuleTile.TilingRule.Neighbor)(((int)tilingRule.m_Neighbors[index] + 1) % 3);
GUI.changed = true;
Event.current.Use();
}
index++;
}
else
{
switch (tilingRule.m_RuleTransform)
{
case RuleTile.TilingRule.Transform.Rotated:
GUI.DrawTexture(r, autoTransforms[0]);
break;
case RuleTile.TilingRule.Transform.MirrorX:
GUI.DrawTexture(r, autoTransforms[1]);
break;
case RuleTile.TilingRule.Transform.MirrorY:
GUI.DrawTexture(r, autoTransforms[2]);
break;
}
if (Event.current.type == EventType.MouseDown && r.Contains(Event.current.mousePosition))
{
tilingRule.m_RuleTransform = (RuleTile.TilingRule.Transform)(((int)tilingRule.m_RuleTransform + 1) % 4);
GUI.changed = true;
Event.current.Use();
}
}
}
}
}
private void SpriteOnGUI(Rect rect, RuleTile.TilingRule tilingRule)
{
tilingRule.m_Sprites[0] = EditorGUI.ObjectField(new Rect(rect.xMax - rect.height, rect.yMin, rect.height, rect.height), tilingRule.m_Sprites[0], typeof(Sprite), false) as Sprite;
}
internal static void RuleMatrixOnGUI(RuleTile tile, Rect rect, RuleTile.TilingRule tilingRule)
{
Handles.color = EditorGUIUtility.isProSkin ? new Color(1f, 1f, 1f, 0.2f) : new Color(0f, 0f, 0f, 0.2f);
int index = 0;
float w = rect.width / 3f;
float h = rect.height / 3f;
for (int y = 0; y <= 3; y++)
{
float top = rect.yMin + y * h;
Handles.DrawLine(new Vector3(rect.xMin, top), new Vector3(rect.xMax, top));
}
for (int x = 0; x <= 3; x++)
{
float left = rect.xMin + x * w;
Handles.DrawLine(new Vector3(left, rect.yMin), new Vector3(left, rect.yMax));
}
Handles.color = Color.white;
for (int y = 0; y <= 2; y++)
{
for (int x = 0; x <= 2; x++)
{
Rect r = new Rect(rect.xMin + x * w, rect.yMin + y * h, w - 1, h - 1);
if (x != 1 || y != 1)
{
tile.RuleOnGUI(r, new Vector2Int(x, y), tilingRule.m_Neighbors[index]);
if (Event.current.type == EventType.MouseDown && r.Contains(Event.current.mousePosition))
{
int change = 1;
if (Event.current.button == 1)
{
change = -1;
}
var allConsts = tile.m_NeighborType.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
var neighbors = allConsts.Select(c => (int)c.GetValue(null)).ToList();
neighbors.Sort();
int oldIndex = neighbors.IndexOf(tilingRule.m_Neighbors[index]);
int newIndex = (int)Mathf.Repeat(oldIndex + change, neighbors.Count);
tilingRule.m_Neighbors[index] = neighbors[newIndex];
GUI.changed = true;
Event.current.Use();
}
index++;
}
else
{
switch (tilingRule.m_RuleTransform)
{
case RuleTile.TilingRule.Transform.Rotated:
GUI.DrawTexture(r, autoTransforms[0]);
break;
case RuleTile.TilingRule.Transform.MirrorX:
GUI.DrawTexture(r, autoTransforms[1]);
break;
case RuleTile.TilingRule.Transform.MirrorY:
GUI.DrawTexture(r, autoTransforms[2]);
break;
}
if (Event.current.type == EventType.MouseDown && r.Contains(Event.current.mousePosition))
{
tilingRule.m_RuleTransform = (RuleTile.TilingRule.Transform)(((int)tilingRule.m_RuleTransform + 1) % 4);
GUI.changed = true;
Event.current.Use();
}
}
}
}
}
/// <summary>
/// Draws a Rule Matrix for the given Rule for a RuleTile.
/// </summary>
/// <param name="tile">Tile to draw rule for.</param>
/// <param name="rect">GUI Rect to draw rule at.</param>
/// <param name="bounds">Cell bounds of the Rule.</param>
/// <param name="tilingRule">Rule to draw Rule Matrix for.</param>
public virtual void RuleMatrixOnGUI(RuleTile tile, Rect rect, BoundsInt bounds, RuleTile.TilingRule tilingRule)
{
Handles.color = EditorGUIUtility.isProSkin ? new Color(1f, 1f, 1f, 0.2f) : new Color(0f, 0f, 0f, 0.2f);
float w = rect.width / bounds.size.x;
float h = rect.height / bounds.size.y;
for (int y = 0; y <= bounds.size.y; y++)
{
float top = rect.yMin + y * h;
Handles.DrawLine(new Vector3(rect.xMin, top), new Vector3(rect.xMax, top));
}
for (int x = 0; x <= bounds.size.x; x++)
{
float left = rect.xMin + x * w;
Handles.DrawLine(new Vector3(left, rect.yMin), new Vector3(left, rect.yMax));
}
Handles.color = Color.white;
var neighbors = tilingRule.GetNeighbors();
for (int y = bounds.yMin; y < bounds.yMax; y++)
{
for (int x = bounds.xMin; x < bounds.xMax; x++)
{
Vector3Int pos = new Vector3Int(x, y, 0);
Rect r = new Rect(rect.xMin + (x - bounds.xMin) * w, rect.yMin + (-y + bounds.yMax - 1) * h, w - 1, h - 1);
RuleMatrixIconOnGUI(tilingRule, neighbors, pos, r);
}
}
}
internal virtual void RuleMatrixOnGUI(RuleTile tile, Rect rect, Rect sibRect, RuleTile.TilingRule tilingRule)
{
Handles.color = EditorGUIUtility.isProSkin ? new Color(1f, 1f, 1f, 0.2f) : new Color(0f, 0f, 0f, 0.2f);
int index = 0;
float w = rect.width / 3f;
float h = rect.height / 3f;
for (int y = 0; y <= 3; y++)
{
float top = rect.yMin + y * h;
Handles.DrawLine(new Vector3(rect.xMin, top), new Vector3(rect.xMax, top));
if (tilingRule.m_CheckSiblings)
{
float top2 = sibRect.yMin + y * h;
Handles.DrawLine(new Vector3(sibRect.xMin, top2), new Vector3(sibRect.xMax, top2));
}
}
for (int x = 0; x <= 3; x++)
{
float left = rect.xMin + x * w;
Handles.DrawLine(new Vector3(left, rect.yMin), new Vector3(left, rect.yMax));
if (tilingRule.m_CheckSiblings)
{
float left2 = sibRect.xMin + x * w;
Handles.DrawLine(new Vector3(left2, sibRect.yMin), new Vector3(left2, sibRect.yMax));
}
}
Handles.color = Color.white;
for (int y = 0; y <= 2; y++)
{
for (int x = 0; x <= 2; x++)
{
Rect r = new Rect(rect.xMin + x * w, rect.yMin + y * h, w - 1, h - 1);
Rect r2 = new Rect(sibRect.xMin + x * w, sibRect.yMin + y * h, w - 1, h - 1);
if (x != 1 || y != 1)
{
RuleOnGUI(r, y * 3 + x, tilingRule.m_Neighbors[index]);
RuleOnGUI(r2, y * 3 + x, tilingRule.m_SiblingNeighbors[index]);
RuleNeighborUpdate(r, r2, tilingRule, index);
index++;
}
else
{
RuleTransformOnGUI(r, tilingRule.m_RuleTransform);
RuleTransformOnGUI(r2, tilingRule.m_RuleTransform);
RuleTransformUpdate(r, r2, tilingRule);
}
}
}
}
public void DrawRule(Rect rect, RuleTile.TilingRuleOutput rule, bool isOverride, RuleTile.TilingRule originalRule, bool isMissing)
{
if (isMissing)
{
EditorGUI.HelpBox(new Rect(rect.xMin, rect.yMin, rect.width, 16), "Original Tiling Rule missing", MessageType.Warning);
rect.yMin += 16;
}
using (new EditorGUI.DisabledScope(!isOverride))
{
float yPos = rect.yMin + 2f;
float height = rect.height - k_PaddingBetweenRules;
float matrixWidth = k_DefaultElementHeight;
BoundsInt ruleBounds = originalRule.GetBounds();
BoundsInt ruleGuiBounds = ruleTileEditor.GetRuleGUIBounds(ruleBounds, originalRule);
Vector2 matrixSize = ruleTileEditor.GetMatrixSize(ruleGuiBounds);
Vector2 matrixSizeRate = matrixSize / Mathf.Max(matrixSize.x, matrixSize.y);
Vector2 matrixRectSize = new Vector2(matrixWidth * matrixSizeRate.x, k_DefaultElementHeight * matrixSizeRate.y);
Vector2 matrixRectPosition = new Vector2(rect.xMax - matrixWidth * 2f - 10f, yPos);
matrixRectPosition.x += (matrixWidth - matrixRectSize.x) * 0.5f;
matrixRectPosition.y += (k_DefaultElementHeight - matrixRectSize.y) * 0.5f;
Rect inspectorRect = new Rect(rect.xMin, yPos, rect.width - matrixWidth * 2f - 20f, height);
Rect matrixRect = new Rect(matrixRectPosition, matrixRectSize);
Rect spriteRect = new Rect(rect.xMax - matrixWidth - 5f, yPos, matrixWidth, k_DefaultElementHeight);
ruleTileEditor.RuleInspectorOnGUI(inspectorRect, rule);
ruleTileEditor.SpriteOnGUI(spriteRect, rule);
if (!isMissing)
{
using (new EditorGUI.DisabledScope(true))
ruleTileEditor.RuleMatrixOnGUI(overrideTile.m_InstanceTile, matrixRect, ruleGuiBounds, originalRule);
}
}
}
public override void RuleMatrixOnGUI(RuleTile tile, Rect rect, BoundsInt bounds, RuleTile.TilingRule tilingRule)
{
var hexTile = tile as HexagonalRuleTile;
bool flatTop = hexTile.m_FlatTop;
Handles.color = EditorGUIUtility.isProSkin ? new Color(1f, 1f, 1f, 0.2f) : new Color(0f, 0f, 0f, 0.2f);
float w = rect.width / (flatTop ? bounds.size.y : bounds.size.x);
float h = rect.height / (flatTop ? bounds.size.x : bounds.size.y);
// Grid
if (flatTop)
{
for (int y = 0; y <= bounds.size.y; y++)
{
float left = rect.xMin + y * w;
float offset = 0;
if (y == 0 && bounds.yMax % 2 == 0)
{
offset = h / 2;
}
else if (y == bounds.size.y && bounds.yMin % 2 != 0)
{
offset = h / 2;
}
Handles.DrawLine(new Vector3(left, rect.yMin + offset), new Vector3(left, rect.yMax - offset));
if (y < bounds.size.y)
{
bool noOffset = (y + bounds.yMax) % 2 != 0;
for (int x = 0; x < (noOffset ? (bounds.size.x + 1) : bounds.size.x); x++)
{
float top = rect.yMin + x * h + (noOffset ? 0 : h / 2);
Handles.DrawLine(new Vector3(left, top), new Vector3(left + w, top));
}
}
}
}
else
{
for (int y = 0; y <= bounds.size.y; y++)
{
float top = rect.yMin + y * h;
float offset = 0;
if (y == 0 && bounds.yMax % 2 == 0)
{
offset = w / 2;
}
else if (y == bounds.size.y && bounds.yMin % 2 != 0)
{
offset = w / 2;
}
Handles.DrawLine(new Vector3(rect.xMin + offset, top), new Vector3(rect.xMax - offset, top));
if (y < bounds.size.y)
{
bool noOffset = (y + bounds.yMax) % 2 != 0;
for (int x = 0; x < (noOffset ? (bounds.size.x + 1) : bounds.size.x); x++)
{
float left = rect.xMin + x * w + (noOffset ? 0 : w / 2);
Handles.DrawLine(new Vector3(left, top), new Vector3(left, top + h));
}
}
}
}
var neighbors = tilingRule.GetNeighbors();
// Icons
Handles.color = Color.white;
for (int y = bounds.yMin; y < bounds.yMax; y++)
{
int xMax = y % 2 == 0 ? bounds.xMax : (bounds.xMax - 1);
for (int x = bounds.xMin; x < xMax; x++)
{
Vector3Int pos = new Vector3Int(x, y, 0);
Vector2 offset = new Vector2(x - bounds.xMin, -y + bounds.yMax - 1);
Rect r;
if (flatTop)
{
r = new Rect(rect.xMin + offset.y * w, rect.yMax - offset.x * h - h, w - 1, h - 1);
}
else
{
r = new Rect(rect.xMin + offset.x * w, rect.yMin + offset.y * h, w - 1, h - 1);
}
if (y % 2 != 0)
{
if (flatTop)
{
r.y -= h / 2;
}
else
{
r.x += w / 2;
}
}
if (x != 0 || y != 0)
{
if (neighbors.ContainsKey(pos))
{
RuleOnGUI(r, pos, neighbors[pos]);
RuleTooltipOnGUI(r, neighbors[pos]);
}
if (RuleNeighborUpdate(r, tilingRule, neighbors, pos))
{
tile.UpdateRemoteRulePositions();
}
}
else
{
// Center
RuleTransformOnGUI(r, tilingRule.m_RuleTransform);
if (RuleTransformUpdate(r, tilingRule))
{
tile.UpdateRemoteRulePositions();
}
}
}
}
}
static private RuleTile.TilingRule FindBlobTileRule(int index)
{
RuleTile.TilingRule rule = new RuleTile.TilingRule();
Dictionary <Vector3Int, int> tileRule = new Dictionary <Vector3Int, int>();
switch (index)
{
case 0:
tileRule.Add(TOP, 2);
tileRule.Add(LEFT, 2);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(DOWNRIGHT, 1);
break;
case 1:
tileRule.Add(TOP, 2);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWNLEFT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(DOWNRIGHT, 1);
break;
case 2:
tileRule.Add(TOP, 2);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 2);
tileRule.Add(DOWNLEFT, 1);
tileRule.Add(DOWN, 1);
break;
case 10:
tileRule.Add(TOP, 1);
tileRule.Add(TOPRIGHT, 1);
tileRule.Add(LEFT, 2);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(DOWNRIGHT, 1);
break;
case 11:
tileRule.Add(TOPLEFT, 1);
tileRule.Add(TOP, 1);
tileRule.Add(TOPRIGHT, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWNLEFT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(DOWNRIGHT, 1);
break;
case 12:
tileRule.Add(TOPLEFT, 1);
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 2);
tileRule.Add(DOWNLEFT, 1);
tileRule.Add(DOWN, 1);
break;
case 20:
tileRule.Add(TOP, 1);
tileRule.Add(TOPRIGHT, 1);
tileRule.Add(LEFT, 2);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 2);
break;
case 21:
tileRule.Add(TOPLEFT, 1);
tileRule.Add(TOP, 1);
tileRule.Add(TOPRIGHT, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 2);
break;
case 22:
tileRule.Add(TOPLEFT, 1);
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 2);
tileRule.Add(DOWN, 2);
break;
case 3:
tileRule.Add(TOP, 2);
tileRule.Add(LEFT, 2);
tileRule.Add(RIGHT, 2);
tileRule.Add(DOWN, 1);
break;
case 13:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 2);
tileRule.Add(RIGHT, 2);
tileRule.Add(DOWN, 1);
break;
case 23:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 2);
tileRule.Add(RIGHT, 2);
tileRule.Add(DOWN, 2);
break;
case 31:
tileRule.Add(TOP, 2);
tileRule.Add(LEFT, 2);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 2);
break;
case 32:
tileRule.Add(TOP, 2);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 2);
break;
case 33:
tileRule.Add(TOP, 2);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 2);
tileRule.Add(DOWN, 2);
break;
case 34:
tileRule.Add(TOP, 2);
tileRule.Add(LEFT, 2);
tileRule.Add(RIGHT, 2);
tileRule.Add(DOWN, 2);
break;
case 4:
// 1:
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
// 2:
tileRule.Add(TOP, 2);
tileRule.Add(LEFT, 2);
tileRule.Add(DOWNRIGHT, 2);
break;
case 5:
// 1:
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWNLEFT, 1);
tileRule.Add(DOWN, 1);
// 2:
tileRule.Add(TOP, 2);
tileRule.Add(DOWNRIGHT, 2);
break;
case 6:
// 1:
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(DOWNRIGHT, 1);
// 2:
tileRule.Add(TOP, 2);
tileRule.Add(DOWNLEFT, 2);
break;
case 7:
// 1:
tileRule.Add(LEFT, 1);
tileRule.Add(DOWN, 1);
// 2:
tileRule.Add(TOP, 2);
tileRule.Add(RIGHT, 2);
tileRule.Add(DOWNLEFT, 2);
break;
case 8:
// 1:
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
// 2:
tileRule.Add(TOP, 2);
tileRule.Add(DOWNLEFT, 2);
tileRule.Add(DOWNRIGHT, 2);
break;
case 9:
// 1:
tileRule.Add(TOPLEFT, 1);
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(DOWNRIGHT, 1);
// 2:
tileRule.Add(TOPRIGHT, 2);
tileRule.Add(DOWNLEFT, 2);
break;
case 14:
// 1:
tileRule.Add(TOP, 1);
tileRule.Add(TOPRIGHT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
// 2:
tileRule.Add(LEFT, 2);
tileRule.Add(DOWNRIGHT, 2);
break;
case 15:
// 1:
tileRule.Add(TOPLEFT, 1);
tileRule.Add(TOP, 1);
tileRule.Add(TOPRIGHT, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWNLEFT, 1);
tileRule.Add(DOWN, 1);
// 2:
tileRule.Add(DOWNRIGHT, 2);
break;
case 16:
// 1:
tileRule.Add(TOPLEFT, 1);
tileRule.Add(TOP, 1);
tileRule.Add(TOPRIGHT, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(DOWNRIGHT, 1);
// 2:
tileRule.Add(DOWNLEFT, 2);
break;
case 17:
// 1:
tileRule.Add(TOPLEFT, 1);
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(DOWN, 1);
// 2:
tileRule.Add(RIGHT, 2);
tileRule.Add(DOWNLEFT, 2);
break;
case 18:
// 1:
tileRule.Add(TOPLEFT, 1);
tileRule.Add(TOP, 1);
tileRule.Add(TOPRIGHT, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
// 2:
tileRule.Add(DOWNLEFT, 2);
tileRule.Add(DOWNRIGHT, 2);
break;
case 19:
// 1:
tileRule.Add(TOP, 1);
tileRule.Add(TOPRIGHT, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWNLEFT, 1);
tileRule.Add(DOWN, 1);
// 2:
tileRule.Add(TOPLEFT, 2);
tileRule.Add(DOWNRIGHT, 2);
break;
case 24:
// 1:
tileRule.Add(TOP, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(DOWNRIGHT, 1);
// 2:
tileRule.Add(TOPRIGHT, 2);
tileRule.Add(LEFT, 2);
break;
case 25:
// 1:
tileRule.Add(TOPLEFT, 1);
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWNLEFT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(DOWNRIGHT, 1);
// 2:
tileRule.Add(TOPRIGHT, 2);
break;
case 26:
// 1:
tileRule.Add(TOP, 1);
tileRule.Add(TOPRIGHT, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWNLEFT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(DOWNRIGHT, 1);
// 2:
tileRule.Add(TOPLEFT, 2);
break;
case 27:
// 1:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(DOWNLEFT, 1);
tileRule.Add(DOWN, 1);
// 2:
tileRule.Add(TOPLEFT, 2);
tileRule.Add(RIGHT, 2);
break;
case 28:
// 1:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWNLEFT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(DOWNRIGHT, 1);
// 2:
tileRule.Add(TOPLEFT, 2);
tileRule.Add(TOPRIGHT, 2);
break;
case 29:
// 1:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(DOWNRIGHT, 1);
// 2:
tileRule.Add(TOPLEFT, 2);
tileRule.Add(TOPRIGHT, 2);
tileRule.Add(DOWNLEFT, 2);
break;
case 30:
// 1:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWNLEFT, 1);
tileRule.Add(DOWN, 1);
// 2:
tileRule.Add(TOPLEFT, 2);
tileRule.Add(TOPRIGHT, 2);
tileRule.Add(DOWNRIGHT, 2);
break;
case 35:
// 1:
tileRule.Add(TOP, 1);
tileRule.Add(RIGHT, 1);
// 2:
tileRule.Add(TOPRIGHT, 2);
tileRule.Add(LEFT, 2);
tileRule.Add(DOWN, 2);
break;
case 36:
// 1:
tileRule.Add(TOPLEFT, 1);
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
// 2:
tileRule.Add(TOPRIGHT, 2);
tileRule.Add(DOWN, 2);
break;
case 37:
// 1:
tileRule.Add(TOP, 1);
tileRule.Add(TOPRIGHT, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
// 2:
tileRule.Add(TOPLEFT, 2);
tileRule.Add(DOWN, 2);
break;
case 38:
// 1:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
// 2:
tileRule.Add(TOPLEFT, 2);
tileRule.Add(RIGHT, 2);
tileRule.Add(DOWN, 2);
break;
case 39:
// 1:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
// 2:
tileRule.Add(TOPLEFT, 2);
tileRule.Add(TOPRIGHT, 2);
tileRule.Add(DOWN, 2);
break;
case 40:
// 1:
tileRule.Add(TOP, 1);
tileRule.Add(TOPRIGHT, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
// 2:
tileRule.Add(TOPLEFT, 2);
tileRule.Add(DOWNLEFT, 2);
tileRule.Add(DOWNRIGHT, 2);
break;
case 41:
// 1:
tileRule.Add(TOPLEFT, 1);
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
// 2:
tileRule.Add(TOPRIGHT, 2);
tileRule.Add(DOWNLEFT, 2);
tileRule.Add(DOWNRIGHT, 2);
break;
case 42:
// 1:
tileRule.Add(TOP, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
// 2:
tileRule.Add(TOPRIGHT, 2);
tileRule.Add(LEFT, 2);
tileRule.Add(DOWNRIGHT, 2);
break;
case 43:
// 1:
tileRule.Add(TOPLEFT, 1);
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWNLEFT, 1);
tileRule.Add(DOWN, 1);
// 2:
tileRule.Add(TOPRIGHT, 2);
tileRule.Add(DOWNRIGHT, 2);
break;
case 44:
// 1:
tileRule.Add(TOP, 1);
tileRule.Add(TOPRIGHT, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(DOWNRIGHT, 1);
// 2:
tileRule.Add(TOPLEFT, 2);
tileRule.Add(DOWNLEFT, 2);
break;
case 45:
// 1:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(DOWN, 1);
// 2:
tileRule.Add(TOPLEFT, 2);
tileRule.Add(RIGHT, 2);
tileRule.Add(DOWNLEFT, 2);
break;
case 46:
// 1:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
// 2:
tileRule.Add(TOPLEFT, 2);
tileRule.Add(TOPRIGHT, 2);
tileRule.Add(DOWNLEFT, 2);
tileRule.Add(DOWNRIGHT, 2);
break;
default:
return(null);
}
rule.ApplyNeighbors(tileRule);
return(rule);
}
static private RuleTile.TilingRule FindWangTileRule(int index)
{
RuleTile.TilingRule rule = new RuleTile.TilingRule();
Dictionary <Vector3Int, int> tileRule = new Dictionary <Vector3Int, int>();
switch (index)
{
case 0:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
break;
case 1:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(DOWNRIGHT, 2);
break;
case 3:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(DOWNLEFT, 2);
break;
case 11:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(TOPRIGHT, 2);
break;
case 13:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(TOPLEFT, 2);
break;
case 2:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 2);
break;
case 6:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 2);
tileRule.Add(DOWN, 1);
break;
case 8:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 2);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
break;
case 12:
tileRule.Add(TOP, 2);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
break;
case 4:
tileRule.Add(TOP, 2);
tileRule.Add(LEFT, 2);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(TOPLEFT, 2);
break;
case 5:
tileRule.Add(TOP, 2);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 2);
tileRule.Add(DOWN, 1);
tileRule.Add(TOPRIGHT, 2);
break;
case 9:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 2);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 2);
tileRule.Add(DOWNLEFT, 2);
break;
case 10:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 2);
tileRule.Add(DOWN, 2);
tileRule.Add(DOWNRIGHT, 2);
break;
case 14:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(TOPLEFT, 2);
tileRule.Add(DOWNRIGHT, 2);
break;
case 15:
tileRule.Add(TOP, 1);
tileRule.Add(LEFT, 1);
tileRule.Add(RIGHT, 1);
tileRule.Add(DOWN, 1);
tileRule.Add(TOPRIGHT, 2);
tileRule.Add(DOWNLEFT, 2);
break;
case 7:
return(null);
}
rule.ApplyNeighbors(tileRule);
return(rule);
}
public virtual void RuleMatrixOnGUI(RuleTile tile, Rect rect, BoundsInt bounds, RuleTile.TilingRule tilingRule)
{
Handles.color = EditorGUIUtility.isProSkin ? new Color(1f, 1f, 1f, 0.2f) : new Color(0f, 0f, 0f, 0.2f);
float w = rect.width / bounds.size.x;
float h = rect.height / bounds.size.y;
for (int y = 0; y <= bounds.size.y; y++)
{
float top = rect.yMin + y * h;
Handles.DrawLine(new Vector3(rect.xMin, top), new Vector3(rect.xMax, top));
}
for (int x = 0; x <= bounds.size.x; x++)
{
float left = rect.xMin + x * w;
Handles.DrawLine(new Vector3(left, rect.yMin), new Vector3(left, rect.yMax));
}
Handles.color = Color.white;
var neighbors = tilingRule.GetNeighbors();
for (int y = bounds.yMin; y < bounds.yMax; y++)
{
for (int x = bounds.xMin; x < bounds.xMax; x++)
{
Vector3Int pos = new Vector3Int(x, y, 0);
Rect r = new Rect(rect.xMin + (x - bounds.xMin) * w, rect.yMin + (-y + bounds.yMax - 1) * h, w - 1, h - 1);
if (x != 0 || y != 0)
{
if (neighbors.ContainsKey(pos))
{
RuleOnGUI(r, pos, neighbors[pos]);
RuleTooltipOnGUI(r, neighbors[pos]);
}
if (RuleNeighborUpdate(r, tilingRule, neighbors, pos))
{
tile.UpdateNeighborPositions();
}
}
else
{
RuleTransformOnGUI(r, tilingRule.m_RuleTransform);
if (RuleTransformUpdate(r, tilingRule))
{
tile.UpdateNeighborPositions();
}
}
}
}
}
private static void RuleInspectorOnGUI(Rect rect, RuleTile.TilingRule tilingRule)
{
var y = rect.yMin;
EditorGUI.BeginChangeCheck();
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Rule");
tilingRule.m_RuleTransform = (RuleTile.TilingRule.Transform)EditorGUI.EnumPopup(
new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight),
tilingRule.m_RuleTransform);
y += k_SingleLineHeight;
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Collider");
tilingRule.m_ColliderType = (Tile.ColliderType)EditorGUI.EnumPopup(
new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight),
tilingRule.m_ColliderType);
y += k_SingleLineHeight;
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Output");
tilingRule.m_Output = (RuleTile.TilingRule.OutputSprite)EditorGUI.EnumPopup(
new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight),
tilingRule.m_Output);
y += k_SingleLineHeight;
if (tilingRule.m_Output == RuleTile.TilingRule.OutputSprite.Animation)
{
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Speed");
tilingRule.m_AnimationSpeed = EditorGUI.FloatField(
new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight),
tilingRule.m_AnimationSpeed);
y += k_SingleLineHeight;
}
if (tilingRule.m_Output == RuleTile.TilingRule.OutputSprite.Random)
{
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Noise");
tilingRule.m_PerlinScale =
EditorGUI.Slider(
new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight),
tilingRule.m_PerlinScale, 0.001f, 0.999f);
y += k_SingleLineHeight;
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Shuffle");
tilingRule.m_RandomTransform = (RuleTile.TilingRule.Transform)EditorGUI.EnumPopup(
new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight),
tilingRule.m_RandomTransform);
y += k_SingleLineHeight;
}
if (tilingRule.m_Output != RuleTile.TilingRule.OutputSprite.Single)
{
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Size");
EditorGUI.BeginChangeCheck();
var newLength =
EditorGUI.IntField(
new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight),
tilingRule.m_Sprites.Length);
if (EditorGUI.EndChangeCheck())
{
Array.Resize(ref tilingRule.m_Sprites, Math.Max(newLength, 1));
}
y += k_SingleLineHeight;
for (var i = 0; i < tilingRule.m_Sprites.Length; i++)
{
tilingRule.m_Sprites[i] =
EditorGUI.ObjectField(
new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight),
tilingRule.m_Sprites[i], typeof(Sprite), false) as Sprite;
y += k_SingleLineHeight;
}
}
}
private float GetElementHeight(int index)
{
RuleTile.TilingRule rule = tile.m_TilingRules[index];
return(GetElementHeight(rule));
}
protected override void DoRuleMatrixOnGUI(RuleTile ruleTile, Rect rect, RuleTile.TilingRule tilingRule)
{
var isoTile = (IsometricRuleTile)ruleTile;
RuleMatrixOnGUI(isoTile, rect, tilingRule);
}
public override void RuleMatrixOnGUI(RuleTile tile, Rect rect, BoundsInt bounds, RuleTile.TilingRule tilingRule)
{
bool flatTop = hexTile.m_FlatTop;
Handles.color = EditorGUIUtility.isProSkin ? new Color(1f, 1f, 1f, 0.2f) : new Color(0f, 0f, 0f, 0.2f);
float w = rect.width / (flatTop ? bounds.size.y : bounds.size.x);
float h = rect.height / (flatTop ? bounds.size.x : bounds.size.y);
// Grid
if (flatTop)
{
for (int y = 0; y <= bounds.size.y; y++)
{
float left = rect.xMin + y * w;
float offset = 0;
if (y == 0 && bounds.yMax % 2 == 0)
{
offset = h / 2;
}
else if (y == bounds.size.y && bounds.yMin % 2 != 0)
{
offset = h / 2;
}
Handles.DrawLine(new Vector3(left, rect.yMin + offset), new Vector3(left, rect.yMax - offset));
if (y < bounds.size.y)
{
bool noOffset = (y + bounds.yMax) % 2 != 0;
for (int x = 0; x < (noOffset ? (bounds.size.x + 1) : bounds.size.x); x++)
{
float top = rect.yMin + x * h + (noOffset ? 0 : h / 2);
Handles.DrawLine(new Vector3(left, top), new Vector3(left + w, top));
}
}
}
}
else
{
for (int y = 0; y <= bounds.size.y; y++)
{
float top = rect.yMin + y * h;
float offset = 0;
if (y == 0 && bounds.yMax % 2 == 0)
{
offset = w / 2;
}
else if (y == bounds.size.y && bounds.yMin % 2 != 0)
{
offset = w / 2;
}
Handles.DrawLine(new Vector3(rect.xMin + offset, top), new Vector3(rect.xMax - offset, top));
if (y < bounds.size.y)
{
bool noOffset = (y + bounds.yMax) % 2 != 0;
for (int x = 0; x < (noOffset ? (bounds.size.x + 1) : bounds.size.x); x++)
{
float left = rect.xMin + x * w + (noOffset ? 0 : w / 2);
Handles.DrawLine(new Vector3(left, top), new Vector3(left, top + h));
}
}
}
}
var neighbors = tilingRule.GetNeighbors();
// Icons
Handles.color = Color.white;
for (int y = bounds.yMin; y < bounds.yMax; y++)
{
int xMax = y % 2 == 0 ? bounds.xMax : (bounds.xMax - 1);
for (int x = bounds.xMin; x < xMax; x++)
{
Vector3Int pos = new Vector3Int(x, y, 0);
Vector2 offset = new Vector2(x - bounds.xMin, -y + bounds.yMax - 1);
Rect r = flatTop
? new Rect(rect.xMin + offset.y * w, rect.yMax - offset.x * h - h, w - 1, h - 1)
: new Rect(rect.xMin + offset.x * w, rect.yMin + offset.y * h, w - 1, h - 1);
if (y % 2 != 0)
{
if (flatTop)
{
r.y -= h / 2;
}
else
{
r.x += w / 2;
}
}
RuleMatrixIconOnGUI(tilingRule, neighbors, pos, r);
}
}
}
private static void RuleMatrixOnGUI(IsometricRuleTile isoTile, Rect rect, RuleTile.TilingRule tilingRule)
{
Handles.color = EditorGUIUtility.isProSkin ? new Color(1f, 1f, 1f, 0.2f) : new Color(0f, 0f, 0f, 0.2f);
int index = 0;
float w = rect.width / 3f;
float h = rect.height / 3f;
// Grid
for (int y = 0; y <= 3; y++)
{
float left = rect.xMin + (y * rect.width) / 6;
float right = left + rect.width / 2;
float bottom = rect.yMin + (y * rect.height) / 6;
float top = bottom + rect.height / 2;
Handles.DrawLine(new Vector3(left, top), new Vector3(right, bottom));
}
for (int x = 0; x <= 3; x++)
{
float left = rect.xMin + (x * rect.width) / 6;
float right = left + rect.width / 2;
float top = rect.yMax - (x * rect.height) / 6;
float bottom = top - rect.height / 2;
Handles.DrawLine(new Vector3(left, bottom), new Vector3(right, top));
}
Handles.color = Color.white;
// Icons
for (int y = 0; y <= 2; y++)
{
for (int x = 0; x <= 2; x++)
{
Rect r = new Rect(
rect.xMin + ((x + y) * rect.width) / 6,
rect.yMin + ((2 - x + y) * rect.height) / 6,
w - 1, h - 1);
if (x != 1 || y != 1)
{
isoTile.RuleOnGUI(r, s_Arrows[y, x], tilingRule.m_Neighbors[index]);
if (Event.current.type == EventType.MouseDown && r.Contains(Event.current.mousePosition))
{
var allConsts = isoTile.m_NeighborType.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
var neighbors = allConsts.Select(c => (int)c.GetValue(null)).ToList();
neighbors.Sort();
int oldIndex = neighbors.IndexOf(tilingRule.m_Neighbors[index]);
int newIndex = (int)Mathf.Repeat(oldIndex + GetMouseChange(), neighbors.Count);
tilingRule.m_Neighbors[index] = neighbors[newIndex];
GUI.changed = true;
Event.current.Use();
}
index++;
}
else
{
switch (tilingRule.m_RuleTransform)
{
case RuleTile.TilingRule.Transform.Rotated:
GUI.DrawTexture(r, autoTransforms[0]);
break;
case RuleTile.TilingRule.Transform.MirrorX:
GUI.DrawTexture(r, autoTransforms[1]);
break;
case RuleTile.TilingRule.Transform.MirrorY:
GUI.DrawTexture(r, autoTransforms[2]);
break;
}
if (Event.current.type == EventType.MouseDown && ContainsMousePosition(r))
{
tilingRule.m_RuleTransform = (RuleTile.TilingRule.Transform)(((int)tilingRule.m_RuleTransform + 1) % 4);
GUI.changed = true;
Event.current.Use();
}
}
}
}
}
public MenuItemData(RuleTile.TilingRule mRule, RuleTile.TilingRule.Transform mNewValue)
{
this.m_Rule = mRule;
this.m_NewValue = mNewValue;
}
private void splitUpSmartMaterial()
{
if (tile.m_smartMaterialSource != null)
{
//get provided material
var assetPath = AssetDatabase.GetAssetPath(tile.m_smartMaterialSource);
TextureImporter ti = AssetImporter.GetAtPath(assetPath) as TextureImporter;
ti.isReadable = true;
var cellWidth = tile.m_smartMaterialSource.texture.width / 12.0f;
var cellHeight = tile.m_smartMaterialSource.texture.height / 6.0f;
var spriteWidth = cellWidth * 2;
var spriteHeight = cellHeight * 2;
//build new ones
List <SpriteMetaData> newSprites = new List <SpriteMetaData>();
foreach (var smartRule in allSmartRules)
{
var thisSprite = new SpriteMetaData();
thisSprite.alignment = (int)SpriteAlignment.Center;
thisSprite.name = smartRule.name;
var x = smartRule.bottomLeftIndex % 12 - 1;
var y = smartRule.bottomLeftIndex / 12;
thisSprite.rect = new Rect(
x * cellWidth,
y * cellHeight,
spriteWidth,
spriteHeight
);
newSprites.Add(thisSprite);
}
//update new sprite slice
ti.spriteImportMode = SpriteImportMode.Multiple;
ti.spritesheet = newSprites.ToArray();
EditorUtility.SetDirty(ti);
ti.SaveAndReimport();
//fetch new sprites
var generatedSprites = AssetDatabase.LoadAllAssetsAtPath(assetPath)
.OfType <Sprite>().ToList();
//build rule tiles
tile.m_TilingRules = new List <RuleTile.TilingRule>();
foreach (var rule in allSmartRules)
{
var newRule = new RuleTile.TilingRule();
rule.neighborRules.CopyTo(newRule.m_Neighbors, 0);
newRule.m_Sprites = new[] { generatedSprites.Find(x => x.name == rule.name) };
tile.m_TilingRules.Add(newRule);
}
//need to do this or you can't see the tiles in the pallette
tile.m_DefaultSprite = generatedSprites.Find(x => x.name == "default");
//editor update
MakeReorderableList();
SaveTile();
}
}
static void ProcessSubtileTexture(Texture2D _texture, AutoTileLookup _lookup)
{
//Spprite importer stuff to prep the asset for slicing.
string path = AssetDatabase.GetAssetPath(_texture);
var importer = AssetImporter.GetAtPath(path) as TextureImporter;
importer.textureType = TextureImporterType.Sprite;
importer.spriteImportMode = SpriteImportMode.Multiple;
importer.mipmapEnabled = false;
importer.filterMode = FilterMode.Point;
importer.spritePivot = Vector2.down;
importer.textureCompression = TextureImporterCompression.Uncompressed;
var textureSettings = new TextureImporterSettings();
importer.ReadTextureSettings(textureSettings);
textureSettings.spriteMeshType = SpriteMeshType.FullRect;
textureSettings.spriteExtrude = 0;
importer.SetTextureSettings(textureSettings);
//for A2s we know the subtil size is width/4
int minSpriteSize = _texture.width / 4;
//Slice the asset
Rect[] rects = InternalSpriteUtility.GenerateGridSpriteRectangles(
_texture,
Vector2.zero,
new Vector2(minSpriteSize, minSpriteSize),
Vector2.zero);
List <Rect> rectList = new List <Rect>(rects);
string filenameNoExtension = Path.GetFileNameWithoutExtension(path);
List <SpriteMetaData> metas = new List <SpriteMetaData>();
int count = 0;
foreach (Rect rect in rectList)
{
var meta = new SpriteMetaData();
meta.pivot = Vector2.one * 0.5f;//center
meta.alignment = (int)SpriteAlignment.Center;
meta.rect = rect;
int xpos = count % 4;
int ypos = Mathf.CeilToInt(count / 4);
int rightside = xpos % 2;
int topside = (ypos + 1) % 2;
int lookup = (topside * 2) + rightside;
meta.name = RuleTileEditor.m_ModDirections[lookup] + count.ToString("00") + "_" + filenameNoExtension;
metas.Add(meta);
count++;
}
importer.spritesheet = metas.ToArray();
AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);
Object[] objects = AssetDatabase.LoadAllAssetsAtPath(path);
List <Sprite> sprites = new List <Sprite>();
for (int i = 0; i < objects.Length; i++)
{
//filter out non-sprites. I was getting some extra entry here.
if ((objects[i] as Sprite) != null)
{
sprites.Add(objects[i] as Sprite);
}
}
sprites.Sort((Sprite x, Sprite y) => x.name.CompareTo(y.name));
RuleTile m_tile = ScriptableObject.CreateInstance <RuleTile>();
m_tile.m_TilingRules = new List <RuleTile.TilingRule>();
int rulecount = 0;
for (int i = 255; i >= 0; i--)
{
RuleTile.TilingRule rule = ImportAutotile.GetRule(i);
if (rule != null)
{
AddSpritesToRule(ref rule, sprites, rulecount, _lookup);
rulecount++;
m_tile.m_TilingRules.Add(rule);
}
}
AssetDatabase.CreateAsset(m_tile, "Assets/" + filenameNoExtension + "tile.asset");
}
public override void OnInspectorGUI()
{
tile.m_DefaultSprite = EditorGUILayout.ObjectField("Default Sprite", tile.m_DefaultSprite, typeof(Sprite), false) as Sprite;
tile.m_DefaultGameObject = EditorGUILayout.ObjectField("Default Game Object", tile.m_DefaultGameObject, typeof(GameObject), false) as GameObject;
tile.m_DefaultColliderType = (Tile.ColliderType)EditorGUILayout.EnumPopup("Default Collider", tile.m_DefaultColliderType);
serializedObject.Update();
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(color);
EditorGUILayout.PropertyField(tileType);
var baseFields = typeof(RuleTile).GetFields().Select(field => field.Name);
var fields = target.GetType().GetFields().Select(field => field.Name).Where(field => !baseFields.Contains(field));
foreach (var field in fields)
{
EditorGUILayout.PropertyField(serializedObject.FindProperty(field), true);
}
if (EditorGUI.EndChangeCheck())
{
serializedObject.ApplyModifiedProperties();
}
EditorGUILayout.Space();
if (GUILayout.Button($"Export {tile.tileType}"))
{
string path = Application.dataPath + $"/Tiles/{tile.tileType}_export.txt";
StreamWriter writer = new StreamWriter(path, false);
foreach (var rule in tile.m_TilingRules)
{
writer.WriteLine(rule.m_Output);
foreach (var sprite in rule.m_Sprites)
{
writer.WriteLine(sprite.name.Replace($"{target.name}_", ""));
}
foreach (var neighbor in rule.m_Neighbors)
{
writer.WriteLine(neighbor);
}
}
writer.Close();
}
if (GUILayout.Button($"Import {tile.tileType}"))
{
TextAsset data = AssetDatabase.LoadAssetAtPath <TextAsset>($"Assets/Tiles/{tile.tileType}_export.txt");
Sprite[] sprites = AssetDatabase.LoadAllAssetsAtPath($"Assets/Sprites/{tile.tileType}/{target.name}.png").OfType <Sprite>().ToArray();
if (sprites.Length == 0)
{
Debug.LogError($"Fail to Load Assets/Sprites/{tile.tileType}/{target.name}.png");
}
List <string> text = new List <string>(data.text.Split('\n'));
int index = 0;
bool isDirt = target.name == "Dirt";
List <RuleTile.TilingRule> rules = new List <RuleTile.TilingRule>();
while (text.Count - 1 > index)
{
var rule = new RuleTile.TilingRule();
rule.m_Neighbors = new int[8];
rule.m_Output = (RuleTile.TilingRule.OutputSprite)Enum.Parse(typeof(RuleTile.TilingRule.OutputSprite), text[index++]);
switch (rule.m_Output)
{
case RuleTile.TilingRule.OutputSprite.Random:
{
rule.m_Sprites = new Sprite[3];
for (int j = 0; j < 3; j++)
{
rule.m_Sprites[j] = sprites[int.Parse(text[index++])];
}
break;
}
default:
{
rule.m_Sprites = new Sprite[1];
rule.m_Sprites[0] = sprites[int.Parse(text[index++])];
break;
}
}
for (int j = 0; j < 8; j++)
{
int neighbor = int.Parse(text[index++]);
if (neighbor == 4 && isDirt)
{
neighbor = 5;
}
rule.m_Neighbors[j] = neighbor;
}
rules.Add(rule);
}
tile.m_DefaultSprite = sprites[0];
tile.m_TilingRules.Clear();
foreach (var rule in rules)
{
tile.m_TilingRules.Add(rule);
}
}
if (m_ReorderableList != null && tile.m_TilingRules != null)
{
m_ReorderableList.DoLayoutList();
}
}
