/// <summary>
/// Creates a set of objects in which each object represents a GUI for a material parameter.
/// </summary>
/// <param name="mat">Material for whose parameters to create GUI for.</param>
/// <param name="layout">Layout to add the parameter GUI elements to.</param>
/// <returns>A material parameter GUI object for each supported material parameter.</returns>
internal static MaterialParamGUI[] CreateMaterialGUI(Material mat, GUILayout layout)
{
Shader shader = mat.Shader;
if (shader == null)
return new MaterialParamGUI[0];
List<MaterialParamGUI> guiParams = new List<MaterialParamGUI>();
ShaderParameter[] shaderParams = shader.Parameters;
foreach (var param in shaderParams)
{
if (param.Internal)
continue;
switch (param.Type)
{
case ShaderParameterType.Float:
layout.AddSpace(5);
guiParams.Add(new MaterialParamFloatGUI(param, mat, layout));
break;
case ShaderParameterType.Vector2:
layout.AddSpace(5);
guiParams.Add(new MaterialParamVec2GUI(param, mat, layout));
break;
case ShaderParameterType.Vector3:
layout.AddSpace(5);
guiParams.Add(new MaterialParamVec3GUI(param, mat, layout));
break;
case ShaderParameterType.Vector4:
layout.AddSpace(5);
guiParams.Add(new MaterialParamVec4GUI(param, mat, layout));
break;
case ShaderParameterType.Matrix3:
layout.AddSpace(5);
guiParams.Add(new MaterialParamMat3GUI(param, mat, layout));
break;
case ShaderParameterType.Matrix4:
layout.AddSpace(5);
guiParams.Add(new MaterialParamMat4GUI(param, mat, layout));
break;
case ShaderParameterType.Color:
layout.AddSpace(5);
guiParams.Add(new MaterialParamColorGUI(param, mat, layout));
break;
case ShaderParameterType.Texture2D:
case ShaderParameterType.Texture3D:
case ShaderParameterType.TextureCube:
layout.AddSpace(5);
guiParams.Add(new MaterialParamTextureGUI(param, mat, layout));
break;
}
}
return guiParams.ToArray();
}
/// <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>
/// 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>
/// Recreates the entire curve editor GUI depending on the currently selected scene object.
/// </summary>
private void RebuildGUI()
{
GUI.Clear();
guiCurveEditor = null;
guiFieldDisplay = null;
if (selectedSO == null)
{
GUILabel warningLbl = new GUILabel(new LocEdString("Select an object to animate in the Hierarchy or Scene windows."));
GUILayoutY vertLayout = GUI.AddLayoutY();
vertLayout.AddFlexibleSpace();
GUILayoutX horzLayout = vertLayout.AddLayoutX();
vertLayout.AddFlexibleSpace();
horzLayout.AddFlexibleSpace();
horzLayout.AddElement(warningLbl);
horzLayout.AddFlexibleSpace();
return;
}
// Top button row
GUIContent playIcon = new GUIContent(EditorBuiltin.GetAnimationWindowIcon(AnimationWindowIcon.Play),
new LocEdString("Play"));
GUIContent recordIcon = new GUIContent(EditorBuiltin.GetAnimationWindowIcon(AnimationWindowIcon.Record),
new LocEdString("Record"));
GUIContent prevFrameIcon = new GUIContent(EditorBuiltin.GetAnimationWindowIcon(AnimationWindowIcon.FrameBack),
new LocEdString("Previous frame"));
GUIContent nextFrameIcon = new GUIContent(EditorBuiltin.GetAnimationWindowIcon(AnimationWindowIcon.FrameForward),
new LocEdString("Next frame"));
GUIContent addKeyframeIcon = new GUIContent(EditorBuiltin.GetAnimationWindowIcon(AnimationWindowIcon.AddKeyframe),
new LocEdString("Add keyframe"));
GUIContent addEventIcon = new GUIContent(EditorBuiltin.GetAnimationWindowIcon(AnimationWindowIcon.AddEvent),
new LocEdString("Add event"));
GUIContent optionsIcon = new GUIContent(EditorBuiltin.GetLibraryWindowIcon(LibraryWindowIcon.Options),
new LocEdString("Options"));
playButton = new GUIToggle(playIcon, EditorStyles.Button);
recordButton = new GUIToggle(recordIcon, EditorStyles.Button);
prevFrameButton = new GUIButton(prevFrameIcon);
frameInputField = new GUIIntField();
nextFrameButton = new GUIButton(nextFrameIcon);
addKeyframeButton = new GUIButton(addKeyframeIcon);
addEventButton = new GUIButton(addEventIcon);
optionsButton = new GUIButton(optionsIcon);
playButton.OnToggled += x =>
{
if(x)
SwitchState(State.Playback);
else
SwitchState(State.Normal);
};
recordButton.OnToggled += x =>
{
if (x)
SwitchState(State.Recording);
else
SwitchState(State.Normal);
};
prevFrameButton.OnClick += () =>
{
SetCurrentFrame(currentFrameIdx - 1);
switch (state)
{
case State.Recording:
case State.Normal:
PreviewFrame(currentFrameIdx);
break;
default:
SwitchState(State.Normal);
break;
}
};
frameInputField.OnChanged += x =>
{
SetCurrentFrame(x);
switch (state)
{
case State.Recording:
case State.Normal:
PreviewFrame(currentFrameIdx);
break;
default:
SwitchState(State.Normal);
break;
}
};
nextFrameButton.OnClick += () =>
{
SetCurrentFrame(currentFrameIdx + 1);
switch (state)
{
case State.Recording:
case State.Normal:
PreviewFrame(currentFrameIdx);
break;
default:
SwitchState(State.Normal);
break;
}
};
addKeyframeButton.OnClick += () =>
{
SwitchState(State.Normal);
guiCurveEditor.AddKeyFrameAtMarker();
};
addEventButton.OnClick += () =>
{
SwitchState(State.Normal);
guiCurveEditor.AddEventAtMarker();
};
optionsButton.OnClick += () =>
{
Vector2I openPosition = ScreenToWindowPos(Input.PointerPosition);
AnimationOptions dropDown = DropDownWindow.Open<AnimationOptions>(this, openPosition);
dropDown.Initialize(this);
};
// Property buttons
addPropertyBtn = new GUIButton(new LocEdString("Add property"));
delPropertyBtn = new GUIButton(new LocEdString("Delete selected"));
addPropertyBtn.OnClick += () =>
{
Action openPropertyWindow = () =>
{
Vector2I windowPos = ScreenToWindowPos(Input.PointerPosition);
FieldSelectionWindow fieldSelection = DropDownWindow.Open<FieldSelectionWindow>(this, windowPos);
fieldSelection.OnFieldSelected += OnFieldAdded;
};
if (clipInfo.clip == null)
{
LocEdString title = new LocEdString("Warning");
LocEdString message =
new LocEdString("Selected object doesn't have an animation clip assigned. Would you like to create" +
" a new animation clip?");
DialogBox.Open(title, message, DialogBox.Type.YesNoCancel, type =>
{
if (type == DialogBox.ResultType.Yes)
{
string clipSavePath;
if (BrowseDialog.SaveFile(ProjectLibrary.ResourceFolder, "*.asset", out clipSavePath))
{
SwitchState(State.Empty);
clipSavePath = Path.ChangeExtension(clipSavePath, ".asset");
AnimationClip newClip = new AnimationClip();
ProjectLibrary.Create(newClip, clipSavePath);
LoadAnimClip(newClip);
Animation animation = selectedSO.GetComponent<Animation>();
if (animation == null)
animation = selectedSO.AddComponent<Animation>();
animation.DefaultClip = newClip;
EditorApplication.SetSceneDirty();
SwitchState(State.Normal);
openPropertyWindow();
}
}
});
}
else
{
if (clipInfo.isImported)
{
LocEdString title = new LocEdString("Warning");
LocEdString message =
new LocEdString("You cannot add/edit/remove curves from animation clips that" +
" are imported from an external file.");
DialogBox.Open(title, message, DialogBox.Type.OK);
}
else
{
SwitchState(State.Normal);
openPropertyWindow();
}
}
};
delPropertyBtn.OnClick += () =>
{
if (clipInfo.clip == null)
return;
SwitchState(State.Normal);
if (clipInfo.isImported)
{
LocEdString title = new LocEdString("Warning");
LocEdString message =
new LocEdString("You cannot add/edit/remove curves from animation clips that" +
" are imported from an external file.");
DialogBox.Open(title, message, DialogBox.Type.OK);
}
else
{
LocEdString title = new LocEdString("Warning");
LocEdString message = new LocEdString("Are you sure you want to remove all selected fields?");
DialogBox.Open(title, message, DialogBox.Type.YesNo, x =>
{
if (x == DialogBox.ResultType.Yes)
{
RemoveSelectedFields();
ApplyClipChanges();
}
});
}
};
GUIPanel mainPanel = GUI.AddPanel();
GUIPanel backgroundPanel = GUI.AddPanel(1);
GUILayout mainLayout = mainPanel.AddLayoutY();
buttonLayout = mainLayout.AddLayoutX();
buttonLayout.AddSpace(5);
buttonLayout.AddElement(playButton);
buttonLayout.AddElement(recordButton);
buttonLayout.AddSpace(5);
buttonLayout.AddElement(prevFrameButton);
buttonLayout.AddElement(frameInputField);
buttonLayout.AddElement(nextFrameButton);
buttonLayout.AddSpace(5);
buttonLayout.AddElement(addKeyframeButton);
buttonLayout.AddElement(addEventButton);
buttonLayout.AddSpace(5);
buttonLayout.AddElement(optionsButton);
buttonLayout.AddFlexibleSpace();
buttonLayoutHeight = playButton.Bounds.height;
GUITexture buttonBackground = new GUITexture(null, EditorStyles.HeaderBackground);
buttonBackground.Bounds = new Rect2I(0, 0, Width, buttonLayoutHeight);
backgroundPanel.AddElement(buttonBackground);
GUILayout contentLayout = mainLayout.AddLayoutX();
GUILayout fieldDisplayLayout = contentLayout.AddLayoutY(GUIOption.FixedWidth(FIELD_DISPLAY_WIDTH));
guiFieldDisplay = new GUIAnimFieldDisplay(fieldDisplayLayout, FIELD_DISPLAY_WIDTH,
Height - buttonLayoutHeight * 2, selectedSO);
guiFieldDisplay.OnEntrySelected += OnFieldSelected;
GUILayout bottomButtonLayout = fieldDisplayLayout.AddLayoutX();
bottomButtonLayout.AddElement(addPropertyBtn);
bottomButtonLayout.AddElement(delPropertyBtn);
horzScrollBar = new GUIResizeableScrollBarH();
horzScrollBar.OnScrollOrResize += OnHorzScrollOrResize;
vertScrollBar = new GUIResizeableScrollBarV();
vertScrollBar.OnScrollOrResize += OnVertScrollOrResize;
GUITexture separator = new GUITexture(null, EditorStyles.Separator, GUIOption.FixedWidth(3));
contentLayout.AddElement(separator);
GUILayout curveLayout = contentLayout.AddLayoutY();
GUILayout curveLayoutHorz = curveLayout.AddLayoutX();
GUILayout horzScrollBarLayout = curveLayout.AddLayoutX();
horzScrollBarLayout.AddElement(horzScrollBar);
horzScrollBarLayout.AddFlexibleSpace();
editorPanel = curveLayoutHorz.AddPanel();
curveLayoutHorz.AddElement(vertScrollBar);
curveLayoutHorz.AddFlexibleSpace();
scrollBarHeight = horzScrollBar.Bounds.height;
scrollBarWidth = vertScrollBar.Bounds.width;
Vector2I curveEditorSize = GetCurveEditorSize();
guiCurveEditor = new GUICurveEditor(this, editorPanel, curveEditorSize.x, curveEditorSize.y);
guiCurveEditor.OnFrameSelected += OnFrameSelected;
guiCurveEditor.OnEventAdded += OnEventsChanged;
guiCurveEditor.OnEventModified += EditorApplication.SetProjectDirty;
guiCurveEditor.OnEventDeleted += OnEventsChanged;
guiCurveEditor.OnCurveModified += () =>
{
SwitchState(State.Normal);
ApplyClipChanges();
PreviewFrame(currentFrameIdx);
EditorApplication.SetProjectDirty();
};
guiCurveEditor.OnClicked += () =>
{
if(state != State.Recording)
SwitchState(State.Normal);
};
guiCurveEditor.Redraw();
horzScrollBar.SetWidth(curveEditorSize.x);
vertScrollBar.SetHeight(curveEditorSize.y);
UpdateScrollBarSize();
}
/// <summary>
/// Recreates all the GUI elements used by this inspector.
/// </summary>
private void BuildGUI()
{
if (InspectedObject != null)
{
Camera camera = (Camera)InspectedObject;
projectionTypeField.OnSelectionChanged += x =>
{
camera.ProjectionType = (ProjectionType)x;
MarkAsModified();
ConfirmModify();
ToggleTypeSpecificFields((ProjectionType)x);
};
fieldOfView.OnChanged += x => { camera.FieldOfView = (Degree)x; MarkAsModified(); };
fieldOfView.OnFocusLost += ConfirmModify;
orthoHeight.OnChanged += x => { camera.OrthoHeight = x; MarkAsModified(); };
orthoHeight.OnConfirmed += ConfirmModify;
orthoHeight.OnFocusLost += ConfirmModify;
aspectField.OnChanged += x => { camera.AspectRatio = x; MarkAsModified(); };
aspectField.OnConfirmed += ConfirmModify;
aspectField.OnFocusLost += ConfirmModify;
nearPlaneField.OnChanged += x => { camera.NearClipPlane = x; MarkAsModified(); };
nearPlaneField.OnConfirmed += ConfirmModify;
nearPlaneField.OnFocusLost += ConfirmModify;
farPlaneField.OnChanged += x => { camera.FarClipPlane = x; MarkAsModified(); };
farPlaneField.OnConfirmed += ConfirmModify;
farPlaneField.OnFocusLost += ConfirmModify;
viewportXField.OnChanged += x =>
{
Rect2 rect = camera.ViewportRect;
rect.x = x;
camera.ViewportRect = rect;
MarkAsModified();
};
viewportXField.OnConfirmed += ConfirmModify;
viewportXField.OnFocusLost += ConfirmModify;
viewportYField.OnChanged += x =>
{
Rect2 rect = camera.ViewportRect;
rect.y = x;
camera.ViewportRect = rect;
MarkAsModified();
};
viewportYField.OnConfirmed += ConfirmModify;
viewportYField.OnFocusLost += ConfirmModify;
viewportWidthField.OnChanged += x =>
{
Rect2 rect = camera.ViewportRect;
rect.width = x;
camera.ViewportRect = rect;
MarkAsModified();
};
viewportWidthField.OnConfirmed += ConfirmModify;
viewportWidthField.OnFocusLost += ConfirmModify;
viewportHeightField.OnChanged += x =>
{
Rect2 rect = camera.ViewportRect;
rect.height = x;
camera.ViewportRect = rect;
MarkAsModified();
};
viewportHeightField.OnConfirmed += ConfirmModify;
viewportHeightField.OnFocusLost += ConfirmModify;
clearFlagsFields.OnSelectionChanged += x =>
{
camera.ClearFlags = (ClearFlags) x;
MarkAsModified();
ConfirmModify();
};
clearStencilField.OnChanged += x => { camera.ClearStencil = (ushort) x; };
clearStencilField.OnConfirmed += ConfirmModify;
clearStencilField.OnFocusLost += ConfirmModify;
clearDepthField.OnChanged += x => { camera.ClearDepth = x; };
clearDepthField.OnConfirmed += ConfirmModify;
clearDepthField.OnFocusLost += ConfirmModify;
clearColorField.OnChanged += x =>
{
camera.ClearColor = x;
MarkAsModified();
ConfirmModify();
};
priorityField.OnChanged += x => { camera.Priority = x; MarkAsModified(); };
priorityField.OnConfirmed += ConfirmModify;
priorityField.OnFocusLost += ConfirmModify;
layersField.OnSelectionChanged += x =>
{
ulong layers = 0;
bool[] states = layersField.States;
for (int i = 0; i < states.Length; i++)
layers |= states[i] ? Layers.Values[i] : 0;
layersValue = layers;
camera.Layers = layers;
MarkAsModified();
ConfirmModify();
};
mainField.OnChanged += x =>
{
camera.Main = x;
MarkAsModified();
ConfirmModify();
};
hdrField.OnChanged += x =>
{
camera.HDR = x;
MarkAsModified();
ConfirmModify();
};
skyboxField.OnChanged += x =>
{
Texture skyboxTex = Resources.Load<Texture>(x);
camera.Skybox = skyboxTex as TextureCube;
MarkAsModified();
ConfirmModify();
};
Layout.AddElement(projectionTypeField);
Layout.AddElement(fieldOfView);
Layout.AddElement(orthoHeight);
Layout.AddElement(aspectField);
Layout.AddElement(nearPlaneField);
Layout.AddElement(farPlaneField);
GUILayoutX viewportTopLayout = Layout.AddLayoutX();
viewportTopLayout.AddElement(new GUILabel(new LocEdString("Viewport"), GUIOption.FixedWidth(100)));
GUILayoutY viewportContentLayout = viewportTopLayout.AddLayoutY();
GUILayoutX viewportTopRow = viewportContentLayout.AddLayoutX();
viewportTopRow.AddElement(viewportXField);
viewportTopRow.AddElement(viewportWidthField);
GUILayoutX viewportBotRow = viewportContentLayout.AddLayoutX();
viewportBotRow.AddElement(viewportYField);
viewportBotRow.AddElement(viewportHeightField);
Layout.AddElement(clearFlagsFields);
Layout.AddElement(clearColorField);
Layout.AddElement(clearDepthField);
Layout.AddElement(clearStencilField);
Layout.AddElement(priorityField);
Layout.AddElement(layersField);
Layout.AddElement(mainField);
Layout.AddElement(hdrField);
Layout.AddElement(skyboxField);
postProcessFoldout.OnToggled += x =>
{
Persistent.SetBool("postProcess_Expanded", x);
postProcessLayout.Active = x;
};
Layout.AddElement(postProcessFoldout);
postProcessLayout = Layout.AddLayoutX();
{
postProcessLayout.AddSpace(10);
GUILayoutY contentsLayout = postProcessLayout.AddLayoutY();
postProcessGUI = new PostProcessSettingsGUI(camera.PostProcess, contentsLayout, Persistent);
postProcessGUI.OnChanged += x => { camera.PostProcess = x; MarkAsModified(); };
postProcessGUI.OnConfirmed += ConfirmModify;
}
ToggleTypeSpecificFields(camera.ProjectionType);
postProcessLayout.Active = Persistent.GetBool("postProcess_Expanded");
}
}
private void OnInitialize()
{
ProjectLibrary.OnEntryAdded += OnEntryChanged;
ProjectLibrary.OnEntryImported += OnEntryChanged;
ProjectLibrary.OnEntryRemoved += OnEntryChanged;
GUILayoutY contentLayout = GUI.AddLayoutY();
searchBarLayout = contentLayout.AddLayoutX();
searchField = new GUITextField();
searchField.OnChanged += OnSearchChanged;
searchField.OnFocusGained += StopRename;
GUIContent clearIcon = new GUIContent(EditorBuiltin.GetLibraryWindowIcon(LibraryWindowIcon.Clear),
new LocEdString("Clear"));
GUIButton clearSearchBtn = new GUIButton(clearIcon);
clearSearchBtn.OnClick += OnClearClicked;
clearSearchBtn.SetWidth(40);
GUIContent optionsIcon = new GUIContent(EditorBuiltin.GetLibraryWindowIcon(LibraryWindowIcon.Options),
new LocEdString("Options"));
optionsButton = new GUIButton(optionsIcon);
optionsButton.OnClick += OnOptionsClicked;
optionsButton.SetWidth(40);
searchBarLayout.AddElement(searchField);
searchBarLayout.AddElement(clearSearchBtn);
searchBarLayout.AddElement(optionsButton);
folderBarLayout = contentLayout.AddLayoutX();
GUIContent homeIcon = new GUIContent(EditorBuiltin.GetLibraryWindowIcon(LibraryWindowIcon.Home),
new LocEdString("Home"));
GUIButton homeButton = new GUIButton(homeIcon, GUIOption.FixedWidth(FOLDER_BUTTON_WIDTH));
homeButton.OnClick += OnHomeClicked;
GUIContent upIcon = new GUIContent(EditorBuiltin.GetLibraryWindowIcon(LibraryWindowIcon.Up),
new LocEdString("Up"));
GUIButton upButton = new GUIButton(upIcon, GUIOption.FixedWidth(FOLDER_BUTTON_WIDTH));
upButton.OnClick += OnUpClicked;
folderBarLayout.AddElement(homeButton);
folderBarLayout.AddElement(upButton);
folderBarLayout.AddSpace(10);
contentScrollArea = new GUIScrollArea(GUIOption.FlexibleWidth(), GUIOption.FlexibleHeight());
contentLayout.AddElement(contentScrollArea);
contentLayout.AddFlexibleSpace();
entryContextMenu = LibraryMenu.CreateContextMenu(this);
content = new LibraryGUIContent(this, contentScrollArea);
Refresh();
dropTarget = new LibraryDropTarget(this);
dropTarget.Bounds = GetScrollAreaBounds();
dropTarget.OnStart += OnDragStart;
dropTarget.OnDrag += OnDragMove;
dropTarget.OnLeave += OnDragLeave;
dropTarget.OnDropResource += OnResourceDragDropped;
dropTarget.OnDropSceneObject += OnSceneObjectDragDropped;
dropTarget.OnEnd += OnDragEnd;
Selection.OnSelectionChanged += OnSelectionChanged;
Selection.OnResourcePing += OnPing;
}
/// <summary>
/// Constructs a new animation field entry and appends the necessary GUI elements to the provided layouts.
/// </summary>
/// <param name="layouts">Layouts to append the GUI elements to.</param>
/// <param name="path">Path of the curve field.</param>
/// <param name="childEntries">Sub-path names of the child entries to display.</param>
/// <param name="colors">Colors of the curves to display, for each child entry.</param>
public GUIAnimComplexEntry(GUIAnimFieldLayouts layouts, string path, string[] childEntries, Color[] colors)
: base(layouts, path, false, 20)
{
foldout = new GUIToggle("", EditorStyles.Expand);
foldout.OnToggled += Toggle;
GUILabel spacer = new GUILabel("", GUIOption.FixedHeight(GetEntryHeight()));
foldoutLayout = layouts.overlay.AddLayoutX();
foldoutLayout.AddSpace(5);
foldoutLayout.AddElement(foldout);
foldoutLayout.AddElement(spacer);
foldoutLayout.AddFlexibleSpace();
underlaySpacing = new GUILabel("", GUIOption.FixedHeight(GetEntryHeight()));
layouts.underlay.AddElement(underlaySpacing);
children = new GUIAnimSimpleEntry[childEntries.Length];
for (int i = 0; i < childEntries.Length; i++)
{
Color color;
if (i < colors.Length)
color = colors[i];
else
color = Color.White;
children[i] = new GUIAnimSimpleEntry(layouts, path + childEntries[i], color, true);
children[i].OnEntrySelected += x => { OnEntrySelected?.Invoke(x); };
}
Toggle(false);
}
/// <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>
/// Sets a resource whose GUI is to be displayed in the inspector. Clears any previous contents of the window.
/// </summary>
/// <param name="resourcePath">Resource path relative to the project of the resource to inspect.</param>
private void SetObjectToInspect(String resourcePath)
{
activeResource = ProjectLibrary.Load<Resource>(resourcePath);
if (activeResource == null)
return;
currentType = InspectorType.Resource;
inspectorScrollArea = new GUIScrollArea();
GUI.AddElement(inspectorScrollArea);
inspectorLayout = inspectorScrollArea.Layout;
GUIPanel titlePanel = inspectorLayout.AddPanel();
titlePanel.SetHeight(RESOURCE_TITLE_HEIGHT);
GUILayoutY titleLayout = titlePanel.AddLayoutY();
titleLayout.SetPosition(PADDING, PADDING);
string name = Path.GetFileNameWithoutExtension(resourcePath);
string type = activeResource.GetType().Name;
LocString title = new LocEdString(name + " (" + type + ")");
GUILabel titleLabel = new GUILabel(title);
titleLayout.AddFlexibleSpace();
GUILayoutX titleLabelLayout = titleLayout.AddLayoutX();
titleLabelLayout.AddElement(titleLabel);
titleLayout.AddFlexibleSpace();
GUIPanel titleBgPanel = titlePanel.AddPanel(1);
GUITexture titleBg = new GUITexture(null, EditorStyles.InspectorTitleBg);
titleBgPanel.AddElement(titleBg);
inspectorLayout.AddSpace(COMPONENT_SPACING);
inspectorResource = new InspectorResource();
inspectorResource.panel = inspectorLayout.AddPanel();
var persistentProperties = persistentData.GetProperties(activeResource.UUID);
inspectorResource.inspector = InspectorUtility.GetInspector(activeResource.GetType());
inspectorResource.inspector.Initialize(inspectorResource.panel, activeResource, persistentProperties);
inspectorLayout.AddFlexibleSpace();
}