TylerTemp
commented
4 months ago Hi,
Methods/Properties
if they can also check for methods and properties
For the decorator itself, The parameters can be methods or properties or fields.
[DisableIf(nameof(IsDisabledByMethod))] public string methodChecker;
public bool IsDisabledByMethod()
{
// add your logic here
return true;
}
// change your getter accordingly. This is just an example
public bool IsDisabledByProperty
{
get => true;
private set {}
}
[DisableIf(nameof(IsDisabledByProperty))] public string propertyChecker;As for the decorated target, using on method is possible with SaintsEditor enabled. Because of the limitation from Unity, this feature requires an Editor level component.
To enable it (read more about it here):
Window-Saints-Apply SaintsEditor. After the project finish re-compile, goWindow-Saints-SaintsEditorto tweak configs.
Once it's done, you can use PlayaShowIf/PlayaHideIf/PlayaEnableIf/PlayaDisableIf, which are an "upgraded" version of ShowIf/HideIf etc. They works for both methods and normal fields.
public bool showMyMethod;
#region example of using property value
[Button, PlayaShowIf(nameof(showMyMethod))]
public void MyMethod1()
{
Debug.Log("Method1");
}
#endregion
#region example of using method callback
#if UNITY_EDITOR // this macro is not required, but in case you want to call some editor only methods
public bool ShouldShowMyMethod()
{
// write your logic here
return showMyMethod;
}
#endif
#if UNITY_EDITOR
[Button, PlayaShowIf(nameof(ShouldShowMyMethod))]
#endif
public void MyMethod2()
{
Debug.Log("Method2");
}
#endregion
// this works on normal field too
[PlayaShowIf(nameof(showMyMethod))]
public int myInt;It works just like ShowIf:
Please note, that once you enable SaintsEditor globally, meta attributes from NaugutyAttributes will no longer work. If you using Odin, you need to disable Odin's inspector.
Properties as Target
and properties in addition to fields.
If you mean the properties as target (well, as parameters, see section above)
SerializedField for properties works fine with either ShowIf/HideIf and PlayaShowIf/PlayaHideIf.
Non-SerializedField for properties needs using PlayaShowIf/PlayaHideIf
public bool boolValue;
// DisableIf works on serialized property as expected
[field: SerializeField, DisableIf(nameof(boolValue))]
public Color ColorAutoProperty { get; private set; }
// non serialized property needs `Playa` to help
[ShowInInspector, PlayaShowIf(nameof(boolValue))]
public static Color MyStaticProp => Color.green; // native Property
[ShowInInspector, PlayaShowIf(nameof(boolValue))]
public static Color StaticField = Color.blue; // non serialized Property
[ShowInInspector, PlayaShowIf(nameof(boolValue))]
public static readonly string StaticReadOnlyField = "Building Nothing Out of Something"; // non serialized Field
[ShowInInspector, PlayaShowIf(nameof(boolValue))]
public const float MyConst = 3.14f; // non serialized Field(This feature has a bug in UI Toolkit I'm working on, please try this code AFTER the next release)
Enum Supports
if they could check for specific values of enum fields
Well, at this point enum is not supported yet. I'm not aware that this feature is so commonly needed. As both NaughtyAttributes and Odin support it, I'll consider adding this feature too.
A workround before it's added:
[Serializable]
public enum EnumState
{
Off,
On,
}
public EnumState state;
#if UNITY_EDITOR
[EnableIf(nameof(isOn))]
#endif
public string editable;
#if UNITY_EDITOR
private bool isOn() => state == EnumState.On;
#endifLogic Operation
if they could be also logically chained in an "and" statement
Both Show/Hide/Enable/Disable-If and Playa version supports and & or operation, but it's not very readable.
I didn't add an and/or operation, but it's possible using this way:
For "Show" and "Disable", parameters are "and"
For "Hide" and "Enable", parameters are "or"
and multiple decorators are always "or".
public bool bool1;
public bool bool2;
// disable==1&&2
[DisableIf(nameof(bool1), nameof(bool2))]
public string disable1And2;
// disable==1||2
[DisableIf(nameof(bool1)), DisableIf(nameof(bool2))]
public string disable1Or2;
// enable==1&&2, which means disable==!(1&&2)==!1||!2
[EnableIf(nameof(bool1)), EnableIf(nameof(bool2))]
public string enable1And2;
// enable==1||2, which means disable==!(1||2)==!1&&!2
[EnableIf(nameof(bool1), nameof(bool2))]
public string enable1Or2;This is not a readable API design, but it keeps the code clean and works (. It will stay as this unless there is a better way to do it.
ACCIAI0
In particular, i'd like to know if they can also check for methods and properties in addition to fields. another thing that would really great is if they could check for specific values of enum fields and if they could be also logically chained in an "and" statement. Too bad they can't do that yet, because it look like a very powerful alternative to Odin!