protected override void Edit(bool array) { DEditorGUI.WithLabel("Compression", () => { PropertyType.CompressionEnabled = DEditorGUI.Toggle(PropertyType.CompressionEnabled); EditorGUI.BeginDisabledGroup(PropertyType.CompressionEnabled == false); PropertyType.MinValue = Mathf.Min(DEditorGUI.IntFieldOverlay(PropertyType.MinValue, "Min"), PropertyType.MaxValue - 1); PropertyType.MaxValue = Mathf.Max(DEditorGUI.IntFieldOverlay(PropertyType.MaxValue, "Max"), PropertyType.MinValue + 1); GUILayout.Label("Bits: " + PropertyType.BitsRequired, EditorStyles.miniLabel, GUILayout.ExpandWidth(false)); EditorGUI.EndDisabledGroup(); }); //DEditorGUI.WithLabel("Min Value", () => { PropertyType.MinValue = EditorGUILayout.IntField(PropertyType.MinValue); }); //DEditorGUI.WithLabel("Max Value", () => { PropertyType.MaxValue = EditorGUILayout.IntField(PropertyType.MaxValue); }); //DEditorGUI.WithLabel("Info", () => { // EditorGUILayout.LabelField("Bits: " + BoltMath.BitsRequired(PropertyType.MaxValue - PropertyType.MinValue)); //}); //PropertyType.MinValue = Mathf.Min(PropertyType.MinValue, PropertyType.MaxValue - 1); //PropertyType.MaxValue = Mathf.Max(PropertyType.MaxValue, PropertyType.MinValue + 1); }
protected override void Edit(bool array) { DEditorGUI.EditSmoothingAlgorithm(Asset, Definition, false); DEditorGUI.WithLabel("Axes", () => { PropertyType.Selection = DEditorGUI.EditAxisSelection(PropertyType.Selection); }); if (Asset is StateDefinition) { DEditorGUI.WithLabel("Strict Comparison", () => { PropertyType.StrictEquality = EditorGUILayout.Toggle(PropertyType.StrictEquality); }); } if (PropertyType.Selection != AxisSelections.Disabled) { bool quaternion = PropertyType.Selection == AxisSelections.XYZ; DEditorGUI.WithLabel(quaternion ? "Quaternion Compression" : "Axis Compression", () => { if (quaternion) { PropertyType.QuaternionCompression = DEditorGUI.EditFloatCompression(PropertyType.QuaternionCompression); } else { DEditorGUI.EditAxes(PropertyType.EulerCompression, PropertyType.Selection); } }); } }
protected override void Edit(bool array) { DEditorGUI.EditSmoothingAlgorithm(Asset, Definition, false); DEditorGUI.WithLabel("Axes", () => { PropertyType.Selection = DEditorGUI.EditAxisSelection(PropertyType.Selection); }); PropertyCommandSettings cmdSettings = Definition.CommandAssetSettings; PropertyStateSettings stateSettings = Definition.StateAssetSettings; if (Asset is StateDefinition) { DEditorGUI.WithLabel("Strict Comparison", () => { PropertyType.StrictEquality = EditorGUILayout.Toggle(PropertyType.StrictEquality); }); DEditorGUI.WithLabel("Teleport Threshold", () => { if (cmdSettings != null) { cmdSettings.SnapMagnitude = EditorGUILayout.FloatField(cmdSettings.SnapMagnitude); } if (stateSettings != null) { stateSettings.SnapMagnitude = EditorGUILayout.FloatField(stateSettings.SnapMagnitude); } }); } DEditorGUI.WithLabel("Axis Compression", () => { DEditorGUI.EditAxes(PropertyType.Compression, PropertyType.Selection); }); }
protected override void Edit(bool array) { DEditorGUI.WithLabel("Encoding & Length", () => { PropertyType.Encoding = (StringEncodings)EditorGUILayout.EnumPopup(PropertyType.Encoding); PropertyType.MaxLength = Mathf.Clamp(DEditorGUI.IntFieldOverlay(PropertyType.MaxLength, "Max Length (1 - 140)"), 1, 140); }); }
protected override void Edit(bool array) { DEditorGUI.WithLabel("Object Type", () => { PropertyType.StructGuid = DEditorGUI.AssetPopup( AscensionWindow.Project.Structs.Cast <AssetDefinition>(), PropertyType.StructGuid, new[] { Asset.Guid }); }); }
void EditEvent(EventDefinition def) { DEditorGUI.WithLabel("Global Senders", () => { def.GlobalSenders = (GlobalEventSenders)EditorGUILayout.EnumPopup(def.GlobalSenders); DEditorGUI.SetTooltip("Who can send this as an global event?"); }); DEditorGUI.WithLabel("Entity Senders", () => { def.EntitySenders = (EntityEventSenders)EditorGUILayout.EnumPopup(def.EntitySenders); DEditorGUI.SetTooltip("Who can send this as an entity event?"); }); // add button EditPropertyList(def, def.Properties); }
protected override void Edit(bool array) { DEditorGUI.EditSmoothingAlgorithm(Asset, Definition, false); if (Asset is StateDefinition) { if (Definition.StateAssetSettings.SmoothingAlgorithm == SmoothingAlgorithms.Interpolation) { DEditorGUI.WithLabel("Interpolation Mode", () => { PropertyType.IsAngle = DEditorGUI.ToggleDropdown("As Angle", "As Float", PropertyType.IsAngle); }); } } DEditorGUI.WithLabel("Compression", () => { PropertyType.Compression = DEditorGUI.EditFloatCompression(PropertyType.Compression); }); }
protected override void Edit(bool array) { DEditorGUI.WithLabel("Element Type", () => { PropertyType.ElementType = DEditorGUI.PropertyTypePopup(PropertyType.AllowedElementTypes, PropertyType.ElementType); }); DEditorGUI.WithLabel("Element Count", () => { PropertyType.ElementCount = Mathf.Max(2, EditorGUILayout.IntField(PropertyType.ElementCount)); }); if (PropertyType.ElementType.HasSettings) { EditorGUILayout.BeginVertical(); PropertyEditorRegistry.GetEditor(PropertyType.ElementType) .EditArrayElement(Asset, Definition, PropertyType.ElementType); EditorGUILayout.EndVertical(); } }
void EditCommand(CommandDefinition def) { DEditorGUI.WithLabel("Correction Interpolation", () => { def.SmoothFrames = DEditorGUI.IntFieldOverlay(def.SmoothFrames, "Frames"); }); //DEditorGUI.WithLabel("Compress Zero Values", () => { // def.CompressZeroValues = EditorGUILayout.Toggle(def.CompressZeroValues); //}); // add button DEditorGUI.Header("Input", "commands"); GUILayout.Space(2); EditPropertyList(def, def.Input); // add button DEditorGUI.Header("Result", "position"); GUILayout.Space(2); EditPropertyList(def, def.Result); }
protected override void Edit(bool array) { DEditorGUI.WithLabel("Space", () => { PropertyType.Space = (TransformSpaces)EditorGUILayout.EnumPopup(PropertyType.Space); }); DEditorGUI.EditSmoothingAlgorithm(Asset, Definition); DEditorGUI.Header("Position", "position"); DEditorGUI.WithLabel("Axes", () => { PropertyType.PositionSelection = DEditorGUI.EditAxisSelection(PropertyType.PositionSelection); }); if (PropertyType.PositionSelection != AxisSelections.Disabled) { if (Asset is StateDefinition) { DEditorGUI.WithLabel("Strict Comparison", () => { PropertyType.PositionStrictCompare = EditorGUILayout.Toggle(PropertyType.PositionStrictCompare); }); DEditorGUI.WithLabel("Teleport Threshold", () => { Definition.StateAssetSettings.SnapMagnitude = EditorGUILayout.FloatField(Definition.StateAssetSettings.SnapMagnitude); }); } DEditorGUI.WithLabel("Compression", () => { DEditorGUI.EditAxes(PropertyType.PositionCompression, PropertyType.PositionSelection); }); } DEditorGUI.Header("Rotation", "rotation"); DEditorGUI.WithLabel("Axes", () => { PropertyType.RotationSelection = DEditorGUI.EditAxisSelection(PropertyType.RotationSelection); }); if (PropertyType.RotationSelection != AxisSelections.Disabled) { if (Asset is StateDefinition) { DEditorGUI.WithLabel("Strict Comparison", () => { PropertyType.RotationStrictCompare = EditorGUILayout.Toggle(PropertyType.RotationStrictCompare); }); } bool quaternion = PropertyType.RotationSelection == AxisSelections.XYZ; DEditorGUI.WithLabel(quaternion ? "Compression (Quaternion)" : "Compression (Euler)", () => { if (quaternion) { PropertyType.RotationCompressionQuaternion = DEditorGUI.EditFloatCompression(PropertyType.RotationCompressionQuaternion); } else { DEditorGUI.EditAxes(PropertyType.RotationCompression, PropertyType.RotationSelection); } }); } }
void EditProperty(AssetDefinition def, PropertyDefinition p, bool first, bool last) { BeginBackground(); GUILayout.BeginHorizontal(DEditorGUI.HeaderBackground, GUILayout.Height(DEditorGUI.HEADER_HEIGHT)); if ((Event.current.modifiers & EventModifiers.Control) == EventModifiers.Control) { if (DEditorGUI.IconButton("minus-editor")) { if (EditorUtility.DisplayDialog("Delete Property", string.Format("Do you want to delete '{0}' (Property)?", p.Name), "Yes", "No")) { p.Deleted = true; } } } else { if (DEditorGUI.Toggle("arrow-down", "arrow-right", p.Expanded && (p.PropertyType.HasSettings || p.PropertyType.MecanimApplicable))) { p.Expanded = !p.Expanded; } } if (def is StateDefinition || def is ObjectDefinition) { p.Name = DEditorGUI.TextFieldOverlay(p.Name, p.Priority.ToString(), GUILayout.Width(181)); switch (p.ReplicationMode) { case ReplicationMode.Everyone: DEditorGUI.Toggle("controller-plus", true); break; case ReplicationMode.EveryoneExceptController: DEditorGUI.Toggle("controller", false); break; case ReplicationMode.OnlyOwnerAndController: DEditorGUI.Toggle("controller-only", true); break; case ReplicationMode.LocalForEachPlayer: DEditorGUI.Toggle("owner-only", true); break; } } else { p.Name = EditorGUILayout.TextField(p.Name, GUILayout.Width(200)); } DEditorGUI.SetTooltip("Name. The name of this property, has to be a valid C# property name."); // edit property type DEditorGUI.PropertyTypePopup(def, p); DEditorGUI.SetTooltip("Type. The type of this property."); EditorGUI.BeginDisabledGroup(def.SortOrder != SortOrder.Manual); if (DEditorGUI.IconButton("arrow-down", !last)) { p.Adjust += 1; } if (DEditorGUI.IconButton("arrow-up", !first)) { p.Adjust -= 1; } EditorGUI.EndDisabledGroup(); EditorGUILayout.EndHorizontal(); if (p.Controller) { p.ReplicationMode = ReplicationMode.Everyone; p.Controller = false; Save(); } if (p.Expanded) { GUILayout.Space(2); //DEditorGUI.WithLabel("Comment", () => { // p.Comment = EditorGUILayout.TextField(p.Comment); //}); if (def is StateDefinition || def is ObjectDefinition) { DEditorGUI.WithLabel("Replication", () => { p.Priority = DEditorGUI.EditPriority(p.Priority, p.PropertyType.HasPriority); p.ReplicationMode = (ReplicationMode)EditorGUILayout.EnumPopup(p.ReplicationMode); }); } if (def is CommandDefinition) { if (p.PropertyType.CanSmoothCorrections && ((CommandDefinition)def).Result.Contains(p)) { DEditorGUI.WithLabel("Smooth Corrections", () => { p.CommandAssetSettings.SmoothCorrection = EditorGUILayout.Toggle(p.CommandAssetSettings.SmoothCorrection); }); } } if (p.PropertyType.MecanimApplicable && (def is StateDefinition)) { DEditorGUI.WithLabel("Mecanim", () => { EditorGUILayout.BeginHorizontal(); if (p.PropertyType is PropertyTypeFloat) { p.StateAssetSettings.MecanimMode = (MecanimMode)EditorGUILayout.EnumPopup(p.StateAssetSettings.MecanimMode); EditorGUI.BeginDisabledGroup(p.StateAssetSettings.MecanimMode == MecanimMode.Disabled); p.StateAssetSettings.MecanimDirection = (MecanimDirection)EditorGUILayout.EnumPopup(p.StateAssetSettings.MecanimDirection); switch (p.StateAssetSettings.MecanimMode) { case MecanimMode.Parameter: if (p.StateAssetSettings.MecanimDirection == MecanimDirection.UsingAscensionProperties) { p.StateAssetSettings.MecanimDamping = DEditorGUI.FloatFieldOverlay(p.StateAssetSettings.MecanimDamping, "Damping Time"); } break; case MecanimMode.LayerWeight: p.StateAssetSettings.MecanimLayer = DEditorGUI.IntFieldOverlay(p.StateAssetSettings.MecanimLayer, "Layer Index"); break; } EditorGUI.EndDisabledGroup(); } else { p.StateAssetSettings.MecanimMode = (MecanimMode)(int)EditorGUILayout.Popup((int)p.StateAssetSettings.MecanimMode, new string[] { "Disabled", "Parameter" }); EditorGUI.BeginDisabledGroup(p.StateAssetSettings.MecanimMode == MecanimMode.Disabled); p.StateAssetSettings.MecanimDirection = (MecanimDirection)EditorGUILayout.EnumPopup(p.StateAssetSettings.MecanimDirection); if (p.PropertyType is PropertyTypeTrigger) { p.StateAssetSettings.MecanimLayer = DEditorGUI.IntFieldOverlay(p.StateAssetSettings.MecanimLayer, "Layer Index"); } EditorGUI.EndDisabledGroup(); } EditorGUILayout.EndHorizontal(); }); } if (p.PropertyType.HasSettings) { PropertyEditorRegistry.GetEditor(p.PropertyType.GetType()).Edit(def, p); } } else { GUILayout.Space(2); } EditorGUILayout.EndVertical(); }
void EditState(StateDefinition def) { DEditorGUI.WithLabel("Inheritance", () => { def.IsAbstract = DEditorGUI.ToggleDropdown("Is Abstract", "Is Concrete", def.IsAbstract); def.ParentGuid = DEditorGUI.AssetPopup("Parent: ", Project.States.Cast <AssetDefinition>(), def.ParentGuid, Project.GetInheritanceTree(def)); }); EditorGUI.BeginDisabledGroup(def.IsAbstract); DEditorGUI.WithLabel("Bandwidth", () => { GUILayout.BeginHorizontal(); def.PacketMaxBits = Mathf.Clamp(DEditorGUI.IntFieldOverlay(def.PacketMaxBits, "Bits/Packet"), 128, 4096); def.PacketMaxProperties = Mathf.Clamp(DEditorGUI.IntFieldOverlay(def.PacketMaxProperties, "Properties/Packet"), 1, 255); GUILayout.EndHorizontal(); }); EditorGUI.EndDisabledGroup(); DEditorGUI.WithLabel("Import Mecanim Modes", () => { replicationMode = (ReplicationMode)EditorGUILayout.EnumPopup("Replication Mode", replicationMode); mecanimDirection = (MecanimDirection)EditorGUILayout.EnumPopup("Mecanim Mode", mecanimDirection); }); DEditorGUI.WithLabel("Import Mecanim Parameters", () => { mecanimController = EditorGUILayout.ObjectField(mecanimController, typeof(RuntimeAnimatorController), true) as RuntimeAnimatorController; if (mecanimController) { if (GUILayout.Button("Import", EditorStyles.miniButton)) { try { AC ac = (AC)mecanimController; #if UNITY_5 for (int i = 0; i < ac.parameters.Length; ++i) { ImportMecanimParameter(def, ac.parameters[i]); } #else for (int i = 0; i < ac.parameterCount; ++i) { ImportMecanimParameter(def, ac.GetParameter(i)); } for (int i = 0; i < ac.layerCount; ++i) { ImportMecanimLayer(def, ac, i); } #endif Save(); } finally { mecanimController = null; } } } }); var groups = def.Properties .Where(x => x.PropertyType.MecanimApplicable) .Where(x => x.StateAssetSettings.MecanimMode != MecanimMode.Disabled) .GroupBy(x => x.StateAssetSettings.MecanimDirection); if (groups.Count() == 1) { var currentDirection = groups.First().Key; DEditorGUI.WithLabel("Mecanim (State Wide)", () => { var selectedDirection = (MecanimDirection)EditorGUILayout.EnumPopup(currentDirection); if (currentDirection != selectedDirection) { foreach (var property in def.Properties.Where(x => x.PropertyType.MecanimApplicable)) { property.StateAssetSettings.MecanimDirection = selectedDirection; } Save(); } }); } else if (groups.Count() > 1) { DEditorGUI.WithLabel("Mecanim (State Wide)", () => { string[] options = new string[] { "Using Animator Methods", "Using Bolt Properties", "Mixed (WARNING)" }; int index = EditorGUILayout.Popup(2, options); if (index != 2) { foreach (var property in def.Properties.Where(x => x.PropertyType.MecanimApplicable)) { property.StateAssetSettings.MecanimDirection = (MecanimDirection)index; } Save(); } }); } EditPropertyList(def, def.Properties); Guid guid = def.ParentGuid; while (guid != Guid.Empty) { var parent = Project.FindState(guid); GUILayout.Label(string.Format("Inherited from {0}", parent.Name), DEditorGUI.MiniLabelButtonStyle); EditorGUI.BeginDisabledGroup(true); EditPropertyList(parent, parent.Properties); EditorGUI.EndDisabledGroup(); guid = parent.ParentGuid; } }