/// <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;
}
