VisualTreeAsset SetUpEnemy() { VisualTreeAsset aAsset = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Assets/Editor/UXML Files/EnemyEditor.uxml"); mCurrentObjectElement = aAsset.CloneTree(); mEnAttackSound = mCurrentObjectElement.Q <ObjectField>("enemy_attack_sound"); mEnAttackSound.objectType = typeof(AudioClip); mEnAttackSound.RegisterCallback <ChangeEvent <Object> >((aEv) => GenHelpers.OnAttackSoundSelection((AudioClip)aEv.newValue, mEnAttackSound)); mEnDeathSound = mCurrentObjectElement.Q <ObjectField>("enemy_death_sound"); mEnDeathSound.objectType = typeof(AudioClip); mEnDeathSound.RegisterCallback <ChangeEvent <Object> >((aEv) => GenHelpers.OnDeathSoundSelection((AudioClip)aEv.newValue, mEnDeathSound)); mEnemyType = mCurrentObjectElement.Q <EnumField>("enemy_type"); mEnemyType.Init(Enemy.Type.Collider); mEnemyType.RegisterCallback <ChangeEvent <System.Enum> >((aEv) => OnEnemyTypeChanged((Enemy.Type)aEv.newValue)); mEnProjectile = mCurrentObjectElement.Q <ObjectField>("enemy_projectile"); mEnProjectile.objectType = typeof(Projectile); mEnProjectile.RegisterCallback <ChangeEvent <Object> >((aEv) => GenHelpers.OnEnemyProjectileSelection((Projectile)aEv.newValue, mEnProjectile)); mEnemyAnimList = new ReorderableList(new List <AnimationData>(), typeof(AnimationData)); mEnemyAnimList.drawHeaderCallback = (Rect aRect) => { EditorGUI.LabelField(aRect, "Move Animation Sprites"); }; mEnemyAnimList.drawElementCallback = UpdateEnemyAnimationList; mEnemyAnimList.onAddCallback = AddNewAnimation; mCurrentObjectElement.Q <IMGUIContainer>("enemy_animation_sprites").onGUIHandler = EnemyOnGUI; return(aAsset); }
public void OpenClipsTransitionsModal(MVideoClip clip, MTransition transition) { var modalContent = this.ShowModalWindow("Transition"); // Create a new field and assign it its value. var TypeField = new EnumField("Type:", transition.Type); modalContent.Add(TypeField); var durationField = new FloatField("Duration:"); durationField.value = transition.duration; modalContent.Add(durationField); TypeField.RegisterCallback <ChangeEvent <System.Enum> >((evt) => { transition.Type = (MTransition.TransitionType)evt.newValue; }); durationField.RegisterCallback <ChangeEvent <float> >((evt) => { transition.duration = evt.newValue; }); }
public override VisualElement CreateInspectorGUI() { var rootView = new VisualElement(); string pathUxml = PackagePath + "Editor/MeshSubdivisionRenderer.uxml"; string pathUss = PackagePath + "Editor/MeshSubdivisionRenderer.uss"; var treeAsset = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>(pathUxml); var styleAsset = AssetDatabase.LoadAssetAtPath <StyleSheet>(pathUss); treeAsset.CloneTree(rootView); rootView.styleSheets.Add(styleAsset); _meshTypeEnum = rootView.Q <EnumField>("enumMeshType"); _meshTypeEnum.Init(MeshTypeInEditor.Quad); _meshTypeEnum.value = GetMeshType((Mesh)_meshProp.objectReferenceValue); _meshTypeEnum.RegisterCallback <ChangeEvent <Enum> >( (evt) => OnChangeMesh(evt.newValue)); _meshShadingEnum = rootView.Q <EnumField>("enumMeshShading"); _meshShadingEnum.Init(MeshShading.Lit); _meshShadingEnum.value = GetMeshShading(); _meshShadingEnum.RegisterCallback <ChangeEvent <Enum> >( (evt) => OnChangeMeshShading(evt.newValue)); _subdInterpEnum = rootView.Q <EnumField>("enumSubdInterp"); _subdInterpEnum.Init(SubdInterp.None); _subdInterpEnum.value = GetSubdInterp(); _subdInterpEnum.RegisterCallback <ChangeEvent <Enum> >( (evt) => OnChangeSubdInterp(evt.newValue)); _castShadowsToggle = rootView.Q <Toggle>("toggleCastShadows"); _castShadowsToggle.value = _castShadowsProp.boolValue; _castShadowsToggle.RegisterCallback <ChangeEvent <bool> >( (evt) => OnChangeCastShadows(evt.newValue)); _cullingToggle = rootView.Q <Toggle>("toggleCulling"); _cullingToggle.value = _enableCullingProp.boolValue; _cullingToggle.RegisterCallback <ChangeEvent <bool> >( (evt) => OnChangeDoCulling(evt.newValue)); _targetPixelSlider = rootView.Q <SliderInt>("sliderTargetPixel"); _targetPixelSlider.value = _targetPixelSizeProp.intValue; _targetPixelSlider.RegisterCallback <ChangeEvent <int> >( (evt) => OnChangeTargetPixelSize(evt.newValue)); _targetPixelText = rootView.Q <TextField>("textTargetPixel"); _targetPixelText.value = _targetPixelSizeProp.intValue.ToString(); _targetPixelText.RegisterCallback <ChangeEvent <string> >( (evt) => OnChangeTargetPixelSize(evt.newValue)); _debugCameraObject = rootView.Q <ObjectField>("objectDebugCamera"); _debugCameraObject.objectType = typeof(Camera); _debugCameraObject.value = _debugCameraProp.objectReferenceValue; _debugCameraObject.RegisterCallback <ChangeEvent <UnityEngine.Object> >( (evt) => OnChangeDebugCamera(evt.newValue)); return(rootView); }
private void SubscribeToButtonCallbacks() { ContainerElement.Q <Button>("refresh-actions-button").clickable.clicked += OnRefreshActions; ContainerElement.Q <Button>("refresh-transitions-button").clickable.clicked += OnRefreshTransitions; m_newStateButton.clickable.clicked += OnNewStateClicked; m_saveGraphButton.clickable.clicked += OnSaveGraph; m_stateTemplateEnumField.RegisterCallback <ChangeEvent <System.Enum> >(evt => { SetTemplateData(evt.newValue); }); }
private void BindFields() { m_ScaleModeField.RegisterCallback <ChangeEvent <Enum> >(evt => UpdateScaleModeValues((PanelScaleModes)evt.newValue)); m_ScreenMatchModeField.RegisterCallback <ChangeEvent <Enum> >(evt => UpdateScreenMatchModeValues((PanelScreenMatchModes)evt.newValue)); m_ClearColorField.RegisterCallback <ChangeEvent <bool> >(evt => UpdateColorClearValue(evt.newValue)); m_SortOrderField.RegisterCallback <ChangeEvent <float> >(evt => SetSortOrder(evt)); }
private void BindFields() { m_ScaleModeField.RegisterCallback <ChangeEvent <Enum> >(evt => UpdateScaleModeValues((PanelScaleMode)evt.newValue)); m_ScreenMatchModeField.RegisterCallback <ChangeEvent <Enum> >(evt => UpdateScreenMatchModeValues((PanelScreenMatchMode)evt.newValue)); m_ClearColorField.RegisterCallback <ChangeEvent <bool> >(evt => UpdateColorClearValue(evt.newValue)); m_ThemeStyleSheetField.RegisterValueChangedCallback(evt => UpdateHelpBoxDisplay()); }
public SimpleStackNode(MathStackNode node) { var visualTree = Resources.Load("SimpleStackNodeHeader") as VisualTreeAsset; m_Header = visualTree.Instantiate(); m_TitleItem = m_Header.Q <Label>(name: "titleLabel"); m_TitleItem.AddToClassList("label"); m_TitleEditor = m_Header.Q(name: "titleField") as TextField; m_TitleEditor.AddToClassList("textfield"); m_TitleEditor.visible = false; m_TitleEditor.RegisterCallback <FocusOutEvent>(e => { OnEditTitleFinished(); }); m_TitleEditor.Q("unity-text-input").RegisterCallback <KeyDownEvent>(OnKeyPressed); headerContainer.Add(m_Header); m_OperationControl = m_Header.Q <EnumField>(name: "operationField"); m_OperationControl.Init(MathStackNode.Operation.Addition); m_OperationControl.value = node.currentOperation; m_OperationControl.RegisterCallback <ChangeEvent <Enum> >(v => { node.currentOperation = (MathStackNode.Operation)v.newValue; MathNode mathNode = userData as MathNode; if (mathNode != null && mathNode.mathBook != null) { mathNode.mathBook.inputOutputs.ComputeOutputs(); } }); var inputPort = InstantiatePort(Orientation.Vertical, Direction.Input, Port.Capacity.Single, typeof(float)); var outputPort = InstantiatePort(Orientation.Vertical, Direction.Output, Port.Capacity.Single, typeof(float)); inputPort.portName = ""; outputPort.portName = ""; inputContainer.Add(inputPort); outputContainer.Add(outputPort); RegisterCallback <MouseDownEvent>(OnMouseUpEvent); userData = node; viewDataKey = node.nodeID.ToString(); title = node.name; inputPort.userData = node; outputPort.userData = node; }
VisualTreeAsset SetUpStaticObject() { VisualTreeAsset aAsset = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Assets/Editor/UXML Files/StaticObjectEditor.uxml"); mCurrentObjectElement = aAsset.CloneTree(); mSObjSprite = mCurrentObjectElement.Q <ObjectField>("static_object_sprite"); mSObjSprite.objectType = typeof(Sprite); mSObjSprite.RegisterCallback <ChangeEvent <Object> >((aEv) => GenHelpers.OnSpriteSelection((Sprite)aEv.newValue, mSObjSprite)); mColliderType = mCurrentObjectElement.Q <EnumField>("static_object_collider"); mColliderType.Init(GameScriptable.ColliderType.None); mColliderType.RegisterCallback <ChangeEvent <System.Enum> >((aEv) => OnColliderTypeChanged((GameScriptable.ColliderType)aEv.newValue)); return(aAsset); }
public VariableField(Guid id) { guid = id; fieldName = $"worldvar-value-field-{worldVars.GetName(guid)}"; AddToClassList(USS_CLASS_NAME); label = new Label(worldVars.GetName(guid)); Add(label); // Create the type changer dropdown typeChoice = new EnumField(worldVars.GetType(guid)); typeChoice.AddToClassList("worldvar-type-dropdown"); Add(typeChoice); // Register type update callback on dropdown value change typeChoice.RegisterCallback <ChangeEvent <Enum> >(UpdateWorldvarType); // Add a type-specific class based on the current type AddToClassList(TYPE_CLASS_NAME_TEMPLATE + typeChoice.text.ToLower()); // Create a simple container to hold the value field fieldContainer = new VisualElement(); fieldContainer.AddToClassList("worldvar-value-container"); Add(fieldContainer); DrawValueField(); // Create a button at the end to remove the variable var button = new Button() { text = "-", name = $"remove-{worldVars.GetName(guid)}" }; button.AddToClassList("worldvar-remove-button"); // Method to actually remove it is the Remove() method so link that button.clickable.clicked += Remove; Add(button); // Register to collection change events worldVars.VariableRemoved += (guid) => { if (guid == id) { RemoveFromHierarchy(); } }; worldVars.GetVariable(guid).ValueChanged += SetFieldValue; worldVars.GetVariable(guid).NameChanged += SetLabelText; worldVars.GetVariable(guid).TypeChanged += OnTypeChange; }
VisualTreeAsset SetUpPickable() { VisualTreeAsset aAsset = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Assets/Editor/UXML Files/PickableEditor.uxml"); mCurrentObjectElement = aAsset.CloneTree(); mItemType = mCurrentObjectElement.Q <EnumField>("item_type"); mItemType.Init(Item.Type.HealthBoost); mItemType.RegisterCallback <ChangeEvent <System.Enum> >((aEv) => OnItemTypeChanged((Item.Type)aEv.newValue)); mItemSound = mCurrentObjectElement.Q <ObjectField>("item_collect_sound"); mItemSound.objectType = typeof(AudioClip); mItemSound.RegisterCallback <ChangeEvent <Object> >((aEv) => GenHelpers.OnCollectSoundSelection((AudioClip)aEv.newValue, mItemSound)); mItemSprite = mCurrentObjectElement.Q <ObjectField>("item_idle_sprite"); mItemSprite.objectType = typeof(Sprite); mItemSprite.RegisterCallback <ChangeEvent <Object> >((aEv) => GenHelpers.OnSpriteSelection((Sprite)aEv.newValue, mItemSprite)); return(aAsset); }
public static UnityEditor.SettingsProvider CreateSettingsProvider() { var provider = new UnityEditor.SettingsProvider("Project/Serilog", SettingsScope.Project) { label = "Serilog", activateHandler = (searchContext, rootElement) => { m_Settings = SerilogSettings.Instance; var logLevelField = new EnumField("Log Level", m_Settings.LogLevel); logLevelField.RegisterCallback <ChangeEvent <Enum> >(SerilogSettings_OnValueChanged); rootElement.Add(logLevelField); }, keywords = new HashSet <string>(new[] { "Logging", "Serilog", "Log Level" }) }; return(provider); }
protected void Init() { AddToClassList(USS_CLASS_NAME); AddToClassList("rounded"); m_KeyField = new TextField("World State") { value = m_WorldStateDescription.Key }; m_KeyField.tooltip = "The identifier of the world state."; m_KeyField.maxLength = 30; hierarchy.Add(m_KeyField); m_KeyField.RegisterCallback <ChangeEvent <string> >(KeyFieldChanged); hierarchy.Add(new Label("Desired Value")); ConfiguratorValueType?enumType = ConfiguratorTypeConverter.GetTypeFromObject(m_WorldStateDescription.Value); m_EnumFieldValueType = new EnumField("Type", enumType != null ? enumType : ConfiguratorValueType.BOOL) { tooltip = "Data type of the world state." }; m_EnumFieldValueType.AddToClassList("desiredValue"); hierarchy.Add(m_EnumFieldValueType); m_EnumFieldValueType.RegisterCallback <ChangeEvent <Enum> >(EnumChanged); m_ValueField = ConfiguratorTypeConverter.CreateFieldBasedOnType(enumType.Value, m_WorldStateDescription.Value, "Value", ValueFieldChanged); m_ValueField.tooltip = "Value of the world state."; m_ValueField.AddToClassList("desiredValue"); hierarchy.Add(m_ValueField); this.AddManipulator(new Clickable(() => OnMouseDown?.Invoke(this))); this.AddManipulator(new ContextualMenuManipulator(_menubuilder => { _menubuilder.menu.AppendAction("Delete", _dropDownMenuAction => OnDelete?.Invoke(this), DropdownMenuAction.Status.Normal); _menubuilder.menu.AppendAction("Duplicate", _dropDownMenuAction => OnDuplicate?.Invoke(this), DropdownMenuAction.Status.Normal); })); }
void CreateNewObjectVE() { VisualTreeAsset aAsset; switch (mActiveType) { case GameObjectType.None: return; case GameObjectType.Pickable: aAsset = SetUpPickable(); break; case GameObjectType.Projectile: aAsset = SetUpProjectile(); break; case GameObjectType.SpawnFactory: aAsset = SetUpSpawnFactory(); break; case GameObjectType.Enemy: aAsset = SetUpEnemy(); break; case GameObjectType.StaticObject: aAsset = SetUpStaticObject(); break; default: return; } if (aAsset == null) { return; } mLayerType = mCurrentObjectElement.Q <EnumField>("gobj_layer"); mLayerType.Init(Level.LayerTypes.Environment); mLayerType.RegisterCallback <ChangeEvent <System.Enum> >((aEv) => OnLayerChanged((Level.LayerTypes)aEv.newValue)); mCurrentObjectElement.Q <Button>("gobj_data").RegisterCallback <MouseUpEvent>((aEv) => SaveAsScriptableAsset()); mEditoryBlock.Add(mCurrentObjectElement); }
protected override void SetBaseVisualElement(VisualElement visualElement) { VisualElement choseShapeField = new ChoseShapeDataField <ShapeData>( ShapeAction.ShapeDataFactory, ShapeAction, "Chose Shape: ", () => ShapeAction.ShapeData, shapeData => ShapeAction.SetShapeData(shapeData)); visualElement.Add(choseShapeField); EnumField highlightField = new EnumField("Set Highlight") { value = ShapeAction.Highlight }; highlightField.Init(ShapeAction.Highlight); highlightField.RegisterCallback <ChangeEvent <Enum> >(evt => ShapeAction.SetHighlightType((HighlightType)evt.newValue)); visualElement.Add(highlightField); }
public override VisualElement CreateInspectorGUI() { #region Fields EnumField pentatonic = rootElement.Query <EnumField>("pentatonic").First(); pentatonic.value = starSystem.pentatonic; pentatonic.RegisterCallback <ChangeEvent <System.Enum> >( e => { starSystem.pentatonic = (PentatonicScale)e.newValue; EditorUtility.SetDirty(starSystem); } ); #endregion #region Display Orbit Data // Store visual element that will contain the planet sub-inspectors. orbitList = rootElement.Query <VisualElement>("orbitList").First(); UpdateOrbitLines(); #endregion #region Buttons // Assign methods to the click events of the two buttons. Button btnAddOrbit = rootElement.Query <Button>("btnAddNewOrbit").First(); btnAddOrbit.clickable.clicked += AddOrbitLine; Button btnRemoveAllOrbits = rootElement.Query <Button>("btnRemoveAllOrbits").First(); btnRemoveAllOrbits.clickable.clicked += RemoveAll; Button btnRefresh = rootElement.Query <Button>("refresh").First(); btnRefresh.clickable.clicked += UpdateOrbitLines; #endregion return(rootElement); }
public NoteSubEditor(OrbitLineSubEditor orbitLineSubEditor, Note note) { this.orbitLineSubEditor = orbitLineSubEditor; this.note = note; VisualTreeAsset visualTree = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Assets/Examples/StarSystemScene/Scripts/Editor/StarSystemEditor/NoteSubEditor.uxml"); visualTree.CloneTree(this); StyleSheet stylesheet = AssetDatabase.LoadAssetAtPath <StyleSheet>("Assets/Examples/StarSystemScene/Scripts/Editor/StarSystemEditor/NoteSubEditor.uss"); this.styleSheets.Add(stylesheet); this.AddToClassList("noteSubeditor"); #region Fields SliderInt octave = this.Query <SliderInt>("octave").First(); octave.value = note.octave; octave.RegisterCallback <ChangeEvent <int> >( e => { note.octave = e.newValue; EditorUtility.SetDirty(note); } ); // Find an object field with the name and set the type ObjectField synthPrefab = this.Query <ObjectField>("synthPrefab").First(); synthPrefab.objectType = typeof(GameObject); synthPrefab.value = note.synth; synthPrefab.RegisterCallback <ChangeEvent <Object> >( e => { note.synth = (GameObject)e.newValue; EditorUtility.SetDirty(note); } ); Slider velocity = this.Query <Slider>("velocity").First(); velocity.value = note.velocity; velocity.label = "Velocity " + velocity.value.ToString("F3"); velocity.RegisterCallback <ChangeEvent <float> >( e => { note.velocity = e.newValue; velocity.label = "Velocity " + e.newValue.ToString("F3"); EditorUtility.SetDirty(note); } ); Slider length = this.Query <Slider>("length").First(); length.value = note.length; length.label = "Length " + length.value.ToString("F3"); length.RegisterCallback <ChangeEvent <float> >( e => { note.length = e.newValue; length.label = "Length " + e.newValue.ToString("F3"); EditorUtility.SetDirty(note); } ); Slider size = this.Query <Slider>("size").First(); size.value = note.size; size.label = "Size " + size.value.ToString("F3"); size.RegisterCallback <ChangeEvent <float> >( e => { note.size = e.newValue; size.label = "Size " + e.newValue.ToString("F3"); EditorUtility.SetDirty(note); } ); EnumField noteValue = this.Query <EnumField>("noteValue").First(); noteValue.value = note.note; noteValue.RegisterCallback <ChangeEvent <System.Enum> >( e => { note.note = (NoteValue)e.newValue; EditorUtility.SetDirty(note); } ); #endregion #region Buttons Button btnRemoveNote = this.Query <Button>("btnRemove").First(); btnRemoveNote.clickable.clicked += RemoveNote; #endregion }
private void Connect() { _settings = Resources.Load <BuildToolsSettings>("BuildToolsSettings"); _commonBuildData = Resources.Load <BuildData>("BuildData_Common") ?? LoadData("BuildData_Common"); _debugBuildData = Resources.Load <BuildData>("BuildData_Debug") ?? LoadData("BuildData_Debug"); _releaseBuildData = Resources.Load <BuildData>("BuildData_Release") ?? LoadData("BuildData_Release"); var buildToolsVersionLabel = rootVisualElement.Q <Label>("BuildToolsVersionLabel"); buildToolsVersionLabel.text = _settings.version; /*var buildPathTextField = rootVisualElement.Q<TextField>("BuildsFolderPathTextField"); * buildPathTextField.value = _settings.buildFolderPath; * buildPathTextField.RegisterCallback<FocusOutEvent>(evt => SaveDataChanges()); * buildPathTextField.RegisterCallback<InputEvent>((evt) => * { * _settings.buildFolderPath = buildPathTextField.value; * }); * * var buildSelectFolderButton = rootVisualElement.Q<Button>("SelectBuildsFolderButton"); * buildSelectFolderButton.RegisterCallback<MouseUpEvent>((evt) => * { * buildPathTextField.value = GetFolderPath(); * _settings.buildFolderPath = buildPathTextField.value; * });*/ _screenOrientationField = rootVisualElement.Q <EnumField>("ScreenOrientationEnum"); _screenOrientationField.Init(_commonBuildData.screenOrientation); _screenOrientationField.value = _commonBuildData.screenOrientation; _screenOrientationField.RegisterCallback <FocusOutEvent>(evt => SaveDataChanges()); _screenOrientationField.RegisterCallback <ChangeEvent <Enum> >((evt) => { Debug.Log($"Changed Screen Orientation | from {_commonBuildData.screenOrientation} to {(UIOrientation) evt.newValue}"); _commonBuildData.screenOrientation = (UIOrientation)evt.newValue; }); _taskNumberField = rootVisualElement.Q <TextField>("TaskNumberField"); _taskNumberField.value = _commonBuildData.taskNumber; _taskNumberField.RegisterCallback <FocusOutEvent>(evt => SaveDataChanges()); _taskNumberField.RegisterCallback <InputEvent>((evt) => { Debug.Log($"Changed Task Number | from {_commonBuildData.taskNumber} to {evt.newData}"); _commonBuildData.taskNumber = evt.newData; }); if (string.IsNullOrEmpty(_commonBuildData.taskNumber)) { _taskNumberField.value = SetTaskNumber(); _commonBuildData.taskNumber = _taskNumberField.value; } var autoSetTaskNumberToggle = rootVisualElement.Q <Button>("SetTaskNumberButton"); autoSetTaskNumberToggle.RegisterCallback <FocusOutEvent>(evt => SaveDataChanges()); autoSetTaskNumberToggle.RegisterCallback <MouseUpEvent>((evt) => { var newTaskNumber = SetTaskNumber(); Debug.Log($"Changed Task Number from Button | from {_commonBuildData.taskNumber} to {newTaskNumber}"); _commonBuildData.taskNumber = newTaskNumber; _taskNumberField.value = newTaskNumber; }); _appVersionField = rootVisualElement.Q <TextField>("AppVersionField"); _appVersionField.value = _commonBuildData.productVersion; _appVersionField.RegisterCallback <FocusOutEvent>(evt => SaveDataChanges()); _appVersionField.RegisterCallback <InputEvent>((evt) => { Debug.Log($"Changed App Version | from {_commonBuildData.productVersion} to {evt.newData}"); _commonBuildData.productVersion = evt.newData; }); ConnectSpecificData(_debugBuildData, "Debug"); ConnectSpecificData(_releaseBuildData, "Release"); }
private void SetupUI() { var styleSheet = AssetDatabase.LoadAssetAtPath <StyleSheet>($"{Utils.packageFolderName}/Editor/StyleSheets/PerformanceTrackerWindow.uss"); rootVisualElement.styleSheets.Add(styleSheet); m_RefreshFromSearch = Delayer.Throttle(RefreshFromSearch); var toolbar = new UnityEditor.UIElements.Toolbar(); toolbar.AddToClassList("perf-toolbar"); toolbar.style.height = PtStyles.itemHeight; var searchBox = new VisualElement(); searchBox.AddToClassList("perf-search-box"); AddSelectorLabel(toolbar, "Tracker"); m_SearchField = new ToolbarSearchField(); m_SearchField.AddToClassList("perf-search-tracker"); m_SearchField.value = m_FilterText; m_SearchField.RegisterCallback <ChangeEvent <string> >((evt) => { m_RefreshFromSearch.Execute(evt.newValue); }); searchBox.Add(m_SearchField); toolbar.Add(searchBox); var resetAllCountersButton = new Button(ResetAllCounters); resetAllCountersButton.text = "Reset all counters"; resetAllCountersButton.AddToClassList("perf-tracker-toolbar-button"); toolbar.Add(resetAllCountersButton); AddSelectorLabel(toolbar, "Update Speed"); var choices = PtModel.RefreshRates.Select(r => r.label).ToList(); var updateSpeedSelector = new UnityEditor.UIElements.PopupField <string>(choices, 0); updateSpeedSelector.value = PtModel.RefreshRates[m_UpdateSpeedIndex].label; updateSpeedSelector.AddToClassList("perf-update-speed-selector"); updateSpeedSelector.RegisterCallback <ChangeEvent <string> >((evt) => { m_UpdateSpeedIndex = Array.FindIndex(PtModel.RefreshRates, (r) => r.label == evt.newValue); ScheduleNextRefresh(); SendAnalytics(Analytics.WindowUsageType.ChangeMonitoringSpeed); }); toolbar.Add(updateSpeedSelector); AddSelectorLabel(toolbar, "Columns"); var columnsChoice = PtModel.ColumnDescriptors.Where(desc => desc.columnsSelectorMaskId > 0).Select(desc => desc.label).ToList(); var columnsSelector = new MaskField(columnsChoice, m_ShownColumn); columnsSelector.RegisterCallback <ChangeEvent <int> >((evt) => { m_ShownColumn = evt.newValue; CreateHeaders(); RefreshTrackers(); SendAnalytics(Analytics.WindowUsageType.ChangeColumnLayout); }); columnsSelector.AddToClassList("perf-columns-selector"); toolbar.Add(columnsSelector); AddSelectorLabel(toolbar, "Sort By"); m_SortBySelector = new EnumField(ColumnId.Name); m_SortBySelector.value = m_SortBy; m_SortBySelector.AddToClassList("perf-sort-by-selector"); m_SortBySelector.RegisterCallback <ChangeEvent <Enum> >((evt) => { ChangeSortOrder((ColumnId)evt.newValue); SendAnalytics(Analytics.WindowUsageType.ChangeSortBy); }); toolbar.Add(m_SortBySelector); var settingsBtn = new Button(() => { SettingsService.OpenUserPreferences(PerformanceTrackerSettings.settingsKey); SendAnalytics(Analytics.WindowUsageType.OpenPreferences); }); settingsBtn.style.backgroundImage = Icons.settings; settingsBtn.style.width = PtStyles.itemHeight - 3; settingsBtn.style.height = PtStyles.itemHeight - 3; toolbar.Add(settingsBtn); rootVisualElement.Add(toolbar); // Set List View Header: m_HeaderRow = new VisualElement(); m_HeaderRow.AddToClassList("perf-header-row-container"); m_HeaderRow.style.flexDirection = FlexDirection.Row; rootVisualElement.Add(m_HeaderRow); CreateHeaders(); m_PinnedTrackersView = new ListView(m_PinnedTrackers, PtStyles.itemHeight, MakeItem, BindPinnedItem); m_PinnedTrackersView.name = k_PinnedTrackerList; m_PinnedTrackersView.AddToClassList("perf-tracker-list"); m_PinnedTrackersView.selectionType = SelectionType.Multiple; m_PinnedTrackersView.style.flexGrow = 0; m_PinnedTrackersView.Q <VisualElement>(null, "unity-scroll-view__content-viewport").RegisterCallback <GeometryChangedEvent>(SyncHeaderAndListsGeometry); rootVisualElement.Add(m_PinnedTrackersView); m_TrackersView = new ListView(m_FilteredTrackers, PtStyles.itemHeight, MakeItem, BindUnpinnedItem); m_TrackersView.name = k_TrackerList; m_TrackersView.AddToClassList("perf-tracker-list"); m_TrackersView.selectionType = SelectionType.Multiple; m_TrackersView.style.flexGrow = 1.0f; m_TrackersView.Q <VisualElement>(null, "unity-scroll-view__content-viewport").RegisterCallback <GeometryChangedEvent>(SyncHeaderAndListsGeometry); rootVisualElement.Add(m_TrackersView); m_NeedsUpdate = true; ScheduleNextRefresh(); UpdateTrackers(); }
public ResponseCurveEditor(UtilityAIConsiderationEditor utilityAIConsiderationEditor, ResponseCurve responseCurve) { this.utilityAIConsiderationEditor = utilityAIConsiderationEditor; this.responseCurve = responseCurve; VisualTreeAsset visualTree = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Assets/UtilityAI/Scripts/Editor/Response Curve Editor/ResponseCurveEditor.uxml"); visualTree.CloneTree(this); StyleSheet stylesheet = AssetDatabase.LoadAssetAtPath <StyleSheet>("Assets/UtilityAI/Scripts/Editor/Response Curve Editor/ResponseCurveEditor.uss"); this.styleSheets.Add(stylesheet); this.AddToClassList("responseCurveEditor"); EnumField curveTypeField = this.Query <EnumField>("curveType").First(); curveTypeField.Init(CurveType.Linear); curveTypeField.value = responseCurve.curveType; curveTypeField.RegisterCallback <ChangeEvent <Enum> >( e => { responseCurve.curveType = (CurveType)e.newValue; utilityAIConsiderationEditor.UpdateResponseCurve(); } ); FloatField xShiftField = this.Query <FloatField>("xShift").First(); xShiftField.value = responseCurve.xShift; xShiftField.RegisterCallback <ChangeEvent <float> >( e => { responseCurve.xShift = (float)e.newValue; utilityAIConsiderationEditor.UpdateResponseCurve(); } ); FloatField yShiftField = this.Query <FloatField>("yShift").First(); yShiftField.value = responseCurve.yShift; yShiftField.RegisterCallback <ChangeEvent <float> >( e => { responseCurve.yShift = (float)e.newValue; utilityAIConsiderationEditor.UpdateResponseCurve(); } ); FloatField slopeField = this.Query <FloatField>("slope").First(); slopeField.value = responseCurve.slope; slopeField.RegisterCallback <ChangeEvent <float> >( e => { responseCurve.slope = (float)e.newValue; utilityAIConsiderationEditor.UpdateResponseCurve(); } ); FloatField exponentialField = this.Query <FloatField>("exponential").First(); exponentialField.value = responseCurve.exponential; exponentialField.RegisterCallback <ChangeEvent <float> >( e => { responseCurve.exponential = (float)e.newValue; utilityAIConsiderationEditor.UpdateResponseCurve(); } ); Box box = new Box() { style = { flexGrow = 1, marginTop = 5, marginBottom = 5, marginLeft = 5, marginRight = 5, height = 300, } }; this.Add(box); VisualElement meshContainer = new VisualElement() { style = { flexGrow = 1, } }; box.Add(meshContainer); meshContainer.generateVisualContent += DrawGraph; }
public void OnEnable() { setupWindow(); // Data dataRoot.Add(new Label("Choose a Item:")); objectData = new ObjectField(); objectData.objectType = typeof(Item); dataRoot.Add(objectData); objectData.RegisterCallback <ChangeEvent <UnityEngine.Object> >((evt) => { var change = (evt.target as ObjectField).value; item = change as Item; UpdateBinding(); }); dataRoot.Add(new Spacer(30)); dataRoot.Add(new Label("Name:")); nameTextField = new TextField(); nameTextField.bindingPath = "objectName"; dataRoot.Add(nameTextField); dataRoot.Add(new Spacer(30)); dataRoot.Add(new Label("Item Type:")); var itemTypeEnumField = new EnumField(ItemTypes.HealthBoost); itemTypeEnumField.bindingPath = "itemType"; dataRoot.Add(itemTypeEnumField); itemTypeEnumField.RegisterCallback <ChangeEvent <Enum> >((evt) => { var change = evt.newValue; if (item) { item.itemType = Convert.ToInt32(change); } }); // sprites Button newData = new Button(() => { Item newItem = CreateInstance <Item>(); newItem.objectName = "Item"; var path = "Assets/Resources/Gauntlet/Prefabs/Items"; AssetDatabase.CreateAsset(newItem, AssetDatabase.GenerateUniqueAssetPath(path + "/Item-00.asset")); AssetDatabase.SaveAssets(); AssetDatabase.Refresh(); objectData.value = newItem; UpdateBinding(); }); newData.text = "New"; spriteRoot.Add(newData); spriteRoot.Add(new Spacer(30)); spriteRoot.Add(new Label("Item Sprite:")); objectTileSprite = new ObjectField(); objectTileSprite.objectType = typeof(Sprite); objectTileSprite.bindingPath = "mainSprite"; spriteRoot.Add(objectTileSprite); objectTileSpriteImage = new Image() { style = { width = 100, height = 100, borderLeftWidth = 2, borderRightWidth = 2, borderTopWidth = 2, borderBottomWidth = 2, marginTop = 10, marginBottom = 20, marginLeft = 10, borderColor = Color.gray }, scaleMode = ScaleMode.ScaleToFit }; objectTileSprite.RegisterCallback <ChangeEvent <UnityEngine.Object> >((evt) => { var change = (evt.target as ObjectField).value; if (change) { var sprite = change as Sprite; GauntletLevelEditor.rebindImageTexture(ref objectTileSpriteImage, sprite); } else { objectTileSpriteImage.image = null; } if (objectData.value) { (objectData.value as Item).mainSprite = change as Sprite; } Repaint(); parentWindow.rebindPrefabListView(); }); spriteRoot.Add(objectTileSpriteImage); }
public void OnEnable() { VisualElement root = rootVisualElement; VisualElement vt = Resources.Load <VisualTreeAsset>("Editor/SDFWizardMarkup").Instantiate(); vt.styleSheets.Add(Resources.Load <StyleSheet>("Editor/SDFWizardStyle")); root.Add(vt); Label dLabel = vt.Q <Label> (null, "dLabel"); Image dropBox = vt.Q <Image> ("DropBox"); SliderInt sizeSlider = vt.Q <SliderInt> ("SizeSlider"); IntegerField sizeField = vt.Q <IntegerField> ("SizeField"); Slider tresholdSlider = vt.Q <Slider> ("TresholdSlider"); FloatField tresholdField = vt.Q <FloatField> ("TresholdField"); SliderInt sampleSlider = vt.Q <SliderInt> ("SampleSlider"); IntegerField sampleField = vt.Q <IntegerField> ("SampleField"); EnumField channelSelect = vt.Q <EnumField> ("ChannelSelect"); Box channelDisplay = vt.Q <Box> ("ChannelDisplay"); EnumField modeSelect = vt.Q <EnumField> ("RenderingSelect"); EnumField tilingSelect = vt.Q <EnumField> ("TilingSelect"); channelSelect.Init(WizardUtils.ColorChannel.Alpha); modeSelect.Init(SDFConverter.RenderingMode.DistanceOnly); tilingSelect.Init(TextureWrapMode.Repeat); bool validated = false; dropBox.RegisterCallback <DragEnterEvent>((e) => { foreach (var item in DragAndDrop.objectReferences) { if (item.GetType() == typeof(Texture2D)) { validated = true; } } dropBox.tintColor = validated ? new Color(.6f, .94f, .2f) : new Color(.94f, .3f, .2f); dLabel.style.color = validated ? new Color(.6f, .94f, .2f) : new Color(.94f, .3f, .2f); }); dropBox.RegisterCallback <DragUpdatedEvent>((e) => { if (validated) { DragAndDrop.visualMode = DragAndDropVisualMode.Copy; } }); dropBox.RegisterCallback <DragPerformEvent>((e) => { if (validated) { for (int i = 0; i < DragAndDrop.objectReferences.Length; i++) { var item = (UnityEngine.Object)DragAndDrop.objectReferences[i]; string path = DragAndDrop.paths[i]; if (item.GetType() == typeof(Texture2D)) { string newPath = path.Substring(0, path.LastIndexOf(".")) + "_SDF.png"; string systemPath = Application.dataPath.Substring(0, Application.dataPath.Length - 6) + newPath; var texture = item as Texture2D; texture.wrapMode = (TextureWrapMode)tilingSelect.value; var outData = SDFConverter.RenderSDF(texture, sizeField.value, tresholdField.value, sampleField.value, channelSelect.value, modeSelect.value); System.IO.File.WriteAllBytes(systemPath, outData.EncodeToPNG()); AssetDatabase.Refresh(); var importer = (TextureImporter)AssetImporter.GetAtPath(newPath); var importerSettings = new TextureImporterSettings(); ((TextureImporter)AssetImporter.GetAtPath(path)).ReadTextureSettings(importerSettings); importer.SetTextureSettings(importerSettings); importer.sRGBTexture &= modeSelect.value.Equals(SDFConverter.RenderingMode.RGBDistance); importer.textureCompression = TextureImporterCompression.Uncompressed; importer.SaveAndReimport(); AssetDatabase.ImportAsset(newPath); } } } }); dropBox.RegisterCallback <DragExitedEvent>((e) => { validated = false; dropBox.tintColor = Color.white; dLabel.style.color = Color.white; }); dropBox.RegisterCallback <DragLeaveEvent>((e) => { validated = false; dropBox.tintColor = Color.white; dLabel.style.color = Color.white; }); sizeSlider.RegisterCallback <ChangeEvent <int> >((e) => { sizeField.value = 2 << e.newValue; }); sizeField.RegisterCallback <ChangeEvent <int> >((e) => { int c = 0; int v = e.newValue; while (v > 2) { c++; v >>= 1; } sizeSlider.value = c; sizeField.value = 2 << c; }); tresholdSlider.RegisterCallback <ChangeEvent <float> >((e) => { tresholdField.value = 1f - e.newValue; }); tresholdField.RegisterCallback <ChangeEvent <float> >((e) => { tresholdSlider.value = 1f - e.newValue; }); sampleSlider.RegisterCallback <ChangeEvent <int> >((e) => { sampleField.value = e.newValue; }); sampleField.RegisterCallback <ChangeEvent <int> >((e) => { sampleSlider.value = e.newValue; }); channelSelect.RegisterCallback <ChangeEvent <Enum> >((e) => { switch (e.newValue) { case WizardUtils.ColorChannel.Red: channelDisplay.style.backgroundColor = new Color(.94f, .3f, .2f); break; case WizardUtils.ColorChannel.Green: channelDisplay.style.backgroundColor = new Color(.6f, .94f, .2f); break; case WizardUtils.ColorChannel.Blue: channelDisplay.style.backgroundColor = new Color(.2f, .6f, .94f); break; case WizardUtils.ColorChannel.Alpha: channelDisplay.style.backgroundColor = Color.grey; break; default: channelDisplay.style.backgroundColor = Color.white; break; } }); }
public void OnEnable() { VisualElement root = this.rootVisualElement; root.style.flexDirection = FlexDirection.Row; root.style.paddingTop = 20; root.style.paddingBottom = 20; VisualElement gameRoot = new VisualElement() { style = { width = width * 0.22f, paddingRight = 20, paddingLeft = 20 } }; VisualElement mapRoot = new VisualElement() { style = { alignContent = Align.Center, width = width * 0.56f } }; VisualElement levelRoot = new VisualElement() { style = { width = width * 0.22f, paddingLeft = 20, paddingRight = 20 } }; root.Add(gameRoot); root.Add(mapRoot); root.Add(levelRoot); //game root { gameRoot.Add(new Label("Choose a Gauntlet Game:")); gameData = new ObjectField(); gameData.objectType = typeof(GauntletGame); gameRoot.Add(gameData); gameData.RegisterCallback <ChangeEvent <UnityEngine.Object> >((evt) => { var change = (evt.target as ObjectField).value; game = change as GauntletGame; levelData.value = null; playerData.value = null; rebindLevelListView(); }); Button createGameButton = new Button(() => { var newGame = CreateInstance <GauntletGame>(); var path = "Assets/Resources/Gauntlet/GameData"; AssetDatabase.CreateAsset(newGame, AssetDatabase.GenerateUniqueAssetPath(path + "/GameData-00.asset")); EditorUtility.SetDirty(newGame); AssetDatabase.SaveAssets(); AssetDatabase.Refresh(); gameData.value = newGame; }); createGameButton.text = "Create New Game"; gameRoot.Add(createGameButton); Button saveDataButton = new Button(() => { if (game != null) { var path = EditorUtility.OpenFolderPanel("Export Game Data", "", ""); if (path == null) { return; } if (path.Length != 0) { game.saveGameData(path); } } }); saveDataButton.text = "Save Game Data"; gameRoot.Add(saveDataButton); VisualElement levelListDataRoot = new VisualElement() { style = { flexDirection = FlexDirection.Row, paddingTop = 20, paddingBottom = 40, height = 300 } }; VisualElement levelListRoot = new VisualElement() { style = { flexGrow = 0.75f } }; VisualElement levelButtonsRoot = new VisualElement() { style = { flexGrow = 0.25f, justifyContent = Justify.Center, paddingLeft = 10, paddingRight = 10 } }; levelListDataRoot.Add(levelListRoot); levelListDataRoot.Add(levelButtonsRoot); gameRoot.Add(levelListDataRoot); Label levelLabel = new Label("List of Levels:"); levelListRoot.Add(levelLabel); levelListRoot.Add(createLevelListView()); Button upButton = new Button(() => { if (game != null) { int newIndex = game.changeLevelOrder(levelListView.selectedIndex, true); rebindLevelListView(); levelListView.selectedIndex = newIndex; } }); Button downButton = new Button(() => { if (game != null) { int newIndex = game.changeLevelOrder(levelListView.selectedIndex, false); rebindLevelListView(); levelListView.selectedIndex = newIndex; } }); Button removeButton = new Button(() => { if (game != null && levelListView.selectedIndex >= 0) { game.levels.RemoveAt(levelListView.selectedIndex); rebindLevelListView(); } }); Button editButton = new Button(() => { if (game != null && levelListView.selectedIndex >= 0) { levelData.value = game.levels[levelListView.selectedIndex]; } }); upButton.text = "Move Up"; downButton.text = "Move Down"; removeButton.text = "Remove"; editButton.text = "Edit"; levelButtonsRoot.Add(upButton); levelButtonsRoot.Add(downButton); levelButtonsRoot.Add(removeButton); levelButtonsRoot.Add(editButton); gameRoot.Add(new Label("Choose a Player for this Game:")); playerData = new ObjectField(); playerData.objectType = typeof(Player); gameRoot.Add(playerData); playerData.RegisterCallback <ChangeEvent <UnityEngine.Object> >((evt) => { var change = (evt.target as ObjectField).value; if (game) { game.playerObject = change as Player; } }); // Level gameRoot.Add(new Label("Choose a Level to edit:")); levelData = new ObjectField(); levelData.objectType = typeof(GauntletLevel); gameRoot.Add(levelData); gameRoot.Add(new Label("Level Name:")); levelData.RegisterCallback <ChangeEvent <UnityEngine.Object> >((evt) => { var change = (evt.target as ObjectField).value; level = change as GauntletLevel; UpdateLevelBinding(); tileMap.createGrid(level); }); var levelName = new TextField(); levelName.bindingPath = "levelName"; gameRoot.Add(levelName); Button addLevelButton = new Button(() => { if (game != null && level != null) { game.levels.Add(level); EditorUtility.SetDirty(game); AssetDatabase.SaveAssets(); AssetDatabase.Refresh(); rebindLevelListView(); } }); addLevelButton.text = "Add Level To Game"; gameRoot.Add(addLevelButton); // New Level Button newLevelButton = new Button(() => { var newLevel = CreateInstance <GauntletLevel>(); newLevel.initialize("TestLevel", levelSizeSlider.value, 570); var path = "Assets/Resources/Gauntlet/LevelData"; AssetDatabase.CreateAsset(newLevel, AssetDatabase.GenerateUniqueAssetPath(path + "/LevelData-00.asset")); EditorUtility.SetDirty(newLevel); AssetDatabase.SaveAssets(); AssetDatabase.Refresh(); levelData.value = newLevel; }); newLevelButton.text = "Create New Level"; newLevelButton.style.marginTop = 40; gameRoot.Add(newLevelButton); levelSizeSlider = new SliderInt(5, 35); levelSizeSlider.value = 20; var levelSizeLabel = new Label("Size of New Level:" + levelSizeSlider.value); gameRoot.Add(levelSizeLabel); levelSizeSlider.RegisterCallback <ChangeEvent <int> >((evt) => { levelSizeLabel.text = "Size of New Level: " + evt.newValue; }); gameRoot.Add(levelSizeSlider); } tileMap = new TileMap(); tileMap.levelEditor = this; mapRoot.Add(tileMap.gridContainer); // Level Root levelRoot.Add(new Label("Choose a prefab to place:")); MapPrefabTypesField = new EnumField(MapPrefabTypes.GroundTile); MapPrefabTypesField.RegisterCallback <ChangeEvent <Enum> >((evt) => { rebindPrefabListView(); }); levelRoot.Add(MapPrefabTypesField); //levelRoot.Add(createSpriteList()); levelRoot.Add(createMapTileList()); var eraseToggle = new Toggle("Erase Mode"); eraseToggle.RegisterCallback <ChangeEvent <bool> >((evt) => { tileMap.eraseMode = evt.newValue; }); levelRoot.Add(eraseToggle); var timeLimit = new SliderInt(60, 600); var timeLimitLabel = new Label("Time Limit: " + timeLimit.value + " seconds"); levelRoot.Add(timeLimitLabel); timeLimit.RegisterCallback <ChangeEvent <int> >((evt) => { timeLimitLabel.text = "Time Limit: " + evt.newValue + " seconds"; }); timeLimit.bindingPath = "timeLimit"; levelRoot.Add(timeLimit); levelRoot.Add(new Label("Current Layer:")); EnumField mapLayers = new EnumField(MapLayers.Layer1); mapLayers.RegisterCallback <ChangeEvent <Enum> >((evt) => { var change = evt.newValue; tileMap.changeLayer(Convert.ToInt32(change)); }); levelRoot.Add(mapLayers); levelRoot.Add(new Label("Viewable layers in editor:")); var layer1Toggle = new Toggle("Layer 1") { value = true }; var layer2Toggle = new Toggle("Layer 2") { value = true }; var layer3Toggle = new Toggle("Layer 3") { value = true }; layer1Toggle.RegisterCallback <ChangeEvent <bool> >((evt) => { tileMap.layersOn[0] = evt.newValue; }); layer2Toggle.RegisterCallback <ChangeEvent <bool> >((evt) => { tileMap.layersOn[1] = evt.newValue; }); layer3Toggle.RegisterCallback <ChangeEvent <bool> >((evt) => { tileMap.layersOn[2] = evt.newValue; }); levelRoot.Add(layer1Toggle); levelRoot.Add(layer2Toggle); levelRoot.Add(layer3Toggle); levelRoot.Add(new Label("Type of asset to create/edit:")); EnumField prefabEnums = new EnumField(PrefabTypes.GroundTile); levelRoot.Add(prefabEnums); Button createEditPrefabButton = new Button(() => { switch (prefabEnums.value) { case PrefabTypes.Player: { assetWindow = PrefabEditor.createWindow <GauntletPlayerEditor>(_window, "Player Editor"); break; } case PrefabTypes.Enemy: { assetWindow = PrefabEditor.createWindow <GauntletEnemyEditor>(_window, "Enemy Editor"); break; } case PrefabTypes.GroundTile: { assetWindow = PrefabEditor.createWindow <GauntletGroundTileEditor>(_window, "Ground Tile Editor"); break; } case PrefabTypes.SpawnFactory: { assetWindow = PrefabEditor.createWindow <GauntletSpawnFactoryEditor>(_window, "Spawn Factory Editor"); break; } case PrefabTypes.Projectile: { assetWindow = PrefabEditor.createWindow <GauntletProjectileEditor>(_window, "Projectile Editor"); break; } case PrefabTypes.Item: { assetWindow = PrefabEditor.createWindow <GauntletItemEditor>(_window, "Item Editor"); break; } case PrefabTypes.Portal: { assetWindow = PrefabEditor.createWindow <GauntletPortalEditor>(_window, " Portal Editor"); break; } case PrefabTypes.SpawnPoint: { assetWindow = PrefabEditor.createWindow <GauntletSpawnPointEditor>(_window, "Spawn Point Editor"); break; } default: break; } }); createEditPrefabButton.text = "Create/Edit Prefab"; levelRoot.Add(createEditPrefabButton); }
protected sealed override void SetupUI() { var replicatorRowAsset = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>(k_ReplicatorRowPath); replicatorRowAsset.CloneTree(this); base.SetupUI(); m_ContentContainer = this.Q <VisualElement>(k_ContentContainerName); m_Foldout = this.Q <Foldout>(k_RowFoldoutName); m_Foldout.RegisterValueChangedCallback(evt => { var expanded = evt.newValue; m_ContentContainer.style.display = expanded ? DisplayStyle.Flex : DisplayStyle.None; if (expanded) { RulesModule.CollapsedNodes.Remove(BackingObject); } else { RulesModule.CollapsedNodes.Add(BackingObject); } RulesDrawer.BuildReplicatorsList(); }); m_Foldout.RegisterCallback <ExecuteCommandEvent>(RulesModule.PickObject); if (IsGroup) { m_Foldout.visible = false; } else { var expanded = !RulesModule.CollapsedNodes.Contains(BackingObject); m_Foldout.value = expanded; m_ContentContainer.style.display = expanded ? DisplayStyle.Flex : DisplayStyle.None; } m_MatchCountEnum = this.Q <EnumField>(k_MatchCountEnum); m_MatchCountEnum.Init(RulesModule.ReplicatorCountOption.Every); m_MatchCountEnum.RegisterCallback <ChangeEvent <System.Enum> >(OnChangeMatchCountDropdown); m_MaxCountField = this.Q <IntegerField>(k_MaxInstancesName); m_MaxCountField.RegisterValueChangedCallback(OnMaxInstanceChanged); m_MaxCountField.RegisterCallback <ExecuteCommandEvent>(RulesModule.PickObject); SetupProxyPresetUI(m_Entity); m_GroupDrillInButton = this.Q <Button>(k_GroupDrillIn); m_GroupDrillInButton.clicked += () => { var ruleSet = m_Entity.GetComponent <ProxyRuleSet>(); RulesModule.RuleSetInstance = ruleSet; RulesDrawer.BuildReplicatorsList(); }; if (!IsGroup) { m_GroupDrillInButton.style.display = DisplayStyle.None; } m_SimMatchCount = this.Q <Label>(k_SimMatchCountName); SetupReplicatorRow(); if (IsGroup) { m_AddButtonHoverElement.SetEnabled(false); } CreateAddContentButton(); RegisterCallback <KeyDownEvent>(OnKeyDown); }
/// <summary> /// Creates the UI elements and registers callbacks. /// </summary> public void OnEnable() { syncBehaviour = target as RemoteConfigSyncBehaviour; rootVisualElement = new VisualElement(); rootVisualElement.styleSheets.Add(AssetDatabase.LoadAssetAtPath <StyleSheet>(stylePath)); // Show the Script field (not-editable) like standard inspectors do. var script = MonoScript.FromMonoBehaviour(syncBehaviour); var scriptField = new ObjectField("Script") { value = script }; scriptField.SetEnabled(false); rootVisualElement.Add(scriptField); // PrefixSource enum dropdown control. When PrefixSource changes, observe whether the // KeyPrefix field should be shown/hidden. var prefixSourceProp = serializedObject.FindProperty("PrefixSource"); prefixSourceField = new EnumField("Prefix Source", syncBehaviour.PrefixSource); prefixSourceField.BindProperty(prefixSourceProp); prefixSourceField.RegisterCallback <ChangeEvent <Enum> >(OnPrefixSourceChange); rootVisualElement.Add(prefixSourceField); // KeyPrefix control, only shown if syncBehaviour.PrefixSource == PrefixSource.Custom. var keyPrefixProperty = serializedObject.FindProperty("KeyPrefix"); keyPrefixField = new PropertyField(keyPrefixProperty); if (syncBehaviour.PrefixSource == PrefixSource.Custom) { rootVisualElement.Add(keyPrefixField); } // Sync All Fields control. var syncAllProp = serializedObject.FindProperty("SyncAllFields"); syncAllField = new PropertyField(syncAllProp); syncAllField.RegisterCallback <ChangeEvent <bool> >(OnSyncAllFieldsChange); rootVisualElement.Add(syncAllField); // Include sub-fields var includeSubProp = serializedObject.FindProperty("IncludeSubFields"); includeSubFieldsField = new PropertyField(includeSubProp); if (syncBehaviour.SyncAllFields) { rootVisualElement.Add(includeSubFieldsField); } var buttonContainer = new TemplateContainer(); // Use row class to place buttons side-by-side. buttonContainer.AddToClassList("row"); // Add a button that can invoke the SyncFields function on the object during gameplay. var syncButton = new Button(() => SyncFields()) { text = "Sync Fields" }; buttonContainer.Add(syncButton); // Add a button that prompts RemoteConfigSyncUIWindow to update sync targets. var updateButton = new Button(() => SyncWindow.RefreshSyncTargets()) { text = "Update targets" }; buttonContainer.Add(updateButton); // Add button to open the RemoteConfigSyncWindow. var rcWindowButton = new Button(() => SyncWindow.OpenWindow()) { text = "Open Sync Window" }; buttonContainer.Add(rcWindowButton); rootVisualElement.Add(buttonContainer); }
void SetArtistTool() { VisualElement root = rootVisualElement; root.Clear(); VisualTreeAsset ArtistToolVisualTree = Resources.Load <VisualTreeAsset>("ArtistTool"); ArtistToolVisualTree.CloneTree(root); root.styleSheets.Add(Resources.Load <StyleSheet>("ArtistTool")); SerializedObject serialized_TimeController = new SerializedObject(TimeController); Slider timeSlider = root.Q <Slider>(name: "Time"); timeSlider.Bind(serialized_TimeController); #region SkyColor //add a Gradient Editor Setter VisualElement gradientVisualElement = root.Q <VisualElement>(name: "SkyGradient"); if (gradientVisualElement != null) { GradientField gradientField = gradientVisualElement.Q <GradientField>(); SerializedObject serialized_MaterialSetter = new SerializedObject(SkyColorSetter); gradientField.bindingPath = "gradient"; gradientField.Bind(serialized_MaterialSetter); gradientVisualElement.Q <Label>().text = "Sky Gradient"; } #endregion #region Ruins GradientEditorSetter("RuinsGradient", "Ruins Gradient", RuinsColorSetter); #endregion #region Trees GradientEditorSetter("TreesGradient", "Trees Gradient", TreesColorSetter); #endregion #region Rim GradientEditorSetter("RimColor", "Rim Gradient", RimColorSetter); #endregion #region Lights #region SunLights SerializedObject serialized_SunSpot = new SerializedObject(SunSpot_Group); VisualElement sunLightVisualElement = root.Q <VisualElement>(name: "Sunlight"); FloatField sunLightIntensity = root.Q <FloatField>(name: "Intensity"); if (sunLightVisualElement.Q <VisualElement>(name: "LightGradient") != null) { GradientField sunLightGradient = sunLightVisualElement.Q <VisualElement>(name: "LightGradient").Q <GradientField>(); sunLightGradient.Bind(serialized_SunSpot); sunLightGradient.label = "Gradient"; } sunLightIntensity.value = GetSpotLightIntensity(); sunLightIntensity.RegisterCallback <ChangeEvent <float> >(ChangeIntensitySpotLightsEvent); #endregion #region GrassLight SerializedObject serialized_GrassLight_Group = new SerializedObject(GrassLight_Group); VisualElement grassLightVisualElement = root.Q <VisualElement>(name: "GrassLight"); FloatField grassLightIntensity = root.Q <FloatField>(name: "Intensity"); if (grassLightVisualElement.Q <VisualElement>(name: "LightGradient") != null) { GradientField grassLightGradient = grassLightVisualElement.Q <VisualElement>(name: "LightGradient").Q <GradientField>(); grassLightGradient.Bind(serialized_GrassLight_Group); grassLightGradient.label = "Gradient"; } grassLightIntensity.value = GetSpotLightIntensity(); SerializedObject serialized_GrassLight = new SerializedObject(GrassLight); grassLightIntensity.Bind(serialized_GrassLight); #endregion #region cave Light SerializedObject serialized_CaveHoleLight = new SerializedObject(CaveHoleLight); VisualElement caveLightVisualElement = root.Q <VisualElement>(name: "CaveHoleLight"); caveLightVisualElement.Q <FloatField>(name: "Falloff").Bind(serialized_CaveHoleLight); Slider fallOffSlider = caveLightVisualElement.Q <Slider>(name: "FalloffIntencity"); FloatField fallOffField = fallOffSlider.Q <FloatField>(name: "CurrentValue"); fallOffSlider.Bind(serialized_CaveHoleLight); fallOffField.SetValueWithoutNotify(CaveHoleLight.falloffIntensity); fallOffField.RegisterCallback <ChangeEvent <float> >((evt) => fallOffSlider.value = evt.newValue); fallOffSlider.RegisterCallback <ChangeEvent <float> >((evt) => fallOffField.SetValueWithoutNotify(evt.newValue)); #endregion #region Visualisers var AllGradientElements = root.Query <GradientField>(); if (AllGradientElements != null) { AllGradientElements.ForEach((element) => { //registerCallback for Gradient to apply changes on scene element.RegisterCallback <ChangeEvent <Gradient> >(ChangeGradientEvent); VisualElement visualiser = element.Q <VisualElement>(name: "VisualisationColor"); //Init color of visualisation cube float currentTime = TimeController.timeValue; visualiser.style.backgroundColor = element.value.Evaluate(currentTime); //register Callback for each visualisation cube when gradient Changes element.RegisterCallback <ChangeEvent <Gradient> >((evt) => { float timeOfChange = TimeController.timeValue; visualiser.style.backgroundColor = evt.newValue.Evaluate(currentTime); }); //register Callback for each visualisation cube when Time Changes timeSlider.RegisterCallback <ChangeEvent <float> >((evt) => { visualiser.style.backgroundColor = element.value.Evaluate(evt.newValue); }); }); } #endregion #endregion #region Wind Shader // Set Initial Values VisualElement windComponent = root.Q <VisualElement>(name: "Wind"); if (windComponent != null) { Vector4Field windDirectionQuaternion = windComponent.Q <Vector4Field>(name: "WindDirection"); windDirectionQuaternion.value = GetWindDirection(); FloatField windScaleFloat = windComponent.Q <FloatField>(name: "WindScale"); windScaleFloat.value = GetWindScale(); MinMaxValue minMaxStrength = GetWindStrength(); VisualElement windStrengthHolder = windComponent.Q <VisualElement>(name: "WinStrengthHolder"); MinMaxSlider windStrengthSlider = windStrengthHolder.Q <MinMaxSlider>(name: "WindStrength"); windStrengthSlider.highLimit = minMaxStrength.HighLimit; windStrengthSlider.lowLimit = minMaxStrength.LowLimit; windStrengthSlider.value = new Vector2(minMaxStrength.minValue, minMaxStrength.maxValue); windStrengthHolder.Q <Label>(name: "MinValue").text = "Min Value :" + minMaxStrength.minValue; windStrengthHolder.Q <Label>(name: "MaxValue").text = "Max Value :" + minMaxStrength.maxValue; FloatField windSpeedFloat = windComponent.Q <FloatField>(name: "WindSpeed"); windSpeedFloat.value = GetWindSpeed(); //Set Callbacks values windDirectionQuaternion.RegisterCallback <ChangeEvent <Vector4> >(ChangeWindDirection); windScaleFloat.RegisterCallback <ChangeEvent <float> >(ChangeWindScale); windStrengthSlider.RegisterCallback <ChangeEvent <Vector2> >(ChangeWindStrength); windSpeedFloat.RegisterCallback <ChangeEvent <float> >(ChangeWindSpeed); } #endregion #region Postprocessing #region WhiteBalance //serialize White balance property SerializedObject serialized_whiteBalanceProperty = new SerializedObject(whiteBalanceProperty); //Get White balance Visual Element VisualElement whiteBalanceVisualElement = root.Q <VisualElement>(name: "WhiteBalance"); #region Temperature //Get White Balance temperature Visual Element VisualElement whiteBalanceTemperatureVE = whiteBalanceVisualElement.Q <VisualElement>(name: "Temperature"); //Get White Balance temperature Slider Slider whiteBalanceTemperatureSlider = whiteBalanceTemperatureVE.Q <Slider>(name: "SliderValue"); //Bind Slider to value whiteBalanceTemperatureSlider.bindingPath = "temperature.m_Value"; whiteBalanceTemperatureSlider.Bind(serialized_whiteBalanceProperty); //Get White Balance temperature Float Field FloatField whiteBalanceTemperatureFloat = whiteBalanceTemperatureVE.Q <FloatField>(name: "CurrentValue"); //Set default Temperature whiteBalanceTemperatureFloat.SetValueWithoutNotify(whiteBalanceProperty.temperature.value); //Register change callback for the float field to change the slider value. Changing slider value will change the values bound with it. whiteBalanceTemperatureFloat.RegisterCallback <ChangeEvent <float> >((evt) => whiteBalanceTemperatureSlider.value = evt.newValue); //Register change Callback for the slider, to change the float fiel Without notification (to avoid triggering Float field callback) whiteBalanceTemperatureSlider.RegisterCallback <ChangeEvent <float> >((evt) => whiteBalanceTemperatureFloat.SetValueWithoutNotify(evt.newValue)); #endregion #region Tint //Get White Balance Tint Visual Element VisualElement whiteBalanceTintVE = whiteBalanceVisualElement.Q <VisualElement>(name: "Tint"); //Get White Balance Tint Slider Slider whiteBalanceTintSlider = whiteBalanceTintVE.Q <Slider>(name: "SliderValue"); //Bind Slider to value whiteBalanceTintSlider.bindingPath = "tint.m_Value"; whiteBalanceTintSlider.Bind(serialized_whiteBalanceProperty); //Get White Balance Tint Float Field FloatField whiteBalanceTintFloat = whiteBalanceTintVE.Q <FloatField>(name: "CurrentValue"); //Set default Tint whiteBalanceTintFloat.SetValueWithoutNotify(whiteBalanceProperty.tint.value); //Register change callback for the float field to change the slider value. Changing slider value will change the values bound with it. whiteBalanceTintFloat.RegisterCallback <ChangeEvent <float> >((evt) => whiteBalanceTintSlider.value = evt.newValue); //Register change Callback for the slider, to change the float fiel Without notification (to avoid triggering Float field callback) whiteBalanceTintSlider.RegisterCallback <ChangeEvent <float> >((evt) => whiteBalanceTintFloat.SetValueWithoutNotify(evt.newValue)); #endregion #endregion #region Bloom //serialize bloom property SerializedObject serialized_BloomProperty = new SerializedObject(BloomProperty); //Get Bloom Visual Element VisualElement bloomVisualElement = root.Q <VisualElement>(name: "Bloom"); //Get Bloom Tint Color ColorField bloomTint = bloomVisualElement.Q <ColorField>(name: "Tint"); //Bind color to value bloomTint.bindingPath = "tint.m_Value"; bloomTint.Bind(serialized_BloomProperty); //Get Bloom Intensity FloatField bloomIntensity = bloomVisualElement.Q <FloatField>(name: "Intensity"); //Bind color to value bloomIntensity.bindingPath = "intensity.m_Value"; bloomIntensity.Bind(serialized_BloomProperty); #endregion #endregion #region VFX SerializedObject serialized_GlowParticleSystem = new SerializedObject(GlowParticleSystem); VisualElement VFXVisualElement = root.Q <VisualElement>(name: "VFX"); FloatField VFXEmission = VFXVisualElement.Q <FloatField>(name: "Emission"); VFXEmission.bindingPath = "EmissionModule.rateOverTime.scalar"; VFXEmission.Bind(serialized_GlowParticleSystem); EnumField VFXRenderMode = VFXVisualElement.Q <EnumField>(name: "RenderMode"); VFXRenderMode.Init(GlowParticleSystem.GetComponent <ParticleSystemRenderer>().renderMode); VFXRenderMode.RegisterCallback <ChangeEvent <string> >(ChangeRenderMode); ObjectField VFXMaterial = VFXVisualElement.Q <ObjectField>(name: "Material"); VFXMaterial.objectType = typeof(Material); VFXMaterial.RegisterCallback <ChangeEvent <string> >(ChangeRenderMaterial); #endregion root.Q <Button>(name: "SaveButton").clicked += SaveButton; root.Q <Button>(name: "ResetButton").clicked += ResetToInitialSceneValues; }
public void OnEnable() { setupWindow(); // Data dataRoot.Add(new Label("Choose a Enemy:")); objectData = new ObjectField(); objectData.objectType = typeof(Enemy); dataRoot.Add(objectData); objectData.RegisterCallback <ChangeEvent <UnityEngine.Object> >((evt) => { var change = (evt.target as ObjectField).value; enemy = change as Enemy; UpdateBinding(); }); dataRoot.Add(new Spacer(30)); dataRoot.Add(new Label("Name:")); nameTextField = new TextField(); nameTextField.bindingPath = "objectName"; dataRoot.Add(nameTextField); addSlider(ref dataRoot, 20, 100, "Health: ", "health"); addSlider(ref dataRoot, 30, 500, "Walk Speed: ", "walkSpeed"); addSlider(ref dataRoot, 1, 100, "Time Between Each Attack (s): ", "attackTimeInterval"); dataRoot.Add(new Spacer(30)); dataRoot.Add(new Label("Attack Style:")); var attackStyleEnumField = new EnumField(AttackStyles.RangeBased); dataRoot.Add(attackStyleEnumField); attackStyleEnumField.RegisterCallback <ChangeEvent <Enum> >((evt) => { var change = evt.newValue; if (enemy) { enemy.attackStyle = Convert.ToInt32(change); } }); dataRoot.Add(new Spacer(30)); dataRoot.Add(new Label("Weapon:")); var weaponData = new ObjectField(); weaponData.objectType = typeof(Projectile); weaponData.bindingPath = "weapon"; dataRoot.Add(weaponData); // sprites Button newData = new Button(() => { Enemy newEnemy = CreateInstance <Enemy>(); newEnemy.objectName = "Enemy"; var path = "Assets/Resources/Gauntlet/Prefabs/Enemies"; AssetDatabase.CreateAsset(newEnemy, AssetDatabase.GenerateUniqueAssetPath(path + "/Enemy-00.asset")); AssetDatabase.SaveAssets(); AssetDatabase.Refresh(); objectData.value = newEnemy; UpdateBinding(); }); newData.text = "New"; spriteRoot.Add(newData); spriteRoot.Add(new Spacer(30)); spriteRoot.Add(new Label("Enemy Sprite:")); objectTileSprite = new ObjectField(); objectTileSprite.objectType = typeof(Sprite); objectTileSprite.bindingPath = "mainSprite"; spriteRoot.Add(objectTileSprite); objectTileSpriteImage = new Image() { style = { width = 100, height = 100, borderLeftWidth = 2, borderRightWidth = 2, borderTopWidth = 2, borderBottomWidth = 2, marginTop = 10, marginBottom = 20, marginLeft = 10, borderColor = Color.gray }, scaleMode = ScaleMode.ScaleToFit }; objectTileSprite.RegisterCallback <ChangeEvent <UnityEngine.Object> >((evt) => { var change = (evt.target as ObjectField).value; if (change) { var sprite = change as Sprite; GauntletLevelEditor.rebindImageTexture(ref objectTileSpriteImage, sprite); } else { objectTileSpriteImage.image = null; } if (objectData.value) { (objectData.value as Enemy).mainSprite = change as Sprite; } Repaint(); parentWindow.rebindPrefabListView(); }); spriteRoot.Add(objectTileSpriteImage); }
private void OnMaterialsDropped(Material[] droppedMaterials) { remappingRoot.Clear(); DisposeOfSerializedObjects(); //Construct a dictionary between shaders and their materials shadersToMaterials = new Dictionary <Shader, List <SerializedObject> >(); foreach (Material material in droppedMaterials) { if (!shadersToMaterials.TryGetValue(material.shader, out var list)) { list = new List <SerializedObject>(); shadersToMaterials.Add(material.shader, list); } list.Add(new SerializedObject(material)); } foreach (var pair in shadersToMaterials) { Box shaderRoot = new Box(); shaderRoot.AddToClassList("innerPadding"); remappingRoot.Add(shaderRoot); Shader shader = pair.Key; ObjectField shaderField = new ObjectField { objectType = typeof(Shader), value = shader }; shaderField.SetEnabled(false); shaderRoot.Add(shaderField); //RemapType, to a set of keys referring to values that could be remapped. var remapsFrom = new Dictionary <RemapType, HashSet <string> >(); var remapsTo = new Dictionary <RemapType, HashSet <string> >(); List <SerializedObject> materials = pair.Value; foreach (SerializedObject materialSO in materials) { SerializedProperty savedProperties = materialSO.FindProperty("m_SavedProperties"); //Textures ------------------------------------------------------------------------- SerializedProperty texEnvsArray = savedProperties.FindPropertyRelative("m_TexEnvs"); var textureKeys = new HashSet <string>(); remapsTo.Add(RemapType.Texture, textureKeys); var textureKeysFrom = new HashSet <string>(); remapsFrom.Add(RemapType.Texture, textureKeysFrom); for (int i = 0; i < texEnvsArray.arraySize; i++) { SerializedProperty texEnv = texEnvsArray.GetArrayElementAtIndex(i); SerializedProperty key = texEnv.FindPropertyRelative("first"); SerializedProperty texture = texEnv.FindPropertyRelative("second.m_Texture"); textureKeys.Add(key.stringValue); //Only add to the "from", if there is a key with a meaningful value in it. if (texture.objectReferenceValue != null) { textureKeysFrom.Add(key.stringValue); } } //----------------------------------------------------------------------------------- //Floats ---------------------------------------------------------------------------- SerializedProperty floatsArray = savedProperties.FindPropertyRelative("m_Floats"); //floats have no way of telling if they're not set, so they can use the same set var floatKeys = new HashSet <string>(); remapsTo.Add(RemapType.Float, floatKeys); remapsFrom.Add(RemapType.Float, floatKeys); for (int i = 0; i < floatsArray.arraySize; i++) { SerializedProperty @float = floatsArray.GetArrayElementAtIndex(i); SerializedProperty key = @float.FindPropertyRelative("first"); floatKeys.Add(key.stringValue); } //----------------------------------------------------------------------------------- //Vectors and Colors ---------------------------------------------------------------- SerializedProperty colorsArray = savedProperties.FindPropertyRelative("m_Colors"); //colors have no way of telling if they're not set, so they can use the same set var vectorKeys = new HashSet <string>(); remapsTo.Add(RemapType.VectorOrColor, vectorKeys); remapsFrom.Add(RemapType.VectorOrColor, vectorKeys); for (int i = 0; i < colorsArray.arraySize; i++) { SerializedProperty vector = colorsArray.GetArrayElementAtIndex(i); SerializedProperty key = vector.FindPropertyRelative("first"); vectorKeys.Add(key.stringValue); } //----------------------------------------------------------------------------------- } //CONTROLS var remapTypeField = new EnumField("Remap Type", RemapType.None) { name = remapTypeName }; remapTypeField.RegisterCallback <ChangeEvent <Enum> >(SelectedRemapType); shaderRoot.Add(remapTypeField); PopupField <string> popupFromField = new PopupField <string>(fromKeyLabel, noneList, 0) { name = fromKeyPopupName }; popupFromField.SetEnabled(false); shaderRoot.Add(popupFromField); PopupField <string> popupToField = new PopupField <string>(toKeyLabel, noneList, 0) { name = toKeyPopupName }; popupToField.SetEnabled(false); shaderRoot.Add(popupToField); Button remapButton = new Button { text = "Remap", name = remapButtonName }; remapButton.SetEnabled(false); shaderRoot.Add(remapButton); void SelectedRemapType(ChangeEvent <Enum> remapEvt) { if (remapEvt == null) { throw new ArgumentNullException(nameof(remapEvt)); } RemapType value = (RemapType)remapEvt.newValue; if (value == RemapType.None) { GetButton().SetEnabled(false); GetRemapTo().SetEnabled(false); GetRemapFrom().SetEnabled(false); return; } PopupField <string> child = GetRemapFrom(); int index = shaderRoot.IndexOf(child); child.RemoveFromHierarchy(); List <string> choicesFrom = remapsFrom[value].ToList(); choicesFrom.Insert(0, none); popupFromField = new PopupField <string>(fromKeyLabel, choicesFrom, none) { name = fromKeyPopupName }; shaderRoot.Insert(index, popupFromField); popupFromField.RegisterCallback <ChangeEvent <string> >(SelectedRemapFrom); } void SelectedRemapFrom(ChangeEvent <string> popupFromEvt) { string remapFromKey = popupFromEvt.newValue; if (remapFromKey == none) { GetButton().SetEnabled(false); GetRemapTo().SetEnabled(false); return; } PopupField <string> child = GetRemapTo(); int index = shaderRoot.IndexOf(child); child.RemoveFromHierarchy(); List <string> choicesTo = remapsTo[(RemapType)remapTypeField.value].ToList(); choicesTo.Insert(0, none); popupToField = new PopupField <string>(toKeyLabel, choicesTo, none) { name = toKeyPopupName }; shaderRoot.Insert(index, popupToField); popupToField.RegisterCallback <ChangeEvent <string>, (PopupField <string>, string)>(SelectedRemapTo, (popupToField, remapFromKey)); } void SelectedRemapTo(ChangeEvent <string> popupToEvt, (PopupField <string> popupToField, string remapFromKey) args) { string remapToKey = popupToEvt.newValue; VisualElement background = args.popupToField.Q(null, PopupField <string> .inputUssClassName); if (remapToKey == none) { GetButton().SetEnabled(false); background.style.unityBackgroundImageTintColor = default; return; } if (remapToKey == args.remapFromKey) { background.style.unityBackgroundImageTintColor = new Color(1f, 0.46f, 0.51f); return; } background.style.unityBackgroundImageTintColor = default; var button = GetButton(); button.SetEnabled(true); button.RemoveManipulator(button.clickable); button.clickable = new Clickable(() => PerformRemap(shader, (RemapType)GetRemapType().value, args.remapFromKey, remapToKey)); button.AddManipulator(button.clickable); } Button GetButton() => shaderRoot.Q <Button>(remapButtonName); EnumField GetRemapType() => shaderRoot.Q <EnumField>(remapTypeName); PopupField <string> GetRemapFrom() => shaderRoot.Q <PopupField <string> >(fromKeyPopupName); PopupField <string> GetRemapTo() => shaderRoot.Q <PopupField <string> >(toKeyPopupName); } }