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);
    }
Example #2
0
        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); });
 }
Example #5
0
 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);
    }
Example #11
0
        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);
        }
Example #12
0
        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);
    }
Example #14
0
        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);
        }
Example #15
0
    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);
    }
Example #16
0
    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();
        }
Example #19
0
    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;
    }
Example #20
0
    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);
    }
Example #21
0
        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;
                }
            });
        }
Example #22
0
    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);
    }
Example #23
0
        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;
    }
Example #26
0
    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);
            }
        }