artificetoolkit

KO | EN

gitlite — search

#python #hacktoberfest #ai #go #android #machine-learning #deep-learning #docker #java #windows #cli #kubernetes #pytorch #openai

artificetoolkit

(★ 263)

A Unity toolkit that allows easy editor customization with simple C# attributes.

파일 탐색기

최종 버전 다운로드 (.zip)

- artifice_addpackage.png
- artifice_addpackage.png.meta
- artifice_artificeeditorwindow.png
- artifice_artificeeditorwindow.png.meta
- artifice_artificemenueditorwindow.gif
- artifice_artificemenueditorwindow.gif.meta
- artifice_assetonly.png
- artifice_assetonly.png.meta
- artifice_boxgroup.jpg
- artifice_boxgroup.jpg.meta
- artifice_button.gif
- artifice_button.gif.meta
- artifice_buttonproperty.gif
- artifice_buttonproperty.gif.meta
- artifice_childgameobjectonly.gif
- artifice_childgameobjectonly.gif.meta
- artifice_comparison.png
- artifice_comparison.png.meta
- artifice_enableif.gif
- artifice_enableif.gif.meta
- artifice_enumtoggle.png
- artifice_enumtoggle.png.meta
- artifice_exampleportrait.png
- artifice_exampleportrait.png.meta
- artifice_foldoutgroup.jpg
- artifice_foldoutgroup.jpg.meta
- artifice_groupbeginend.gif
- artifice_groupbeginend.gif.meta
- artifice_horizontalgroup.png
- artifice_horizontalgroup.png.meta
- artifice_ignorelist.png
- artifice_ignorelist.png.meta
- artifice_inlineobject.gif
- artifice_inlineobject.gif.meta
- artifice_inlineproperty.png
- artifice_inlineproperty.png.meta
- artifice_inspectorheader.gif
- artifice_inspectorheader.gif.meta
- artifice_listelementname.gif
- artifice_listelementname.gif.meta
- artifice_menuitem.png
- artifice_menuitem.png.meta
- artifice_previewscriptable.gif
- artifice_previewscriptable.gif.meta
- artifice_previewsprite.png
- artifice_previewsprite.png.meta
- artifice_readonly.jpg
- artifice_readonly.jpg.meta
- artifice_required.png
- artifice_required.png.meta
- artifice_sceneonly.png
- artifice_sceneonly.png.meta
- artifice_serializedDictionary.gif
- artifice_serializedDictionary.gif.meta
- artifice_serializedDictionaryCode.png
- artifice_serializedDictionaryCode.png.meta
- artifice_serializedreference.gif
- artifice_serializedreference.gif.meta
- artifice_sort.jpg
- artifice_sort.jpg.meta
- artifice_tabgroup.gif
- artifice_tabgroup.gif.meta
- artifice_title.png
- artifice_title.png.meta
- artifice_toggle.png
- artifice_toggle.png.meta
- artifice_validateinput.gif
- artifice_validateinput.gif.meta
- artifice_validator.gif
- artifice_validator.gif.meta
- artifice_validator.png
- artifice_validator.png.meta
- artifice_verticalgroup.jpg
- artifice_verticalgroup.jpg.meta
- artifice_wizard.png
- artifice_wizard.png.meta
- - Artifice_Style_AbstractListView.uss
  - Artifice_Style_AbstractListView.uss.meta
  - Artifice_VisualElement_AbstractListView.cs
  - Artifice_VisualElement_AbstractListView.cs.meta
  - Artifice_VisualElement_ListView.cs
  - Artifice_VisualElement_ListView.cs.meta
  - ArtificeTableListView.meta
- - Artifice_Style_ArtificeMenuEditorWindow.uss
  - Artifice_Style_ArtificeMenuEditorWindow.uss.meta
  - Artifice_VisualElement_ArtificeMenuItem.cs
  - Artifice_VisualElement_ArtificeMenuItem.cs.meta
  - ArtificeMenuEditorWindow.cs
  - ArtificeMenuEditorWindow.cs.meta
  - ArtificeMenuTreeNode.cs
  - ArtificeMenuTreeNode.cs.meta
- - artifice_bars.png
  - artifice_bars.png.meta
  - artifice_circle-exclamation.png
  - artifice_circle-exclamation.png.meta
  - artifice_comment.png
  - artifice_comment.png.meta
  - artifice_fast forward.png
  - artifice_fast forward.png.meta
  - artifice_folder.png
  - artifice_folder.png.meta
  - artifice_gameobject.png
  - artifice_gameobject.png.meta
  - artifice_gear.png
  - artifice_gear.png.meta
  - artifice_magnifying-glass.png
  - artifice_magnifying-glass.png.meta
  - artifice_maximize.png
  - artifice_maximize.png.meta
  - artifice_pause.png
  - artifice_pause.png.meta
  - artifice_play.png
  - artifice_play.png.meta
  - artifice_refresh.png
  - artifice_refresh.png.meta
  - Artifice_SCR_CommonResourcesHolder.cs
  - Artifice_SCR_CommonResourcesHolder.cs.meta
  - artifice_script.png
  - artifice_script.png.meta
  - artifice_star.png
  - artifice_star.png.meta
  - artifice_transform.png
  - artifice_transform.png.meta
  - artifice_triangle-exclamation.png
  - artifice_triangle-exclamation.png.meta
  - artifice_unity.png
  - artifice_unity.png.meta
- - Artifice_CustomAttributeDrawer.cs
  - Artifice_CustomAttributeDrawer.cs.meta
  - Artifice_CustomAttributeDrawerAttribute.cs
  - Artifice_CustomAttributeDrawerAttribute.cs.meta
  - CustomAttributeDrawer_BorderAttribute.meta
  - CustomAttributeDrawer_ButtonAttribute.meta
  - CustomAttributeDrawer_ButtonPropertyAttribute.meta
  - CustomAttributeDrawer_EnableIfAttribute.meta
  - CustomAttributeDrawer_EnumToggleAttribute.meta
  - CustomAttributeDrawer_HideInArtificeAttribute.meta
  - CustomAttributeDrawer_HideLabelAttribute.meta
  - CustomAttributeDrawer_InfoBoxAttribute.meta
  - CustomAttributeDrawer_InlineObjectAttribute.meta
  - CustomAttributeDrawer_InlinePropertyAttribute.meta
  - CustomAttributeDrawer_LabelWidthAttribute.meta
  - CustomAttributeDrawer_LayoutPercentAttribute.meta
  - CustomAttributeDrawer_LayoutPixelsAttribute.meta
  - CustomAttributeDrawer_ListElementNameAttribute.meta
  - CustomAttributeDrawer_MaxValueAttribute.meta
  - CustomAttributeDrawer_MeasureUnitAttribute.meta
  - CustomAttributeDrawer_MinValueAttribute.meta
  - CustomAttributeDrawer_OnValueChangedAttribute.meta
  - CustomAttributeDrawer_PreviewFieldAttribute.meta
  - CustomAttributeDrawer_PreviewScriptableAttribute.meta
  - CustomAttributeDrawer_RangeAttribute.meta
  - CustomAttributeDrawer_ReadOnlyAttribute.meta
  - CustomAttributeDrawer_SafeTooltipAttribute.meta
  - CustomAttributeDrawer_SortAttribute.meta
  - CustomAttributeDrawer_SpaceAttribute.meta
  - CustomAttributeDrawer_TitleAttribute.meta
  - CustomAttributeDrawer_Validators.meta
  - CustomAttributeDrawers_Groups.meta
- - Artifice_EditorWindow_IgnoreList.cs
  - Artifice_EditorWindow_IgnoreList.cs.meta
  - Artifice_Style_EditorWindow_IgnoreList.uss
  - Artifice_Style_EditorWindow_IgnoreList.uss.meta
- - Artifice_InspectorHeader_Dock.cs
  - Artifice_InspectorHeader_Dock.cs.meta
  - Artifice_InspectorHeader_Main.cs
  - Artifice_InspectorHeader_Main.cs.meta
  - Artifice_Style_InspectorHeader.uss
  - Artifice_Style_InspectorHeader.uss.meta
- - Artifice_Style_SerializedDictionary.uss
  - Artifice_Style_SerializedDictionary.uss.meta
  - ArtificeEditor_PropertyDrawer_SerializedDictionary.cs
  - ArtificeEditor_PropertyDrawer_SerializedDictionary.cs.meta
  - ArtificeEditor_VisualElement_DictionaryListView.cs
  - ArtificeEditor_VisualElement_DictionaryListView.cs.meta
- - Artifice_Style_SerializedHashSet.uss
  - Artifice_Style_SerializedHashSet.uss.meta
  - ArtificeEditor_PropertyDrawer_SerializedHashSet.cs
  - ArtificeEditor_PropertyDrawer_SerializedHashSet.cs.meta
  - ArtificeEditor_VisualElement_HashSetListView.cs
  - ArtificeEditor_VisualElement_HashSetListView.cs.meta
- - Artifice_StylesHolder.asset
  - Artifice_StylesHolder.asset.meta
  - StylesHolder.cs
  - StylesHolder.cs.meta
- - UIBuilder.cs
  - UIBuilder.cs.meta
- - SerializedPropertyDataCopier.cs
  - SerializedPropertyDataCopier.cs.meta
- - Artifice_EditorWindow_Validator.meta
  - Artifice_SCR_ValidatorConfig.cs
  - Artifice_SCR_ValidatorConfig.cs.meta
  - Artifice_Toolbar_Validator.meta
  - Artifice_Validator.cs
  - Artifice_Validator.cs.meta
  - Artifice_ValidatorExtensions.cs
  - Artifice_ValidatorExtensions.cs.meta
  - Artifice_ValidatorModule.cs
  - Artifice_ValidatorModule.cs.meta
  - Artifice_ValidatorModule_CustomAttributeChecker.cs
  - Artifice_ValidatorModule_CustomAttributeChecker.cs.meta
  - Artifice_ValidatorModule_GameObjectBatching.cs
  - Artifice_ValidatorModule_GameObjectBatching.cs.meta
  - Artifice_ValidatorModule_IsArtificeEnabled.cs
  - Artifice_ValidatorModule_IsArtificeEnabled.cs.meta
  - Artifice_ValidatorModule_NullScriptChecker_GameObjects.cs
  - Artifice_ValidatorModule_NullScriptChecker_GameObjects.cs.meta
  - Artifice_ValidatorModule_ScriptableObject_CustomAttributeChecker.cs
  - Artifice_ValidatorModule_ScriptableObject_CustomAttributeChecker.cs.meta
  - Artifice_ValidatorModule_ScriptableObject_NullReferenceChecker.cs
  - Artifice_ValidatorModule_ScriptableObject_NullReferenceChecker.cs.meta
  - Artifice_ValidatorModule_SerializedPropertyBatching.cs
  - Artifice_ValidatorModule_SerializedPropertyBatching.cs.meta
  - IArtifice_ShouldIncludeInValidation.cs
  - IArtifice_ShouldIncludeInValidation.cs.meta
- - Artifice_Style_LabeledButton.uss
  - Artifice_Style_LabeledButton.uss.meta
  - Artifice_Style_SlidingGroup.uss
  - Artifice_Style_SlidingGroup.uss.meta
  - Artifice_Style_ToggleButton.uss
  - Artifice_Style_ToggleButton.uss.meta
  - Artifice_VisualElement_InfoBox.meta
  - Artifice_VisualElement_LabeledButton.cs
  - Artifice_VisualElement_LabeledButton.cs.meta
  - Artifice_VisualElement_SlidingGroup.cs
  - Artifice_VisualElement_SlidingGroup.cs.meta
  - Artifice_VisualElement_ToggleButton.cs
  - Artifice_VisualElement_ToggleButton.cs.meta
- - Artifice_EditorWindow_HomeSettings.cs
  - Artifice_EditorWindow_HomeSettings.cs.meta
  - Artifice_EditorWindow_Wizard.cs
  - Artifice_EditorWindow_Wizard.cs.meta
  - Artifice_Style_HomeSettings.uss
  - Artifice_Style_HomeSettings.uss.meta
- abzorba.artificetoolkit.editor.asmdef
- abzorba.artificetoolkit.editor.asmdef.meta
- Artifice_ArtificeListView.meta
- Artifice_ArtificeMenuEditorWindow.meta
- Artifice_CommonResources.meta
- Artifice_CustomAttributeDrawers.meta
- Artifice_CustomDrawerUtility.cs
- Artifice_CustomDrawerUtility.cs.meta
- Artifice_IgnoreList.meta
- Artifice_InspectorHeader.meta
- Artifice_PropertyDrawer_ArtificeElement.cs
- Artifice_PropertyDrawer_ArtificeElement.cs.meta
- Artifice_PropertyDrawer_SerializedDictionary.meta
- Artifice_PropertyDrawer_SerializedHashSet.meta
- Artifice_SCR_PersistedData.cs
- Artifice_SCR_PersistedData.cs.meta
- Artifice_SerializedPropertyExtensions.cs
- Artifice_SerializedPropertyExtensions.cs.meta
- Artifice_Style_ArtificeDrawer.uss
- Artifice_Style_ArtificeDrawer.uss.meta
- Artifice_Style_ArtificeEditorWindow.uss
- Artifice_Style_ArtificeEditorWindow.uss.meta
- Artifice_Style_Global.uss
- Artifice_Style_Global.uss.meta
- Artifice_StylesHolder.meta
- Artifice_UIBuilder.meta
- Artifice_Utilities.cs
- Artifice_Utilities.cs.meta
- Artifice_Utilities.meta
- Artifice_Validator.meta
- Artifice_VisualElements.meta
- Artifice_Wizard.meta
- ArtificeDrawer.cs
- ArtificeDrawer.cs.meta
- ArtificeEditorWindow.cs
- ArtificeEditorWindow.cs.meta
- ArtificeInspector.cs
- ArtificeInspector.cs.meta
- IArtifice_Persistence.cs
- IArtifice_Persistence.cs.meta
- - Artifice_ExampleForArtificeAttributes.cs
  - Artifice_ExampleForArtificeAttributes.cs.meta
  - Artifice_SCR_Character.cs
  - Artifice_SCR_Character.cs.meta
  - ExampleCharacter_Kayn.asset
  - ExampleCharacter_Kayn.asset.meta
  - ExampleCharacter_Luther.asset
  - ExampleCharacter_Luther.asset.meta
  - ExampleCharacter_Thaendal.asset
  - ExampleCharacter_Thaendal.asset.meta
- - SerializedDictionary.cs
  - SerializedDictionary.cs.meta
- - SerializedHashSet.cs
  - SerializedHashSet.cs.meta
- - ArtificeIgnoreAttribute.cs
  - ArtificeIgnoreAttribute.cs.meta
  - AssetsOnlyAttribute.cs
  - AssetsOnlyAttribute.cs.meta
  - BorderAttribute.cs
  - BorderAttribute.cs.meta
  - BoxGroupAttribute.cs
  - BoxGroupAttribute.cs.meta
  - BoxGroupBeginAttribute.cs
  - BoxGroupBeginAttribute.cs.meta
  - ButtonAttribute.cs
  - ButtonAttribute.cs.meta
  - ButtonPropertyAttribute.cs
  - ButtonPropertyAttribute.cs.meta
  - ChildGameObjectsOnlyAttribute.cs
  - ChildGameObjectsOnlyAttribute.cs.meta
  - ConditionalInfoBoxAttribute.cs
  - ConditionalInfoBoxAttribute.cs.meta
  - CustomAttribute.cs
  - CustomAttribute.cs.meta
  - EnableIfAttribute.cs
  - EnableIfAttribute.cs.meta
  - EnumToggleAttribute.cs
  - EnumToggleAttribute.cs.meta
  - FoldoutGroupAttribute.cs
  - FoldoutGroupAttribute.cs.meta
  - FoldoutGroupBeginAttribute.cs
  - FoldoutGroupBeginAttribute.cs.meta
  - ForceArtificeAttribute.cs
  - ForceArtificeAttribute.cs.meta
  - GroupAttribute.cs
  - GroupAttribute.cs.meta
  - GroupEndAttribute.cs
  - GroupEndAttribute.cs.meta
  - HideInArtificeAttribute.cs
  - HideInArtificeAttribute.cs.meta
  - HideLabelAttribute.cs
  - HideLabelAttribute.cs.meta
  - HorizontalGroupAttribute.cs
  - HorizontalGroupAttribute.cs.meta
  - HorizontalGroupBeginAttribute.cs
  - HorizontalGroupBeginAttribute.cs.meta
  - InfoBoxAttribute.cs
  - InfoBoxAttribute.cs.meta
  - InlineObjectAttribute.cs
  - InlineObjectAttribute.cs.meta
  - InlinePropertyAttribute.cs
  - InlinePropertyAttribute.cs.meta
  - LabelWidthAttribute.cs
  - LabelWidthAttribute.cs.meta
  - LayoutPercentAttribute.cs
  - LayoutPercentAttribute.cs.meta
  - LayoutPixelsAttribute.cs
  - LayoutPixelsAttribute.cs.meta
  - ListElementNameAttribute.cs
  - ListElementNameAttribute.cs.meta
  - MaxValueAttribute.cs
  - MaxValueAttribute.cs.meta
  - MeasureUnitAttribute.cs
  - MeasureUnitAttribute.cs.meta
  - MinValueAttribute.cs
  - MinValueAttribute.cs.meta
  - OnValueChanged.cs
  - OnValueChanged.cs.meta
  - PreviewScriptableAttribute.cs
  - PreviewScriptableAttribute.cs.meta
  - PreviewSpriteAttribute.cs
  - PreviewSpriteAttribute.cs.meta
  - RangeAttribute.cs
  - RangeAttribute.cs.meta
  - ReadOnlyAttribute.cs
  - ReadOnlyAttribute.cs.meta
  - RequiredAttribute.cs
  - RequiredAttribute.cs.meta
  - SafeTooltipAttribute.cs
  - SafeTooltipAttribute.cs.meta
  - SceneObjectsOnlyAttribute.cs
  - SceneObjectsOnlyAttribute.cs.meta
  - SortAttribute.cs
  - SortAttribute.cs.meta
  - SpaceAttribute.cs
  - SpaceAttribute.cs.meta
  - TabGroupAttribute.cs
  - TabGroupAttribute.cs.meta
  - TableListAttribute.cs
  - TableListAttribute.cs.meta
  - TitleAttribute.cs
  - TitleAttribute.cs.meta
  - ValidateInputAttribute.cs
  - ValidateInputAttribute.cs.meta
  - ValidateJsonAttribute.cs
  - ValidateJsonAttribute.cs.meta
  - ValidateUxmlAttribute.cs
  - ValidateUxmlAttribute.cs.meta
  - ValidatorAttribute.cs
  - ValidatorAttribute.cs.meta
  - VerticalGroupAttribute.cs
  - VerticalGroupAttribute.cs.meta
  - VerticalGroupBeginAttribute.cs
  - VerticalGroupBeginAttribute.cs.meta
- abzorba.artificetoolkit.customattributes.asmdef
- abzorba.artificetoolkit.customattributes.asmdef.meta
- Artifice_Example.meta
- Artifice_SerializedDictionary.meta
- Artifice_SerializedHashSet.meta
- ArtificeElement.cs
- ArtificeElement.cs.meta
- CustomAttributes.meta
- IArtifice_ArrayAppliedAttribute.cs
- IArtifice_ArrayAppliedAttribute.cs.meta
- IArtifice_RequiresCheckForValidationInclusion.cs
- IArtifice_RequiresCheckForValidationInclusion.cs.meta
CHANGELOG.md
CHANGELOG.md.meta
Documentation.meta
Editor.meta
LICENSE
LICENSE.meta
package.json
package.json.meta
README.md
README.md.meta
Runtime.meta

# 설치 가이드

1. 코드 내려받기

git clone https://github.com/AbZorbaGames/artificetoolkit

깃허브에서 프로젝트 코드 전체를 내 컴퓨터로 내려받습니다.

cd artificetoolkit

방금 내려받은 프로젝트 폴더 안으로 이동합니다.

2. Node.js

쉬움 추천

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
Node.js npm 명령어를 쓰려면 Node.js가 설치되어 있어야 합니다. LTS(장기지원) 버전을 추천합니다.

npm install

package.json에 명시된 라이브러리들을 내려받아 설치합니다.

npm start

개발/실행 서버를 켭니다.

✅ 명령어 실행 후 터미널에 나타나는 주소(보통 http://localhost:3000 형태)를 브라우저에서 열어보세요.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Artifice Toolkit
Normally, extending Unity’s editor requires specialized knowledge of IMGUI or the UI Toolkit libraries, along with maintaining separate files for each editor extension. This makes the editor's capabilities less accessible and often a hassle to research, learn and develop.

The ArtificeToolkit simplifies this process by providing custom attributes that can be applied directly in the source code, automatically altering the appearance of properties in the editor. The toolkit can be used in a variety of creative ways and can even be extended by creating new attributes.

To demonstrate its usage and effectiveness, see the following MonoBehaviour script's inspector. On the left is the default inspector generated by Unity, and on the right is the same script with a few additional attributes.

## Why use the ArtificeToolkit?

- Visually "lightweight" inspectors reduce cognitive load by removing unnecessary information.
- A simplified interface helps developers focus on relevant details, minimizing distractions.
- Apply assertions on your serialized fields through validations, to always be sure that certain rules are being followed.

## What is included in the ArtificeToolkit?
The Artifice Toolkit offers various powerful tools:

1. [Artifice Inspector](#artifice-inspector-and-custom-attributes): Alter the appearance of your editor's inspector with simple C# custom attributes. This is editor scripting without the editor scripting knowledge being required!

2. [Artifice Validator](#artifice-validator): Attach validator attributes to your serialized properties to always make sure certain rules are being followed. Do not waste time on absent minded mistakes ever again.

3. [Artifice Drawer](#artifice-drawer): The ArtificeDrawer is what renders everything in the ArtificeToolkit. Invoke the drawer in your Editor Scripts with a SerializedObject or SerializedProperty and you will receive the rendered result of it. This essentially makes the ArtificeDrawer a first-class citizen inspector.
   
4. [Artifice Editor Window](#artificeeditorwindow): Write your own Editor windows with custom layouts, functionality, and more, just as if you were writing an Inspector using custom attributes. Be sure to also check out the [Artifice Menu Editor Window](#artificemenueditorwindow).

## Unity Version Support
The ArtificeToolkit has been primarily tested and optimized for Unity 2022, ensuring stable and consistent performance. It is also compatible with Unity 2023, where it has been thoroughly tested to maintain functionality. While the toolkit works with Unity 2021, users may encounter occasional warnings; these will be addressed in upcoming updates to improve compatibility with older versions.

## How to Install into Your Unity Project

You can add the ArtificeToolkit to your Unity project as a package through Git. Follow these steps:
- Navigate to `Window -> Package Manager` in Unity.
- Click the **"+"** icon in the top-left corner of thePackage Manager.
- Select **"Add package from Git URL..."**.
- In the popup that appears, paste the following URL: https://github.com/AbZorbaGames/artificetoolkit.git

# Artifice Inspector and Custom Attributes
By using custom attributes in your MonoBehaviour scripts you can quickly alter the inspector's appearance. In this section, you will find all the attributes which are tested and ready for use.

**NOTE:** By default, the Artifice Drawer is disabled. You can always turn it on/off through the dedicated MenuItem "ArtificeToolkit/Wizard Settings"

## Top Recommended Attributes
Following are the simplest to use attributes which can have a big impact on visuals of the inspector.

- [FoldoutGroup](#foldout-group)
- [Required](#required)
- [InlineObject](#inlineobject)
- [Button](#button)

## Group Attributes
Group Attributes can be used to bring together various properties in a form of a group. Such groups can also work in a nested manner as shown in the [BoxGroup](#boxgroup) example.

- [BoxGroup](#boxgroup)
- [FoldoutGroup](#foldout-group)
- [TabGroup](#tab-group)
- [HorizontalGroup](#horizontal-group)
- [VerticalGroup](#vertical-group)
- [Begin/End Group Attributes](#group-begin-and-group-end-attributes)

Note: BoxGroup and FoldoutGroup can be further enhanced using the GroupColor enum.

## Validation Attributes
Validation Attributes are used to assert certain rules over your properties. This is achieved in the inspector visualy using an error prompt, and through the use of the [ArtificeValidator](#artifice-validator).

- [Required](#required)
- [AssetOnly](#assetonly)
- [SceneObjectOnly](#sceneobjectonly)
- [ChildGameObjectOnly](#childgameobjectonly)
- [ValidateInput](#validateinput)
- [ValidateUxml](#validateuxml)
- [ValidateJson](#validatejson)
- [MinValue](#minvalue)
- [MaxValue](#maxvalue)

## Essential and Easy Attributes
These attributes can and should be used frequently. They will at a bare minimum simplify and make the inspector more readable.

- [Title](#title)
- [EnumToggle](#enumtoggle)
- [EnableIf](#enableif)
- [Button](#button)
- [ButtonProperty](#buttonproperty)
- [PreviewSprite](#previewsprite)
- [PreviewScriptable](#previewscriptable)
- [ReadOnly](#readonly)
- [Sort](#sort)

## Miscellaneous
- [ArtificeIgnore](#artificeignore)
- [InlineObject](#inlineobject)
- [InlineProperty](#inlineproperty)
- [Space](#space)
- [Range](#range)
- [HideLabel](#hidelabel)
- [HideInArtifice](#hideinartifice)
- [InfoBox](#infobox)
- [ConditionalInfoBox](#conditionalinfobox)
- [ListElementName](#listelementname)
- [MeasureUnit](#measureunit)
- [ForceArtifice](#forceartifice)
- [OnValueChanged](#onvaluechanged)
- [SafeTooltip](#safetooltip)

## Why Order Matters!
When applying custom attributes to a property, it’s important to understand the order in which they are applied during the rendering process. Internally, custom attributes are applied at the following key rendering points:

1. Pre Property GUI: Before the property is drawn in the Inspector.
2. On Property GUI: Replaces the property’s default GUI entirely.
3. Post Property GUI: Applied after the property is drawn.
4. Wrap Property GUI: Encapsulates all previous steps inside a new container. An example of this is how Group Attributes work.
5. Property Bound GUI: This is called after the property has been drawn, useful when dealing with PropertyField because its children are built lazily in the UI.

For most attributes, the order they are applied follows the order of declaration. However, attributes that use OnWrap GUI (like group attributes) are applied in <b>reverse order</b>, which can lead to unexpected behavior if not handled carefully.

Example
Consider this example with conflicting attributes. Both the BoxGroup and the EnableIf work by utilizing the Wrap Property GUI:
```c#
[SerializeField]
private bool shouldEnable;

[SerializeField, BoxGroup("Test")]
private int x;

[SerializeField, EnableIf(nameof(shouldEnable)), BoxGroup("Test")]
private int y;
```

If we trace how property 'y' will get rendered, it would firstly resolve the BoxGroup("Test") which has already included property 'x'. Then, it would resolve EnableIf wrapping the BoxGroup inside of the EnableIf.

This is "probably" an undesired effect, unless executed by design. Its wrong, since now the enable if does not encapsulate only the 'y' property, but the entire BoxGroup which holds both 'x' and 'y'.

So the correct version of the above code would be 
```c#
[SerializeField]
private bool shouldEnable;

[SerializeField, BoxGroup("Test")]
private int x;

[SerializeField, BoxGroup("Test"), EnableIf(nameof(shouldEnable), true)]
private int y;
```
In this version, EnableIf is applied first, ensuring that property y behaves as expected—only, and the the BoxGroup is resolved, wrapping the wrapper of the EnableIf.

## All Attributes

### BoxGroup
The simplest form of a Group attribute is the BoxGroup. Every serialized property of the script will be rendered inside of a container with the given title.

```c#
[SerializeField, BoxGroup("GroupA")]
private int first;

[SerializeField, BoxGroup("GroupA")]
private int second;

[SerializeField, BoxGroup("GroupA/GroupB")]
private int third;
```  
![box-group-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_boxgroup.jpg)

### Foldout Group
The FoldoutGroup extends the BoxGroup by allowing the user to optionally collapse the container.

```c#
[SerializeField, BoxGroup("GroupExample/GroupA")]
private int first;

[SerializeField, BoxGroup("GroupExample/GroupA")]
private int second;

[SerializeField, FoldoutGroup("GroupExample/GroupB")]
private int third;

[SerializeField, FoldoutGroup("GroupExample/GroupB")]
private int fourth;
```
![foldout-group-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_foldoutgroup.jpg)

### Tab Group
The TabGroup allows you to create tabs inside of the Unity inspector. The syntax is more complex than Box and Foldout groups but it is well worth it. The first string dictates the name of the group and the second one dictates the name of the tab. All the properties that belong in the same group and same tab, will be contained together.

```c#
[SerializeField, TabGroup("Example", "Integers")]
private int first;

[SerializeField, TabGroup("Example", "Integers")]
private int second;

[SerializeField, TabGroup("Example", "Strings")]
private string third;

[SerializeField, TabGroup("Example", "Strings")]
private string fourth;

[SerializeField, TabGroup("Example", "Strings")]
private string fifth;
```
![tab-group-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_tabgroup.gif)

### Horizontal Group
The HorizontalGroup attribute allows you to align multiple properties into a single line, instead of having every property be rendered in a new line. Note, that the Horizontal and Vertical groups do not show their titles and are solely used for structuring.

```c#
[SerializeField, HorizontalGroup("horizontal1")]
private List<int> leftColumn;

[SerializeField, HorizontalGroup("horizontal1")]
private List<int> rightColumn;
```
![horizontal-group-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_horizontalgroup.png)

### Vertical Group
The Vertical Group is only useful inside of a horizontal group, to dictate a vertical column of properties inside of it.

```c#
[SerializeField, HorizontalGroup("horizontal1"), VerticalGroup("horizontal1/vertical")]
private List<int> leftColumn;

[SerializeField, HorizontalGroup("horizontal1"), VerticalGroup("horizontal1/vertical")]
private int leftColumnInteger;

[SerializeField, HorizontalGroup("horizontal1")]
private List<int> rightColumn;
```
![vertical-group-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_verticalgroup.jpg)

### Group Begin and Group End attributes
If you want a plethora of elements to be added in a Group (for example a BoxGroup), it becomes really repetitive and this felt unwanted. For this reason, artifice now supports an alternate way of using groups called the Begin/End paradigm.

This process, makes adding EnableIf and Colors to groups much easier and more intuitive! The only GroupAttribute not supported yet is the TabGroup which will be implemented in the future.

```c#
[EnableIf(nameof(shouldShowGroup))]
[BoxGroupBegin("A", GroupColor.Blue)] 
public int x;

[HorizontalGroupBegin("A/row")]
public int y;
public int z;
[GroupEnd]

[FoldoutGroupBegin("A/Settings", GroupColor.Blue)]
public int a;
public int b;
public int c;
[GroupEnd]

[GroupEnd]

public bool shouldShowGroup = true;
```

---

### Required
The Required field prompts the inspector with an error indicator if the property has not been set. This is GREATLY important in Unity, where it is common to initialize fields and dependencies through [SerializedField] properties. This is what makes the Required field the most important and most commonly used validation attribute.

```c#
[SerializeField, Required] 
private Transform requiredFieldExample;
```

![required-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_required.png)

### AssetOnly
AssetOnly validates that the value of the serialized property is an asset. This is useful when you have a field for a prefab that will be potentially instantiated. It is common to drag a GameObject from the scene, instead of the assets.

```c#
[SerializeField, Required, AssetOnly] 
private Transform requiredAssetOnlyExample;
```

![assetonly-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_assetonly.png)

### SceneObjectOnly
Works exactly like the [AssetOnly](#assetonly) attribute but in-reverse. This validates that the serialized property value is of an instantiated gameobject in any loaded scene.

```c#
[SerializeField, Required, SceneObjectOnly] 
private Transform requiredSceneOnlyExample;
```

![sceneobjectonly-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_sceneonly.png)

### ChildGameObjectOnly
In Unity, it is also common to have scripts which require references from the children of the GameObject. Use the ChildGameObjectOnly attribute to assert this behaviour.

In addition, when this attribute is used, the inspector is further enhanced allowing for optimized search of the hierarchy, previewing only the valid GameObjects/Scripts based on the type of the serialized property..

```c#
[SerializeField, Required, ChildGameObjectOnly] 
private Transform requiredChildOnlyExample;
```

![sceneobjectonly-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_childgameobjectonly.gif)

### ValidateInput

The ValidateInput attribute allows you to create custom validations on the spot. It can be applied to any attribute, and takes as a parameter the path to some other value (does not have to be serialized). It then validates the value - either that be a field, property or method - and shows your validation message if the return value was false.

```c#
[SerializeField, ValidateInput(nameof(ValidatePeople), "You need to provide at least one person.")] 
private List<Person> people = new();

private bool ValidatePeople()
{
   return people.Any();
}
```

![validateinput-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_validateinput.gif)

### ValidateUxml

The ValidateUxml attribute is used to validate a string which needs to be in a standard Uxml format.

### ValidateJson

The ValidateJson attribute is used to validate a string which needs to be in a standard Json format.

---

### Title
The Title attribute allows you to highlight a specific part or property of your inspector. It can also be used in combination with the [HideLabel](#hidelabel) to create a new visual representation of fields as shown below.

```c#
[SerializeField, Title("Name")]
private string name;

[SerializeField, Title("Age"), HideLabel, Range(0, 100)]
private int age;

[SerializeField, Title("City"), HideLabel]
private string city;
```

![title-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_title.png)

### EnumToggle
EnumToggle converts the conventional for of enum rendering to a multi-button preview. The [Flags] attribute is also supported. Note, that this is useful mostly in enums with a small number of different values.

```c#
public enum Directions
{ 
    Up, Down, Left, Right
}

[SerializeField, EnumToggle] 
private Directions direction;
```

![enumtoggle-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_enumtoggle.png)

### EnableIf
The EnableIf attribute allows you to conditionally show or hide a serialized property based on the value of another field, property, or even a method within the same scope.
This is especially useful for exposing optional settings or parameters that depend on a boolean flag, an enum value, or a custom validation check.

Refer to the EnableIf constructor for detailed usage examples and supported parameter types.

```c#
[SerializeField]
private bool shouldSpawnParticlesOnDestroy;

[SerializeField, FoldoutGroup("On Death", GroupColor.Red)]
private ParticleSystem prefabOnDeathParticles;

[SerializeField, FoldoutGroup("On Death", GroupColor.Red)]
private float onDeathDurationSeconds;

[SerializeField, EnableIf(nameof(shouldSpawnParticlesOnDestroy)), FoldoutGroup("On Death", GroupColor.Red)]
private float onDeathSoundFxVolume;
```

![enableif-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_enableif.gif)

---

**NOTE**: The custom attributes of the Artifice, are processed from last to first. This allows us to perform various tricks since both the EnableIf and the FoldoutGroup, wrap the property in another VisualElement container. By having the EnableIf before the FoldoutGroup, on the LAST instance of the FoldoutGroup, the EnableIf captures the entire FoldoutGroup, although we have only declared it at a single serialized property.

---

### Button
Button allows you to quickly turn any method into a button in the inspector to invoke at your hearts content. Buttons can be placed inline using an optional parameter. Otherwise they will be grouped in a sliding container to keep your inspector clean and simple.

It is worth noting that buttons will always appear last in the rendering order. You can use any of the [GroupAttributes](#BoxGroup) to place the button in ane existing group in the same scope.

**NOTE**: If you want to use a method as a button in a more complex layout, read [ButtonProperty](#buttonproperty)

```c#
[SerializeField] 
private string parameterTest = "test";

[Button(true)]
private void TestMethod()
{
    Debug.Log("Invoked from editor button!");
}

[Button]
private void TestMethodInline()
{
    Debug.Log("Invoked from editor button!");
}

[Button(true, "parameterTest")]
private void TestMethodWithParameters(string parameter)
{
    Debug.Log($"Invoked from editor button! Dynamic Parameter: {parameter}");
}
```

![button-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_button.gif)

### ButtonProperty
ButtonProperty allows you to use all the other attributes and apply them in your Button. But... this cannot be directly applied to a method declaration. You need to create an `ArtificeElement` property and apply to it all your desired attributes.

```c#
[Serializable]
public class TestClass
{
    [HideInArtifice]
    public bool shouldShow;
    
    // public ArtificeElement element;
    [ButtonProperty(nameof(ToggleShouldShow)), HorizontalGroup("row"), LayoutPercent(25)]
    public ArtificeElement methodToggleShouldShow;
    
    [ButtonProperty(nameof(Method1)), VerticalGroup("row/col"), EnableIf(nameof(shouldShow))]
    public ArtificeElement methodNestedMethod;
    
    [ButtonProperty(nameof(Method2)), VerticalGroup("row/col"), EnableIf(nameof(shouldShow))]
    public ArtificeElement methodNestedMethodWithParam;
    
    public void ToggleShouldShow()
    {
        shouldShow = !shouldShow;
    }
    
    public void Method1()
    {
        Debug.Log("This is Method 1");
    }
    
    public void Method2()
    {
        Debug.Log("This is Method 2");
    }
}
```

![button-property-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_buttonproperty.gif)

### InlineObject
This is one of the most magical attributes in the Artifice Toolkit. It allows you to dynamically instantiate a `UnityEngine.Object` type (ex. `ScriptableObject`) inspector inside of another inspector. This can even work in a nested manner, previewing scriptable objects inside of other scriptable objects etc.

```c#
[CreateAssetMenu(menuName = "ScriptableObject/Character")]
public class SCR_Character : ScriptableObject
{
    [PreviewSprite, HorizontalGroup("row"), HideLabel]
    public Texture2D icon;

[Title("First Name"), HorizontalGroup("row"), VerticalGroup("col"), HideLabel]
    public string firstName;
        
    [Title("Last Name"), HorizontalGroup("row"), VerticalGroup("col"), HideLabel]
    public string lastName;
}

[SerializeField, InlineObject]
private List<SCR_Character> mainCharacter;
```

![inline-object-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_previewscriptable.gif)

The `InlineObject` attribute allows you to render any `UnityEngine.Object` reference directly in the Inspector (e.g., `MonoBehaviour`, `Material`, `Texture`, etc.).

### PreviewSprite
PreviewSprite works only on the Sprite and Texture2D serialized properties. It renders an enlarged image of the selected value.

```c#
[SerializeField, PreviewSprite] 
private Sprite characterPortrait;
```

![previewsprite-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_previewsprite.png)

---

### ReadOnly

```c#
[SerializeField, ReadOnly] 
private float gravity = 9.81f;

[SerializeField, ReadOnly, ForceArtifice]
private Vector3 up = new Vector3(0f, 1f, 0f);
```

![readonly-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_readonly.jpg)

**NOTE**: To make Vector3 and similar structs be readonly, we need to enforce the usage of artifice in their nested properties. This is why, [ForceArtifice](#forceartifice) is used.

---

### Sort

The Sort attribute is used to order fields in the Unity Inspector. It supports inheritance and nested classes. Properties with a lower Sort number have higher priority and appear first in the list. By default, all properties have a sorting value of 0.

```c#
[Serializable]
public class Stats
{
  [Sort(1)]
  public int Damage;
  
  [Sort(0)]
  public int Durability;
}
 
public class Weapon: ScriptableObject
{
  [Sort(3)]
  public Stats Stats;
}

public class Sword: Weapon
{
  [Sort(1)]
  public string Name;
  
  [Sort(2)]
  public string Description;
}
```

![sort-example](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_sort.jpg)

**NOTE**: The `Script` name is preserved in the top of the editor.

---

### ArtificeIgnore
Some classes may not use any custom attribute but are slow on rendering since ArtificeToolkit still needs to check for attributes. In this case, you can apply the `[ArtificeIgnore]` attribute to the MonoBehaviour or ScriptableObject class to have it be rendered with the default IMGUI UI.

**NOTE**: Some classes may come from third-party providers and may not be able to apply the `[ArtificeIgnore]`. In this case, you can add it to the artifice ignore list from the context actions of the inspector. This is a locally stored setting.

---

### InlineProperty

The `InlineProperty` attribute renders a property with visible children (such as a `struct` or class) directly in the Inspector, bypassing the default foldout behavior.

It supports three styling modes:

- **WithTitle** – Displays a styled container with a header title (similar to `BoxGroup`).
- **WithoutTitle** – Displays a styled container without a header title.
- **WithoutTitleBorderless** – Renders child properties without a header or border.

### Space
The Space attribute can receive up to four parameters reflecting the margin in pixels you want your element to have from top, bottom, left, right directions.

### Range
The Range attribute works on integers and floats and allows you to control them through a sliding bar. For this, a min and max value are required.

### HideLabel
The HideLabel attribute as the name suggests, finds and dynamically hides the label of the label.

### HideInArtifice
The HideInArtifice label works exactly as the default HideInInspector and does as it suggests. It skips the property from being rendered.

### InfoBox
The InfoBox allows you to add informational or warning prompts to a property. This could be useful for example to document or explain some rules regarding a specific value.

### ConditionalInfoBox
The ConditionalInfoBox allows you to optionally show an InfoBox when some condition is met, in a similar fashion as [EnableIf](#enableif).

### ListElementName
Using this attribute you can append to a list's elements, an extra identifier based on some nested field of the element type. This element can be applied to a list or array only, and the string parameter should match a child property of the element type.

```c#
[Serializable]
public class RaceGeneralInfo
{
    public enum RaceType
    {
        Human,
        Elf,
        Orc
    }
    
    [SerializeField] 
    private RaceType race;
    
    [SerializeField] 
    private int maxAge;

[SerializeField] 
    private float maxHeight;
}

[ListElementName("race")]
public List<RaceGeneralInfo> info = new();
```

![](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_listelementname.gif)

### MeasureUnit
MeasureUnit appends any string passed to it at the right of a property. This can be commonly used to indicate whether a time value is measured in seconds or milliseconds! It can even be used as a self documented part of the code it self.

### MinValue
MinValue asserts a minimum int or float value to the serialized property.

Note: Currently this only works while the inspector is open. There is nothing stoping the value of going below the minimum value if the inspector is closed.

### MaxValue
As [MinValue](#minvalue) but for a maximum value.

### ForceArtifice
The ArtificeDrawer is responsible for rendering the inspector using VisualElements, applying custom properties when necessary. For optimization, if no custom attributes are detected, it skips the Artifice rendering and falls back to a default IMGUIContainer.

However, there are cases where we might want to enforce the use of Artifice, even for nested properties that don't have custom attributes. In these scenarios, this attribute ensures that Artifice is always used, overriding the default behavior.

### OnValueChanged
OnValueChanged will invoke a specified method as soon as the property's value is changed.

```c#
[SerializeField, OnValueChanged(nameof(TestMethod))] 
private int x;

public void TestMethod()
{
  Debug.Log("test");
}
```

### SafeTooltip
The default UnityEngine `Tooltip` interacts really poorly with Artifice lists for some mysterious reasons. To avoid such issues, use the `SafeTooltip` which has the exact same functionality.

## Extra Features
The ArtificeToolkit comes with a lot of extra stuff that will be briefly mentioned here. In the future, more documentation will be added in this section.

1. <b>SerializedDictionary</b>: ArtificeToolkit holds its own serializable dictionary implementation. It can be used and controlled in the inspector with any serializable type. It behaves like a plain list in the editor, allowing you to add duplicate keys while editing, but provides visual warnings and safely skips duplicates during deserialization to maintain dictionary integrity.

2. <b>Serialized Interfaces and Abstract Classes</b>: In Artifice, you can use [SerializeReference] and [ForceArtifice] in order to have serialized interface or abstract types in your inspector. Artifice will allow you to select which implementor or inherited type you want, and it will instance the managed reference automatically.
<br><br>**NOTE:** This feature is only supported in Unity 2022 and later. This is caused by the lack of property value tracking for generic types which was added later.

```c#
[Serializable]
public abstract class TraitBase
{
   public bool enabled;
   
   public virtual void Update() {}
}

///
/// Inherited classes from TraitBase (Hunger, Health, Energy)
///
```

3. <b>IArtifice_Persistence</b>: In case you need to add persistency to your editor scripts, you can use this interface and implement its methods to support any persisted information.

4. 4.<b>Artifice_SCR_CommonResourcesHolder</b>: ArtificeToolkit uses icons which are publicly exposed even for other editor tools to utilize.

5. <b>UIBuilder</b>: Dynamically rebuild visual elements using the UIBuilder to have dynamic DOM updates.

6. A plethora of specifalized Artifice_SerializedPropertyExtensions.
 
7. A plethora of Visual Elements like:
    - Artifice_VisualElement_ToggleButton
    - Artifice_VisualElement_FoldoutGroup
    - Artifice_VisualElement_InfoBox

7. You can selectively choose to ignore any C# type by using the "Ignore List" found in the MenuItem "ArtificeToolkit". From there you can search a type and append it into the ignored list. This will cause ArtificeToolkit to fallback to the Unity default rendering system for the specific property. Therefore this feature is for cases where you are experiencing problems with a specific type (e.g. LocalizedString has shown some issues in the past).
<div style="display: flex; justify-content: center;">
  <img src="./Documentation/artifice_ignorelist.png" alt="PNG Example"/>
</div>

8. The ArtificeToolkit now providers the InspectorHeader, a simple utility header to help manage crowded inspectors by providing a searchbar, filtering and collapse/expand all components. It can be toggled on and off through `Menu > ArtificeToolkit > Settings Wizard`. On the additional settings, you can also enable or disable the `CategoryButtons` which make it easier to filter from various types of scripts.
<div style="display: flex; justify-content: center;">
  <img src="./Documentation/artifice_inspectorheader.gif" alt="GIF Example"/>
</div>

9. You can create attributes which may or may not need to be evaluated by the validator. The most intuitive example is the EnableIf attribute. When something is not enabled, the validator should not be showing nested validation logs meant for the property and its children. <br><br>To do this for your own custom attributes, use the IArtifice_RequiresCheckForValidationInclusion interface on the attribute and implement IArtifice_ShouldIncludeInValidation in its corresponding custom attribute drawer. You can see a live example of this with EnableIfAttribute and the Artifice_CustomAttributeDrawer_EnableIfAttribute.
10. ArtificeToolkit introduces SerializedHashSet, a hash set that serializes as a list in the Inspector, combining efficient lookups with full editor visibility. 
11. ArtificeElement is a lightweight, empty structure which renders as an empty VisualElement. This allows you to apply `CustomAttributes` over it to make your layout more complex. Most commonly used with [ButtonProperty](#buttonproperty)

# Artifice Validator
The best way to solve bugs, is to avoid creating them. Assertions are one of the most powerful ways to do this and it is considered one of the best programming practices. Using the Artifice Validator, you can apply assertions in your serialized properties.

![artifice-validator](https://raw.githubusercontent.com/AbZorbaGames/artificetoolkit/main/Documentation/artifice_validator.png)

The Validator works with attributes which inherit from the ValidatorAttribute class. Such attributes have an additional implementation explaining what they are supposed to be asserting. The most common use case the [Required](#required) attribute, to make sure the property has been assigned with a reference.

Browsing the validator settings, you can find a configuration for each Validator Module which can be optionally set to override the default Validator configurations. This is useful for expensive validations that may be required to run on only specific subfolders of the assets.

## Validator in CI or Build scripts
The Artifice_Validator provides the `RunSynchronousValidation` method which returns a List of `ValidatorLog`. This method, will open all scenes contained within the Validator Config file and run the main Validation coroutine on them to gather and return potential logs.

## Creating new CustomAttributes for your own Validations

Creating your own validations is simple. You need to:

1. **Create a Custom Attribute**  
   Define a custom attribute by inheriting from `ValidatorAttribute`. This attribute encapsulates the logic for what needs to be validated. For example, you might want to ensure a property is required or falls within a specific range.

**NOTE**: By default, when a CustomAttribute is used on an Array or a List, the attribute is injected to the children of the array/list. If you intend your attribute to be applied to he array/list it self, add the `IArtifice_ArrayAppliedAttribute` interface to the attribute in question.

2. **Implement an Artifice_CustomAttributeDrawer_Validator**  
   Create a drawer class inheriting from `Artifice_CustomAttributeDrawer_Validator_BASE`. This class will define how the validation is performed and how any validation errors or warnings are displayed in the Unity Inspector.

### Example: Required Attribute

Below is an example of how to implement a "Required" attribute to ensure that a property has been assigned a reference.

```csharp
[Artifice_CustomAttributeDrawer(typeof(RequiredAttribute))]
public class Artifice_CustomAttributeDrawer_RequiredAttribute : Artifice_CustomAttributeDrawer_Validator_BASE
{
    public override string LogMessage { get; } = "Property is required.";
    public override Sprite LogSprite { get; } = Artifice_SCR_CommonResourcesHolder.instance.ErrorIcon;
    public override LogType LogType { get; } = LogType.Error;

// Determine if this validator applies to the given property
    protected override bool IsApplicableToProperty(SerializedProperty property)
    {
        return property.propertyType == SerializedPropertyType.ObjectReference;
    }

// Validate the property
    public override bool IsValid(SerializedProperty property)
    {
        return property.objectReferenceValue != null;
    }
}
```

# Artifice Drawer
The ArtificeDrawer is what renders everything when the Artifice Inspector is enabled. The ArtificeDrawer can receive a SerializedObject or SerializedProperty and returns a VisualElement of the rendered result. It essentially parses the SerializedObject or SerializedProperty and renders either the default result or the enhanced result if CustomAttributes have been used on that property.

This section will only interest you if you want to learn the underlying secrets of how the ArtificeToolkit works at its core and learn how to extend it with your own CustomAttributes and tools. Knowledge regarding CustomEditors, CustomPropertyDrawers etc will be needed.

## ArtificeDrawer GUI Steps
When a property directly uses a CustomAttribute, the drawer will access the respective [CustomAttributeDrawer](#custom-attribute-drawer) and call its GUI steps in order

1. Pre GUI: Appends a VisualElement before the property.
  2. On GUI: Replaces the property with the result of this method. Only applies with IsReplacingProperty is set on true.
  3. Post GUI: Appends a VisualElement after the property.
  4. Wrap GUI: Returns a new VisualElement which adds the VisualElements from the previous steps inside of it.
  5. On Bound Property GUI: Executes code when the OnGUI VisualElement is attached in the inspector.

## Creating New CustomAttributes

To create a new `CustomAttribute`, follow these steps:

1. **YourCustomAttribute**: Create your custom attribute by inheriting from `System.Attribute`. This should be placed in a **runtime** folder so it can be applied to your components or ScriptableObjects.
   
2. **Artifice_CustomAttributeDrawer_YourAttribute**: Create a custom attribute drawer by inheriting from `Artifice_CustomAttributeDrawer`. This drawer class must be placed inside an **Editor** folder.

To link the attribute with its drawer, mark the drawer class with `[CustomPropertyDrawer(typeof(YourAttribute))]`.

### Example: `TitleAttribute`

In this example, we create a custom `TitleAttribute` that adds a styled header to serialized fields in the Unity Inspector.

### Step 1: Create the `TitleAttribute`

Create the `TitleAttribute` in a **runtime** folder. This attribute takes a string title, which will be used as a label in the Inspector.

```c#
using System;
using UnityEngine;

[AttributeUsage(AttributeTargets.Field, Inherited = true, AllowMultiple = false)]
public class TitleAttribute : CustomAttribute
{
    public string Title { get; }

public TitleAttribute(string title)
    {
        Title = title;
    }
}
```

### Step 2: Create the CustomDrawer
Now, create a custom drawer for the TitleAttribute in an Editor folder. This drawer will display the title as a label in the Unity Inspector.

```c#
using UnityEditor;
using UnityEngine.UIElements;
using ArtificeToolkit.Editor.Artifice_CustomAttributeDrawers;

[CustomPropertyDrawer(typeof(TitleAttribute))]
public class Artifice_CustomAttributeDrawer_Title : Artifice_CustomAttributeDrawer
{
    private TitleAttribute _titleAttribute;

// Initialize the TitleAttribute
    public Artifice_CustomAttributeDrawer_Title()
    {
        _titleAttribute = (TitleAttribute)Attribute;
    }

// Override to insert the custom label before the property field
    public override VisualElement OnPrePropertyGUI(SerializedProperty property)
    {
        // Create a label using the title from the attribute
        return new Label(_titleAttribute.Title)
        {
            style =
            {
                unityFontStyleAndWeight = FontStyle.Bold,
                fontSize = 14,
                color = Color.white
            }
        };
    }
}
```

**NOTE**: When overriding the `OnPropertyGUI` method to completely override how the property will be rendered, you MUST also set `public override bool IsReplacingPropertyField { get; } = true;`.

How to Use:
You can now use the TitleAttribute in any of your MonoBehaviour or ScriptableObject classes to add custom headers to your serialized fields:

```c#
using UnityEngine;

public class ExampleComponent : MonoBehaviour
{
    [Title("Player Settings")]
    public float health;

[Title("Weapon Settings")]
    public int ammoCount;
}

```

# ArtificeEditorWindow and ArtificeMenuEditorWindow

ArtificeToolkit provides two base classes for building custom Unity
editor windows:

-   `ArtificeEditorWindow`
-   `ArtificeMenuEditorWindow`

Both approaches rely on attribute-driven UI generation, eliminating the
need for traditional custom editor scripting.

------------------------------------------------------------------------

# ArtificeEditorWindow

`ArtificeEditorWindow` allows you to create a fully functional editor
window by simply inheriting from the base class and decorating fields
and methods with Artifice attributes.

No manual `OnGUI`, UI Toolkit setup, or custom inspectors are required.

## Example

``` csharp
public class SCR_QuickSettings : ArtificeEditorWindow
{
    [MenuItem("Test/Quick Settings")]
    public static void ShowWindow() => GetWindow<SCR_QuickSettings>("Quick Settings");
    
    [Header("Time Management")]
    [SerializeField, UnityEngine.Range(0f, 10f), OnValueChanged(nameof(UpdateState))]
    private float timeScale = 1f;

[Header("Rendering & Quality")]
    [SerializeField, OnValueChanged(nameof(UpdateState))]
    private bool showFPSCounter;

[SerializeField, OnValueChanged(nameof(UpdateState))]
    private bool disableFog;

[Header("Physics Debug")]
    [SerializeField, OnValueChanged(nameof(UpdateState))]
    private bool showPhysicsColliders;

[SerializeField]
    private Color debugGizmoColor = Color.green;

#region Actions

[HorizontalGroup("Actions")]
    [Button]
    private void ResetTimeScale()
    {
        timeScale = 1f;
        UpdateState();
    }

[HorizontalGroup("Actions")]
    [Button]
    private void ClearConsole()
    {
        var logEntries = System.Type.GetType("UnityEditor.LogEntries, UnityEditor.dll");
        var clearMethod = logEntries?.GetMethod(
            "Clear",
            System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public
        );
        clearMethod?.Invoke(null, null);
    }

#endregion

private void UpdateState()
    {
        Time.timeScale = timeScale;

// Apply additional settings here, for example:
        // RenderSettings.fog = !disableFog;
    }
}
```

## Behavior

-   The window is created using `GetWindow<T>()`.
-   Fields are automatically rendered based on attributes.
-   Methods marked with `[Button]` are rendered as clickable buttons.
-   Layout attributes such as `[Header]` and `[HorizontalGroup]` control
    structure.
-   `[OnValueChanged]` enables reactive state updates.

The result is a fully functional editor window without custom rendering
code.

------------------------------------------------------------------------

# ArtificeMenuEditorWindow

`ArtificeMenuEditorWindow` is designed for building structured,
multi-panel editor tools. It provides a tree-based navigation system and
dynamic content rendering.

It is particularly suited for:

-   Tool collections
-   Asset management panels
-   ScriptableObject editing workflows
-   Multi-section editor environments

## Core Concept

To use it:

1.  Inherit from `ArtificeMenuEditorWindow`.
2.  Override `BuildMenuTree()`.
3.  Return a list of `ArtificeMenuTreeNode` objects representing the
    menu hierarchy.

When a node is selected, its associated object is rendered in the
content panel.

### Important Notes

- All scriptable object instances that do not live in the AssetDatabase, need to happen with `CreateAndRegister<T>` to keep track and keep the memory clean without leaks.
- All Unity editor windows inherit from `ScriptableObject`. This means that you can use ALL editor windows (IMGUI, UI
  Toolkit, or
  `ArtificeEditorWindow`).
- `ArtificeMenuEditorWindow` instances can be nested to create
  multi-panel systems.
- You can also add icons using the `sprite:` parameter of the `ArtificeMenuTreeNode`.

------------------------------------------------------------------------

## Example

``` csharp
public class MyToolboxWindow : ArtificeMenuEditorWindow
{
    [MenuItem("Test/My Toolbox")]
    public static void ShowWindow() => GetWindow<MyToolboxWindow>("My Toolbox");

public override string ViewPersistenceKey { get; set; } = "MyToolbox_PersistenceKey";

protected override List<ArtificeMenuTreeNode> BuildMenuTree()
    {
        var characters = LoadAllCharacters();
        var items = LoadAllItems();
        
        var list = new List<ArtificeMenuTreeNode>
        {
            new("Settings", CreateAndRegister<SCR_QuickSettings>()),

new("Editor", null)
            {
                Children =
                {
                    // Add additional editor tools here.
                }
            },

new("Entities", null)
            {
                Children =
                {
                    new ArtificeMenuTreeNode(
                        "Characters",
                        null,
                        null,
                        characters
                            .Select(character => new ArtificeMenuTreeNode(character.name, character))
                            .ToList()
                    ),

new ArtificeMenuTreeNode(
                        "Items",
                        null,
                        null,
                        items
                            .Select(item => new ArtificeMenuTreeNode(item.name, item))
                            .ToList()
                    ),
                }
            }
        };
        
        return list;
    }
    
    private List<SCR_Character> LoadAllCharacters()
    {
        var guids = AssetDatabase.FindAssets("t:SCR_Character");

return guids
            .Select(AssetDatabase.GUIDToAssetPath)
            .Select(AssetDatabase.LoadAssetAtPath<SCR_Character>)
            .Where(asset => asset != null)
            .ToList();
    }
    
    private List<SCR_Item> LoadAllItems()
    {
        var guids = AssetDatabase.FindAssets("t:SCR_Item");

return guids
            .Select(AssetDatabase.GUIDToAssetPath)
            .Select(AssetDatabase.LoadAssetAtPath<SCR_Item>)
            .Where(asset => asset != null)
            .ToList();
    }
}
```

------------------------------------------------------------------------

# Summary

## Use `ArtificeEditorWindow` when:

-   You need a single-purpose editor window.
-   The layout is straightforward.
-   You want minimal setup and zero manual drawing code.

## Use `ArtificeMenuEditorWindow` when:

-   You are building a tool suite.
-   You need hierarchical navigation.
-   You are managing multiple asset types.
-   You want scalable, structured editor tooling.

Both approaches eliminate boilerplate and enable clean, attribute-driven
editor development.

## Known Issues
- In Unity 2021.x.x the following warning may appear due to value tracking not working generic types of serialized properties.
```
Serialized property type Generic does not support value tracking; callback is not set for characters
UnityEditor.RetainedMode:UpdateSchedulers ()
```
 
- ArtificeToolkit follows Unity's active Personal/Light or Professional/Dark Editor theme automatically in Unity 2022.3 and later.

- `UnityEngine.Tooltip` breaks the rendering of Artifice lists. Use `SafeTooltip` instead.

artificetoolkit

파일 탐색기

# 설치 가이드

2. Node.js

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

artificetoolkit

파일 탐색기

# 설치 가이드

2. Node.js

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README