/// <summary> /// Gets overrides for this /// </summary> /// <param name="overrides">A list of overrides to fill</param> /// <param name="validCount">Returns the number of valid overrides for Rules</param> /// <exception cref="ArgumentNullException">The input overrides list is not valid</exception> public void GetOverrides(List <KeyValuePair <RuleTile.TilingRule, RuleTile.TilingRuleOutput> > overrides, ref int validCount) { if (overrides == null) { throw new System.ArgumentNullException("overrides"); } overrides.Clear(); if (m_Tile) { foreach (var originalRule in m_Tile.m_TilingRules) { RuleTile.TilingRuleOutput overrideRule = this[originalRule]; overrides.Add(new KeyValuePair <RuleTile.TilingRule, RuleTile.TilingRuleOutput>(originalRule, overrideRule)); } } validCount = overrides.Count; foreach (var overrideRule in m_OverrideTilingRules) { if (!overrides.Exists(o => o.Key.m_Id == overrideRule.m_Id)) { var originalRule = new RuleTile.TilingRule() { m_Id = overrideRule.m_Id }; overrides.Add(new KeyValuePair <RuleTile.TilingRule, RuleTile.TilingRuleOutput>(originalRule, overrideRule)); } } }
/// <summary> /// Gets the overriding TilingRuleOutput of a given TilingRule. /// </summary> /// <param name="original">The original TilingRule that is overridden</param> public RuleTile.TilingRuleOutput this[RuleTile.TilingRule originalRule] { get { foreach (var overrideRule in m_OverrideTilingRules) { if (overrideRule.m_Id == originalRule.m_Id) { return(overrideRule); } } return(null); } set { for (int i = m_OverrideTilingRules.Count - 1; i >= 0; i--) { if (m_OverrideTilingRules[i].m_Id == originalRule.m_Id) { m_OverrideTilingRules.RemoveAt(i); break; } } if (value != null) { var overrideRule = new RuleTile.TilingRuleOutput(); CopyTilingRule(value, overrideRule); m_OverrideTilingRules.Add(overrideRule); } } }
/// <summary> /// Draws an Inspector for the Rule /// </summary> /// <param name="rect">Rect to draw Inspector in</param> /// <param name="tilingRule">Rule to draw Inspector for</param> public void RuleInspectorOnGUI(Rect rect, RuleTile.TilingRuleOutput tilingRule) { float y = rect.yMin; GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "GameObject"); tilingRule.m_GameObject = (GameObject)EditorGUI.ObjectField(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), "", tilingRule.m_GameObject, typeof(GameObject), false); 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; GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Translate"); tilingRule.m_TileTranslate = (Vector3)EditorGUI.Vector3Field(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), "", tilingRule.m_TileTranslate); y += k_SingleLineHeight; GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Rotate"); tilingRule.m_TileRotate = (Vector3)EditorGUI.Vector3Field(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), "", tilingRule.m_TileRotate); y += k_SingleLineHeight; GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Scale"); tilingRule.m_TileScale = (Vector3)EditorGUI.Vector3Field(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), "", tilingRule.m_TileScale); 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(); int newLength = EditorGUI.DelayedIntField(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 (int 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; } } }
/// <summary> /// Copies a Tiling Rule from a given Tiling Rule /// </summary> /// <param name="from">A Tiling Rule to copy from</param> /// <param name="to">A Tiling Rule to copy to</param> public static void CopyTilingRule(RuleTile.TilingRuleOutput from, RuleTile.TilingRuleOutput to) { to.m_Id = from.m_Id; to.m_Sprites = from.m_Sprites.Clone() as Sprite[]; to.m_GameObject = from.m_GameObject; to.m_AnimationSpeed = from.m_AnimationSpeed; to.m_PerlinScale = from.m_PerlinScale; to.m_Output = from.m_Output; to.m_ColliderType = from.m_ColliderType; to.m_RandomTransform = from.m_RandomTransform; }
/// <summary> /// Gets the GUI element height for a TilingRuleOutput /// </summary> /// <param name="rule">Rule to get height for</param> /// <returns>GUI element height for a TilingRuleOutput </returns> public float GetElementHeight(RuleTile.TilingRuleOutput rule) { float inspectorHeight = k_DefaultElementHeight + k_PaddingBetweenRules; switch (rule.m_Output) { case RuleTile.TilingRule.OutputSprite.Random: case RuleTile.TilingRule.OutputSprite.Animation: inspectorHeight = k_DefaultElementHeight + k_SingleLineHeight * (rule.m_Sprites.Length + 3) + k_PaddingBetweenRules; break; } return(inspectorHeight); }
/// <summary> /// Draws the Rule element for the Rule list /// </summary> /// <param name="rect">Rect to draw the Rule Element in</param> /// <param name="index">Index of the Rule Element to draw</param> /// <param name="active">Whether the Rule Element is active</param> /// <param name="focused">Whether the Rule Element is focused</param> public void DrawRuleElement(Rect rect, int index, bool active, bool focused) { RuleTile.TilingRule originalRule = m_Rules[index].Key; if (originalRule == null) { return; } RuleTile.TilingRuleOutput overrideRule = m_Rules[index].Value; bool isMissing = index >= m_MissingOriginalRuleIndex; DrawToggleInternal(new Rect(rect.xMin, rect.yMin, 16, rect.height)); DrawRuleInternal(new Rect(rect.xMin + 16, rect.yMin, rect.width - 16, rect.height)); void DrawToggleInternal(Rect r) { EditorGUI.BeginChangeCheck(); bool enabled = EditorGUI.Toggle(new Rect(r.xMin, r.yMin, r.width, k_SingleLineHeight), overrideRule != null); if (EditorGUI.EndChangeCheck()) { if (enabled) { overrideTile[originalRule] = originalRule; } else { overrideTile[originalRule] = null; } SaveTile(); } } void DrawRuleInternal(Rect r) { EditorGUI.BeginChangeCheck(); DrawRule(r, overrideRule ?? originalRule, overrideRule != null, originalRule, isMissing); if (EditorGUI.EndChangeCheck()) { SaveTile(); } } }
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)) { var yPos = rect.yMin + 2f; var height = rect.height - k_PaddingBetweenRules; var matrixWidth = k_DefaultElementHeight; var ruleBounds = originalRule.GetBounds(); var ruleGuiBounds = ruleTileEditor.GetRuleGUIBounds(ruleBounds, originalRule); var matrixSize = ruleTileEditor.GetMatrixSize(ruleGuiBounds); var matrixSizeRate = matrixSize / Mathf.Max(matrixSize.x, matrixSize.y); var matrixRectSize = new Vector2(matrixWidth * matrixSizeRate.x, k_DefaultElementHeight * matrixSizeRate.y); var matrixRectPosition = new Vector2(rect.xMax - matrixWidth * 2f - 10f, yPos); matrixRectPosition.x += (matrixWidth - matrixRectSize.x) * 0.5f; matrixRectPosition.y += (k_DefaultElementHeight - matrixRectSize.y) * 0.5f; var inspectorRect = new Rect(rect.xMin, yPos, rect.width - matrixWidth * 2f - 20f, height); var matrixRect = new Rect(matrixRectPosition, matrixRectSize); var 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); } } } }
/// <summary> /// Draws a Sprite field for the Rule /// </summary> /// <param name="rect">Rect to draw Sprite Inspector in</param> /// <param name="tilingRule">Rule to draw Sprite Inspector for</param> public virtual void SpriteOnGUI(Rect rect, RuleTile.TilingRuleOutput tilingRule) { tilingRule.m_Sprites[0] = EditorGUI.ObjectField(rect, tilingRule.m_Sprites[0], typeof(Sprite), false) as Sprite; }
public virtual void SpriteOnGUI(Rect rect, RuleTile.TilingRuleOutput 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; }