Feature request - [ShowInInspector]

[MikeSzym]

One of our most used attributes from Odin is the [ShowInInspector] attribute, usually in combination with [ReadOnly] -> https://odininspector.com/attributes/show-in-inspector-attribute

Example use cases:

• show private variables (usually with ReadOnly -> visualize but prevent modifications)
• show serialized auto-properties (super useful for data deserialized with JSON etc; e.g. [field: ShowInInspector, ReadOnly] public bool ShowAlert { get; set; } )
• can also be used to show static variables though we don't use it for that

While it is possible to achieve the above via the Debug view in inspector, this is not a convenient solution. Debug view ignores custom inspectors and shows all data, not just what is wanted by the developers

[v0lt13]

You can hide stuff in the debug view via Unity's HideInInspector attribute or in the case of the static members display you can use the HideProperty Attribute as well.

Have you also considered adding the debug view as a separate tab for easier cycling?

For your example use case scenarios, does simply creating a editor field like this not work?

[SerializeField, ReadOnly] private int intField;
[field: SerializeField, ReadOnly] private int intProperty { get; set; }

And as I said before you can already display static members for debug purposes.

[MikeSzym]

Yes, this is possible but this doesn't seem to be a good way of doing this

The idea is to easily show (optionally using any of the decorative, conditional or grouping attributes) variables that you want to see in runtime

Your suggestions don't really allow for this:

• Debug view removes all the custom inspector things and most of the attribute goodies. Additionally you suggest marking other unrelated fields/properties as hidden which is definitely not a good design
• Changing fields/variables to serializable cannot be considered a good solution as this is something that might be intentionally not serialized (I should have used a private auto-property in original example...)

Overall it seems simple -> "I want to show X", nothing more

[v0lt13]

Here is the thing, its not possible to have custom inspector and property attributes on non serialized fields, since Unity bases its entire editor on what its able to serialize, so if I just display a non serialized field in the editor using reflection no attribute on it will run unless I hard code it.

Odin rewrites the entire serialization and editor system from unity so it has much finer control over how it displays stuff, so unless I do the same and rewrite the entire editor and serialization system (which will also bloat the package) I can't have non serialized properties be controlled by other attributes.

So if you want to customize those debug fields you need to serialize them, or the alternative though its a lot more hassle you can create a custom editor and use some API functions I added in the next update to create and bind fields to non serialized members and add the customization directly there, but yeah the whole point of attributes is to not have to do that.

[TylerTemp]

@MikeSzym Just to mention that: this is actually a hell lot of work...

For NaughtyAttributes, which only support some specific type (no class/struct support) & without editing support, it's around 100 lines of code

For SaintsField, which supports nearly any type + interface with editing (but no custom drawer support), it's around 2.8k lines of code

For Tri-Inspector, which supports any type (except dictionary) + interface + editing, it's around 200 lines base + 150 lines extra + 500 lines extra + some other parts I believe I haven't read yet...

Sometimes Unity's built-in tools are way too limited for this function

[v0lt13]

The thing is that I have already done something like this before to display button parameters in the button drawer and in the update I'm currently working on I refactored it and made it part of the public API
so I can create fields for non serialized members no problem, its just that I can't have property drawers on it.

Heck this is something even unity does for their PropertyField.

[MikeSzym]

@v0lt13 well, even without drawers it would be super useful, to show all the runtime gameplay variables - strings, ints, floats, bools and enums. Basically the basic primitive types

[v0lt13]

I can add it like I added showing of static variables, it looks something like this:

It can appear like a separate option in the context menu, something like "Show Non Serialized Members".

How does that sound? And right now I can also display the return values of parameterless methods, does it make sense to do that? Does it seem useful?

[MikeSzym]

@v0lt13 yeah, this looks great or at least good enough for 99% of use cases

[v0lt13]

Added equivalent in update 2.6.1, where you can now show all non serialized members via the object context menu

[v0lt13]

Yeah the feature ended up causing more issues then anticipated, its going to be removed next update and replaced with a ShowInInpsector attribute.

[MikeSzym]

Oh, nice! Thanks a ton!