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(); } }