public CameraPreview(Camera camera, GUIPanel previewsPanel)
{
Camera = camera;
previewPanel = previewsPanel.AddPanel();
// Render texture GUI
renderTexturePanel = previewPanel.AddPanel();
renderTextureGUI = new GUIRenderTexture(null);
renderTexturePanel.AddElement(renderTextureGUI);
// Control GUI
controlsPanel = previewPanel.AddPanel(-1);
GUILayoutX controlsLayout = controlsPanel.AddLayoutX();
controlsLayout.SetHeight(16);
cameraNameLabel = new GUILabel(string.Empty);
pinButton = new GUIButton(string.Empty);
pinButton.SetWidth(16);
pinButton.SetHeight(16);
pinButton.OnClick += () =>
{
IsPinned = !IsPinned;
UpdatePinButton();
};
controlsLayout.AddElement(cameraNameLabel);
controlsLayout.AddFlexibleSpace();
controlsLayout.AddElement(pinButton);
UpdatePinButton();
}
/// <summary>
/// Common code called by both Initialize() overloads.
/// </summary>
/// <param name="mainGui">Primary GUI panel to add the GUI elements to.</param>
/// <param name="previewGui">Secondary GUI panel located at the bottom of the inspector window, aimed primarily for
/// resource previews, but can be used for any purpose.</param>
/// <param name="persistent">A set of properties that the inspector can read/write. They will be persisted even
/// after the inspector is closed and restored when it is re-opened.</param>
private void InitializeBase(GUIPanel mainGui, GUIPanel previewGui, SerializableProperties persistent)
{
rootGUI = mainGui;
this.persistent = persistent;
GUILayout contentLayoutX = mainGui.AddLayoutX();
contentLayoutX.AddSpace(5);
GUILayout contentLayoutY = contentLayoutX.AddLayoutY();
contentLayoutY.AddSpace(5);
GUIPanel contentPanel = contentLayoutY.AddPanel();
contentLayoutY.AddSpace(5);
contentLayoutX.AddSpace(5);
GUIPanel backgroundPanel = mainGui.AddPanel(START_BACKGROUND_DEPTH);
GUITexture inspectorContentBg = new GUITexture(null, EditorStylesInternal.InspectorContentBg);
backgroundPanel.AddElement(inspectorContentBg);
mainPanel = contentPanel;
previewPanel = previewGui;
layout = GUI.AddLayoutY();
}
/// <inheritdoc/>
protected internal override void Initialize()
{
LoadResource();
PlainText plainText = InspectedObject as PlainText;
if (plainText == null)
{
return;
}
GUIPanel textPanel = Layout.AddPanel();
GUILayout textLayoutY = textPanel.AddLayoutY();
textLayoutY.AddSpace(5);
GUILayout textLayoutX = textLayoutY.AddLayoutX();
textLayoutX.AddSpace(5);
textLayoutX.AddElement(textLabel);
textLayoutX.AddSpace(5);
textLayoutY.AddSpace(5);
GUIPanel textBgPanel = textPanel.AddPanel(1);
textBgPanel.AddElement(textBg);
}
/// <summary>
/// Initializes the inspector. Must be called after construction.
/// </summary>
/// <param name="gui">GUI panel to add the GUI elements to.</param>
/// <param name="instance">Instance of the object whose fields to display GUI for.</param>
/// <param name="persistent">A set of properties that the inspector can read/write. They will be persisted even
/// after the inspector is closed and restored when it is re-opened.</param>
internal virtual void Initialize(GUIPanel gui, object instance, SerializableProperties persistent)
{
rootGUI = gui;
this.persistent = persistent;
GUILayout contentLayoutX = gui.AddLayoutX();
contentLayoutX.AddSpace(5);
GUILayout contentLayoutY = contentLayoutX.AddLayoutY();
contentLayoutY.AddSpace(5);
GUIPanel contentPanel = contentLayoutY.AddPanel();
contentLayoutY.AddSpace(5);
contentLayoutX.AddSpace(5);
GUIPanel backgroundPanel = gui.AddPanel(START_BACKGROUND_DEPTH);
GUITexture inspectorContentBg = new GUITexture(null, EditorStyles.InspectorContentBg);
backgroundPanel.AddElement(inspectorContentBg);
mainPanel = contentPanel;
layout = GUI.AddLayoutY();
inspectedObject = instance;
Initialize();
Refresh();
}
private void OnInitialize()
{
GUILayoutY mainLayout = GUI.AddLayoutY();
string[] aspectRatioTitles = new string[aspectRatios.Length + 1];
aspectRatioTitles[0] = "Free";
for (int i = 0; i < aspectRatios.Length; i++)
{
aspectRatioTitles[i + 1] = aspectRatios[i].width + ":" + aspectRatios[i].height;
}
GUIListBoxField aspectField = new GUIListBoxField(aspectRatioTitles, new LocEdString("Aspect ratio"));
aspectField.OnSelectionChanged += OnAspectRatioChanged;
GUILayoutY buttonLayoutVert = mainLayout.AddLayoutY();
GUILayoutX buttonLayout = buttonLayoutVert.AddLayoutX();
buttonLayout.AddElement(aspectField);
buttonLayout.AddFlexibleSpace();
buttonLayoutVert.AddFlexibleSpace();
renderTextureGUI = new GUIRenderTexture(null);
renderTextureBg = new GUITexture(Builtin.WhiteTexture);
renderTextureBg.SetTint(BG_COLOR);
noCameraLabel = new GUILabel(new LocEdString("(No main camera in scene)"));
GUIPanel rtPanel = mainLayout.AddPanel();
rtPanel.AddElement(renderTextureGUI);
GUIPanel bgPanel = rtPanel.AddPanel(1);
bgPanel.AddElement(renderTextureBg);
GUILayoutY alignLayoutY = rtPanel.AddLayoutY();
alignLayoutY.AddFlexibleSpace();
GUILayoutX alignLayoutX = alignLayoutY.AddLayoutX();
alignLayoutX.AddFlexibleSpace();
alignLayoutX.AddElement(noCameraLabel);
alignLayoutX.AddFlexibleSpace();
alignLayoutY.AddFlexibleSpace();
UpdateRenderTexture(Width, Height);
currentCamera = Scene.Camera;
bool hasMainCamera = currentCamera != null;
renderTextureGUI.Active = hasMainCamera;
noCameraLabel.Active = !hasMainCamera;
ToggleOnDemandDrawing(EditorApplication.IsOnDemandDrawingEnabled());
NotifyNeedsRedraw();
}
/// <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)
{
activeResourcePath = resourcePath;
if (!ProjectLibrary.Exists(resourcePath))
{
return;
}
ResourceMeta meta = ProjectLibrary.GetMeta(resourcePath);
Type resourceType = meta.Type;
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 = resourceType.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, EditorStylesInternal.InspectorTitleBg);
titleBgPanel.AddElement(titleBg);
inspectorLayout.AddSpace(COMPONENT_SPACING);
inspectorResource = new InspectorResource();
inspectorResource.panel = inspectorLayout.AddPanel();
var persistentProperties = persistentData.GetProperties(meta.UUID.ToString());
inspectorResource.inspector = InspectorUtility.GetInspector(resourceType);
inspectorResource.inspector.Initialize(inspectorResource.panel, activeResourcePath, persistentProperties);
inspectorLayout.AddFlexibleSpace();
}
/// <inheritdoc/>
public override void BuildGUI()
{
main = Layout.AddPanel(0, 1, 1, GUIOption.FixedHeight(ENTRY_HEIGHT));
overlay = main.AddPanel(-1, 0, 0, GUIOption.FixedHeight(ENTRY_HEIGHT));
underlay = main.AddPanel(1, 0, 0, GUIOption.FixedHeight(ENTRY_HEIGHT));
GUILayoutX mainLayout = main.AddLayoutX();
GUILayoutY overlayLayout = overlay.AddLayoutY();
GUILayoutY underlayLayout = underlay.AddLayoutY();
icon = new GUITexture(null, GUIOption.FixedWidth(32), GUIOption.FixedHeight(32));
messageLabel = new GUILabel(new LocEdString(""), EditorStyles.MultiLineLabel, GUIOption.FixedHeight(MESSAGE_HEIGHT));
functionLabel = new GUILabel(new LocEdString(""), GUIOption.FixedHeight(CALLER_LABEL_HEIGHT));
mainLayout.AddSpace(PADDING);
GUILayoutY iconLayout = mainLayout.AddLayoutY();
iconLayout.AddFlexibleSpace();
iconLayout.AddElement(icon);
iconLayout.AddFlexibleSpace();
mainLayout.AddSpace(PADDING);
GUILayoutY messageLayout = mainLayout.AddLayoutY();
messageLayout.AddSpace(PADDING);
messageLayout.AddElement(messageLabel);
messageLayout.AddElement(functionLabel);
messageLayout.AddSpace(PADDING);
mainLayout.AddFlexibleSpace();
mainLayout.AddSpace(PADDING);
background = new GUITexture(Builtin.WhiteTexture, GUIOption.FixedHeight(ENTRY_HEIGHT));
underlayLayout.AddElement(background);
GUIButton button = new GUIButton(new LocEdString(""), EditorStyles.Blank, GUIOption.FixedHeight(ENTRY_HEIGHT));
overlayLayout.AddElement(button);
button.OnClick += OnClicked;
button.OnDoubleClick += OnDoubleClicked;
}
/// <inheritdoc/>
protected internal override void Initialize()
{
LoadResource();
ScriptCode scriptCode = InspectedObject as ScriptCode;
if (scriptCode == null)
{
return;
}
importOptions = GetImportOptions();
isEditorField.OnChanged += x =>
{
importOptions.EditorScript = x;
};
GUIPanel textPanel = Layout.AddPanel();
GUILayout textLayoutY = textPanel.AddLayoutY();
textLayoutY.AddSpace(5);
GUILayout textLayoutX = textLayoutY.AddLayoutX();
textLayoutX.AddSpace(5);
textLayoutX.AddElement(textLabel);
textLayoutX.AddSpace(5);
textLayoutY.AddSpace(5);
GUIPanel textBgPanel = textPanel.AddPanel(1);
textBgPanel.AddElement(textBg);
Layout.AddElement(isEditorField);
GUIButton reimportButton = new GUIButton(new LocEdString("Reimport"));
reimportButton.OnClick += TriggerReimport;
GUILayout reimportButtonLayout = Layout.AddLayoutX();
reimportButtonLayout.AddElement(reimportButton);
reimportButtonLayout.AddFlexibleSpace();
}
/// <inheritdoc/>
protected internal override void Initialize()
{
LoadResource();
ScriptCode scriptCode = InspectedObject as ScriptCode;
if (scriptCode == null)
{
return;
}
importOptions = GetImportOptions();
isEditorField.OnChanged += x =>
{
importOptions.EditorScript = x;
};
GUIPanel textPanel = Layout.AddPanel();
GUILayout textLayoutY = textPanel.AddLayoutY();
textLayoutY.AddSpace(5);
GUILayout textLayoutX = textLayoutY.AddLayoutX();
textLayoutX.AddSpace(5);
textLayoutX.AddElement(textLabel);
textLayoutX.AddSpace(5);
textLayoutY.AddSpace(5);
GUIPanel textBgPanel = textPanel.AddPanel(1);
textBgPanel.AddElement(textBg);
Layout.AddElement(isEditorField);
Layout.AddSpace(10);
reimportButton = new GUIReimportButton(InspectedResourcePath, Layout, () =>
{
ProjectLibrary.Reimport(InspectedResourcePath, importOptions, true);
});
UpdateGUIValues();
}
/// <inheritdoc/>
protected internal override void Initialize(int index)
{
guiLayout = layout.AddLayoutY(index);
GUILayoutX guiTitleLayout = guiLayout.AddLayoutX();
GUIToggle guiFoldout = new GUIToggle(title, EditorStyles.Foldout);
guiFoldout.Value = isExpanded;
guiFoldout.AcceptsKeyFocus = false;
guiFoldout.OnToggled += OnFoldoutToggled;
guiTitleLayout.AddElement(guiFoldout);
GUILayoutX categoryContentLayout = guiLayout.AddLayoutX();
categoryContentLayout.AddSpace(IndentAmount);
guiContentPanel = categoryContentLayout.AddPanel();
GUILayoutX guiIndentLayoutX = guiContentPanel.AddLayoutX();
guiIndentLayoutX.AddSpace(IndentAmount);
GUILayoutY guiIndentLayoutY = guiIndentLayoutX.AddLayoutY();
guiIndentLayoutY.AddSpace(IndentAmount);
ChildLayout = guiIndentLayoutY.AddLayoutY();
guiIndentLayoutY.AddSpace(IndentAmount);
guiIndentLayoutX.AddSpace(IndentAmount);
categoryContentLayout.AddSpace(IndentAmount);
short backgroundDepth = (short)(Inspector.START_BACKGROUND_DEPTH - depth - 1);
string bgPanelStyle = depth % 2 == 0
? EditorStylesInternal.InspectorContentBgAlternate
: EditorStylesInternal.InspectorContentBg;
GUIPanel backgroundPanel = guiContentPanel.AddPanel(backgroundDepth);
GUITexture inspectorContentBg = new GUITexture(null, bgPanelStyle);
backgroundPanel.AddElement(inspectorContentBg);
guiContentPanel.Active = isExpanded;
}
/// <summary>
/// Creates a new GUI layout of the specified type, with a texture background.
/// </summary>
/// <typeparam name="T">Type of layout to create.</typeparam>
/// <param name="layout">Parent layout to add the layout to.</param>
/// <param name="background">Texture to display on the background.</param>
/// <param name="backgroundColor">Color to apply to the background texture.</param>
/// <param name="padding">Optional padding to apply between element borders and content.</param>
/// <returns>New GUI layout with background object.</returns>
public static GUILayoutWithBackground Create <T>(GUILayout layout, SpriteTexture background, Color backgroundColor,
RectOffset padding = new RectOffset()) where T : GUILayout, new()
{
GUIPanel mainPanel = layout.AddPanel();
GUILayoutX mainLayout = mainPanel.AddLayoutX();
GUILayout contentLayout;
if (padding.top > 0 || padding.bottom > 0)
{
GUILayoutY paddingVertLayout = mainLayout.AddLayoutY();
if (padding.top > 0)
{
paddingVertLayout.AddSpace(padding.top);
}
if (padding.left > 0 || padding.right > 0)
{
GUILayoutX paddingHorzLayout = paddingVertLayout.AddLayoutX();
if (padding.left > 0)
{
paddingHorzLayout.AddSpace(padding.left);
}
contentLayout = new T();
paddingHorzLayout.AddElement(contentLayout);
if (padding.right > 0)
{
paddingHorzLayout.AddSpace(padding.right);
}
}
else
{
contentLayout = new T();
paddingVertLayout.AddElement(contentLayout);
}
if (padding.bottom > 0)
{
paddingVertLayout.AddSpace(padding.bottom);
}
}
else
{
if (padding.left > 0 || padding.right > 0)
{
GUILayoutX paddingHorzLayout = mainLayout.AddLayoutX();
if (padding.left > 0)
{
paddingHorzLayout.AddSpace(padding.left);
}
contentLayout = new T();
paddingHorzLayout.AddElement(contentLayout);
if (padding.right > 0)
{
paddingHorzLayout.AddSpace(padding.right);
}
}
else
{
contentLayout = new T();
mainLayout.AddElement(contentLayout);
}
}
GUIPanel bgPanel = mainPanel.AddPanel(1);
GUITexture bgTexture = new GUITexture(Builtin.WhiteTexture);
bgTexture.SetTint(backgroundColor);
bgPanel.AddElement(bgTexture);
return(new GUILayoutWithBackground(mainPanel, contentLayout));
}
/// <summary>
/// Rebuilds the GUI object header if needed.
/// </summary>
/// <param name="layoutIndex">Index at which to insert the GUI elements.</param>
protected void BuildGUI(int layoutIndex)
{
Action BuildEmptyGUI = () =>
{
guiInternalTitleLayout = guiTitleLayout.InsertLayoutX(0);
guiInternalTitleLayout.AddElement(new GUILabel(title));
guiInternalTitleLayout.AddElement(new GUILabel("Empty", GUIOption.FixedWidth(100)));
if (!property.IsValueType)
{
GUIContent createIcon = new GUIContent(EditorBuiltin.GetInspectorWindowIcon(InspectorWindowIcon.Create),
new LocEdString("Create"));
guiCreateBtn = new GUIButton(createIcon, GUIOption.FixedWidth(30));
guiCreateBtn.OnClick += OnCreateButtonClicked;
guiInternalTitleLayout.AddElement(guiCreateBtn);
}
};
Action BuildFilledGUI = () =>
{
guiInternalTitleLayout = guiTitleLayout.InsertLayoutX(0);
GUIToggle guiFoldout = new GUIToggle(title, EditorStyles.Foldout);
guiFoldout.Value = isExpanded;
guiFoldout.AcceptsKeyFocus = false;
guiFoldout.OnToggled += OnFoldoutToggled;
guiInternalTitleLayout.AddElement(guiFoldout);
if (!style.StyleFlags.HasFlag(InspectableFieldStyleFlags.NotNull))
{
GUIContent clearIcon = new GUIContent(EditorBuiltin.GetInspectorWindowIcon(InspectorWindowIcon.Clear),
new LocEdString("Clear"));
GUIButton clearBtn = new GUIButton(clearIcon, GUIOption.FixedWidth(20));
clearBtn.OnClick += OnClearButtonClicked;
guiInternalTitleLayout.AddElement(clearBtn);
}
if (isExpanded)
{
SerializableObject serializableObject = property.GetObject();
SerializableField[] fields = serializableObject.Fields;
if (fields.Length > 0)
{
guiChildLayout = guiLayout.AddLayoutX();
guiChildLayout.AddSpace(IndentAmount);
GUIPanel guiContentPanel = guiChildLayout.AddPanel();
GUILayoutX guiIndentLayoutX = guiContentPanel.AddLayoutX();
guiIndentLayoutX.AddSpace(IndentAmount);
GUILayoutY guiIndentLayoutY = guiIndentLayoutX.AddLayoutY();
guiIndentLayoutY.AddSpace(IndentAmount);
GUILayoutY guiContentLayout = guiIndentLayoutY.AddLayoutY();
guiIndentLayoutY.AddSpace(IndentAmount);
guiIndentLayoutX.AddSpace(IndentAmount);
guiChildLayout.AddSpace(IndentAmount);
short backgroundDepth = (short)(Inspector.START_BACKGROUND_DEPTH - depth - 1);
string bgPanelStyle = depth % 2 == 0
? EditorStylesInternal.InspectorContentBgAlternate
: EditorStylesInternal.InspectorContentBg;
GUIPanel backgroundPanel = guiContentPanel.AddPanel(backgroundDepth);
GUITexture inspectorContentBg = new GUITexture(null, bgPanelStyle);
backgroundPanel.AddElement(inspectorContentBg);
int currentIndex = 0;
foreach (var field in fields)
{
if (!field.Flags.HasFlag(SerializableFieldAttributes.Inspectable))
{
continue;
}
string childPath = path + "/" + field.Name;
InspectableField inspectable = CreateInspectable(parent, field.Name, childPath,
currentIndex, depth + 1, new InspectableFieldLayout(guiContentLayout), field.GetProperty(), InspectableFieldStyle.Create(field));
children.Add(inspectable);
currentIndex += inspectable.GetNumLayoutElements();
}
}
}
else
{
guiChildLayout = null;
}
};
if (state == State.None)
{
if (propertyValue != null)
{
BuildFilledGUI();
state = State.Filled;
}
else
{
BuildEmptyGUI();
state = State.Empty;
}
}
else if (state == State.Empty)
{
if (propertyValue != null)
{
guiInternalTitleLayout.Destroy();
guiCreateBtn = null;
BuildFilledGUI();
state = State.Filled;
}
}
else if (state == State.Filled)
{
foreach (var child in children)
{
child.Destroy();
}
children.Clear();
guiInternalTitleLayout.Destroy();
guiCreateBtn = null;
if (guiChildLayout != null)
{
guiChildLayout.Destroy();
guiChildLayout = null;
}
if (propertyValue == null)
{
BuildEmptyGUI();
state = State.Empty;
}
else
{
BuildFilledGUI();
}
}
}
/// <summary>
/// Creates inspectable fields all the fields/properties of the specified object.
/// </summary>
/// <param name="obj">Object whose fields the GUI will be drawn for.</param>
/// <param name="parent">Parent Inspector to draw in.</param>
/// <param name="path">Full path to the field this provided object was retrieved from.</param>
/// <param name="depth">
/// Determines how deep within the inspector nesting hierarchy is this objects. Some fields may contain other
/// fields, in which case you should increase this value by one.
/// </param>
/// <param name="layout">Parent layout that all the field GUI elements will be added to.</param>
/// <param name="overrideCallback">
/// Optional callback that allows you to override the look of individual fields in the object. If non-null the
/// callback will be called with information about every field in the provided object. If the callback returns
/// non-null that inspectable field will be used for drawing the GUI, otherwise the default inspector field type
/// will be used.
/// </param>
public static List <InspectableField> CreateFields(SerializableObject obj, Inspector parent, string path,
int depth, GUILayoutY layout, FieldOverrideCallback overrideCallback = null)
{
// Retrieve fields and sort by order
SerializableField[] fields = obj.Fields;
Array.Sort(fields,
(x, y) =>
{
int orderX = x.Flags.HasFlag(SerializableFieldAttributes.Order) ? x.Style.Order : 0;
int orderY = y.Flags.HasFlag(SerializableFieldAttributes.Order) ? y.Style.Order : 0;
return(orderX.CompareTo(orderY));
});
// Generate per-field GUI while grouping by category
Dictionary <string, Tuple <int, GUILayoutY> > categories = new Dictionary <string, Tuple <int, GUILayoutY> >();
int rootIndex = 0;
List <InspectableField> inspectableFields = new List <InspectableField>();
foreach (var field in fields)
{
if (!field.Flags.HasFlag(SerializableFieldAttributes.Inspectable))
{
continue;
}
string category = null;
if (field.Flags.HasFlag(SerializableFieldAttributes.Category))
{
category = field.Style.CategoryName;
}
Tuple <int, GUILayoutY> categoryInfo = null;
if (!string.IsNullOrEmpty(category))
{
if (!categories.TryGetValue(category, out categoryInfo))
{
InspectableFieldLayout fieldLayout = new InspectableFieldLayout(layout);
GUILayoutY categoryRootLayout = fieldLayout.AddLayoutY(rootIndex);
GUILayoutX guiTitleLayout = categoryRootLayout.AddLayoutX();
bool isExpanded = parent.Persistent.GetBool(path + "/[" + category + "]_Expanded");
GUIToggle guiFoldout = new GUIToggle(category, EditorStyles.Foldout);
guiFoldout.Value = isExpanded;
guiFoldout.AcceptsKeyFocus = false;
guiFoldout.OnToggled += x =>
{
parent.Persistent.SetBool(path + "/[" + category + "]_Expanded", x);
};
guiTitleLayout.AddElement(guiFoldout);
GUILayoutX categoryContentLayout = categoryRootLayout.AddLayoutX();
categoryContentLayout.AddSpace(IndentAmount);
GUIPanel guiContentPanel = categoryContentLayout.AddPanel();
GUILayoutX guiIndentLayoutX = guiContentPanel.AddLayoutX();
guiIndentLayoutX.AddSpace(IndentAmount);
GUILayoutY guiIndentLayoutY = guiIndentLayoutX.AddLayoutY();
guiIndentLayoutY.AddSpace(IndentAmount);
GUILayoutY categoryLayout = guiIndentLayoutY.AddLayoutY();
guiIndentLayoutY.AddSpace(IndentAmount);
guiIndentLayoutX.AddSpace(IndentAmount);
categoryContentLayout.AddSpace(IndentAmount);
short backgroundDepth = (short)(Inspector.START_BACKGROUND_DEPTH - depth - 1);
string bgPanelStyle = depth % 2 == 0
? EditorStylesInternal.InspectorContentBgAlternate
: EditorStylesInternal.InspectorContentBg;
GUIPanel backgroundPanel = guiContentPanel.AddPanel(backgroundDepth);
GUITexture inspectorContentBg = new GUITexture(null, bgPanelStyle);
backgroundPanel.AddElement(inspectorContentBg);
categories[category] = new Tuple <int, GUILayoutY>(0, categoryLayout);
rootIndex++;
}
}
int currentIndex;
GUILayoutY parentLayout;
if (categoryInfo != null)
{
currentIndex = categoryInfo.Item1;
parentLayout = categoryInfo.Item2;
}
else
{
currentIndex = rootIndex;
parentLayout = layout;
}
string fieldName = field.Name;
string childPath = string.IsNullOrEmpty(path) ? fieldName : path + "/" + fieldName;
InspectableField inspectableField = null;
if (overrideCallback != null)
{
inspectableField = overrideCallback(field, parent, path, new InspectableFieldLayout(parentLayout),
currentIndex, depth);
}
if (inspectableField == null)
{
inspectableField = CreateField(parent, fieldName, childPath,
currentIndex, depth, new InspectableFieldLayout(parentLayout), field.GetProperty(),
InspectableFieldStyle.Create(field));
}
inspectableFields.Add(inspectableField);
currentIndex += inspectableField.GetNumLayoutElements();
if (categoryInfo != null)
{
categories[category] = new Tuple <int, GUILayoutY>(currentIndex, parentLayout);
}
else
{
rootIndex = currentIndex;
}
}
return(inspectableFields);
}
private void OnInitialize()
{
Title = "Project Manager";
Width = 500;
Height = 290;
GUILayout vertLayout = GUI.AddLayoutY();
vertLayout.AddSpace(5);
GUILayout firstRow = vertLayout.AddLayoutX();
vertLayout.AddFlexibleSpace();
GUILayout secondRow = vertLayout.AddLayoutX();
vertLayout.AddSpace(5);
GUILayout thirdRow = vertLayout.AddLayoutX();
vertLayout.AddFlexibleSpace();
GUILayout fourthRow = vertLayout.AddLayoutX();
vertLayout.AddSpace(5);
projectInputBox = new GUITextField(new LocEdString("Project path"), 70, false, "", GUIOption.FixedWidth(398));
projectInputBox.Value = EditorSettings.LastOpenProject;
GUIButton openBtn = new GUIButton(new LocEdString("Open"), GUIOption.FixedWidth(75));
openBtn.OnClick += OpenProject;
firstRow.AddSpace(5);
firstRow.AddElement(projectInputBox);
firstRow.AddSpace(15);
firstRow.AddElement(openBtn);
firstRow.AddSpace(5);
GUILabel recentProjectsLabel = new GUILabel(new LocEdString("Recent projects:"));
secondRow.AddSpace(5);
secondRow.AddElement(recentProjectsLabel);
secondRow.AddFlexibleSpace();
GUIButton browseBtn = new GUIButton(new LocEdString("Browse"), GUIOption.FixedWidth(75));
browseBtn.OnClick += BrowseClicked;
secondRow.AddElement(browseBtn);
secondRow.AddSpace(5);
thirdRow.AddSpace(5);
GUIPanel recentProjectsPanel = thirdRow.AddPanel();
thirdRow.AddSpace(15);
GUILayoutY thirdRowVertical = thirdRow.AddLayoutY();
GUIButton createBtn = new GUIButton(new LocEdString("Create new"), GUIOption.FixedWidth(75));
createBtn.OnClick += CreateClicked;
thirdRowVertical.AddElement(createBtn);
thirdRowVertical.AddFlexibleSpace();
thirdRow.AddSpace(5);
recentProjectsArea = new GUIScrollArea(GUIOption.FixedWidth(385), GUIOption.FixedHeight(170));
GUILayoutX recentProjectsLayout = recentProjectsPanel.AddLayoutX();
recentProjectsLayout.AddSpace(10);
GUILayoutY recentProjectsPanelY = recentProjectsLayout.AddLayoutY();
recentProjectsPanelY.AddSpace(5);
recentProjectsPanelY.AddElement(recentProjectsArea);
recentProjectsPanelY.AddSpace(5);
recentProjectsLayout.AddFlexibleSpace();
GUIPanel scrollAreaBgPanel = recentProjectsPanel.AddPanel(1);
GUITexture scrollAreaBgTex = new GUITexture(null, true, EditorStylesInternal.ScrollAreaBg);
scrollAreaBgPanel.AddElement(scrollAreaBgTex);
autoLoadToggle = new GUIToggle("");
autoLoadToggle.Value = EditorSettings.AutoLoadLastProject;
GUILabel autoLoadLabel = new GUILabel(new LocEdString("Automatically load last open project"));
GUIButton cancelBtn = new GUIButton(new LocEdString("Cancel"), GUIOption.FixedWidth(75));
cancelBtn.OnClick += CancelClicked;
fourthRow.AddSpace(5);
fourthRow.AddElement(autoLoadToggle);
fourthRow.AddElement(autoLoadLabel);
fourthRow.AddFlexibleSpace();
fourthRow.AddElement(cancelBtn);
fourthRow.AddSpace(5);
RefreshRecentProjects();
}
/// <summary>
/// Builds GUI for the specified GUI element style.
/// </summary>
/// <param name="layout">Layout to append the GUI elements to.</param>
/// <param name="depth">Determines the depth at which the element is rendered.</param>
public void BuildGUI(GUILayout layout, int depth)
{
short backgroundDepth = (short)(Inspector.START_BACKGROUND_DEPTH - depth - 1);
string bgPanelStyle = depth % 2 == 0
? EditorStylesInternal.InspectorContentBgAlternate
: EditorStylesInternal.InspectorContentBg;
GUIToggle foldout = new GUIToggle(new LocEdString("Style"), EditorStyles.Foldout);
foldout.AcceptsKeyFocus = false;
GUITexture inspectorContentBg = new GUITexture(null, bgPanelStyle);
layout.AddElement(foldout);
GUIPanel panel = layout.AddPanel();
GUIPanel backgroundPanel = panel.AddPanel(backgroundDepth);
backgroundPanel.AddElement(inspectorContentBg);
GUILayoutX guiIndentLayoutX = panel.AddLayoutX();
guiIndentLayoutX.AddSpace(IndentAmount);
GUILayoutY guiIndentLayoutY = guiIndentLayoutX.AddLayoutY();
guiIndentLayoutY.AddSpace(IndentAmount);
GUILayoutY contentLayout = guiIndentLayoutY.AddLayoutY();
guiIndentLayoutY.AddSpace(IndentAmount);
guiIndentLayoutX.AddSpace(IndentAmount);
fontField = new GUIResourceField(typeof(Font), new LocEdString("Font"));
fontSizeField = new GUIIntField(new LocEdString("Font size"));
horzAlignField = new GUIEnumField(typeof(TextHorzAlign), new LocEdString("Horizontal alignment"));
vertAlignField = new GUIEnumField(typeof(TextVertAlign), new LocEdString("Vertical alignment"));
imagePositionField = new GUIEnumField(typeof(GUIImagePosition), new LocEdString("Image position"));
wordWrapField = new GUIToggleField(new LocEdString("Word wrap"));
contentLayout.AddElement(fontField);
contentLayout.AddElement(fontSizeField);
contentLayout.AddElement(horzAlignField);
contentLayout.AddElement(vertAlignField);
contentLayout.AddElement(imagePositionField);
contentLayout.AddElement(wordWrapField);
normalGUI.BuildGUI(new LocEdString("Normal"), contentLayout);
hoverGUI.BuildGUI(new LocEdString("Hover"), contentLayout);
activeGUI.BuildGUI(new LocEdString("Active"), contentLayout);
focusedGUI.BuildGUI(new LocEdString("Focused"), contentLayout);
normalOnGUI.BuildGUI(new LocEdString("NormalOn"), contentLayout);
hoverOnGUI.BuildGUI(new LocEdString("HoverOn"), contentLayout);
activeOnGUI.BuildGUI(new LocEdString("ActiveOn"), contentLayout);
focusedOnGUI.BuildGUI(new LocEdString("FocusedOn"), contentLayout);
borderGUI = new RectOffsetGUI(new LocEdString("Border"), contentLayout);
marginsGUI = new RectOffsetGUI(new LocEdString("Margins"), contentLayout);
contentOffsetGUI = new RectOffsetGUI(new LocEdString("Content offset"), contentLayout);
fixedWidthField = new GUIToggleField(new LocEdString("Fixed width"));
widthField = new GUIIntField(new LocEdString("Width"));
minWidthField = new GUIIntField(new LocEdString("Min. width"));
maxWidthField = new GUIIntField(new LocEdString("Max. width"));
fixedHeightField = new GUIToggleField(new LocEdString("Fixed height"));
heightField = new GUIIntField(new LocEdString("Height"));
minHeightField = new GUIIntField(new LocEdString("Min. height"));
maxHeightField = new GUIIntField(new LocEdString("Max. height"));
contentLayout.AddElement(fixedWidthField);
contentLayout.AddElement(widthField);
contentLayout.AddElement(minWidthField);
contentLayout.AddElement(maxWidthField);
contentLayout.AddElement(fixedHeightField);
contentLayout.AddElement(heightField);
contentLayout.AddElement(minHeightField);
contentLayout.AddElement(maxHeightField);
foldout.OnToggled += x =>
{
panel.Active = x;
isExpanded = x;
};
fontField.OnChanged += x =>
{
Font font = Resources.Load <Font>(x.UUID);
GetStyle().Font = font;
MarkAsModified();
ConfirmModify();
};
fontSizeField.OnChanged += x => { GetStyle().FontSize = x; MarkAsModified(); };
fontSizeField.OnFocusLost += ConfirmModify;
fontSizeField.OnConfirmed += ConfirmModify;
horzAlignField.OnSelectionChanged += x =>
{
GetStyle().TextHorzAlign = (TextHorzAlign)x;
MarkAsModified();
ConfirmModify();
};
vertAlignField.OnSelectionChanged += x =>
{
GetStyle().TextVertAlign = (TextVertAlign)x;
MarkAsModified();
ConfirmModify();
};
imagePositionField.OnSelectionChanged += x =>
{
GetStyle().ImagePosition = (GUIImagePosition)x;
MarkAsModified();
ConfirmModify();
};
wordWrapField.OnChanged += x => { GetStyle().WordWrap = x; MarkAsModified(); ConfirmModify(); };
normalGUI.OnChanged += x => { GetStyle().Normal = x; MarkAsModified(); ConfirmModify(); };
hoverGUI.OnChanged += x => { GetStyle().Hover = x; MarkAsModified(); ConfirmModify(); };
activeGUI.OnChanged += x => { GetStyle().Active = x; MarkAsModified(); ConfirmModify(); };
focusedGUI.OnChanged += x => { GetStyle().Focused = x; MarkAsModified(); ConfirmModify(); };
normalOnGUI.OnChanged += x => { GetStyle().NormalOn = x; MarkAsModified(); ConfirmModify(); };
hoverOnGUI.OnChanged += x => { GetStyle().HoverOn = x; MarkAsModified(); ConfirmModify(); };
activeOnGUI.OnChanged += x => { GetStyle().ActiveOn = x; MarkAsModified(); ConfirmModify(); };
focusedOnGUI.OnChanged += x => { GetStyle().FocusedOn = x; MarkAsModified(); ConfirmModify(); };
borderGUI.OnChanged += x => { GetStyle().Border = x; MarkAsModified(); };
marginsGUI.OnChanged += x => { GetStyle().Margins = x; MarkAsModified(); };
contentOffsetGUI.OnChanged += x => { GetStyle().ContentOffset = x; MarkAsModified(); };
borderGUI.OnConfirmed += ConfirmModify;
marginsGUI.OnConfirmed += ConfirmModify;
contentOffsetGUI.OnConfirmed += ConfirmModify;
fixedWidthField.OnChanged += x => { GetStyle().FixedWidth = x; MarkAsModified(); ConfirmModify(); };
widthField.OnChanged += x => GetStyle().Width = x;
widthField.OnFocusLost += ConfirmModify;
widthField.OnConfirmed += ConfirmModify;
minWidthField.OnChanged += x => GetStyle().MinWidth = x;
minWidthField.OnFocusLost += ConfirmModify;
minWidthField.OnConfirmed += ConfirmModify;
maxWidthField.OnChanged += x => GetStyle().MaxWidth = x;
maxWidthField.OnFocusLost += ConfirmModify;
maxWidthField.OnConfirmed += ConfirmModify;
fixedHeightField.OnChanged += x => { GetStyle().FixedHeight = x; MarkAsModified(); ConfirmModify(); };
heightField.OnChanged += x => GetStyle().Height = x;
heightField.OnFocusLost += ConfirmModify;
heightField.OnConfirmed += ConfirmModify;
minHeightField.OnChanged += x => GetStyle().MinHeight = x;
minHeightField.OnFocusLost += ConfirmModify;
minHeightField.OnConfirmed += ConfirmModify;
maxHeightField.OnChanged += x => GetStyle().MaxHeight = x;
maxHeightField.OnFocusLost += ConfirmModify;
maxHeightField.OnConfirmed += ConfirmModify;
foldout.Value = isExpanded;
panel.Active = isExpanded;
}
private void OnInitialize()
{
mainLayout = GUI.AddLayoutY();
GUIContent viewIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.View),
new LocEdString("View"));
GUIContent moveIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.Move),
new LocEdString("Move"));
GUIContent rotateIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.Rotate),
new LocEdString("Rotate"));
GUIContent scaleIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.Scale),
new LocEdString("Scale"));
GUIContent localIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.Local),
new LocEdString("Local"));
GUIContent worldIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.World),
new LocEdString("World"));
GUIContent pivotIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.Pivot),
new LocEdString("Pivot"));
GUIContent centerIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.Center),
new LocEdString("Center"));
GUIContent moveSnapIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.MoveSnap),
new LocEdString("Move snap"));
GUIContent rotateSnapIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.RotateSnap),
new LocEdString("Rotate snap"));
GUIToggleGroup handlesTG = new GUIToggleGroup();
viewButton = new GUIToggle(viewIcon, handlesTG, EditorStyles.Button, GUIOption.FlexibleWidth(35));
moveButton = new GUIToggle(moveIcon, handlesTG, EditorStyles.Button, GUIOption.FlexibleWidth(35));
rotateButton = new GUIToggle(rotateIcon, handlesTG, EditorStyles.Button, GUIOption.FlexibleWidth(35));
scaleButton = new GUIToggle(scaleIcon, handlesTG, EditorStyles.Button, GUIOption.FlexibleWidth(35));
GUIToggleGroup coordModeTG = new GUIToggleGroup();
localCoordButton = new GUIToggle(localIcon, coordModeTG, EditorStyles.Button, GUIOption.FlexibleWidth(75));
worldCoordButton = new GUIToggle(worldIcon, coordModeTG, EditorStyles.Button, GUIOption.FlexibleWidth(75));
GUIToggleGroup pivotModeTG = new GUIToggleGroup();
pivotButton = new GUIToggle(pivotIcon, pivotModeTG, EditorStyles.Button, GUIOption.FlexibleWidth(35));
centerButton = new GUIToggle(centerIcon, pivotModeTG, EditorStyles.Button, GUIOption.FlexibleWidth(35));
moveSnapButton = new GUIToggle(moveSnapIcon, EditorStyles.Button, GUIOption.FlexibleWidth(35));
moveSnapInput = new GUIFloatField("", GUIOption.FlexibleWidth(35));
rotateSnapButton = new GUIToggle(rotateSnapIcon, EditorStyles.Button, GUIOption.FlexibleWidth(35));
rotateSnapInput = new GUIFloatField("", GUIOption.FlexibleWidth(35));
GUIContent cameraOptionsIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.SceneCameraOptions), new LocEdString("Camera options"));
cameraOptionsButton = new GUIButton(cameraOptionsIcon);
viewButton.OnClick += () => OnSceneToolButtonClicked(SceneViewTool.View);
moveButton.OnClick += () => OnSceneToolButtonClicked(SceneViewTool.Move);
rotateButton.OnClick += () => OnSceneToolButtonClicked(SceneViewTool.Rotate);
scaleButton.OnClick += () => OnSceneToolButtonClicked(SceneViewTool.Scale);
localCoordButton.OnClick += () => OnCoordinateModeButtonClicked(HandleCoordinateMode.Local);
worldCoordButton.OnClick += () => OnCoordinateModeButtonClicked(HandleCoordinateMode.World);
pivotButton.OnClick += () => OnPivotModeButtonClicked(HandlePivotMode.Pivot);
centerButton.OnClick += () => OnPivotModeButtonClicked(HandlePivotMode.Center);
moveSnapButton.OnToggled += (bool active) => OnMoveSnapToggled(active);
moveSnapInput.OnChanged += (float value) => OnMoveSnapValueChanged(value);
rotateSnapButton.OnToggled += (bool active) => OnRotateSnapToggled(active);
rotateSnapInput.OnChanged += (float value) => OnRotateSnapValueChanged(value);
cameraOptionsButton.OnClick += () => OnCameraOptionsClicked();
GUILayout handlesLayout = mainLayout.AddLayoutX();
handlesLayout.AddElement(viewButton);
handlesLayout.AddElement(moveButton);
handlesLayout.AddElement(rotateButton);
handlesLayout.AddElement(scaleButton);
handlesLayout.AddSpace(10);
handlesLayout.AddElement(localCoordButton);
handlesLayout.AddElement(worldCoordButton);
handlesLayout.AddSpace(10);
handlesLayout.AddElement(pivotButton);
handlesLayout.AddElement(centerButton);
handlesLayout.AddFlexibleSpace();
handlesLayout.AddElement(moveSnapButton);
handlesLayout.AddElement(moveSnapInput);
handlesLayout.AddSpace(10);
handlesLayout.AddElement(rotateSnapButton);
handlesLayout.AddElement(rotateSnapInput);
handlesLayout.AddSpace(10);
handlesLayout.AddElement(cameraOptionsButton);
handlesLayout.SetHeight(viewButton.Bounds.height);
GUIPanel mainPanel = mainLayout.AddPanel();
rtPanel = mainPanel.AddPanel();
// Loading progress
loadLabel = new GUILabel(new LocEdString("Loading scene..."));
loadProgressBar = new GUIProgressBar("", GUIOption.FixedWidth(200));
progressLayout = mainPanel.AddLayoutY();
progressLayout.AddFlexibleSpace();
GUILayout loadLabelLayout = progressLayout.AddLayoutX();
loadLabelLayout.AddFlexibleSpace();
loadLabelLayout.AddElement(loadLabel);
loadLabelLayout.AddFlexibleSpace();
GUILayout progressBarLayout = progressLayout.AddLayoutX();
progressBarLayout.AddFlexibleSpace();
progressBarLayout.AddElement(loadProgressBar);
progressBarLayout.AddFlexibleSpace();
progressLayout.AddFlexibleSpace();
progressLayout.Active = false;
selectionPanel = mainPanel.AddPanel(-1);
sceneAxesPanel = mainPanel.AddPanel(-1);
sceneAxesGUI = new SceneAxesGUI(this, sceneAxesPanel, HandleAxesGUISize, HandleAxesGUISize, ProjectionType.Perspective);
focusCatcher = new GUIButton("", EditorStyles.Blank);
focusCatcher.OnFocusGained += () => hasContentFocus = true;
focusCatcher.OnFocusLost += () => hasContentFocus = false;
GUIPanel focusPanel = GUI.AddPanel(-2);
focusPanel.AddElement(focusCatcher);
viewToolKey = new VirtualButton(ViewToolBinding);
moveToolKey = new VirtualButton(MoveToolBinding);
rotateToolKey = new VirtualButton(RotateToolBinding);
scaleToolKey = new VirtualButton(ScaleToolBinding);
frameKey = new VirtualButton(FrameBinding);
UpdateRenderTexture(Width, Height - HeaderHeight);
UpdateLoadingProgress();
}
private void OnInitialize()
{
GUILayoutX splitLayout = GUI.AddLayoutX();
GUIPanel platformPanel = splitLayout.AddPanel();
GUIPanel platformForeground = platformPanel.AddPanel();
GUILayoutY platformLayout = platformForeground.AddLayoutY();
GUIPanel platformBackground = platformPanel.AddPanel(1);
GUITexture background = new GUITexture(Builtin.WhiteTexture);
background.SetTint(PLATFORM_BG_COLOR);
splitLayout.AddSpace(5);
GUILayoutY optionsLayout = splitLayout.AddLayoutY();
GUILabel platformsLabel = new GUILabel(new LocEdString("Platforms"), EditorStyles.LabelCentered);
platformLayout.AddSpace(5);
platformLayout.AddElement(platformsLabel);
platformLayout.AddSpace(5);
GUIToggleGroup platformToggleGroup = new GUIToggleGroup();
PlatformType[] availablePlatforms = BuildManager.AvailablePlatforms;
platformButtons = new GUIToggle[availablePlatforms.Length];
for (int i = 0; i < availablePlatforms.Length; i++)
{
PlatformType currentPlatform = availablePlatforms[i];
bool isActive = currentPlatform == BuildManager.ActivePlatform;
string platformName = Enum.GetName(typeof(PlatformType), currentPlatform);
if (isActive)
{
platformName += " (Active)";
}
GUIToggle platformToggle = new GUIToggle(new LocEdString(platformName), platformToggleGroup, EditorStyles.Button);
platformToggle.OnToggled += x => OnSelectedPlatformChanged(currentPlatform, x);
platformLayout.AddElement(platformToggle);
platformButtons[i] = platformToggle;
if (isActive)
{
platformToggle.Value = true;
selectedPlatform = currentPlatform;
}
}
platformLayout.AddFlexibleSpace();
GUIButton changePlatformBtn = new GUIButton(new LocEdString("Set active"));
platformLayout.AddElement(changePlatformBtn);
changePlatformBtn.OnClick += ChangeActivePlatform;
platformBackground.AddElement(background);
optionsScrollArea = new GUIScrollArea();
optionsLayout.AddElement(optionsScrollArea);
GUIButton buildButton = new GUIButton(new LocEdString("Build"));
optionsLayout.AddFlexibleSpace();
optionsLayout.AddElement(buildButton);
buildButton.OnClick += TryStartBuild;
BuildPlatformOptionsGUI();
}
/// <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));
}
}
}
}
int minHorzElemSpacing = 0;
if (viewType == ProjectViewType.List16)
{
tileSize = 16;
gridLayout = false;
elementsPerRow = 1;
minHorzElemSpacing = 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, 0,
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;
minHorzElemSpacing = 10;
vertElemSpacing = 12;
break;
case ProjectViewType.Grid48:
tileSize = 48;
elemWidth = tileSize;
elemHeight = tileSize + 36;
minHorzElemSpacing = 8;
vertElemSpacing = 10;
break;
case ProjectViewType.Grid32:
tileSize = 32;
elemWidth = tileSize + 16;
elemHeight = tileSize + 48;
minHorzElemSpacing = 6;
vertElemSpacing = 10;
break;
}
gridLayout = true;
int availableWidth = bounds.width;
elementsPerRow = MathEx.FloorToInt((availableWidth - minHorzElemSpacing) / (float)(elemWidth + minHorzElemSpacing));
int numRows = MathEx.CeilToInt(resourcesToDisplay.Count / (float)Math.Max(elementsPerRow, 1));
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 - minHorzElemSpacing) / (float)(elemWidth + minHorzElemSpacing));
}
int extraRowSpace = availableWidth - minHorzElemSpacing * 2 - elementsPerRow * elemWidth;
paddingLeft = minHorzElemSpacing;
paddingRight = minHorzElemSpacing;
float horzSpacing = 0.0f;
// Distribute the spacing to the padding, as there are not in-between spaces to apply it to
if (extraRowSpace > 0 && elementsPerRow < 2)
{
int extraPadding = extraRowSpace / 2;
paddingLeft += extraPadding;
paddingRight += (extraRowSpace - extraPadding);
extraRowSpace = 0;
}
else
{
horzSpacing = extraRowSpace / (float)(elementsPerRow - 1);
}
elementsPerRow = Math.Max(elementsPerRow, 1);
main.AddSpace(TOP_MARGIN);
GUILayoutX rowLayout = main.AddLayoutX();
rowLayout.AddSpace(paddingLeft);
float spacingCounter = 0.0f;
int elemsInRow = 0;
for (int i = 0; i < resourcesToDisplay.Count; i++)
{
if (elemsInRow == elementsPerRow && elemsInRow > 0)
{
main.AddSpace(vertElemSpacing);
rowLayout = main.AddLayoutX();
rowLayout.AddSpace(paddingLeft);
elemsInRow = 0;
spacingCounter = 0.0f;
}
ResourceToDisplay entry = resourcesToDisplay[i];
elemsInRow++;
if (elemsInRow != elementsPerRow)
{
spacingCounter += horzSpacing;
}
int spacing = (int)spacingCounter;
spacingCounter -= spacing;
LibraryGUIEntry guiEntry = new LibraryGUIEntry(this, rowLayout, entry.path, i, elemWidth, elemHeight,
spacing, entry.type);
entries.Add(guiEntry);
entryLookup[guiEntry.path] = guiEntry;
if (elemsInRow == elementsPerRow)
{
rowLayout.AddSpace(paddingRight);
}
rowLayout.AddSpace(spacing);
}
int extraElements = elementsPerRow - elemsInRow;
int extraSpacing = 0;
if (extraElements > 1)
{
spacingCounter += (extraElements - 1) * horzSpacing;
extraSpacing += (int)spacingCounter;
}
if (extraElements > 0)
{
rowLayout.AddSpace(elemWidth * extraElements + extraSpacing + paddingRight);
}
main.AddFlexibleSpace();
}
// Fix bounds as that makes GUI updates faster
underlay.Bounds = main.Bounds;
overlay.Bounds = main.Bounds;
deepUnderlay.Bounds = main.Bounds;
renameOverlay.Bounds = main.Bounds;
for (int i = 0; i < entries.Count; i++)
{
LibraryGUIEntry guiEntry = entries[i];
guiEntry.Initialize();
}
}
/// <summary>
/// Creates a new curve editor GUI elements.
/// </summary>
/// <param name="window">Parent window of the GUI element.</param>
/// <param name="gui">GUI layout into which to place the GUI element.</param>
/// <param name="width">Width in pixels.</param>
/// <param name="height">Height in pixels.</param>
public GUICurveEditor(AnimationWindow window, GUILayout gui, int width, int height)
{
this.window = window;
this.gui = gui;
this.width = width;
this.height = height;
blankContextMenu = new ContextMenu();
blankContextMenu.AddItem("Add keyframe", AddKeyframeAtPosition);
blankEventContextMenu = new ContextMenu();
blankEventContextMenu.AddItem("Add event", AddEventAtPosition);
keyframeContextMenu = new ContextMenu();
keyframeContextMenu.AddItem("Delete", DeleteSelectedKeyframes);
keyframeContextMenu.AddItem("Edit", EditSelectedKeyframe);
keyframeContextMenu.AddItem("Tangents/Auto", () => { ChangeSelectionTangentMode(TangentMode.Auto); });
keyframeContextMenu.AddItem("Tangents/Free", () => { ChangeSelectionTangentMode(TangentMode.Free); });
keyframeContextMenu.AddItem("Tangents/In/Auto", () => { ChangeSelectionTangentMode(TangentMode.InAuto); });
keyframeContextMenu.AddItem("Tangents/In/Free", () => { ChangeSelectionTangentMode(TangentMode.InFree); });
keyframeContextMenu.AddItem("Tangents/In/Linear", () => { ChangeSelectionTangentMode(TangentMode.InLinear); });
keyframeContextMenu.AddItem("Tangents/In/Step", () => { ChangeSelectionTangentMode(TangentMode.InStep); });
keyframeContextMenu.AddItem("Tangents/Out/Auto", () => { ChangeSelectionTangentMode(TangentMode.OutAuto); });
keyframeContextMenu.AddItem("Tangents/Out/Free", () => { ChangeSelectionTangentMode(TangentMode.OutFree); });
keyframeContextMenu.AddItem("Tangents/Out/Linear", () => { ChangeSelectionTangentMode(TangentMode.OutLinear); });
keyframeContextMenu.AddItem("Tangents/Out/Step", () => { ChangeSelectionTangentMode(TangentMode.OutStep); });
eventContextMenu = new ContextMenu();
eventContextMenu.AddItem("Delete", DeleteSelectedEvents);
eventContextMenu.AddItem("Edit", EditSelectedEvent);
GUIPanel timelinePanel = gui.AddPanel();
guiTimeline = new GUIGraphTime(timelinePanel, width, TIMELINE_HEIGHT);
GUIPanel timelineBgPanel = gui.AddPanel(1);
GUITexture timelineBackground = new GUITexture(null, EditorStyles.Header);
timelineBackground.Bounds = new Rect2I(0, 0, width, TIMELINE_HEIGHT + VERT_PADDING);
timelineBgPanel.AddElement(timelineBackground);
eventsPanel = gui.AddPanel();
eventsPanel.SetPosition(0, TIMELINE_HEIGHT + VERT_PADDING);
guiEvents = new GUIAnimEvents(eventsPanel, width, EVENTS_HEIGHT);
GUIPanel eventsBgPanel = eventsPanel.AddPanel(1);
GUITexture eventsBackground = new GUITexture(null, EditorStyles.Header);
eventsBackground.Bounds = new Rect2I(0, 0, width, EVENTS_HEIGHT + VERT_PADDING);
eventsBgPanel.AddElement(eventsBackground);
drawingPanel = gui.AddPanel();
drawingPanel.SetPosition(0, TIMELINE_HEIGHT + EVENTS_HEIGHT + VERT_PADDING);
guiCurveDrawing = new GUICurveDrawing(drawingPanel, width, height - TIMELINE_HEIGHT - EVENTS_HEIGHT - VERT_PADDING * 2, curveInfos);
guiCurveDrawing.SetRange(60.0f, 20.0f);
GUIPanel sidebarPanel = gui.AddPanel(-10);
sidebarPanel.SetPosition(0, TIMELINE_HEIGHT + EVENTS_HEIGHT + VERT_PADDING);
guiSidebar = new GUIGraphValues(sidebarPanel, SIDEBAR_WIDTH, height - TIMELINE_HEIGHT - EVENTS_HEIGHT - VERT_PADDING * 2);
guiSidebar.SetRange(-10.0f, 10.0f);
}
/// <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.folded = false;
data.foldout = new GUIToggle(allComponents[i].GetType().Name, EditorStyles.Foldout);
data.foldout.AcceptsKeyFocus = false;
SpriteTexture xBtnIcon = EditorBuiltin.GetEditorIcon(EditorIcon.X);
data.removeBtn = new GUIButton(new GUIContent(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>
/// Rebuilds the GUI list header if needed.
/// </summary>
protected void UpdateHeaderGUI()
{
Action BuildEmptyGUI = () =>
{
guiInternalTitleLayout = guiTitleLayout.InsertLayoutX(0);
guiInternalTitleLayout.AddElement(new GUILabel(title));
guiInternalTitleLayout.AddElement(new GUILabel("Empty", GUIOption.FixedWidth(100)));
GUIContent createIcon = new GUIContent(EditorBuiltin.GetInspectorWindowIcon(InspectorWindowIcon.Create),
new LocEdString("Create"));
GUIButton createBtn = new GUIButton(createIcon, GUIOption.FixedWidth(30));
createBtn.OnClick += OnCreateButtonClicked;
guiInternalTitleLayout.AddElement(createBtn);
};
Action BuildFilledGUI = () =>
{
guiInternalTitleLayout = guiTitleLayout.InsertLayoutX(0);
GUIToggle guiFoldout = new GUIToggle(title, EditorStyles.Foldout);
guiFoldout.Value = isExpanded;
guiFoldout.OnToggled += ToggleFoldout;
guiSizeField = new GUIIntField("", GUIOption.FixedWidth(50));
guiSizeField.SetRange(0, int.MaxValue);
GUIContent resizeIcon = new GUIContent(EditorBuiltin.GetInspectorWindowIcon(InspectorWindowIcon.Resize),
new LocEdString("Resize"));
GUIButton guiResizeBtn = new GUIButton(resizeIcon, GUIOption.FixedWidth(30));
guiResizeBtn.OnClick += OnResizeButtonClicked;
GUIContent clearIcon = new GUIContent(EditorBuiltin.GetInspectorWindowIcon(InspectorWindowIcon.Clear),
new LocEdString("Clear"));
GUIButton guiClearBtn = new GUIButton(clearIcon, GUIOption.FixedWidth(30));
guiClearBtn.OnClick += OnClearButtonClicked;
guiInternalTitleLayout.AddElement(guiFoldout);
guiInternalTitleLayout.AddElement(guiSizeField);
guiInternalTitleLayout.AddElement(guiResizeBtn);
guiInternalTitleLayout.AddElement(guiClearBtn);
guiSizeField.Value = GetNumRows();
guiChildLayout = guiLayout.AddLayoutX();
guiChildLayout.AddSpace(IndentAmount);
guiChildLayout.Active = isExpanded;
GUIPanel guiContentPanel = guiChildLayout.AddPanel();
GUILayoutX guiIndentLayoutX = guiContentPanel.AddLayoutX();
guiIndentLayoutX.AddSpace(IndentAmount);
GUILayoutY guiIndentLayoutY = guiIndentLayoutX.AddLayoutY();
guiIndentLayoutY.AddSpace(IndentAmount);
guiContentLayout = guiIndentLayoutY.AddLayoutY();
guiIndentLayoutY.AddSpace(IndentAmount);
guiIndentLayoutX.AddSpace(IndentAmount);
guiChildLayout.AddSpace(IndentAmount);
short backgroundDepth = (short)(Inspector.START_BACKGROUND_DEPTH - depth - 1);
string bgPanelStyle = depth % 2 == 0
? EditorStyles.InspectorContentBgAlternate
: EditorStyles.InspectorContentBg;
GUIPanel backgroundPanel = guiContentPanel.AddPanel(backgroundDepth);
GUITexture inspectorContentBg = new GUITexture(null, bgPanelStyle);
backgroundPanel.AddElement(inspectorContentBg);
};
if (state == State.None)
{
if (!IsNull())
{
BuildFilledGUI();
state = State.Filled;
}
else
{
BuildEmptyGUI();
state = State.Empty;
}
}
else if (state == State.Empty)
{
if (!IsNull())
{
guiInternalTitleLayout.Destroy();
BuildFilledGUI();
state = State.Filled;
}
}
else if (state == State.Filled)
{
if (IsNull())
{
guiInternalTitleLayout.Destroy();
guiChildLayout.Destroy();
BuildEmptyGUI();
state = State.Empty;
}
}
}
/// <summary>
/// Rebuilds the GUI object header if needed.
/// </summary>
/// <param name="layoutIndex">Index at which to insert the GUI elements.</param>
protected void BuildGUI(int layoutIndex)
{
Action BuildEmptyGUI = () =>
{
if (isInline)
{
return;
}
guiInternalTitleLayout = guiTitleLayout.InsertLayoutX(0);
guiInternalTitleLayout.AddElement(new GUILabel(title));
guiInternalTitleLayout.AddElement(new GUILabel("Empty", GUIOption.FixedWidth(100)));
if (!property.IsValueType)
{
GUIContent createIcon = new GUIContent(EditorBuiltin.GetInspectorWindowIcon(InspectorWindowIcon.Create),
new LocEdString("Create"));
guiCreateBtn = new GUIButton(createIcon, GUIOption.FixedWidth(30));
guiCreateBtn.OnClick += OnCreateButtonClicked;
guiInternalTitleLayout.AddElement(guiCreateBtn);
}
};
Action BuildFilledGUI = () =>
{
if (!isInline)
{
guiInternalTitleLayout = guiTitleLayout.InsertLayoutX(0);
GUIToggle guiFoldout = new GUIToggle(title, EditorStyles.Foldout);
guiFoldout.Value = isExpanded;
guiFoldout.AcceptsKeyFocus = false;
guiFoldout.OnToggled += OnFoldoutToggled;
guiInternalTitleLayout.AddElement(guiFoldout);
if (!property.IsValueType && (style == null || !style.StyleFlags.HasFlag(InspectableFieldStyleFlags.NotNull)))
{
GUIContent clearIcon = new GUIContent(
EditorBuiltin.GetInspectorWindowIcon(InspectorWindowIcon.Clear),
new LocEdString("Clear"));
GUIButton clearBtn = new GUIButton(clearIcon, GUIOption.FixedWidth(20));
clearBtn.OnClick += OnClearButtonClicked;
guiInternalTitleLayout.AddElement(clearBtn);
}
}
if (isExpanded || isInline)
{
SerializableObject serializableObject = property.GetObject();
SerializableField[] fields = serializableObject.Fields;
if (fields.Length > 0)
{
GUILayoutY guiContentLayout;
if (!isInline)
{
guiChildLayout = guiLayout.AddLayoutX();
guiChildLayout.AddSpace(IndentAmount);
GUIPanel guiContentPanel = guiChildLayout.AddPanel();
GUILayoutX guiIndentLayoutX = guiContentPanel.AddLayoutX();
guiIndentLayoutX.AddSpace(IndentAmount);
GUILayoutY guiIndentLayoutY = guiIndentLayoutX.AddLayoutY();
guiIndentLayoutY.AddSpace(IndentAmount);
guiContentLayout = guiIndentLayoutY.AddLayoutY();
guiIndentLayoutY.AddSpace(IndentAmount);
guiIndentLayoutX.AddSpace(IndentAmount);
guiChildLayout.AddSpace(IndentAmount);
short backgroundDepth = (short)(Inspector.START_BACKGROUND_DEPTH - depth - 1);
string bgPanelStyle = depth % 2 == 0
? EditorStylesInternal.InspectorContentBgAlternate
: EditorStylesInternal.InspectorContentBg;
GUIPanel backgroundPanel = guiContentPanel.AddPanel(backgroundDepth);
GUITexture inspectorContentBg = new GUITexture(null, bgPanelStyle);
backgroundPanel.AddElement(inspectorContentBg);
}
else
{
guiContentLayout = guiLayout;
}
drawer = new InspectorFieldDrawer(context, guiContentLayout, path, depth + 1);
drawer.AddDefault(serializableObject);
if (!active)
{
foreach (var field in drawer.Fields)
{
field.Active = false;
}
}
}
}
else
{
guiChildLayout = null;
}
};
if (state == State.None)
{
if (propertyValue != null)
{
BuildFilledGUI();
state = State.Filled;
}
else
{
BuildEmptyGUI();
state = State.Empty;
}
}
else if (state == State.Empty)
{
if (propertyValue != null)
{
guiInternalTitleLayout?.Destroy();
guiInternalTitleLayout = null;
guiCreateBtn = null;
BuildFilledGUI();
state = State.Filled;
}
}
else if (state == State.Filled)
{
drawer?.Clear();
guiInternalTitleLayout?.Destroy();
guiInternalTitleLayout = null;
guiCreateBtn = null;
if (guiChildLayout != null)
{
guiChildLayout.Destroy();
guiChildLayout = null;
}
if (propertyValue == null)
{
BuildEmptyGUI();
state = State.Empty;
}
else
{
BuildFilledGUI();
}
}
}
/// <summary>
/// Creates GUI elements required for displaying <see cref="SceneObject"/> fields like name, prefab data and
/// transform (position, rotation, scale). Assumes that necessary inspector scroll area layout has already been
/// created.
/// </summary>
private void CreateSceneObjectFields()
{
GUIPanel sceneObjectPanel = inspectorLayout.AddPanel();
sceneObjectPanel.SetHeight(GetTitleBounds().height);
GUILayoutY sceneObjectLayout = sceneObjectPanel.AddLayoutY();
sceneObjectLayout.SetPosition(PADDING, PADDING);
GUIPanel sceneObjectBgPanel = sceneObjectPanel.AddPanel(1);
GUILayoutX nameLayout = sceneObjectLayout.AddLayoutX();
soActiveToggle = new GUIToggle("");
soActiveToggle.OnToggled += OnSceneObjectActiveStateToggled;
GUILabel nameLbl = new GUILabel(new LocEdString("Name"), GUIOption.FixedWidth(50));
soNameInput = new GUITextBox(false, GUIOption.FlexibleWidth(180));
soNameInput.Text = activeSO.Name;
soNameInput.OnChanged += OnSceneObjectRename;
soNameInput.OnConfirmed += OnModifyConfirm;
soNameInput.OnFocusLost += OnModifyConfirm;
nameLayout.AddElement(soActiveToggle);
nameLayout.AddSpace(3);
nameLayout.AddElement(nameLbl);
nameLayout.AddElement(soNameInput);
nameLayout.AddFlexibleSpace();
GUILayoutX mobilityLayout = sceneObjectLayout.AddLayoutX();
GUILabel mobilityLbl = new GUILabel(new LocEdString("Mobility"), GUIOption.FixedWidth(50));
soMobility = new GUIEnumField(typeof(ObjectMobility), "", 0, GUIOption.FixedWidth(85));
soMobility.Value = (ulong)activeSO.Mobility;
soMobility.OnSelectionChanged += value => activeSO.Mobility = (ObjectMobility)value;
mobilityLayout.AddElement(mobilityLbl);
mobilityLayout.AddElement(soMobility);
soPrefabLayout = sceneObjectLayout.AddLayoutX();
soPos = new GUIVector3Field(new LocEdString("Position"), 50);
sceneObjectLayout.AddElement(soPos);
soPos.OnChanged += OnPositionChanged;
soPos.OnConfirmed += OnModifyConfirm;
soPos.OnFocusLost += OnModifyConfirm;
soRot = new GUIVector3Field(new LocEdString("Rotation"), 50);
sceneObjectLayout.AddElement(soRot);
soRot.OnChanged += OnRotationChanged;
soRot.OnConfirmed += OnModifyConfirm;
soRot.OnFocusLost += OnModifyConfirm;
soScale = new GUIVector3Field(new LocEdString("Scale"), 50);
sceneObjectLayout.AddElement(soScale);
soScale.OnChanged += OnScaleChanged;
soScale.OnConfirmed += OnModifyConfirm;
soScale.OnFocusLost += OnModifyConfirm;
sceneObjectLayout.AddFlexibleSpace();
GUITexture titleBg = new GUITexture(null, EditorStylesInternal.InspectorTitleBg);
sceneObjectBgPanel.AddElement(titleBg);
}
private void OnInitialize()
{
mainLayout = GUI.AddLayoutY();
GUIContent viewIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.View),
new LocEdString("View"));
GUIContent moveIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.Move),
new LocEdString("Move"));
GUIContent rotateIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.Rotate),
new LocEdString("Rotate"));
GUIContent scaleIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.Scale),
new LocEdString("Scale"));
GUIContent localIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.Local),
new LocEdString("Local"));
GUIContent worldIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.World),
new LocEdString("World"));
GUIContent pivotIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.Pivot),
new LocEdString("Pivot"));
GUIContent centerIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.Center),
new LocEdString("Center"));
GUIContent moveSnapIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.MoveSnap),
new LocEdString("Move snap"));
GUIContent rotateSnapIcon = new GUIContent(EditorBuiltin.GetSceneWindowIcon(SceneWindowIcon.RotateSnap),
new LocEdString("Rotate snap"));
GUIToggleGroup handlesTG = new GUIToggleGroup();
viewButton = new GUIToggle(viewIcon, handlesTG, EditorStyles.Button, GUIOption.FlexibleWidth(35));
moveButton = new GUIToggle(moveIcon, handlesTG, EditorStyles.Button, GUIOption.FlexibleWidth(35));
rotateButton = new GUIToggle(rotateIcon, handlesTG, EditorStyles.Button, GUIOption.FlexibleWidth(35));
scaleButton = new GUIToggle(scaleIcon, handlesTG, EditorStyles.Button, GUIOption.FlexibleWidth(35));
GUIToggleGroup coordModeTG = new GUIToggleGroup();
localCoordButton = new GUIToggle(localIcon, coordModeTG, EditorStyles.Button, GUIOption.FlexibleWidth(75));
worldCoordButton = new GUIToggle(worldIcon, coordModeTG, EditorStyles.Button, GUIOption.FlexibleWidth(75));
GUIToggleGroup pivotModeTG = new GUIToggleGroup();
pivotButton = new GUIToggle(pivotIcon, pivotModeTG, EditorStyles.Button, GUIOption.FlexibleWidth(35));
centerButton = new GUIToggle(centerIcon, pivotModeTG, EditorStyles.Button, GUIOption.FlexibleWidth(35));
moveSnapButton = new GUIToggle(moveSnapIcon, EditorStyles.Button, GUIOption.FlexibleWidth(35));
moveSnapInput = new GUIFloatField("", GUIOption.FlexibleWidth(35));
rotateSnapButton = new GUIToggle(rotateSnapIcon, EditorStyles.Button, GUIOption.FlexibleWidth(35));
rotateSnapInput = new GUIFloatField("", GUIOption.FlexibleWidth(35));
viewButton.OnClick += () => OnSceneToolButtonClicked(SceneViewTool.View);
moveButton.OnClick += () => OnSceneToolButtonClicked(SceneViewTool.Move);
rotateButton.OnClick += () => OnSceneToolButtonClicked(SceneViewTool.Rotate);
scaleButton.OnClick += () => OnSceneToolButtonClicked(SceneViewTool.Scale);
localCoordButton.OnClick += () => OnCoordinateModeButtonClicked(HandleCoordinateMode.Local);
worldCoordButton.OnClick += () => OnCoordinateModeButtonClicked(HandleCoordinateMode.World);
pivotButton.OnClick += () => OnPivotModeButtonClicked(HandlePivotMode.Pivot);
centerButton.OnClick += () => OnPivotModeButtonClicked(HandlePivotMode.Center);
moveSnapButton.OnToggled += (bool active) => OnMoveSnapToggled(active);
moveSnapInput.OnChanged += (float value) => OnMoveSnapValueChanged(value);
rotateSnapButton.OnToggled += (bool active) => OnRotateSnapToggled(active);
rotateSnapInput.OnChanged += (float value) => OnRotateSnapValueChanged(value);
GUILayout handlesLayout = mainLayout.AddLayoutX();
handlesLayout.AddElement(viewButton);
handlesLayout.AddElement(moveButton);
handlesLayout.AddElement(rotateButton);
handlesLayout.AddElement(scaleButton);
handlesLayout.AddSpace(10);
handlesLayout.AddElement(localCoordButton);
handlesLayout.AddElement(worldCoordButton);
handlesLayout.AddSpace(10);
handlesLayout.AddElement(pivotButton);
handlesLayout.AddElement(centerButton);
handlesLayout.AddFlexibleSpace();
handlesLayout.AddElement(moveSnapButton);
handlesLayout.AddElement(moveSnapInput);
handlesLayout.AddSpace(10);
handlesLayout.AddElement(rotateSnapButton);
handlesLayout.AddElement(rotateSnapInput);
GUIPanel mainPanel = mainLayout.AddPanel();
rtPanel = mainPanel.AddPanel();
GUIPanel sceneAxesPanel = mainPanel.AddPanel(-1);
sceneAxesGUI = new SceneAxesGUI(this, sceneAxesPanel, HandleAxesGUISize, HandleAxesGUISize, ProjectionType.Perspective);
toggleProfilerOverlayKey = new VirtualButton(ToggleProfilerOverlayBinding);
viewToolKey = new VirtualButton(ViewToolBinding);
moveToolKey = new VirtualButton(MoveToolBinding);
rotateToolKey = new VirtualButton(RotateToolBinding);
scaleToolKey = new VirtualButton(ScaleToolBinding);
duplicateKey = new VirtualButton(DuplicateBinding);
deleteKey = new VirtualButton(DeleteBinding);
frameKey = new VirtualButton(FrameBinding);
UpdateRenderTexture(Width, Height - HeaderHeight);
UpdateProfilerOverlay();
}
private void Rebuild()
{
scrollArea.Layout.Clear();
fields = null;
if (fieldInfos == null || root == null)
{
return;
}
GUILabel header = new GUILabel(new LocEdString("Properties"), EditorStyles.Header);
scrollArea.Layout.AddElement(header);
layouts = new GUIAnimFieldLayouts();
GUIPanel rootPanel = scrollArea.Layout.AddPanel();
GUIPanel mainPanel = rootPanel.AddPanel();
GUIPanel underlayPanel = rootPanel.AddPanel(1);
GUIPanel overlayPanel = rootPanel.AddPanel(-1);
GUIPanel backgroundPanel = rootPanel.AddPanel(2);
layouts.main = mainPanel.AddLayoutY();
layouts.underlay = underlayPanel.AddLayoutY();
layouts.overlay = overlayPanel.AddLayoutY();
layouts.background = backgroundPanel.AddLayoutY();
GUIButton catchAll = new GUIButton("", EditorStyles.Blank);
catchAll.Bounds = new Rect2I(0, 0, width, height - header.Bounds.height);
catchAll.OnClick += () => OnEntrySelected(null);
underlayPanel.AddElement(catchAll);
layouts.main.AddSpace(5);
layouts.underlay.AddSpace(5);
layouts.overlay.AddSpace(5);
layouts.background.AddSpace(3); // Minor hack: Background starts heigher to get it to center better
fields = new GUIAnimFieldEntry[fieldInfos.Count];
for (int i = 0; i < fieldInfos.Count; i++)
{
if (string.IsNullOrEmpty(fieldInfos[i].path))
{
continue;
}
bool entryIsMissing;
if (fieldInfos[i].isUserCurve)
{
string pathSuffix;
SerializableProperty property = Animation.FindProperty(root, fieldInfos[i].path, out pathSuffix);
entryIsMissing = property == null;
}
else
{
entryIsMissing = false;
}
if (!entryIsMissing)
{
Color[] colors = new Color[fieldInfos[i].curveGroup.curveInfos.Length];
for (int j = 0; j < fieldInfos[i].curveGroup.curveInfos.Length; j++)
{
colors[j] = fieldInfos[i].curveGroup.curveInfos[j].color;
}
switch (fieldInfos[i].curveGroup.type)
{
case SerializableProperty.FieldType.Vector2:
fields[i] = new GUIAnimVec2Entry(layouts, fieldInfos[i].path, colors);
break;
case SerializableProperty.FieldType.Vector3:
fields[i] = new GUIAnimVec3Entry(layouts, fieldInfos[i].path, colors);
break;
case SerializableProperty.FieldType.Vector4:
fields[i] = new GUIAnimVec4Entry(layouts, fieldInfos[i].path, colors);
break;
case SerializableProperty.FieldType.Color:
fields[i] = new GUIAnimColorEntry(layouts, fieldInfos[i].path, colors);
break;
case SerializableProperty.FieldType.Bool:
case SerializableProperty.FieldType.Int:
case SerializableProperty.FieldType.Float:
{
Color color;
if (colors.Length > 0)
{
color = colors[0];
}
else
{
color = Color.White;
}
fields[i] = new GUIAnimSimpleEntry(layouts, fieldInfos[i].path, color);
break;
}
}
}
else
{
fields[i] = new GUIAnimMissingEntry(layouts, fieldInfos[i].path);
}
if (fields[i] != null)
{
fields[i].OnEntrySelected += OnEntrySelected;
}
}
if (fieldInfos.Count == 0)
{
GUILabel warningLbl = new GUILabel(new LocEdString("No properties. Add a new property to begin animating."));
GUILayoutY vertLayout = layouts.main.AddLayoutY();
vertLayout.AddFlexibleSpace();
GUILayoutX horzLayout = vertLayout.AddLayoutX();
vertLayout.AddFlexibleSpace();
horzLayout.AddFlexibleSpace();
horzLayout.AddElement(warningLbl);
horzLayout.AddFlexibleSpace();
}
layouts.main.AddSpace(5);
layouts.underlay.AddSpace(5);
layouts.overlay.AddSpace(5);
layouts.background.AddSpace(5);
layouts.main.AddFlexibleSpace();
layouts.underlay.AddFlexibleSpace();
layouts.overlay.AddFlexibleSpace();
layouts.background.AddFlexibleSpace();
}
private void OnInitialize()
{
guiOK = new GUIButton(new LocEdString("OK"));
guiCancel = new GUIButton(new LocEdString("Cancel"));
guiOK.OnClick += OnOK;
guiCancel.OnClick += OnCancel;
GUILayout mainVertLayout = GUI.AddLayoutY();
mainVertLayout.AddSpace(10);
GUILayout editorHorzLayout = mainVertLayout.AddLayoutX();
editorHorzLayout.AddSpace(EDITOR_HORZ_PADDING);
GUIPanel gradientEditorPanel = editorHorzLayout.AddPanel();
editorHorzLayout.AddSpace(EDITOR_HORZ_PADDING);
mainVertLayout.AddSpace(15);
GUILayout buttonHorzLayout = mainVertLayout.AddLayoutX();
buttonHorzLayout.AddFlexibleSpace();
buttonHorzLayout.AddElement(guiOK);
buttonHorzLayout.AddSpace(10);
buttonHorzLayout.AddElement(guiCancel);
buttonHorzLayout.AddFlexibleSpace();
mainVertLayout.AddFlexibleSpace();
editorPanel = gradientEditorPanel.AddPanel(0);
GUIPanel editorOverlay = gradientEditorPanel.AddPanel(-1);
overlayCanvas = new GUICanvas();
editorOverlay.AddElement(overlayCanvas);
GUILayout editorVertLayout = editorPanel.AddLayoutY();
GUILayout guiGradientLayout = editorVertLayout.AddLayoutX();
guiGradientLayout.AddSpace(GradientKeyEditor.RECT_WIDTH / 2);
texture = Texture.Create2D(TEX_WIDTH, TEX_HEIGHT);
spriteTexture = new SpriteTexture(texture);
guiGradientTexture = new GUITexture(spriteTexture, GUITextureScaleMode.StretchToFit);
guiGradientTexture.SetHeight(30);
UpdateTexture();
guiGradientLayout.AddElement(guiGradientTexture);
guiGradientLayout.AddSpace(GradientKeyEditor.RECT_WIDTH / 2);
editorVertLayout.AddSpace(10);
editor = new GradientKeyEditor(editorVertLayout, gradient.GetKeys(), Width - EDITOR_HORZ_PADDING * 2, 20);
editor.OnGradientModified += colorGradient =>
{
gradient = colorGradient;
UpdateTexture();
UpdateKeyLines();
};
editorVertLayout.AddFlexibleSpace();
GUITexture containerBg = new GUITexture(null, EditorStylesInternal.ContainerBg);
Rect2I containerBounds = editor.GetBounds(GUI);
containerBounds.x -= 2;
containerBounds.y -= 2;
containerBounds.width += 4;
containerBounds.height += 6;
containerBg.Bounds = containerBounds;
GUIPanel editorUnderlay = GUI.AddPanel(1);
editorUnderlay.AddElement(containerBg);
UpdateKeyLines();
EditorInput.OnPointerPressed += OnPointerPressed;
EditorInput.OnPointerDoubleClick += OnPointerDoubleClicked;
EditorInput.OnPointerMoved += OnPointerMoved;
EditorInput.OnPointerReleased += OnPointerReleased;
EditorInput.OnButtonUp += OnButtonUp;
}
/// <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>
/// Creates GUI elements required for displaying <see cref="SceneObject"/> fields like name, prefab data and
/// transform (position, rotation, scale). Assumes that necessary inspector scroll area layout has already been
/// created.
/// </summary>
private void CreateSceneObjectFields()
{
GUIPanel sceneObjectPanel = inspectorLayout.AddPanel();
sceneObjectPanel.SetHeight(GetTitleBounds().height);
GUILayoutY sceneObjectLayout = sceneObjectPanel.AddLayoutY();
sceneObjectLayout.SetPosition(PADDING, PADDING);
GUIPanel sceneObjectBgPanel = sceneObjectPanel.AddPanel(1);
GUILayoutX nameLayout = sceneObjectLayout.AddLayoutX();
soActiveToggle = new GUIToggle("");
soActiveToggle.OnToggled += OnSceneObjectActiveStateToggled;
GUILabel nameLbl = new GUILabel(new LocEdString("Name"), GUIOption.FixedWidth(50));
soNameInput = new GUITextBox(false, GUIOption.FlexibleWidth(180));
soNameInput.Text = activeSO.Name;
soNameInput.OnChanged += OnSceneObjectRename;
soNameInput.OnConfirmed += OnModifyConfirm;
soNameInput.OnFocusLost += OnModifyConfirm;
nameLayout.AddElement(soActiveToggle);
nameLayout.AddSpace(3);
nameLayout.AddElement(nameLbl);
nameLayout.AddElement(soNameInput);
nameLayout.AddFlexibleSpace();
GUILayoutX mobilityLayout = sceneObjectLayout.AddLayoutX();
GUILabel mobilityLbl = new GUILabel(new LocEdString("Mobility"), GUIOption.FixedWidth(50));
soMobility = new GUIEnumField(typeof(ObjectMobility), "", 0, GUIOption.FixedWidth(85));
soMobility.Value = (ulong)activeSO.Mobility;
soMobility.OnSelectionChanged += value => activeSO.Mobility = (ObjectMobility)value;
mobilityLayout.AddElement(mobilityLbl);
mobilityLayout.AddElement(soMobility);
soPrefabLayout = sceneObjectLayout.AddLayoutX();
GUILayoutX positionLayout = sceneObjectLayout.AddLayoutX();
GUILabel positionLbl = new GUILabel(new LocEdString("Position"), GUIOption.FixedWidth(50));
soPosX = new GUIFloatField(new LocEdString("X"), 10, "", GUIOption.FixedWidth(60));
soPosY = new GUIFloatField(new LocEdString("Y"), 10, "", GUIOption.FixedWidth(60));
soPosZ = new GUIFloatField(new LocEdString("Z"), 10, "", GUIOption.FixedWidth(60));
soPosX.OnChanged += (x) => OnPositionChanged(0, x);
soPosY.OnChanged += (y) => OnPositionChanged(1, y);
soPosZ.OnChanged += (z) => OnPositionChanged(2, z);
soPosX.OnConfirmed += OnModifyConfirm;
soPosY.OnConfirmed += OnModifyConfirm;
soPosZ.OnConfirmed += OnModifyConfirm;
soPosX.OnFocusLost += OnModifyConfirm;
soPosY.OnFocusLost += OnModifyConfirm;
soPosZ.OnFocusLost += OnModifyConfirm;
positionLayout.AddElement(positionLbl);
positionLayout.AddElement(soPosX);
positionLayout.AddSpace(10);
positionLayout.AddFlexibleSpace();
positionLayout.AddElement(soPosY);
positionLayout.AddSpace(10);
positionLayout.AddFlexibleSpace();
positionLayout.AddElement(soPosZ);
positionLayout.AddFlexibleSpace();
GUILayoutX rotationLayout = sceneObjectLayout.AddLayoutX();
GUILabel rotationLbl = new GUILabel(new LocEdString("Rotation"), GUIOption.FixedWidth(50));
soRotX = new GUIFloatField(new LocEdString("X"), 10, "", GUIOption.FixedWidth(60));
soRotY = new GUIFloatField(new LocEdString("Y"), 10, "", GUIOption.FixedWidth(60));
soRotZ = new GUIFloatField(new LocEdString("Z"), 10, "", GUIOption.FixedWidth(60));
soRotX.OnChanged += (x) => OnRotationChanged(0, x);
soRotY.OnChanged += (y) => OnRotationChanged(1, y);
soRotZ.OnChanged += (z) => OnRotationChanged(2, z);
soRotX.OnConfirmed += OnModifyConfirm;
soRotY.OnConfirmed += OnModifyConfirm;
soRotZ.OnConfirmed += OnModifyConfirm;
soRotX.OnFocusLost += OnModifyConfirm;
soRotY.OnFocusLost += OnModifyConfirm;
soRotZ.OnFocusLost += OnModifyConfirm;
rotationLayout.AddElement(rotationLbl);
rotationLayout.AddElement(soRotX);
rotationLayout.AddSpace(10);
rotationLayout.AddFlexibleSpace();
rotationLayout.AddElement(soRotY);
rotationLayout.AddSpace(10);
rotationLayout.AddFlexibleSpace();
rotationLayout.AddElement(soRotZ);
rotationLayout.AddFlexibleSpace();
GUILayoutX scaleLayout = sceneObjectLayout.AddLayoutX();
GUILabel scaleLbl = new GUILabel(new LocEdString("Scale"), GUIOption.FixedWidth(50));
soScaleX = new GUIFloatField(new LocEdString("X"), 10, "", GUIOption.FixedWidth(60));
soScaleY = new GUIFloatField(new LocEdString("Y"), 10, "", GUIOption.FixedWidth(60));
soScaleZ = new GUIFloatField(new LocEdString("Z"), 10, "", GUIOption.FixedWidth(60));
soScaleX.OnChanged += (x) => OnScaleChanged(0, x);
soScaleY.OnChanged += (y) => OnScaleChanged(1, y);
soScaleZ.OnChanged += (z) => OnScaleChanged(2, z);
soScaleX.OnConfirmed += OnModifyConfirm;
soScaleY.OnConfirmed += OnModifyConfirm;
soScaleZ.OnConfirmed += OnModifyConfirm;
soScaleX.OnFocusLost += OnModifyConfirm;
soScaleY.OnFocusLost += OnModifyConfirm;
soScaleZ.OnFocusLost += OnModifyConfirm;
scaleLayout.AddElement(scaleLbl);
scaleLayout.AddElement(soScaleX);
scaleLayout.AddSpace(10);
scaleLayout.AddFlexibleSpace();
scaleLayout.AddElement(soScaleY);
scaleLayout.AddSpace(10);
scaleLayout.AddFlexibleSpace();
scaleLayout.AddElement(soScaleZ);
scaleLayout.AddFlexibleSpace();
sceneObjectLayout.AddFlexibleSpace();
GUITexture titleBg = new GUITexture(null, EditorStylesInternal.InspectorTitleBg);
sceneObjectBgPanel.AddElement(titleBg);
}
/// <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>
public void Refresh(ProjectViewType viewType, LibraryEntry[] entriesToDisplay)
{
if (mainPanel != null)
{
mainPanel.Destroy();
}
entries = new LibraryGUIEntry[entriesToDisplay.Length];
entryLookup.Clear();
mainPanel = parent.Layout.AddPanel();
GUIPanel contentPanel = mainPanel.AddPanel(1);
overlay = mainPanel.AddPanel(0);
underlay = mainPanel.AddPanel(2);
renameOverlay = mainPanel.AddPanel(-1);
main = contentPanel.AddLayoutY();
if (viewType == ProjectViewType.List16)
{
tileSize = 16;
gridLayout = false;
elementsPerRow = 1;
}
else
{
switch (viewType)
{
case ProjectViewType.Grid64:
tileSize = 64;
break;
case ProjectViewType.Grid48:
tileSize = 48;
break;
case ProjectViewType.Grid32:
tileSize = 32;
break;
}
gridLayout = true;
Rect2I scrollBounds = parent.Bounds;
int availableWidth = scrollBounds.width;
int elemSize = tileSize + GRID_ENTRY_SPACING;
elementsPerRow = (availableWidth - GRID_ENTRY_SPACING * 2) / elemSize;
elementsPerRow = Math.Max(elementsPerRow, 1);
int numRows = MathEx.CeilToInt(entriesToDisplay.Length / (float)elementsPerRow);
int neededHeight = numRows * (elemSize);
bool requiresScrollbar = neededHeight > scrollBounds.height;
if (requiresScrollbar)
{
availableWidth -= parent.ScrollBarWidth;
elementsPerRow = (availableWidth - GRID_ENTRY_SPACING * 2) / elemSize;
}
if (elementsPerRow > 0)
{
labelWidth = (availableWidth - (elementsPerRow + 1) * MIN_HORZ_SPACING) / elementsPerRow;
}
else
{
labelWidth = 0;
}
}
if (viewType == ProjectViewType.List16)
{
for (int i = 0; i < entriesToDisplay.Length; i++)
{
LibraryGUIEntry guiEntry = new LibraryGUIEntry(this, main, entriesToDisplay[i], i, labelWidth);
entries[i] = guiEntry;
entryLookup[guiEntry.path] = guiEntry;
if (i != entriesToDisplay.Length - 1)
{
main.AddSpace(LIST_ENTRY_SPACING);
}
}
main.AddFlexibleSpace();
}
else
{
main.AddSpace(GRID_ENTRY_SPACING / 2);
GUILayoutX rowLayout = main.AddLayoutX();
main.AddSpace(GRID_ENTRY_SPACING);
rowLayout.AddFlexibleSpace();
int elemsInRow = 0;
for (int i = 0; i < entriesToDisplay.Length; i++)
{
if (elemsInRow == elementsPerRow && elemsInRow > 0)
{
rowLayout = main.AddLayoutX();
main.AddSpace(GRID_ENTRY_SPACING);
rowLayout.AddFlexibleSpace();
elemsInRow = 0;
}
LibraryGUIEntry guiEntry = new LibraryGUIEntry(this, rowLayout, entriesToDisplay[i], i, labelWidth);
entries[i] = guiEntry;
entryLookup[guiEntry.path] = guiEntry;
rowLayout.AddFlexibleSpace();
elemsInRow++;
}
int extraElements = elementsPerRow - elemsInRow;
for (int i = 0; i < extraElements; i++)
{
rowLayout.AddSpace(labelWidth);
rowLayout.AddFlexibleSpace();
}
main.AddFlexibleSpace();
}
for (int i = 0; i < entries.Length; i++)
{
LibraryGUIEntry guiEntry = entries[i];
guiEntry.Initialize();
}
}
