//-------------------------------------------------------------------------
private void DrawElementBackgroundCallback(Rect rect, int index, bool isActive, bool isFocused)
{
if (index >= _list.Count)
{
return;
}
//show context menu
if (_showContextMenu && (CallBack_Setting_CanShowContextMenu == null || CallBack_Setting_CanShowContextMenu()))
{
var elementDrawPos = (rect.position);
var ElementSize = (rect.size);
var mousePos = Event.current.mousePosition;
if (Event.current.button == 1 && Property_Show_AddButton && CallBack_Setting_CanAdd(_listViewer))
{
if (mousePos.x > elementDrawPos.x && mousePos.x < elementDrawPos.x + ElementSize.x &&
mousePos.y > elementDrawPos.y && mousePos.y < elementDrawPos.y + ElementSize.y)
{
GenericMenu options = new GenericMenu();
if (_callBack_List_OnAdd != null)
{
options.AddItem(new GUIContent("Insert Above"), false, () => InsertWithAdd(index));
options.AddItem(new GUIContent("Insert Below"), false, () => InsertWithAdd(index + 1));
}
if (CallBack_List_OnDuplicate != null)
{
if (_callBack_List_OnAdd != null || _callBack_List_OnAddOptions != null)
{
options.AddSeparator("");
}
options.AddItem(new GUIContent("Duplicate"), false, () => Duplicate(index));
}
_listViewer.ReleaseKeyboardFocus();
//_listViewer.GrabKeyboardFocus();
options.ShowAsContext();
// isFocused = true;
}
}
if (Callback_Draw_ElementBackground != null)
{
Callback_Draw_ElementBackground(_list, rect, index, isActive, isFocused);
}
}
//draw selected background
if (isFocused && _showContextMenu)
{
DrawQuad(rect, 0, 50, 186, .3f);
}
}
void initializeOrderableLists()
{
groupsList = new ReorderableList(EventsManager.Instance.GroupsContainer.GroupNames, typeof(string));
groupsList.drawHeaderCallback = (rect) => EditorGUI.LabelField(rect, "Groups");
groupsList.drawElementCallback = (rect, index, active, focused) =>
{
Rect r = rect;
r.width = rect.width - ButtonWidth;
EditorGUI.LabelField(r, groupsList.list[index] as string);
r.x += r.width;
r.width = ButtonWidth;
r.height = rect.height * .75f;
if (GUI.Button(r, "Rename"))
{
var win = GetWindow <RenameGroupWindow>(true, "Rename Group", true);
win.SetGroup((groupsList.list[index] as string));
}
};
groupsList.onSelectCallback = list =>
{
selectedGroupName = list.list[list.index] as string;
CreateEventOrderableList();
};
groupsList.onAddCallback = list =>
{
GetWindow <CreateGroupWindow>(true, "Create Group", true);
};
groupsList.onReorderCallback = list => UpdateGroupListOrder(list.list);
groupsList.onRemoveCallback = list =>
{
SelectedGroup = null;
EventsManager.Instance.GroupsContainer.RemoveGroup(list.list[list.index] as string);
list.index = -1;
NotifyGroupDatasetChanged();
groupsList.ReleaseKeyboardFocus();
};
}
private void DisplayBrushReorderableList()
{
Event e = Event.current;
if (m_brushList == null || m_brushList.list != Tileset.Brushes)
{
if (e.type != EventType.Layout)
{
m_brushList = TilesetEditor.CreateBrushReorderableList(Tileset);
m_brushList.onSelectCallback += (ReorderableList list) =>
{
Tileset.BrushContainer brushCont = Tileset.Brushes[list.index];
Tileset.SelectedBrushId = brushCont.Id;
RemoveTileSelection();
if (m_dblClick.IsDblClick)
{
EditorGUIUtility.PingObject(brushCont.BrushAsset);
m_selectBrushInInspector = brushCont.BrushAsset;
}
};
}
}
else
{
GUILayout.BeginVertical(m_customBox);
m_brushList.index = Tileset.Brushes.FindIndex(x => x.Id == Tileset.SelectedBrushId);
m_brushList.index = Mathf.Clamp(m_brushList.index, -1, Tileset.Brushes.Count - 1);
m_brushList.elementHeight = Tileset.VisualTileSize.y + 10f;
m_brushList.DoLayoutList();
Rect rList = GUILayoutUtility.GetLastRect();
if (e.isMouse && !rList.Contains(e.mousePosition))
{
m_brushList.ReleaseKeyboardFocus();
}
GUILayout.EndVertical();
}
}
private void DisplayParameters()
{
Event e = Event.current;
TileSelection tileSelection = Tileset.TileSelection;
if (tileSelection != null)
{
EditorGUILayout.LabelField("Multi-tile editing not allowed", EditorStyles.boldLabel);
}
else
{
UnityEngine.Object prevOwner = m_parameterListOwner;
if (Tileset.SelectedBrushId != Tileset.k_BrushId_Default)
{
m_parameterListOwner = Tileset.FindBrush(Tileset.SelectedBrushId);
}
else
{
m_parameterListOwner = Tileset;
}
if (m_parameterListOwner != null)
{
if (prevOwner != m_parameterListOwner || Tileset.SelectedTileId != m_prevSelectedTileId || m_tileParameterList == null)
{
m_prevSelectedTileId = Tileset.SelectedTileId;
m_tileParameterList = CreateParameterReorderableList(m_parameterListOwner is Tileset ?
((Tileset)m_parameterListOwner).SelectedTile.paramContainer :
((TilesetBrush)m_parameterListOwner).Params);
m_tileParameterList.onChangedCallback += (ReorderableList list) =>
{
EditorUtility.SetDirty(m_parameterListOwner);
};
}
GUILayoutUtility.GetRect(1, 1, GUILayout.Width(Tileset.VisualTileSize.x), GUILayout.Height(Tileset.VisualTileSize.y));
uint tilePreviewData = m_parameterListOwner is Tileset ?
(uint)(((Tileset)m_parameterListOwner).SelectedTileId & Tileset.k_TileDataMask_TileId)
:
((TilesetBrush)m_parameterListOwner).GetAnimTileData();
Rect customUV = m_parameterListOwner is Tileset ? default(Rect) : ((TilesetBrush)m_parameterListOwner).GetAnimUV();
GUI.color = Tileset.BackgroundColor;
GUI.DrawTexture(GUILayoutUtility.GetLastRect(), EditorGUIUtility.whiteTexture);
GUI.color = Color.white;
TilesetEditor.DoGUIDrawTileFromTileData(GUILayoutUtility.GetLastRect(), tilePreviewData, Tileset, customUV);
m_tileParamScrollViewPos = EditorGUILayout.BeginScrollView(m_tileParamScrollViewPos, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
EditorGUI.BeginChangeCheck();
m_tileParameterList.DoLayoutList();
Rect rList = GUILayoutUtility.GetLastRect();
if (e.isMouse && !rList.Contains(e.mousePosition))
{
m_tileParameterList.ReleaseKeyboardFocus();
m_tileParameterList.index = -1;
}
if (EditorGUI.EndChangeCheck())
{
EditorUtility.SetDirty(m_parameterListOwner);
}
EditorGUILayout.EndScrollView();
}
}
}
private void InitReorderedList()
{
if (prefEntryHolder == null)
{
var tmp = Resources.FindObjectsOfTypeAll <PreferenceEntryHolder>();
if (tmp.Length > 0)
{
prefEntryHolder = tmp[0];
}
else
{
prefEntryHolder = ScriptableObject.CreateInstance <PreferenceEntryHolder>();
}
}
if (serializedObject == null)
{
serializedObject = new SerializedObject(prefEntryHolder);
}
userDefList = new ReorderableList(serializedObject, serializedObject.FindProperty("userDefList"), false, true, true, true);
unityDefList = new ReorderableList(serializedObject, serializedObject.FindProperty("unityDefList"), false, true, false, false);
relSpliterPos = EditorPrefs.GetFloat("BGTools.PlayerPrefsEditor.RelativeSpliterPosition", 100 / position.width);
userDefList.drawHeaderCallback = (Rect rect) =>
{
EditorGUI.LabelField(rect, "User defined");
};
userDefList.drawElementBackgroundCallback = OnDrawElementBackgroundCallback;
userDefList.drawElementCallback = (Rect rect, int index, bool isActive, bool isFocused) =>
{
var element = userDefList.serializedProperty.GetArrayElementAtIndex(index);
SerializedProperty key = element.FindPropertyRelative("m_key");
SerializedProperty type = element.FindPropertyRelative("m_typeSelection");
SerializedProperty strValue = element.FindPropertyRelative("m_strValue");
SerializedProperty intValue = element.FindPropertyRelative("m_intValue");
SerializedProperty floatValue = element.FindPropertyRelative("m_floatValue");
float spliterPos = relSpliterPos * rect.width;
rect.y += 2;
EditorGUI.BeginChangeCheck();
EditorGUI.LabelField(new Rect(rect.x, rect.y, spliterPos - 1, EditorGUIUtility.singleLineHeight), new GUIContent(key.stringValue, key.stringValue));
GUI.enabled = false;
EditorGUI.PropertyField(new Rect(rect.x + spliterPos + 1, rect.y, 60, EditorGUIUtility.singleLineHeight), type, GUIContent.none);
GUI.enabled = !showLoadingIndicatorOverlay;
switch ((PreferenceEntry.PrefTypes)type.enumValueIndex)
{
case PreferenceEntry.PrefTypes.Float:
EditorGUI.DelayedFloatField(new Rect(rect.x + spliterPos + 62, rect.y, rect.width - spliterPos - 60, EditorGUIUtility.singleLineHeight), floatValue, GUIContent.none);
break;
case PreferenceEntry.PrefTypes.Int:
EditorGUI.DelayedIntField(new Rect(rect.x + spliterPos + 62, rect.y, rect.width - spliterPos - 60, EditorGUIUtility.singleLineHeight), intValue, GUIContent.none);
break;
case PreferenceEntry.PrefTypes.String:
EditorGUI.DelayedTextField(new Rect(rect.x + spliterPos + 62, rect.y, rect.width - spliterPos - 60, EditorGUIUtility.singleLineHeight), strValue, GUIContent.none);
break;
}
if (EditorGUI.EndChangeCheck())
{
entryAccessor.IgnoreNextChange();
switch ((PreferenceEntry.PrefTypes)type.enumValueIndex)
{
case PreferenceEntry.PrefTypes.Float:
PlayerPrefs.SetFloat(key.stringValue, floatValue.floatValue);
break;
case PreferenceEntry.PrefTypes.Int:
PlayerPrefs.SetInt(key.stringValue, intValue.intValue);
break;
case PreferenceEntry.PrefTypes.String:
PlayerPrefs.SetString(key.stringValue, strValue.stringValue);
break;
}
PlayerPrefs.Save();
}
};
userDefList.onRemoveCallback = (ReorderableList l) =>
{
userDefList.ReleaseKeyboardFocus();
unityDefList.ReleaseKeyboardFocus();
if (EditorUtility.DisplayDialog("Warning!", "Are you sure you want to delete this entry from PlayerPrefs? ", "Yes", "No"))
{
entryAccessor.IgnoreNextChange();
PlayerPrefs.DeleteKey(l.serializedProperty.GetArrayElementAtIndex(l.index).FindPropertyRelative("m_key").stringValue);
PlayerPrefs.Save();
ReorderableList.defaultBehaviours.DoRemoveButton(l);
PrepareData();
GUIUtility.ExitGUI();
}
};
userDefList.onAddDropdownCallback = (Rect buttonRect, ReorderableList l) =>
{
var menu = new GenericMenu();
foreach (PreferenceEntry.PrefTypes type in Enum.GetValues(typeof(PreferenceEntry.PrefTypes)))
{
menu.AddItem(new GUIContent(type.ToString()), false, () =>
{
TextFieldDialog.OpenDialog("Create new property", "Key for the new property:", prefKeyValidatorList, (key) => {
entryAccessor.IgnoreNextChange();
switch (type)
{
case PreferenceEntry.PrefTypes.Float:
PlayerPrefs.SetFloat(key, 0.0f);
break;
case PreferenceEntry.PrefTypes.Int:
PlayerPrefs.SetInt(key, 0);
break;
case PreferenceEntry.PrefTypes.String:
PlayerPrefs.SetString(key, string.Empty);
break;
}
PlayerPrefs.Save();
PrepareData();
Focus();
}, this);
});
}
menu.ShowAsContext();
};
unityDefList.drawElementBackgroundCallback = OnDrawElementBackgroundCallback;
unityDefList.drawElementCallback = (Rect rect, int index, bool isActive, bool isFocused) =>
{
var element = unityDefList.serializedProperty.GetArrayElementAtIndex(index);
SerializedProperty key = element.FindPropertyRelative("m_key");
SerializedProperty type = element.FindPropertyRelative("m_typeSelection");
SerializedProperty strValue = element.FindPropertyRelative("m_strValue");
SerializedProperty intValue = element.FindPropertyRelative("m_intValue");
SerializedProperty floatValue = element.FindPropertyRelative("m_floatValue");
float spliterPos = relSpliterPos * rect.width;
rect.y += 2;
GUI.enabled = false;
EditorGUI.LabelField(new Rect(rect.x, rect.y, spliterPos - 1, EditorGUIUtility.singleLineHeight), new GUIContent(key.stringValue, key.stringValue));
EditorGUI.PropertyField(new Rect(rect.x + spliterPos + 1, rect.y, 60, EditorGUIUtility.singleLineHeight), type, GUIContent.none);
switch ((PreferenceEntry.PrefTypes)type.enumValueIndex)
{
case PreferenceEntry.PrefTypes.Float:
EditorGUI.DelayedFloatField(new Rect(rect.x + spliterPos + 62, rect.y, rect.width - spliterPos - 60, EditorGUIUtility.singleLineHeight), floatValue, GUIContent.none);
break;
case PreferenceEntry.PrefTypes.Int:
EditorGUI.DelayedIntField(new Rect(rect.x + spliterPos + 62, rect.y, rect.width - spliterPos - 60, EditorGUIUtility.singleLineHeight), intValue, GUIContent.none);
break;
case PreferenceEntry.PrefTypes.String:
EditorGUI.DelayedTextField(new Rect(rect.x + spliterPos + 62, rect.y, rect.width - spliterPos - 60, EditorGUIUtility.singleLineHeight), strValue, GUIContent.none);
break;
}
GUI.enabled = !showLoadingIndicatorOverlay;
};
unityDefList.drawHeaderCallback = (Rect rect) =>
{
EditorGUI.LabelField(rect, "Unity defined");
};
}
public void Display()
{
Event e = Event.current;
m_dblClick.Update();
// This way a gui exception is avoided
if (e.type == EventType.Layout && m_selectBrushInInspector != null)
{
Selection.activeObject = m_selectBrushInInspector;
m_selectBrushInInspector = null;
}
if (m_lastTime == 0f)
{
m_lastTime = Time.realtimeSinceStartup;
}
m_timeDt = Time.realtimeSinceStartup - m_lastTime;
m_lastTime = Time.realtimeSinceStartup;
if (Tileset == null)
{
EditorGUILayout.HelpBox("There is no tileset selected", MessageType.Info);
return;
}
else if (Tileset.AtlasTexture == null)
{
EditorGUILayout.HelpBox("There is no atlas texture set", MessageType.Info);
return;
}
else if (Tileset.Tiles.Count == 0)
{
EditorGUILayout.HelpBox("There are no tiles to show in the current tileset", MessageType.Info);
return;
}
if (m_scrollStyle == null)
{
m_scrollStyle = new GUIStyle("ScrollView");
}
if (m_customBox == null)
{
m_customBox = new GUIStyle("Box");
}
float visualTilePadding = 1;
bool isLeftMouseReleased = e.type == EventType.MouseUp && e.button == 0;
bool isRightMouseReleased = e.type == EventType.MouseUp && e.button == 1;
bool isInsideTileScrollArea = e.isMouse && m_rTileScrollArea.Contains(e.mousePosition);
bool isInsideBrushScrollArea = e.isMouse && m_rBrushScrollArea.Contains(e.mousePosition);
// TileViews
if (m_tileViewList == null || m_tileViewList.list != Tileset.TileViews)
{
if (e.type != EventType.Layout)
{
m_tileViewList = TilesetEditor.CreateTileViewReorderableList(Tileset);
m_tileViewList.onSelectCallback += (ReorderableList list) =>
{
m_viewMode = eViewMode.TileView;
RemoveTileSelection();
};
m_tileViewList.onRemoveCallback += (ReorderableList list) =>
{
RemoveTileSelection();
};
}
}
else
{
GUI.color = Color.cyan;
GUILayout.BeginVertical(m_customBox);
m_tileViewList.index = Mathf.Clamp(m_tileViewList.index, -1, Tileset.TileViews.Count - 1);
m_tileViewList.DoLayoutList();
Rect rList = GUILayoutUtility.GetLastRect();
if (e.isMouse && !rList.Contains(e.mousePosition))
{
m_tileViewList.ReleaseKeyboardFocus();
}
GUILayout.EndVertical();
GUI.color = Color.white;
}
TileView tileView = m_tileViewList != null && m_tileViewList.index >= 0 ? Tileset.TileViews[m_tileViewList.index] : null;
if (m_viewMode == eViewMode.Tileset)
{
Tileset.TileRowLength = Mathf.Clamp(EditorGUILayout.IntField("TileRowLength", Tileset.TileRowLength), 1, Tileset.Width);
}
m_viewMode = (eViewMode)EditorGUILayout.EnumPopup("View Mode", m_viewMode);
if (tileView == null)
{
m_viewMode = eViewMode.Tileset;
}
if (m_viewMode != m_prevViewMode)
{
m_prevViewMode = m_viewMode;
RemoveTileSelection();
}
// Draw Background Color Selector
Tileset.BackgroundColor = EditorGUILayout.ColorField("Background Color", Tileset.BackgroundColor);
if (m_prevBgColor != Tileset.BackgroundColor || m_scrollStyle.normal.background == null)
{
m_prevBgColor = Tileset.BackgroundColor;
if (m_scrollStyle.normal.background == null)
{
m_scrollStyle.normal.background = new Texture2D(1, 1)
{
hideFlags = HideFlags.DontSave
}
}
;
m_scrollStyle.normal.background.SetPixel(0, 0, Tileset.BackgroundColor);
m_scrollStyle.normal.background.Apply();
}
//---
string sTileIdLabel = Tileset.SelectedTileId != Tileset.k_TileId_Empty? " (id:" + Tileset.SelectedTileId + ")" : "";
EditorGUILayout.LabelField("Tile Palette" + sTileIdLabel, EditorStyles.boldLabel);
// keeps values safe
m_tileViewRowLength = Mathf.Max(1, m_tileViewRowLength);
float tileAreaWidth = m_tileViewRowLength * (Tileset.VisualTileSize.x + visualTilePadding) + 4f;
float tileAreaHeight = (Tileset.VisualTileSize.y + visualTilePadding) * (1 + (m_visibleTileCount - 1) / m_tileViewRowLength) + 4f;
m_tileViewRowLength = m_viewMode == eViewMode.TileView && tileView != null ? tileView.tileSelection.rowLength : Tileset.TileRowLength;
m_tilesScrollPos = EditorGUILayout.BeginScrollView(m_tilesScrollPos, m_scrollStyle);
{
// Scroll Moving Drag
if (e.type == EventType.MouseDrag && (e.button == 1 || e.button == 2))
{
m_tilesScrollPos -= e.delta;
}
else
{
DoAutoScroll();
}
if (e.isMouse)
{
m_lastTileScrollMousePos = e.mousePosition;
}
if (Tileset.Tiles != null)
{
GUILayoutUtility.GetRect(tileAreaWidth, tileAreaHeight);
m_visibleTileCount = 0;
List <uint> visibleTileList = new List <uint>();
int tileViewWidth = m_viewMode == eViewMode.Tileset ? Tileset.Width : tileView.tileSelection.rowLength;
int tileViewHeight = m_viewMode == eViewMode.Tileset ? Tileset.Height : ((tileView.tileSelection.selectionData.Count - 1) / tileView.tileSelection.rowLength) + 1;
int totalCount = ((((tileViewWidth - 1) / m_tileViewRowLength) + 1) * m_tileViewRowLength) * tileViewHeight;
for (int i = 0; i < totalCount; ++i)
{
int tileId = GetTileIdFromIdx(i, m_tileViewRowLength, tileViewWidth, tileViewHeight);
uint tileData = (uint)tileId;
if (m_viewMode == eViewMode.TileView && tileId != Tileset.k_TileId_Empty)
{
tileData = tileView.tileSelection.selectionData[tileId];
tileId = (int)(tileData & Tileset.k_TileDataMask_TileId);
}
Tile tile = tileId != Tileset.k_TileId_Empty && tileId < Tileset.Tiles.Count ? Tileset.Tiles[tileId] : null;
visibleTileList.Add(tileData);
int tx = m_visibleTileCount % m_tileViewRowLength;
int ty = m_visibleTileCount / m_tileViewRowLength;
Rect rVisualTile = new Rect(2 + tx * (Tileset.VisualTileSize.x + visualTilePadding), 2 + ty * (Tileset.VisualTileSize.y + visualTilePadding), Tileset.VisualTileSize.x, Tileset.VisualTileSize.y);
// Optimization, skipping not visible tiles
Rect rLocalVisualTile = rVisualTile; rLocalVisualTile.position -= m_tilesScrollPos;
if (!rLocalVisualTile.Overlaps(m_rTileScrollSize))
{
; // Do Nothing
}
else
//---
{
// Draw Tile
if (tile == null)
{
HandlesEx.DrawRectWithOutline(rVisualTile, new Color(0f, 0f, 0f, 0.2f), new Color(0f, 0f, 0f, 0.2f));
}
else
{
HandlesEx.DrawRectWithOutline(rVisualTile, new Color(0f, 0f, 0f, 0.1f), new Color(0f, 0f, 0f, 0.1f));
TilesetEditor.DoGUIDrawTileFromTileData(rVisualTile, tileData, Tileset);
}
Rect rTileRect = new Rect(2 + tx * (Tileset.VisualTileSize.x + visualTilePadding), 2 + ty * (Tileset.VisualTileSize.y + visualTilePadding), (Tileset.VisualTileSize.x + visualTilePadding), (Tileset.VisualTileSize.y + visualTilePadding));
if (rVisualTile.Contains(e.mousePosition))
{
if (e.type == EventType.MouseDrag && e.button == 0)
{
m_pointedTileIdxRect = new KeyValuePair <int, Rect>(m_visibleTileCount, rTileRect);
}
else if (e.type == EventType.MouseDown && e.button == 0)
{
m_startDragTileIdxRect = m_pointedTileIdxRect = m_endDragTileIdxRect = new KeyValuePair <int, Rect>(m_visibleTileCount, rTileRect);
}
else if (e.type == EventType.MouseUp && e.button == 0)
{
m_endDragTileIdxRect = new KeyValuePair <int, Rect>(m_visibleTileCount, rTileRect);
DoSetTileSelection();
}
}
if ((isLeftMouseReleased || isRightMouseReleased) && isInsideTileScrollArea && rVisualTile.Contains(e.mousePosition) &&
(m_startDragTileIdxRect.Key == m_endDragTileIdxRect.Key) && // and there is not dragging selection
m_rTileScrollSize.Contains(e.mousePosition - m_tilesScrollPos)) // and it's inside the scroll area
{
Tileset.SelectedTileId = tileId;
//Give focus to SceneView to get key events
FocusSceneView();
if (isRightMouseReleased)
{
TilePropertiesWindow.Show(Tileset);
}
}
else if (tile != null && Tileset.SelectedTileId == tileId)
{
HandlesEx.DrawRectWithOutline(rTileRect, new Color(0f, 0f, 0f, 0.1f), new Color(1f, 1f, 0f, 1f));
}
}
++m_visibleTileCount;
}
m_visibleTileList = visibleTileList;
// Draw selection rect
if (m_startDragTileIdxRect.Key != m_pointedTileIdxRect.Key /*&& m_startDragTileIdxRect.Key == m_endDragTileIdxRect.Key*/)
{
Rect rSelection = new Rect(m_startDragTileIdxRect.Value.center, m_pointedTileIdxRect.Value.center - m_startDragTileIdxRect.Value.center);
rSelection.Set(Mathf.Min(rSelection.xMin, rSelection.xMax), Mathf.Min(rSelection.yMin, rSelection.yMax), Mathf.Abs(rSelection.width), Mathf.Abs(rSelection.height));
rSelection.xMin -= m_startDragTileIdxRect.Value.width / 2;
rSelection.xMax += m_startDragTileIdxRect.Value.width / 2;
rSelection.yMin -= m_startDragTileIdxRect.Value.height / 2;
rSelection.yMax += m_startDragTileIdxRect.Value.height / 2;
HandlesEx.DrawRectWithOutline(rSelection, new Color(0f, 0f, 0f, 0.1f), new Color(1f, 1f, 1f, 1f));
}
}
}
EditorGUILayout.EndScrollView();
if (e.type == EventType.Repaint)
{
m_rTileScrollArea = GUILayoutUtility.GetLastRect();
m_rTileScrollSize = m_rTileScrollArea;
m_rTileScrollSize.position = Vector2.zero; // reset position to the Contains and Overlaps inside the tile scroll view without repositioning the position of local positions
if (tileAreaWidth > m_rTileScrollSize.width)
{
m_rTileScrollSize.height -= GUI.skin.verticalScrollbar.fixedWidth;
}
if (tileAreaHeight > m_rTileScrollSize.height)
{
m_rTileScrollSize.width -= GUI.skin.verticalScrollbar.fixedWidth;
}
}
EditorGUILayout.BeginHorizontal();
string sBrushIdLabel = Tileset.SelectedBrushId > 0 ? " (id:" + Tileset.SelectedBrushId + ")" : "";
EditorGUILayout.LabelField("Brush Palette" + sBrushIdLabel, EditorStyles.boldLabel);
m_displayBrushReordList = EditorUtils.DoToggleButton("Display List", m_displayBrushReordList);
EditorGUILayout.EndHorizontal();
int tileRowLength = (int)(m_rTileScrollSize.width / (Tileset.VisualTileSize.x + visualTilePadding));
if (tileRowLength <= 0)
{
tileRowLength = 1;
}
float fBrushesScrollMaxHeight = Screen.height / 4;
//commented because m_rTileScrollSize.width.height was changed to Screen.height; fBrushesScrollMaxHeight -= fBrushesScrollMaxHeight % 2; // sometimes because size of tile scroll affects size of brush scroll, the height is dancing between +-1, so this is always taking the pair value
float fBrushesScrollHeight = Mathf.Min(fBrushesScrollMaxHeight, 4 + (Tileset.VisualTileSize.y + visualTilePadding) * (1 + (Tileset.Brushes.Count / tileRowLength)));
EditorGUILayout.BeginVertical(GUILayout.MinHeight(fBrushesScrollHeight));
if (m_displayBrushReordList)
{
DisplayBrushReorderableList();
}
else
{
bool isRefreshBrushes = false;
m_brushesScrollPos = EditorGUILayout.BeginScrollView(m_brushesScrollPos, m_scrollStyle);
{
Rect rScrollView = new Rect(0, 0, m_rTileScrollSize.width, 0);
tileRowLength = Mathf.Clamp((int)rScrollView.width / (int)(Tileset.VisualTileSize.x + visualTilePadding), 1, tileRowLength);
if (Tileset.Brushes != null)
{
GUILayout.Space((Tileset.VisualTileSize.y + visualTilePadding) * (1 + (Tileset.Brushes.Count - 1) / tileRowLength));
for (int i = 0; i < Tileset.Brushes.Count; ++i)
{
Tileset.BrushContainer brushCont = Tileset.Brushes[i];
if (brushCont.BrushAsset == null)
{
isRefreshBrushes = true;
continue;
}
int tx = i % tileRowLength;
int ty = i / tileRowLength;
Rect rVisualTile = new Rect(2 + tx * (Tileset.VisualTileSize.x + visualTilePadding), 2 + ty * (Tileset.VisualTileSize.y + visualTilePadding), Tileset.VisualTileSize.x, Tileset.VisualTileSize.y);
//Fix Missing Tileset reference
if (brushCont.BrushAsset.Tileset == null)
{
Debug.LogWarning("Fixed missing tileset reference in brush " + brushCont.BrushAsset.name + " Id(" + brushCont.Id + ")");
brushCont.BrushAsset.Tileset = Tileset;
}
uint tileData = Tileset.k_TileData_Empty;
if (brushCont.BrushAsset.IsAnimated())
{
tileData = brushCont.BrushAsset.GetAnimTileData();
}
else
{
tileData = brushCont.BrushAsset.PreviewTileData();
}
TilesetEditor.DoGUIDrawTileFromTileData(rVisualTile, tileData, Tileset, brushCont.BrushAsset.GetAnimUV());
if ((isLeftMouseReleased || isRightMouseReleased || m_dblClick.IsDblClick) && isInsideBrushScrollArea && rVisualTile.Contains(Event.current.mousePosition))
{
Tileset.SelectedBrushId = brushCont.Id;
RemoveTileSelection();
if (m_dblClick.IsDblClick)
{
EditorGUIUtility.PingObject(brushCont.BrushAsset);
m_selectBrushInInspector = brushCont.BrushAsset;
}
if (isRightMouseReleased)
{
TilePropertiesWindow.Show(Tileset);
}
}
else if (Tileset.SelectedBrushId == brushCont.Id)
{
Rect rSelection = new Rect(2 + tx * (Tileset.VisualTileSize.x + visualTilePadding), 2 + ty * (Tileset.VisualTileSize.y + visualTilePadding), (Tileset.VisualTileSize.x + visualTilePadding), (Tileset.VisualTileSize.y + visualTilePadding));
HandlesEx.DrawRectWithOutline(rSelection, new Color(0f, 0f, 0f, 0.1f), new Color(1f, 1f, 0f, 1f));
}
}
}
if (isRefreshBrushes)
{
Tileset.RemoveNullBrushes();
}
}
EditorGUILayout.EndScrollView();
if (e.type == EventType.Repaint)
{
m_rBrushScrollArea = GUILayoutUtility.GetLastRect();
}
}
EditorGUILayout.EndVertical();
if (GUILayout.Button("Import all brushes found"))
{
TilesetEditor.AddAllBrushesFoundInTheProject(Tileset);
EditorUtility.SetDirty(Tileset);
}
}
public void ReleaseKeyboardFocus()
{
reorderableList.ReleaseKeyboardFocus();
}
public bool Draw(Rect parentPosition, ParentNode selectedNode, Vector2 mousePosition, int mouseButtonId, bool hasKeyboardFocus)
{
bool changeCheck = false;
base.Draw(parentPosition, mousePosition, mouseButtonId, hasKeyboardFocus);
if (m_nodePropertiesStyle == null)
{
m_nodePropertiesStyle = UIUtils.GetCustomStyle(CustomStyle.NodePropertiesTitle);
m_nodePropertiesStyle.normal.textColor = m_nodePropertiesStyle.active.textColor = EditorGUIUtility.isProSkin ? new Color(1f, 1f, 1f) : new Color(0f, 0f, 0f);
}
if (m_isMaximized)
{
KeyCode key = Event.current.keyCode;
if (m_isMouseInside || hasKeyboardFocus)
{
if (key == ShortcutsManager.ScrollUpKey)
{
m_currentScrollPos.y -= 10;
if (m_currentScrollPos.y < 0)
{
m_currentScrollPos.y = 0;
}
Event.current.Use();
}
if (key == ShortcutsManager.ScrollDownKey)
{
m_currentScrollPos.y += 10;
Event.current.Use();
}
}
if (m_forceUpdate)
{
if (m_propertyReordableList != null)
{
m_propertyReordableList.ReleaseKeyboardFocus();
}
m_propertyReordableList = null;
if (m_functionInputsReordableList != null)
{
m_functionInputsReordableList.ReleaseKeyboardFocus();
}
m_functionInputsReordableList = null;
if (m_functionSwitchesReordableList != null)
{
m_functionSwitchesReordableList.ReleaseKeyboardFocus();
}
m_functionSwitchesReordableList = null;
if (m_functionOutputsReordableList != null)
{
m_functionOutputsReordableList.ReleaseKeyboardFocus();
}
m_functionOutputsReordableList = null;
m_forceUpdate = false;
}
GUILayout.BeginArea(m_transformedArea, m_content, m_style);
{
//Draw selected node parameters
if (selectedNode != null)
{
// this hack is need because without it the several FloatFields/Textfields/... would show wrong values ( different from the ones they were assigned to show )
if (m_lastSelectedNode != selectedNode.UniqueId)
{
m_lastSelectedNode = selectedNode.UniqueId;
GUI.FocusControl("");
}
EditorGUILayout.BeginVertical();
{
EditorGUILayout.Separator();
if (selectedNode.UniqueId == ParentWindow.CurrentGraph.CurrentMasterNodeId)
{
m_dummyContent.text = "Output Node";
}
else
{
if (selectedNode.Attributes != null)
{
m_dummyContent.text = selectedNode.Attributes.Name;
}
else if (selectedNode is CommentaryNode)
{
m_dummyContent.text = "Commentary";
}
else
{
m_dummyContent.text = TitleStr;
}
}
EditorGUILayout.LabelField(m_dummyContent, m_nodePropertiesStyle);
EditorGUILayout.Separator();
//UIUtils.RecordObject( selectedNode , "Changing properties on node " + selectedNode.UniqueId);
m_currentScrollPos = EditorGUILayout.BeginScrollView(m_currentScrollPos, GUILayout.Width(0), GUILayout.Height(0));
float labelWidth = EditorGUIUtility.labelWidth;
//if( selectedNode.TextLabelWidth > 0 )
// EditorGUIUtility.labelWidth = selectedNode.TextLabelWidth;
//else
EditorGUIUtility.labelWidth = TransformedArea.width * 0.42f;
changeCheck = selectedNode.SafeDrawProperties();
EditorGUIUtility.labelWidth = labelWidth;
EditorGUILayout.EndScrollView();
}
EditorGUILayout.EndVertical();
if (changeCheck)
{
if (selectedNode.ConnStatus == NodeConnectionStatus.Connected)
{
ParentWindow.SetSaveIsDirty();
}
}
}
else
{
//Draw Graph Params
EditorGUILayout.BeginVertical();
{
EditorGUILayout.Separator();
EditorGUILayout.LabelField("Graph Properties", m_nodePropertiesStyle);
EditorGUILayout.Separator();
m_currentScrollPos = EditorGUILayout.BeginScrollView(m_currentScrollPos, GUILayout.Width(0), GUILayout.Height(0));
float labelWidth = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth = 90;
bool generalIsVisible = m_parentWindow.InnerWindowVariables.ExpandedGeneralShaderOptions;
NodeUtils.DrawPropertyGroup(ref generalIsVisible, " General", DrawGeneralFunction);
m_parentWindow.InnerWindowVariables.ExpandedGeneralShaderOptions = generalIsVisible;
AmplifyShaderFunction function = ParentWindow.CurrentGraph.CurrentShaderFunction;
if (function != null)
{
//function.AdditionalIncludes.Draw( ParentWindow.CurrentGraph.CurrentOutputNode );
//function.AdditionalPragmas.Draw( ParentWindow.CurrentGraph.CurrentOutputNode );
function.AdditionalDirectives.Draw(ParentWindow.CurrentGraph.CurrentOutputNode);
}
bool inputIsVisible = m_parentWindow.InnerWindowVariables.ExpandedFunctionInputs;
NodeUtils.DrawPropertyGroup(ref inputIsVisible, " Function Inputs", DrawFunctionInputs);
m_parentWindow.InnerWindowVariables.ExpandedFunctionInputs = inputIsVisible;
bool swicthIsVisible = m_parentWindow.InnerWindowVariables.ExpandedFunctionSwitches;
NodeUtils.DrawPropertyGroup(ref swicthIsVisible, " Function Switches", DrawFunctionSwitches);
m_parentWindow.InnerWindowVariables.ExpandedFunctionSwitches = swicthIsVisible;
bool outputIsVisible = m_parentWindow.InnerWindowVariables.ExpandedFunctionOutputs;
NodeUtils.DrawPropertyGroup(ref outputIsVisible, " Function Outputs", DrawFunctionOutputs);
m_parentWindow.InnerWindowVariables.ExpandedFunctionOutputs = outputIsVisible;
bool properties = ParentWindow.InnerWindowVariables.ExpandedProperties;
NodeUtils.DrawPropertyGroup(ref properties, " Material Properties", DrawFunctionProperties);
ParentWindow.InnerWindowVariables.ExpandedProperties = properties;
EditorGUIUtility.labelWidth = labelWidth;
EditorGUILayout.EndScrollView();
}
EditorGUILayout.EndVertical();
}
}
// Close window area
GUILayout.EndArea();
}
PostDraw();
return(changeCheck);
}
private void DisplayParameters()
{
Event e = Event.current;
TileSelection tileSelection = Tileset.TileSelection;
if (tileSelection != null)
{
EditorGUILayout.LabelField("Multi-tile editing. Only merge allowed.", EditorStyles.boldLabel);
EditorGUILayout.Space();
EditorGUILayout.HelpBox("This will combine all the parameters found in the tile selection so if a parameter is missing in a tile, it will add the parameter, but if it has it already, it won't change the value.", MessageType.Info);
if (GUILayout.Button("Merge Tile Parameters"))
{
MergeTileParameters(tileSelection.selectionData);
}
EditorGUILayout.Space();
}
else
{
UnityEngine.Object prevOwner = m_parameterListOwner;
if (Tileset.SelectedBrushId != Tileset.k_BrushId_Default)
{
m_parameterListOwner = Tileset.FindBrush(Tileset.SelectedBrushId);
}
else
{
m_parameterListOwner = Tileset;
}
if (m_parameterListOwner != null)
{
if (prevOwner != m_parameterListOwner || Tileset.SelectedTileId != m_prevSelectedTileId || m_tileParameterList == null)
{
m_prevSelectedTileId = Tileset.SelectedTileId;
m_tileParameterList = CreateParameterReorderableList(m_parameterListOwner is Tileset ?
((Tileset)m_parameterListOwner).SelectedTile.paramContainer :
((TilesetBrush)m_parameterListOwner).Params);
m_tileParameterList.onChangedCallback += (ReorderableList list) =>
{
EditorUtility.SetDirty(m_parameterListOwner);
};
}
GUILayoutUtility.GetRect(1, 1, GUILayout.Width(Tileset.VisualTileSize.x), GUILayout.Height(Tileset.VisualTileSize.y));
uint tilePreviewData = m_parameterListOwner is Tileset ?
(uint)(((Tileset)m_parameterListOwner).SelectedTileId & Tileset.k_TileDataMask_TileId)
:
((TilesetBrush)m_parameterListOwner).GetAnimTileData();
Rect customUV = m_parameterListOwner is Tileset ? default(Rect) : ((TilesetBrush)m_parameterListOwner).GetAnimUV();
GUI.color = Tileset.BackgroundColor;
GUI.DrawTexture(GUILayoutUtility.GetLastRect(), EditorGUIUtility.whiteTexture);
GUI.color = Color.white;
TilesetEditor.DoGUIDrawTileFromTileData(GUILayoutUtility.GetLastRect(), tilePreviewData, Tileset, customUV);
m_tileParamScrollViewPos = EditorGUILayout.BeginScrollView(m_tileParamScrollViewPos, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
EditorGUI.BeginChangeCheck();
m_tileParameterList.DoLayoutList();
Rect rList = GUILayoutUtility.GetLastRect();
if (e.type == EventType.MouseDown && !rList.Contains(e.mousePosition))
{
m_tileParameterList.ReleaseKeyboardFocus();
m_tileParameterList.index = -1;
}
if (EditorGUI.EndChangeCheck())
{
EditorUtility.SetDirty(m_parameterListOwner);
}
EditorGUILayout.EndScrollView();
}
}
}
void NotifyEventsDatasetChanged()
{
eventsList.ReleaseKeyboardFocus();
CreateEventOrderableList();
}
void NotifyGroupDatasetChanged()
{
groupsList.list = EventsManager.Instance.GroupsContainer.GroupNames;
groupsList.ReleaseKeyboardFocus();
}
private void DrawElementCallback(ReorderableList list, Rect rect, int index, bool isactive, bool isfocused)
{
Event e = Event.current;
if (_editMode)
{
if (_editMode && (_lastIndex != index || _lastList != list) && isactive)
{
if (_lastList != null)
{
_lastList.ReleaseKeyboardFocus();
_lastList.index = -1;
}
_clearEdit();
_lastIndex = index;
_lastList = list;
}
if (e.type == EventType.KeyDown)
{
if (e.keyCode == KeyCode.Escape)
{
list.ReleaseKeyboardFocus();
_clearEdit();
e.Use();
return;
}
}
}
if (isactive)
{
if (e.type == EventType.MouseDown)
{
if (e.button == 0)
{
if (e.clickCount >= 2 && !_editMode)
{
_setEdit(list, index);
e.Use();
}
}
}
}
if (_editMode && isactive)
{
NodePort oldPort = ((NodePort)list.list[index]);
GUI.SetNextControlName(index.ToString());
EditorGUI.FocusTextInControl(index.ToString());
string newName = oldPort.fieldName;
EditorGUI.BeginChangeCheck();
{
bool contains = false;
Rect lastRect;
try
{
newName = EditorGUI.DelayedTextField(rect, oldPort.fieldName);
lastRect = new Rect(GUILayoutUtility.GetLastRect());
var y = lastRect.yMax - list.GetHeight(); // ReorderableList start Y pos
y += 20; // add ReorderableList title pos
y += index * 20f; //add element y pos
lastRect.position = new Vector2(lastRect.position.x, y);
contains = lastRect.Contains(e.mousePosition);
if (e.type == EventType.MouseDown && !contains)
{
_clearEdit();
Event.current.Use();
}
}
catch (ArgumentException)
{
if (!contains)
{
_clearEdit();
}
}
}
if (EditorGUI.EndChangeCheck())
{
_clearEdit();
string oldName = oldPort.fieldName;
target.PortRename(oldPort, newName);
//update all use this group of graph GetChildGroup Node
_updateGetChildNodeGroup((group, node) =>
{
node.PortRename(node.GetPort(oldName), newName);
});
}
}
}