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