/// <summary>
/// Creates a new rectangle offset GUI.
/// </summary>
/// <param name="title">Text to display on the title bar.</param>
/// <param name="layout">Layout to append the GUI elements to.</param>
public RectOffsetGUI(LocString title, GUILayout layout)
{
GUILayoutX rectLayout = layout.AddLayoutX();
rectLayout.AddElement(new GUILabel(title, GUIOption.FixedWidth(100)));
GUILayoutY rectContentLayout = rectLayout.AddLayoutY();
GUILayoutX rectTopRow = rectContentLayout.AddLayoutX();
GUILayoutX rectBotRow = rectContentLayout.AddLayoutX();
offsetLeftField = new GUIIntField(new LocEdString("Left"), 40);
offsetRightField = new GUIIntField(new LocEdString("Right"), 40);
offsetTopField = new GUIIntField(new LocEdString("Top"), 40);
offsetBottomField = new GUIIntField(new LocEdString("Bottom"), 40);
rectTopRow.AddElement(offsetLeftField);
rectTopRow.AddElement(offsetRightField);
rectBotRow.AddElement(offsetTopField);
rectBotRow.AddElement(offsetBottomField);
offsetLeftField.OnChanged += x =>
{
offset.left = x;
if(OnChanged != null)
OnChanged(offset);
};
offsetRightField.OnChanged += x =>
{
offset.right = x;
if (OnChanged != null)
OnChanged(offset);
};
offsetTopField.OnChanged += x =>
{
offset.top = x;
if (OnChanged != null)
OnChanged(offset);
};
offsetBottomField.OnChanged += x =>
{
offset.bottom = x;
if (OnChanged != null)
OnChanged(offset);
};
Action DoOnConfirmed = () =>
{
if (OnConfirmed != null)
OnConfirmed();
};
offsetLeftField.OnConfirmed += DoOnConfirmed;
offsetLeftField.OnFocusLost += DoOnConfirmed;
offsetRightField.OnConfirmed += DoOnConfirmed;
offsetRightField.OnFocusLost += DoOnConfirmed;
offsetTopField.OnConfirmed += DoOnConfirmed;
offsetTopField.OnFocusLost += DoOnConfirmed;
offsetBottomField.OnConfirmed += DoOnConfirmed;
offsetBottomField.OnFocusLost += DoOnConfirmed;
}
/// <summary>
/// Constructs a new set of GUI elements for inspecting the post process settings object.
/// </summary>
/// <param name="settings">Initial values to assign to the GUI elements.</param>
/// <param name="layout">Layout to append the GUI elements to.</param>
/// <param name="properties">A set of properties that are persisted by the parent inspector. Used for saving state.
/// </param>
public PostProcessSettingsGUI(PostProcessSettings settings, GUILayout layout, SerializableProperties properties)
{
this.settings = settings;
this.properties = properties;
// Auto exposure
enableAutoExposureField.OnChanged += x => { this.settings.EnableAutoExposure = x; MarkAsModified(); ConfirmModify(); };
layout.AddElement(enableAutoExposureField);
autoExposureFoldout.OnToggled += x =>
{
properties.SetBool("autoExposure_Expanded", x);
ToggleFoldoutFields();
};
layout.AddElement(autoExposureFoldout);
autoExposureLayout = layout.AddLayoutX();
{
autoExposureLayout.AddSpace(10);
GUILayoutY contentsLayout = autoExposureLayout.AddLayoutY();
autoExposureGUI = new AutoExposureSettingsGUI(settings.AutoExposure, contentsLayout);
autoExposureGUI.OnChanged += x => { this.settings.AutoExposure = x; MarkAsModified(); };
autoExposureGUI.OnConfirmed += ConfirmModify;
}
// Tonemapping
enableToneMappingField.OnChanged += x => { this.settings.EnableTonemapping = x; MarkAsModified(); ConfirmModify(); };
layout.AddElement(enableToneMappingField);
//// Tonemapping settings
toneMappingFoldout.OnToggled += x =>
{
properties.SetBool("toneMapping_Expanded", x);
ToggleFoldoutFields();
};
layout.AddElement(toneMappingFoldout);
toneMappingLayout = layout.AddLayoutX();
{
toneMappingLayout.AddSpace(10);
GUILayoutY contentsLayout = toneMappingLayout.AddLayoutY();
toneMappingGUI = new TonemappingSettingsGUI(settings.Tonemapping, contentsLayout);
toneMappingGUI.OnChanged += x => { this.settings.Tonemapping = x; MarkAsModified(); };
toneMappingGUI.OnConfirmed += ConfirmModify;
}
//// White balance settings
whiteBalanceFoldout.OnToggled += x =>
{
properties.SetBool("whiteBalance_Expanded", x);
ToggleFoldoutFields();
};
layout.AddElement(whiteBalanceFoldout);
whiteBalanceLayout = layout.AddLayoutX();
{
whiteBalanceLayout.AddSpace(10);
GUILayoutY contentsLayout = whiteBalanceLayout.AddLayoutY();
whiteBalanceGUI = new WhiteBalanceSettingsGUI(settings.WhiteBalance, contentsLayout);
whiteBalanceGUI.OnChanged += x => { this.settings.WhiteBalance = x; MarkAsModified(); };
whiteBalanceGUI.OnConfirmed += ConfirmModify;
}
//// Color grading settings
colorGradingFoldout.OnToggled += x =>
{
properties.SetBool("colorGrading_Expanded", x);
ToggleFoldoutFields();
};
layout.AddElement(colorGradingFoldout);
colorGradingLayout = layout.AddLayoutX();
{
colorGradingLayout.AddSpace(10);
GUILayoutY contentsLayout = colorGradingLayout.AddLayoutY();
colorGradingGUI = new ColorGradingSettingsGUI(settings.ColorGrading, contentsLayout);
colorGradingGUI.OnChanged += x => { this.settings.ColorGrading = x; MarkAsModified(); };
colorGradingGUI.OnConfirmed += ConfirmModify;
}
// Gamma
gammaField.OnChanged += x => { this.settings.Gamma = x; MarkAsModified(); ConfirmModify(); };
layout.AddElement(gammaField);
// Exposure scale
exposureScaleField.OnChanged += x => { this.settings.ExposureScale = x; MarkAsModified(); ConfirmModify(); };
layout.AddElement(exposureScaleField);
ToggleFoldoutFields();
}
/// <summary>
/// Registers a new row in the layout. The row cannot have any further children and can be selected as the output
/// field.
/// </summary>
/// <param name="layout">Layout to append the row GUI elements to.</param>
/// <param name="name">Name of the field.</param>
/// <param name="so">Parent scene object of the field.</param>
/// <param name="component">Parent component of the field. Can be null if field belongs to <see cref="SceneObject"/>.
/// </param>
/// <param name="path">Slash separated path to the field from its parent object.</param>
/// <param name="type">Data type stored in the field.</param>
/// <returns>Element object storing all information about the added field.</returns>
private Element AddFieldRow(GUILayout layout, string name, SceneObject so, Component component, string path, SerializableProperty.FieldType type)
{
Element element = new Element(so, component, path);
GUILayoutX elementLayout = layout.AddLayoutX();
elementLayout.AddSpace(PADDING);
elementLayout.AddSpace(foldoutWidth);
GUILabel label = new GUILabel(new LocEdString(name));
elementLayout.AddElement(label);
GUIButton selectBtn = new GUIButton(new LocEdString("Select"));
selectBtn.OnClick += () => { DoOnElementSelected(element, type); };
elementLayout.AddFlexibleSpace();
elementLayout.AddElement(selectBtn);
elementLayout.AddSpace(5);
element.path = path;
return element;
}
/// <summary>
/// Refreshes the contents of the content area. Must be called at least once after construction.
/// </summary>
/// <param name="viewType">Determines how to display the resource tiles.</param>
/// <param name="entriesToDisplay">Project library entries to display.</param>
/// <param name="bounds">Bounds within which to lay out the content entries.</param>
public void Refresh(ProjectViewType viewType, LibraryEntry[] entriesToDisplay, Rect2I bounds)
{
if (mainPanel != null)
mainPanel.Destroy();
entries.Clear();
entryLookup.Clear();
mainPanel = parent.Layout.AddPanel();
GUIPanel contentPanel = mainPanel.AddPanel(1);
overlay = mainPanel.AddPanel(0);
underlay = mainPanel.AddPanel(2);
deepUnderlay = mainPanel.AddPanel(3);
renameOverlay = mainPanel.AddPanel(-1);
main = contentPanel.AddLayoutY();
List<ResourceToDisplay> resourcesToDisplay = new List<ResourceToDisplay>();
foreach (var entry in entriesToDisplay)
{
if (entry.Type == LibraryEntryType.Directory)
resourcesToDisplay.Add(new ResourceToDisplay(entry.Path, LibraryGUIEntryType.Single));
else
{
FileEntry fileEntry = (FileEntry)entry;
ResourceMeta[] metas = fileEntry.ResourceMetas;
if (metas.Length > 0)
{
if (metas.Length == 1)
resourcesToDisplay.Add(new ResourceToDisplay(entry.Path, LibraryGUIEntryType.Single));
else
{
resourcesToDisplay.Add(new ResourceToDisplay(entry.Path, LibraryGUIEntryType.MultiFirst));
for (int i = 1; i < metas.Length - 1; i++)
{
string path = Path.Combine(entry.Path, metas[i].SubresourceName);
resourcesToDisplay.Add(new ResourceToDisplay(path, LibraryGUIEntryType.MultiElement));
}
string lastPath = Path.Combine(entry.Path, metas[metas.Length - 1].SubresourceName);
resourcesToDisplay.Add(new ResourceToDisplay(lastPath, LibraryGUIEntryType.MultiLast));
}
}
}
}
if (viewType == ProjectViewType.List16)
{
tileSize = 16;
gridLayout = false;
elementsPerRow = 1;
horzElementSpacing = 0;
int elemWidth = bounds.width;
int elemHeight = tileSize;
main.AddSpace(TOP_MARGIN);
for (int i = 0; i < resourcesToDisplay.Count; i++)
{
ResourceToDisplay entry = resourcesToDisplay[i];
LibraryGUIEntry guiEntry = new LibraryGUIEntry(this, main, entry.path, i, elemWidth, elemHeight,
entry.type);
entries.Add(guiEntry);
entryLookup[guiEntry.path] = guiEntry;
if (i != resourcesToDisplay.Count - 1)
main.AddSpace(LIST_ENTRY_SPACING);
}
main.AddFlexibleSpace();
}
else
{
int elemWidth = 0;
int elemHeight = 0;
int vertElemSpacing = 0;
switch (viewType)
{
case ProjectViewType.Grid64:
tileSize = 64;
elemWidth = tileSize;
elemHeight = tileSize + 36;
horzElementSpacing = 10;
vertElemSpacing = 12;
break;
case ProjectViewType.Grid48:
tileSize = 48;
elemWidth = tileSize;
elemHeight = tileSize + 36;
horzElementSpacing = 8;
vertElemSpacing = 10;
break;
case ProjectViewType.Grid32:
tileSize = 32;
elemWidth = tileSize + 16;
elemHeight = tileSize + 48;
horzElementSpacing = 6;
vertElemSpacing = 10;
break;
}
gridLayout = true;
int availableWidth = bounds.width;
elementsPerRow = MathEx.FloorToInt((availableWidth - horzElementSpacing) / (float)(elemWidth + horzElementSpacing));
elementsPerRow = Math.Max(elementsPerRow, 1);
int numRows = MathEx.CeilToInt(resourcesToDisplay.Count / (float)elementsPerRow);
int neededHeight = numRows * elemHeight + TOP_MARGIN;
if (numRows > 0)
neededHeight += (numRows - 1)* vertElemSpacing;
bool requiresScrollbar = neededHeight > bounds.height;
if (requiresScrollbar)
{
availableWidth -= parent.ScrollBarWidth;
elementsPerRow = MathEx.FloorToInt((availableWidth - horzElementSpacing) / (float)(elemWidth + horzElementSpacing));
elementsPerRow = Math.Max(elementsPerRow, 1);
}
int extraRowSpace = availableWidth - (elementsPerRow * (elemWidth + horzElementSpacing) + horzElementSpacing);
main.AddSpace(TOP_MARGIN);
GUILayoutX rowLayout = main.AddLayoutX();
rowLayout.AddSpace(horzElementSpacing);
int elemsInRow = 0;
for (int i = 0; i < resourcesToDisplay.Count; i++)
{
if (elemsInRow == elementsPerRow && elemsInRow > 0)
{
main.AddSpace(vertElemSpacing);
rowLayout.AddSpace(extraRowSpace);
rowLayout = main.AddLayoutX();
rowLayout.AddSpace(horzElementSpacing);
elemsInRow = 0;
}
ResourceToDisplay entry = resourcesToDisplay[i];
LibraryGUIEntry guiEntry = new LibraryGUIEntry(this, rowLayout, entry.path, i, elemWidth, elemHeight,
entry.type);
entries.Add(guiEntry);
entryLookup[guiEntry.path] = guiEntry;
rowLayout.AddSpace(horzElementSpacing);
elemsInRow++;
}
int extraElements = elementsPerRow - elemsInRow;
rowLayout.AddSpace((elemWidth + horzElementSpacing) * extraElements + extraRowSpace);
main.AddFlexibleSpace();
}
for (int i = 0; i < entries.Count; i++)
{
LibraryGUIEntry guiEntry = entries[i];
guiEntry.Initialize();
}
}
/// <summary>
/// Constructs a new resource tile entry.
/// </summary>
/// <param name="owner">Content area this entry is part of.</param>
/// <param name="parent">Parent layout to add this entry's GUI elements to.</param>
/// <param name="path">Path to the project library entry to display data for.</param>
/// <param name="index">Sequential index of the entry in the conent area.</param>
/// <param name="width">Width of the GUI entry.</param>
/// <param name="height">Maximum allowed height for the label.</param>"
/// <param name="type">Type of the entry, which controls its style and/or behaviour.</param>
public LibraryGUIEntry(LibraryGUIContent owner, GUILayout parent, string path, int index, int width, int height,
LibraryGUIEntryType type)
{
GUILayout entryLayout;
if (owner.GridLayout)
entryLayout = parent.AddLayoutY();
else
entryLayout = parent.AddLayoutX();
SpriteTexture iconTexture = GetIcon(path, owner.TileSize);
icon = new GUITexture(iconTexture, GUIImageScaleMode.ScaleToFit,
true, GUIOption.FixedHeight(owner.TileSize), GUIOption.FixedWidth(owner.TileSize));
label = null;
string name = PathEx.GetTail(path);
if (owner.GridLayout)
{
int labelHeight = height - owner.TileSize;
label = new GUILabel(name, EditorStyles.MultiLineLabelCentered,
GUIOption.FixedWidth(width), GUIOption.FixedHeight(labelHeight));
switch (type)
{
case LibraryGUIEntryType.Single:
break;
case LibraryGUIEntryType.MultiFirst:
groupUnderlay = new GUITexture(null, LibraryEntryFirstBg);
break;
case LibraryGUIEntryType.MultiElement:
groupUnderlay = new GUITexture(null, LibraryEntryBg);
break;
case LibraryGUIEntryType.MultiLast:
groupUnderlay = new GUITexture(null, LibraryEntryLastBg);
break;
}
}
else
{
label = new GUILabel(name, GUIOption.FixedWidth(width - owner.TileSize), GUIOption.FixedHeight(height));
switch (type)
{
case LibraryGUIEntryType.Single:
break;
case LibraryGUIEntryType.MultiFirst:
groupUnderlay = new GUITexture(null, LibraryEntryVertFirstBg);
break;
case LibraryGUIEntryType.MultiElement:
groupUnderlay = new GUITexture(null, LibraryEntryVertBg);
break;
case LibraryGUIEntryType.MultiLast:
groupUnderlay = new GUITexture(null, LibraryEntryVertLastBg);
break;
}
}
entryLayout.AddElement(icon);
entryLayout.AddElement(label);
if (groupUnderlay != null)
owner.DeepUnderlay.AddElement(groupUnderlay);
this.owner = owner;
this.index = index;
this.path = path;
this.bounds = new Rect2I();
this.underlay = null;
this.type = type;
this.width = width;
this.height = height;
}
/// <summary>
/// Sets a scene object whose GUI is to be displayed in the inspector. Clears any previous contents of the window.
/// </summary>
/// <param name="so">Scene object to inspect.</param>
private void SetObjectToInspect(SceneObject so)
{
if (so == null)
return;
currentType = InspectorType.SceneObject;
activeSO = so;
inspectorScrollArea = new GUIScrollArea();
scrollAreaHighlight = new GUITexture(Builtin.WhiteTexture);
scrollAreaHighlight.SetTint(HIGHLIGHT_COLOR);
scrollAreaHighlight.Active = false;
GUI.AddElement(inspectorScrollArea);
GUIPanel inspectorPanel = inspectorScrollArea.Layout.AddPanel();
inspectorLayout = inspectorPanel.AddLayoutY();
highlightPanel = inspectorPanel.AddPanel(-1);
highlightPanel.AddElement(scrollAreaHighlight);
// SceneObject fields
CreateSceneObjectFields();
RefreshSceneObjectFields(true);
// Components
Component[] allComponents = so.GetComponents();
for (int i = 0; i < allComponents.Length; i++)
{
inspectorLayout.AddSpace(COMPONENT_SPACING);
InspectorComponent data = new InspectorComponent();
data.instanceId = allComponents[i].InstanceId;
data.foldout = new GUIToggle(allComponents[i].GetType().Name, EditorStyles.Foldout);
data.removeBtn = new GUIButton(new GUIContent(EditorBuiltin.XBtnIcon), GUIOption.FixedWidth(30));
data.title = inspectorLayout.AddLayoutX();
data.title.AddElement(data.foldout);
data.title.AddElement(data.removeBtn);
data.panel = inspectorLayout.AddPanel();
var persistentProperties = persistentData.GetProperties(allComponents[i].InstanceId);
data.inspector = InspectorUtility.GetInspector(allComponents[i].GetType());
data.inspector.Initialize(data.panel, allComponents[i], persistentProperties);
bool isExpanded = data.inspector.Persistent.GetBool(data.instanceId + "_Expanded", true);
data.foldout.Value = isExpanded;
if (!isExpanded)
data.inspector.SetVisible(false);
Type curComponentType = allComponents[i].GetType();
data.foldout.OnToggled += (bool expanded) => OnComponentFoldoutToggled(data, expanded);
data.removeBtn.OnClick += () => OnComponentRemoveClicked(curComponentType);
inspectorComponents.Add(data);
}
inspectorLayout.AddFlexibleSpace();
UpdateDropAreas();
}
/// <summary>
/// Triggered when the user selects a new resource or a scene object, or deselects everything.
/// </summary>
/// <param name="objects">A set of new scene objects that were selected.</param>
/// <param name="paths">A set of absolute resource paths that were selected.</param>
private void OnSelectionChanged(SceneObject[] objects, string[] paths)
{
if (currentType == InspectorType.SceneObject && modifyState == InspectableState.NotModified)
UndoRedo.PopCommand(undoCommandIdx);
Clear();
modifyState = InspectableState.NotModified;
if (objects.Length == 0 && paths.Length == 0)
{
currentType = InspectorType.None;
inspectorScrollArea = new GUIScrollArea();
GUI.AddElement(inspectorScrollArea);
inspectorLayout = inspectorScrollArea.Layout;
inspectorLayout.AddFlexibleSpace();
GUILayoutX layoutMsg = inspectorLayout.AddLayoutX();
layoutMsg.AddFlexibleSpace();
layoutMsg.AddElement(new GUILabel(new LocEdString("No object selected")));
layoutMsg.AddFlexibleSpace();
inspectorLayout.AddFlexibleSpace();
}
else if ((objects.Length + paths.Length) > 1)
{
currentType = InspectorType.None;
inspectorScrollArea = new GUIScrollArea();
GUI.AddElement(inspectorScrollArea);
inspectorLayout = inspectorScrollArea.Layout;
inspectorLayout.AddFlexibleSpace();
GUILayoutX layoutMsg = inspectorLayout.AddLayoutX();
layoutMsg.AddFlexibleSpace();
layoutMsg.AddElement(new GUILabel(new LocEdString("Multiple objects selected")));
layoutMsg.AddFlexibleSpace();
inspectorLayout.AddFlexibleSpace();
}
else if (objects.Length == 1)
{
if (objects[0] != null)
{
UndoRedo.RecordSO(objects[0]);
undoCommandIdx = UndoRedo.TopCommandId;
SetObjectToInspect(objects[0]);
}
}
else if (paths.Length == 1)
{
SetObjectToInspect(paths[0]);
}
}
/// <summary>
/// Creates a new material parameter GUI.
/// </summary>
/// <param name="shaderParam">Shader parameter to create the GUI for. Must be of 4x4 matrix type.</param>
/// <param name="material">Material the parameter is a part of.</param>
/// <param name="layout">Layout to append the GUI elements to.</param>
internal MaterialParamMat4GUI(ShaderParameter shaderParam, Material material, GUILayout layout)
: base(shaderParam)
{
LocString title = new LocEdString(shaderParam.Name);
GUILabel guiTitle = new GUILabel(title, GUIOption.FixedWidth(100));
mainLayout = layout.AddLayoutY();
GUILayoutX titleLayout = mainLayout.AddLayoutX();
titleLayout.AddElement(guiTitle);
titleLayout.AddFlexibleSpace();
GUILayoutY contentLayout = mainLayout.AddLayoutY();
GUILayoutX[] rows = new GUILayoutX[MAT_SIZE];
for (int i = 0; i < rows.Length; i++)
rows[i] = contentLayout.AddLayoutX();
for (int row = 0; row < MAT_SIZE; row++)
{
for (int col = 0; col < MAT_SIZE; col++)
{
int index = row * MAT_SIZE + col;
guiMatFields[index] = new GUIFloatField(row + "," + col, 20, "", GUIOption.FixedWidth(80));
GUIFloatField field = guiMatFields[index];
rows[row].AddElement(field);
rows[row].AddSpace(5);
int hoistedRow = row;
int hoistedCol = col;
field.OnChanged += (x) =>
{
Matrix4 value = material.GetMatrix4(shaderParam.Name);
value[hoistedRow, hoistedCol] = x;
material.SetMatrix4(shaderParam.Name, value);
EditorApplication.SetDirty(material);
};
}
}
}
/// <summary>
/// Constructs a new set of GUI elements for inspecting the limit object.
/// </summary>
/// <param name="prefix">Prefix that identifies the exact type of the limit type.</param>
/// <param name="limitData">Initial values to assign to the GUI elements.</param>
/// <param name="layout">Layout to append the GUI elements to.</param>
/// <param name="properties">A set of properties that are persisted by the parent inspector. Used for saving state.
/// </param>
public LimitCommonGUI(string prefix, LimitCommonData limitData, GUILayout layout, SerializableProperties properties)
{
this.limitData = limitData;
this.properties = properties;
this.prefix = prefix;
hardFoldout.OnToggled += x =>
{
properties.SetBool(prefix + "_hardLimit_Expanded", x);
ToggleLimitFields();
};
contactDistanceField.OnChanged += x => { this.limitData.contactDist = x; MarkAsModified(); };
contactDistanceField.OnFocusLost += ConfirmModify;
contactDistanceField.OnConfirmed += ConfirmModify;
softFoldout.OnToggled += x =>
{
properties.SetBool(prefix + "_softLimit_Expanded", x);
ToggleLimitFields();
};
restitutionField.OnChanged += x => { this.limitData.restitution = x; MarkAsModified(); };
restitutionField.OnFocusLost += ConfirmModify;
springFoldout.OnToggled += x =>
{
properties.SetBool(prefix + "_spring_Expanded", x);
ToggleLimitFields();
};
hardLimitLayout = layout.AddLayoutX();
{
hardLimitLayout.AddSpace(10);
GUILayoutY hardLimitContentsLayout = hardLimitLayout.AddLayoutY();
hardLimitContentsLayout.AddElement(contactDistanceField);
}
softLimitLayout = layout.AddLayoutX();
layout.AddElement(softFoldout);
{
softLimitLayout.AddSpace(10);
GUILayoutY softLimitContentsLayout = softLimitLayout.AddLayoutY();
softLimitContentsLayout.AddElement(restitutionField);
softLimitContentsLayout.AddElement(springFoldout);
springLayout = softLimitContentsLayout.AddLayoutX();
{
springLayout.AddSpace(10);
GUILayoutY springContentsLayout = springLayout.AddLayoutY();
springGUI = new SpringGUI(limitData.spring, springContentsLayout);
springGUI.OnChanged += x => { this.limitData.spring = x; MarkAsModified(); };
springGUI.OnConfirmed += ConfirmModify;
}
}
}
