public static MultiColumnHeaderState CreateDefaultMultiColumnHeaderState(float treeViewWidth)
{
var columns = new[]
{
new MultiColumnHeaderState.Column
{
headerContent = new GUIContent(EditorGUIUtility.FindTexture("FilterByLabel"), "Lorem ipsum dolor sit amet, consectetur adipiscing elit. "),
contextMenuText = "Asset",
headerTextAlignment = TextAlignment.Center,
sortedAscending = true,
sortingArrowAlignment = TextAlignment.Right,
width = 30,
minWidth = 30,
maxWidth = 60,
autoResize = false,
allowToggleVisibility = true
},
new MultiColumnHeaderState.Column
{
headerContent = new GUIContent(EditorGUIUtility.FindTexture("FilterByType"), "Sed hendrerit mi enim, eu iaculis leo tincidunt at."),
contextMenuText = "Type",
headerTextAlignment = TextAlignment.Center,
sortedAscending = true,
sortingArrowAlignment = TextAlignment.Right,
width = 30,
minWidth = 30,
maxWidth = 60,
autoResize = false,
allowToggleVisibility = true
},
new MultiColumnHeaderState.Column
{
headerContent = new GUIContent("Name"),
headerTextAlignment = TextAlignment.Left,
sortedAscending = true,
sortingArrowAlignment = TextAlignment.Center,
width = 150,
minWidth = 60,
autoResize = false,
allowToggleVisibility = false
},
new MultiColumnHeaderState.Column
{
headerContent = new GUIContent("Multiplier", "In sed porta ante. Nunc et nulla mi."),
headerTextAlignment = TextAlignment.Right,
sortedAscending = true,
sortingArrowAlignment = TextAlignment.Left,
width = 110,
minWidth = 60,
autoResize = true
},
new MultiColumnHeaderState.Column
{
headerContent = new GUIContent("Material", "Maecenas congue non tortor eget vulputate."),
headerTextAlignment = TextAlignment.Right,
sortedAscending = true,
sortingArrowAlignment = TextAlignment.Left,
width = 95,
minWidth = 60,
autoResize = true,
allowToggleVisibility = true
},
new MultiColumnHeaderState.Column
{
headerContent = new GUIContent("Note", "Nam at tellus ultricies ligula vehicula ornare sit amet quis metus."),
headerTextAlignment = TextAlignment.Right,
sortedAscending = true,
sortingArrowAlignment = TextAlignment.Left,
width = 70,
minWidth = 60,
autoResize = true
},
new MultiColumnHeaderState.Column
{
headerContent = new GUIContent("Properties", "Nam at tellus ultricies ligula vehicula ornare sit amet quis metus."),
headerTextAlignment = TextAlignment.Right,
sortedAscending = true,
sortingArrowAlignment = TextAlignment.Left,
width = 70,
minWidth = 60,
autoResize = true
}
};
Assert.AreEqual(columns.Length, Enum.GetValues(typeof(MyColumns)).Length, "Number of columns should match number of enum values: You probably forgot to update one of them.");
var state = new MultiColumnHeaderState(columns);
return(state);
}
public override void OnDrawScrollArea()
{
GUILayout.Label(new GUIContent($"Event fixer will replace all saved EventData please be careful", EditorGUIUtility.FindTexture("console.erroricon")));
foreach (var item in needFixEventData)
{
using (var horizon = new EditorGUILayout.HorizontalScope("box"))
{
item.fix = EditorGUILayout.ToggleLeft(GUIContent.none, item.fix, GUILayout.Width(20));
using (var vertical = new EditorGUILayout.VerticalScope())
{
using (var horizon2 = new EditorGUILayout.HorizontalScope())
{
GUILayout.Label($"Method : [{item.originalMethodName}] in Script : [{item.originalScriptName}]");
using (var disable = new EditorGUI.DisabledGroupScope(!classMethodInfo.ContainsKey(item.originalScriptName)))
{
if (GUILayout.Button("Apply Origin Data"))
{
item.modifyScriptName = item.originalScriptName;
item.modifyMethodName = item.originalMethodName;
}
}
}
int currentSelectClass = string.IsNullOrEmpty(item.modifyScriptName) ? 0 : classMethodInfo.Values.ToList().IndexOf(classMethodInfo[item.modifyScriptName]);
using (var check = new EditorGUI.ChangeCheckScope())
{
currentSelectClass = EditorGUILayout.Popup("Event Script", currentSelectClass, classMethodInfo.Select(m => m.Key).ToArray());
if (check.changed)
{
ViewSystemLog.Log(currentSelectClass);
if (currentSelectClass != 0)
{
var c = classMethodInfo.ElementAt(currentSelectClass);
item.modifyScriptName = c.Key;
item.modifyMethodName = "";
}
else
{
item.modifyScriptName = "";
item.modifyMethodName = "";
}
}
}
if (currentSelectClass != 0)
{
using (var check = new EditorGUI.ChangeCheckScope())
{
using (var horizon2 = new EditorGUILayout.HorizontalScope())
{
var c = classMethodInfo.ElementAt(currentSelectClass).Value;
var current = c.SingleOrDefault(m => m.name == item.modifyMethodName);
CMEditorLayout.GroupedPopupField(item.GetHashCode(), new GUIContent("Event Method"), c, current,
(select) =>
{
item.modifyMethodName = select.name;
}
);
}
}
}
}
}
}
}
public void SetData(List <string> propertyCannotBeFound, IEnumerable <ViewSystemComponentData> allComponentDatas, ViewSystemSaveData saveData, Action OnComplete)
{
titleContent = new GUIContent("Missing property fixer");
this.allComponentDatas = allComponentDatas;
this.icon = EditorGUIUtility.FindTexture("MetaFile Icon");
this.lable = "Select the property your wish to fix";
fixerDatas = propertyCannotBeFound.Select(
m =>
{
var x = m.Split(',');
return(new { componentName = x[0], propertyName = x[1] });
}
).GroupBy(m => m.componentName).ToDictionary(o => o.Key, o => o.Select(r => new FixerData(r.propertyName)).ToList());
foreach (var item in fixerDatas)
{
var type = MacacaGames.Utility.GetType(item.Key);
var fis = type.GetFields(ViewSystemVerifier.bindingFlags).Select(m => new CMEditorLayout.GroupedPopupData {
name = m.Name, group = "Filed"
});
var pis = type.GetProperties(ViewSystemVerifier.bindingFlags).Select(m => new CMEditorLayout.GroupedPopupData {
name = m.Name, group = "Property"
});
List <CMEditorLayout.GroupedPopupData> gList = new List <CMEditorLayout.GroupedPopupData>();
gList.AddRange(pis);
gList.AddRange(fis);
fieldsInComponents.Add(item.Key, gList);
}
OnAllClick += () =>
{
fixerDatas.All(x =>
{
x.Value.All(
r =>
{
r.fix = true;
return(true);
}
);
return(true);
});
};
OnNoneClick += () =>
{
fixerDatas.All(x =>
{
x.Value.All(
r =>
{
r.fix = false;
return(true);
}
);
return(true);
});
};
OnCancelClick += () =>
{
};
OnApplyClick += () =>
{
foreach (var item in fixerDatas)
{
var ac = allComponentDatas.Where(m => m.targetComponentType == item.Key);
foreach (var item2 in item.Value)
{
if (item2.delete && item2.fix == true)
{
foreach (var vp in saveData.viewPages)
{
foreach (var vpi in vp.viewPage.viewPageItems)
{
vpi.overrideDatas.RemoveAll(m => m.targetComponentType == item.Key && m.targetPropertyName == item2.originalPropertyName);
}
}
foreach (var vs in saveData.viewStates)
{
foreach (var vpi in vs.viewState.viewPageItems)
{
vpi.overrideDatas.RemoveAll(m => m.targetComponentType == item.Key && m.targetPropertyName == item2.originalPropertyName);
}
}
continue;
}
if (string.IsNullOrEmpty(item2.modifiedPropertyName))
{
continue;
}
if (item2.fix == false)
{
continue;
}
ac.Where(m => m.targetPropertyName == item2.originalPropertyName).All(
x =>
{
x.targetPropertyName = item2.modifiedPropertyName;
return(true);
}
);
}
}
};
}
private void OnEnable()
{
_prefabIcon = EditorGUIUtility.FindTexture("Prefab Icon");
Selection.selectionChanged += HandleSelectionChanged;
}
void DrawInstallation()
{
SetWindowHeight(320f);
if (EditorApplication.isCompiling)
{
EditorGUILayout.Space();
EditorGUILayout.LabelField(new GUIContent(" Compiling scripts...", EditorGUIUtility.FindTexture("cs Script Icon")), Header);
EditorGUILayout.Space();
return;
}
if (StylizedWaterCore.compatibleVersion == false && StylizedWaterCore.untestedVersion == false)
{
GUI.contentColor = Color.red;
EditorGUILayout.LabelField("This version of Unity is not supported.", EditorStyles.boldLabel);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Please upgrade to at least Unity " + StylizedWaterCore.MIN_UNITY_VERSION);
return;
}
//Folder
EditorGUILayout.BeginHorizontal(EditorStyles.helpBox);
EditorGUILayout.LabelField("Unity version");
Color defaultColor = GUI.contentColor;
if (StylizedWaterCore.compatibleVersion)
{
GUI.contentColor = Color.green;
EditorGUILayout.LabelField("Compatible");
GUI.contentColor = defaultColor;
}
else if (StylizedWaterCore.untestedVersion)
{
GUI.contentColor = new Color(1f, 0.65f, 0f);
EditorGUILayout.LabelField("Untested", EditorStyles.boldLabel);
GUI.contentColor = defaultColor;
}
EditorGUILayout.EndHorizontal();
if (StylizedWaterCore.untestedVersion)
{
EditorGUILayout.LabelField("The current Unity version has not been tested yet, or compatibility is being worked on. You may run into issues.", EditorStyles.helpBox);
EditorGUILayout.Space();
}
if (EditorUserBuildSettings.activeBuildTarget == BuildTarget.Android ||
EditorUserBuildSettings.activeBuildTarget == BuildTarget.iOS)
{
//PPSv2
EditorGUILayout.BeginHorizontal(EditorStyles.helpBox);
EditorGUILayout.LabelField("Target graphics API");
if (PlayerSettings.GetGraphicsAPIs(BuildTarget.Android)[0] != UnityEngine.Rendering.GraphicsDeviceType.OpenGLES2 || PlayerSettings.GetGraphicsAPIs(BuildTarget.iOS)[0] != UnityEngine.Rendering.GraphicsDeviceType.OpenGLES2)
{
GUI.contentColor = Color.green;
EditorGUILayout.LabelField("OpenGL ES 3.0 or better");
GUI.contentColor = defaultColor;
}
else
{
GUI.contentColor = Color.red;
EditorGUILayout.LabelField("OpenGL ES 2.0", EditorStyles.boldLabel);
GUI.contentColor = defaultColor;
}
EditorGUILayout.EndHorizontal();
}
//Version
EditorGUILayout.BeginHorizontal(EditorStyles.helpBox);
EditorGUILayout.LabelField("Package version");
defaultColor = GUI.contentColor;
if (StylizedWaterCore.IS_UPDATED)
{
GUI.contentColor = Color.green;
EditorGUILayout.LabelField("Up-to-date");
GUI.contentColor = defaultColor;
}
else
{
GUILayout.FlexibleSpace();
GUI.contentColor = new Color(1f, 0.65f, 0f);
EditorGUILayout.LabelField("Outdated", EditorStyles.boldLabel);
GUI.contentColor = defaultColor;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("");
if (!StylizedWaterCore.IS_UPDATED)
{
if (GUILayout.Button(new GUIContent("Update package"), UpdateText))
{
StylizedWaterCore.OpenStorePage();
}
}
EditorGUILayout.EndHorizontal();
}
private static void FindMessageIcons()
{
s_ErrorIcon = EditorGUIUtility.FindTexture("console.errorIcon");
s_WarningIcon = EditorGUIUtility.FindTexture("console.warnicon");
s_InfoIcon = EditorGUIUtility.FindTexture("console.infoIcon");
}
private static void MenuCreatePostProcessingProfile()
{
var icon = EditorGUIUtility.FindTexture("ImageSequence Icon");
ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, ScriptableObject.CreateInstance <DoCreateImageSequenceAsset>(), "New Image Sequence.asset", icon, null);
}
public static Texture2D GetIconForFile(string fileName)
{
return(FindIconForFile(fileName) ?? EditorGUIUtility.FindTexture(typeof(DefaultAsset)));
}
public void Display()
{
AssetPreview.SetPreviewTextureCacheSize(256); //FIX clickeing issues when displaying multiple prefab previews (when a tile has a prefab attached
Event e = Event.current;
m_dblClick.Update();
//FIX: when a tileset is changed, the layout change and during some frames, the BeginScrollView could return wrong values
// This will make sure the scroll position is updated after mouse is over the control
if (e.isMouse || e.type == EventType.ScrollWheel)
{
m_updateScrollPos = true;
}
// 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;
}
m_sharedData = GetSharedTilesetData(Tileset);
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);
// Create TileView ReorderableList
if (m_sharedData.tileViewList == null || m_sharedData.tileViewList.list != Tileset.TileViews)
{
m_sharedData.tileViewList = TilesetEditor.CreateTileViewReorderableList(Tileset);
m_sharedData.tileViewList.onSelectCallback += (ReorderableList list) =>
{
/* NOTE: this will select the tileview for the painting brush. Commented just in case.
* if(list.index >= 0)
* {
* TileSelection tileSelection = Tileset.TileViews[list.index].tileSelection.Clone();
* tileSelection.FlipVertical();
* Tileset.TileSelection = tileSelection;
* }
* else*/
RemoveTileSelection();
};
m_sharedData.tileViewList.onRemoveCallback += (ReorderableList list) =>
{
RemoveTileSelection();
};
}
// Draw TileView ReorderableList
{
GUI.color = Color.cyan;
GUILayout.BeginVertical(Styles.Instance.customBox);
m_sharedData.tileViewList.index = Mathf.Clamp(m_sharedData.tileViewList.index, -1, Tileset.TileViews.Count - 1);
m_sharedData.tileViewList.DoLayoutList();
Rect rList = GUILayoutUtility.GetLastRect();
if (e.isMouse && !rList.Contains(e.mousePosition))
{
m_sharedData.tileViewList.ReleaseKeyboardFocus();
}
GUILayout.EndVertical();
GUI.color = Color.white;
}
TileView tileView = m_sharedData.tileViewList != null && m_sharedData.tileViewList.index >= 0 ? Tileset.TileViews[m_sharedData.tileViewList.index] : null;
if (tileView == null)
{
Tileset.TileRowLength = Mathf.Clamp(EditorGUILayout.IntField("TileRowLength", Tileset.TileRowLength), 1, Tileset.Width);
}
List <string> viewNameList = new List <string>()
{
"(All)"
};
viewNameList.AddRange(Tileset.TileViews.Select(x => x.name));
string[] tileViewNames = viewNameList.ToArray();
int[] tileViewValues = Enumerable.Range(-1, Tileset.TileViews.Count + 1).ToArray();
EditorGUI.BeginChangeCheck();
m_sharedData.tileViewList.index = EditorGUILayout.IntPopup("Tileset View", m_sharedData.tileViewList.index, tileViewNames, tileViewValues);
if (EditorGUI.EndChangeCheck())
{
RemoveTileSelection();
}
// Draw Background Color Selector
Tileset.BackgroundColor = EditorGUILayout.ColorField("Background Color", Tileset.BackgroundColor);
if (m_prevBgColor != Tileset.BackgroundColor || Styles.Instance.scrollStyle.normal.background == null)
{
m_prevBgColor = Tileset.BackgroundColor;
if (Styles.Instance.scrollStyle.normal.background == null)
{
Styles.Instance.scrollStyle.normal.background = new Texture2D(1, 1)
{
hideFlags = HideFlags.DontSave
}
}
;
Styles.Instance.scrollStyle.normal.background.SetPixel(0, 0, Tileset.BackgroundColor);
Styles.Instance.scrollStyle.normal.background.Apply();
}
//---
// Draw Zoom Selector
EditorGUILayout.BeginHorizontal();
GUILayout.Label(EditorGUIUtility.FindTexture("ViewToolZoom"), GUILayout.Width(35f));
float visualTileZoom = EditorGUILayout.Slider(Tileset.VisualTileSize.x / Tileset.TilePxSize.x, 0.25f, 4f);
Tileset.VisualTileSize = visualTileZoom * Tileset.TilePxSize;
if (GUILayout.Button("Reset", GUILayout.Width(50f)))
{
Tileset.VisualTileSize = new Vector2(32f * Tileset.TilePxSize.x / Tileset.TilePxSize.y, 32f);
}
EditorGUILayout.EndHorizontal();
//---
string sTileIdLabel = Tileset.SelectedTileId != Tileset.k_TileId_Empty? " (id:" + Tileset.SelectedTileId + ")" : "";
EditorGUILayout.LabelField("Tile Palette" + sTileIdLabel, EditorStyles.boldLabel);
// keeps values safe
m_sharedData.tileViewRowLength = Mathf.Max(1, m_sharedData.tileViewRowLength);
float tileAreaWidth = m_sharedData.tileViewRowLength * (Tileset.VisualTileSize.x + visualTilePadding) + 4f;
float tileAreaHeight = (Tileset.VisualTileSize.y + visualTilePadding) * (1 + (m_visibleTileCount - 1) / m_sharedData.tileViewRowLength) + 4f;
m_sharedData.tileViewRowLength = tileView != null ? tileView.tileSelection.rowLength : Tileset.TileRowLength;
//float minTileScrollHeight = (Tileset.VisualTileSize.y + visualTilePadding) * 6f;// NOTE: GUILayout.MinHeight is not working with BeginScrollView
Vector2 tilesScrollPos = EditorGUILayout.BeginScrollView(m_sharedData.tilesScrollPos, Styles.Instance.scrollStyle /*, GUILayout.MinHeight(minTileScrollHeight)*/);
if (m_updateScrollPos)
{
m_sharedData.tilesScrollPos = tilesScrollPos;
}
{
// Scroll Moving Drag
if (e.type == EventType.MouseDrag && (e.button == 1 || e.button == 2))
{
m_sharedData.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 = tileView != null ? tileView.tileSelection.rowLength : Tileset.Width;
int tileViewHeight = tileView != null ? ((tileView.tileSelection.selectionData.Count - 1) / tileView.tileSelection.rowLength) + 1 : Tileset.Height;
int totalCount = ((((tileViewWidth - 1) / m_sharedData.tileViewRowLength) + 1) * m_sharedData.tileViewRowLength) * tileViewHeight;
int tileIdOffset = 0;
for (int i = 0; i < totalCount; ++i)
{
int tileId = GetTileIdFromIdx(i, m_sharedData.tileViewRowLength, tileViewWidth, tileViewHeight) + tileIdOffset;
uint tileData = (uint)tileId;
if (tileView != null && tileId != Tileset.k_TileId_Empty)
{
tileData = tileView.tileSelection.selectionData[tileId - tileIdOffset];
tileId = (int)(tileData & Tileset.k_TileDataMask_TileId);
}
Tile tile = Tileset.GetTile(tileId);
while (tile != null && tile.uv == default(Rect)) // skip invalid tiles
{
tile = Tileset.GetTile(++tileId);
tileData = (uint)tileId;
tileIdOffset = tileId;
}
visibleTileList.Add(tileData);
int tx = m_visibleTileCount % m_sharedData.tileViewRowLength;
int ty = m_visibleTileCount / m_sharedData.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_sharedData.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_sharedData.pointedTileIdxRect = new KeyValuePair <int, Rect>(m_visibleTileCount, rTileRect);
}
else if (e.type == EventType.MouseDown && e.button == 0)
{
m_sharedData.startDragTileIdxRect = m_sharedData.pointedTileIdxRect = m_sharedData.endDragTileIdxRect = new KeyValuePair <int, Rect>(m_visibleTileCount, rTileRect);
}
else if (e.type == EventType.MouseUp && e.button == 0)
{
m_sharedData.endDragTileIdxRect = new KeyValuePair <int, Rect>(m_visibleTileCount, rTileRect);
DoSetTileSelection();
}
}
if ((isLeftMouseReleased || isRightMouseReleased) && isInsideTileScrollArea && rVisualTile.Contains(e.mousePosition) &&
(m_sharedData.startDragTileIdxRect.Key == m_sharedData.endDragTileIdxRect.Key) && // and there is not dragging selection
m_rTileScrollSize.Contains(e.mousePosition - m_sharedData.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_sharedData.startDragTileIdxRect.Key != m_sharedData.pointedTileIdxRect.Key /*&& m_startDragTileIdxRect.Key == m_endDragTileIdxRect.Key*/)
{
Rect rSelection = new Rect(m_sharedData.startDragTileIdxRect.Value.center, m_sharedData.pointedTileIdxRect.Value.center - m_sharedData.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_sharedData.startDragTileIdxRect.Value.width / 2;
rSelection.xMax += m_sharedData.startDragTileIdxRect.Value.width / 2;
rSelection.yMin -= m_sharedData.startDragTileIdxRect.Value.height / 2;
rSelection.yMax += m_sharedData.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();
string[] brushTypeArray = Tileset.GetBrushTypeArray();
if (brushTypeArray != null && brushTypeArray.Length > 0)
{
Tileset.BrushTypeMask = EditorGUILayout.MaskField("Brush Mask", Tileset.BrushTypeMask, brushTypeArray);
}
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 refreshBrushes = false;
Vector2 brushesScrollPos = EditorGUILayout.BeginScrollView(m_sharedData.brushesScrollPos, Styles.Instance.scrollStyle);
if (m_updateScrollPos)
{
m_sharedData.brushesScrollPos = brushesScrollPos;
}
{
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, idx = 0; i < Tileset.Brushes.Count; ++i, ++idx)
{
Tileset.BrushContainer brushCont = Tileset.Brushes[i];
if (brushCont.BrushAsset == null || brushCont.BrushAsset.Tileset != Tileset)
{
refreshBrushes = true;
continue;
}
if (!brushCont.BrushAsset.ShowInPalette || !Tileset.IsBrushVisibleByTypeMask(brushCont.BrushAsset))
{
continue;
}
int tx = idx % tileRowLength;
int ty = idx / 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 (refreshBrushes)
{
Tileset.RemoveInvalidBrushes();
Tileset.UpdateBrushTypeArray();
}
}
EditorGUILayout.EndScrollView();
if (e.type == EventType.Repaint)
{
m_rBrushScrollArea = GUILayoutUtility.GetLastRect();
}
}
EditorGUILayout.EndVertical();
if (GUILayout.Button("Import all brushes found in the project"))
{
TilesetEditor.AddAllBrushesFoundInTheProject(Tileset);
EditorUtility.SetDirty(Tileset);
}
}
public static MultiColumnHeaderState CreateDefaultMultiColumnHeaderState(float treeViewWidth)
{
var columns = new[]
{
new MultiColumnHeaderState.Column
{
headerContent = new GUIContent(EditorGUIUtility.FindTexture("FilterByLabel"), "Category"),
contextMenuText = "Category",
headerTextAlignment = TextAlignment.Center,
sortedAscending = true,
sortingArrowAlignment = TextAlignment.Right,
width = 30,
minWidth = 30,
maxWidth = 60,
autoResize = false,
allowToggleVisibility = true
},
new MultiColumnHeaderState.Column
{
headerContent = new GUIContent("Package -> AssetTarget"),
contextMenuText = "Package",
headerTextAlignment = TextAlignment.Left,
sortedAscending = true,
sortingArrowAlignment = TextAlignment.Center,
width = 250,
minWidth = 60,
autoResize = true,
allowToggleVisibility = false
},
new MultiColumnHeaderState.Column
{
headerContent = new GUIContent("Asset Path"),
// contextMenuText = "Type",
headerTextAlignment = TextAlignment.Left,
sortedAscending = true,
sortingArrowAlignment = TextAlignment.Left,
width = 300,
minWidth = 30,
// maxWidth = 60,
autoResize = true,
allowToggleVisibility = false
},
new MultiColumnHeaderState.Column
{
headerContent = new GUIContent("StreamingAssets?/Load/Filter"),
contextMenuText = "Option",
headerTextAlignment = TextAlignment.Left,
sortedAscending = true,
sortingArrowAlignment = TextAlignment.Left,
width = 600,
minWidth = 60,
autoResize = true,
allowToggleVisibility = true
},
new MultiColumnHeaderState.Column
{
headerContent = new GUIContent("Priority"),
headerTextAlignment = TextAlignment.Left,
sortedAscending = true,
sortingArrowAlignment = TextAlignment.Left,
width = 270,
minWidth = 60,
autoResize = true
},
new MultiColumnHeaderState.Column
{
headerContent = new GUIContent("Build Order"),
headerTextAlignment = TextAlignment.Left,
sortedAscending = true,
sortingArrowAlignment = TextAlignment.Left,
width = 70,
minWidth = 60,
autoResize = true
},
};
// Assert.AreEqual(columns.Length, Enum.GetValues(typeof(MyColumns)).Length, "Number of columns should match number of enum values: You probably forgot to update one of them.");
var state = new MultiColumnHeaderState(columns);
return(state);
}
public static Texture2D FindIconForFile(string fileName)
{
int i = fileName.LastIndexOf('.');
string extension = i == -1 ? "" : fileName.Substring(i + 1).ToLower();
switch (extension)
{
// Most .asset files use their scriptable object defined icon instead of a default one.
case "asset": return(AssetDatabase.GetCachedIcon(fileName) as Texture2D ?? EditorGUIUtility.FindTexture("GameManager Icon"));
case "cginc": return(EditorGUIUtility.FindTexture("CGProgram Icon"));
case "cs": return(EditorGUIUtility.FindTexture("cs Script Icon"));
case "guiskin": return(EditorGUIUtility.FindTexture(typeof(GUISkin)));
case "dll": return(EditorGUIUtility.FindTexture("Assembly Icon"));
case "asmdef": return(EditorGUIUtility.FindTexture(typeof(AssemblyDefinitionAsset)));
case "asmref": return(EditorGUIUtility.FindTexture(typeof(AssemblyDefinitionAsset)));
case "mat": return(EditorGUIUtility.FindTexture(typeof(Material)));
case "physicmaterial": return(EditorGUIUtility.FindTexture(typeof(PhysicMaterial)));
case "prefab": return(EditorGUIUtility.FindTexture("Prefab Icon"));
case "shader": return(EditorGUIUtility.FindTexture(typeof(Shader)));
case "txt": return(EditorGUIUtility.FindTexture(typeof(TextAsset)));
case "unity": return(EditorGUIUtility.FindTexture(typeof(SceneAsset)));
case "prefs": return(EditorGUIUtility.FindTexture(typeof(EditorSettings)));
case "anim": return(EditorGUIUtility.FindTexture(typeof(Animation)));
case "meta": return(EditorGUIUtility.FindTexture("MetaFile Icon"));
case "mixer": return(EditorGUIUtility.FindTexture(typeof(UnityEditor.Audio.AudioMixerController)));
case "uxml": return(EditorGUIUtility.FindTexture(typeof(UnityEngine.UIElements.VisualTreeAsset)));
case "uss": return(EditorGUIUtility.FindTexture(typeof(StyleSheet)));
case "ttf":
case "otf":
case "fon":
case "fnt":
return(EditorGUIUtility.FindTexture(typeof(Font)));
case "aac":
case "aif":
case "aiff":
case "au":
case "mid":
case "midi":
case "mp3":
case "mpa":
case "ra":
case "ram":
case "wma":
case "wav":
case "wave":
case "ogg":
return(EditorGUIUtility.FindTexture(typeof(AudioClip)));
case "ai":
case "apng":
case "png":
case "bmp":
case "cdr":
case "dib":
case "eps":
case "exif":
case "gif":
case "ico":
case "icon":
case "j":
case "j2c":
case "j2k":
case "jas":
case "jiff":
case "jng":
case "jp2":
case "jpc":
case "jpe":
case "jpeg":
case "jpf":
case "jpg":
case "jpw":
case "jpx":
case "jtf":
case "mac":
case "omf":
case "qif":
case "qti":
case "qtif":
case "tex":
case "tfw":
case "tga":
case "tif":
case "tiff":
case "wmf":
case "psd":
case "exr":
case "hdr":
return(EditorGUIUtility.FindTexture(typeof(Texture)));
case "3df":
case "3dm":
case "3dmf":
case "3ds":
case "3dv":
case "3dx":
case "blend":
case "c4d":
case "lwo":
case "lws":
case "ma":
case "max":
case "mb":
case "mesh":
case "obj":
case "vrl":
case "wrl":
case "wrz":
case "fbx":
return(EditorGUIUtility.FindTexture(typeof(Mesh)));
case "dv":
case "mp4":
case "mpg":
case "mpeg":
case "m4v":
case "ogv":
case "vp8":
case "webm":
case "asf":
case "asx":
case "avi":
case "dat":
case "divx":
case "dvx":
case "mlv":
case "m2l":
case "m2t":
case "m2ts":
case "m2v":
case "m4e":
case "mjp":
case "mov":
case "movie":
case "mp21":
case "mpe":
case "mpv2":
case "ogm":
case "qt":
case "rm":
case "rmvb":
case "wmw":
case "xvid":
return(AssetDatabase.GetCachedIcon(fileName) as Texture2D ?? EditorGUIUtility.FindTexture(typeof(VideoClip)));
case "colors":
case "gradients":
case "curves":
case "curvesnormalized":
case "particlecurves":
case "particlecurvessigned":
case "particledoublecurves":
case "particledoublecurvessigned":
return(EditorGUIUtility.FindTexture(typeof(ScriptableObject)));
default: return(null);
}
}
public Texture2D GetEditorTexture(string key)
{
return(EditorGUIUtility.FindTexture(GetIconName(key)));
}
public Texture2D GetEditorTexture(AssetBundleResType resType)
{
return(EditorGUIUtility.FindTexture(GetIconName(resType)));
}
void FindMessageIcons()
{
m_ErrorIcon = EditorGUIUtility.FindTexture("console.errorIcon");
m_WarningIcon = EditorGUIUtility.FindTexture("console.warnicon");
m_InfoIcon = EditorGUIUtility.FindTexture("console.infoIcon");
}
protected Texture2D FindTextureBuiltIn(string name)
{
return(EditorGUIUtility.FindTexture(name));
}
public static void ShowWindow()
{
SceneSwitcher sceneSwitcherWindow = (SceneSwitcher)EditorWindow.GetWindow(typeof(SceneSwitcher));
sceneSwitcherWindow.titleContent = new GUIContent(" Scene Switcher", EditorGUIUtility.FindTexture("BuildSettings.Editor"));
}
public void OnGUI(Rect rect)
{
if (creatingNewConfig == true && GUI.GetNameOfFocusedControl() != "InputField1")
{
creatingNewConfig = false;
}
GUILayout.BeginArea(rect, GUIContent.none);
//SettingPanel
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
GUILayout.FlexibleSpace();
EBPEditorGUILayout.RootSettingLine(G.Module, ChangeRootPath);
GUILayout.FlexibleSpace();
EditorGUILayout.BeginHorizontal();
EditorGUI.BeginDisabledGroup(LoadBundlesFromConfig);
if (ShowTagsDropdown())
{
return;
}
EditorGUI.EndDisabledGroup();
GUILayout.FlexibleSpace();
GUILayout.Space(10);
if (GUILayout.Button(new GUIContent("New", "新建配置文件"), buttonStyle, buttonOptions))
{
ClickedNew(); return;
}
if (GUILayout.Button(new GUIContent("Save", "保存配置文件"), buttonStyle, buttonOptions))
{
ClickedSave(); return;
}
if (creatingNewConfig)
{
ShowInputField();
}
else
{
if (ShowMapDropdown())
{
return;
}
}
if (GUILayout.Button(new GUIContent(EditorGUIUtility.FindTexture("ViewToolOrbit"), "查看该文件"), buttonStyle, GUILayout.Height(25)))
{
ClickedShowConfigFile(); return;
}
EditorGUILayout.EndHorizontal();
GUILayout.FlexibleSpace();
EditorGUILayout.BeginHorizontal();
bool result = EditorGUILayout.Toggle(GUIContent.none, LoadBundlesFromConfig, GUILayout.Width(16));
if (result != LoadBundlesFromConfig)
{
LoadBundlesFromConfig = result;
G.g.bundleTree.LoadBundlesFromConfig = result;
OnChangeBundles();
return;
}
EditorGUI.BeginDisabledGroup(!LoadBundlesFromConfig);
if (ShowBundleConfigsDropdown())
{
return;
}
GUILayout.FlexibleSpace();
EditorGUI.EndDisabledGroup();
EditorGUILayout.LabelField("Mode:", labelStyle, shortLabelOptions2);
int currentPackageModeIndex_new = EditorGUILayout.Popup(selectedPackageModeIndex, G.PackageModeEnum, dropdownStyle, shortPopupOptions);
if (selectedPackageModeIndex != currentPackageModeIndex_new)
{
selectedPackageModeIndex = currentPackageModeIndex_new;
G.Module.UserConfig.Json.PackageMode = G.PackageModeEnum[selectedPackageModeIndex];
G.g.packageTree.UpdateAllFileName();
G.Module.IsDirty = true;
return;
}
GUILayout.Space(10);
EditorGUILayout.LabelField("Lua:", labelStyle, shortLabelOptions);
int currentLuaSourceIndex_new = EditorGUILayout.Popup(selectedLuaSourceIndex, G.LuaSourceEnum, dropdownStyle, shortPopupOptions);
if (selectedLuaSourceIndex != currentLuaSourceIndex_new)
{
selectedLuaSourceIndex = currentLuaSourceIndex_new;
G.Module.UserConfig.Json.LuaSource = G.LuaSourceEnum[selectedLuaSourceIndex];
G.Module.IsDirty = true;
return;
}
GUILayout.Space(10);
EditorGUILayout.LabelField("CompressLevel:", labelStyle, labelOptions);
int compressionLevel_new = EditorGUILayout.IntPopup(G.Module.UserConfig.Json.CompressionLevel, compressionLevelsEnumStr,
compressionLevelEnum, dropdownStyle, miniPopupOptions);
if (compressionLevel_new != G.Module.UserConfig.Json.CompressionLevel)
{
G.Module.UserConfig.Json.CompressionLevel = compressionLevel_new;
G.Module.IsDirty = true;
return;
}
GUILayout.Space(20);
if (GUILayout.Button(new GUIContent("Revert"), buttonStyle, buttonOptions))
{
ClickedRevert(); return;
}
if (G.Module.StateConfigAvailable && !LoadBundlesFromConfig)
{
if (GUILayout.Button(new GUIContent("Build"), buttonStyle, buttonOptions))
{
ClickedApply(); return;
}
}
else
{
if (GUILayout.Button(new GUIContent("Check"), buttonStyle, buttonOptions))
{
ClickedCheck(); return;
}
}
EditorGUILayout.EndHorizontal();
GUILayout.FlexibleSpace();
EditorGUILayout.EndVertical();
//VersionPanel
EditorGUILayout.BeginHorizontal(EditorStyles.helpBox);
EditorGUILayout.LabelField("Resource Version: " + G.Module.ModuleStateConfig.Json.ResourceVersion, labelStyle, GUILayout.MaxWidth(150));
GUILayout.FlexibleSpace();
if (G.Module.UserConfig.Json.PackageMode == "Addon")
{
EditorGUILayout.LabelField("Client Version:", labelStyle, GUILayout.MaxWidth(110));
string addonVersion_new = EditorGUILayout.TextField(G.Module.ModuleStateConfig.Json.ClientVersion);
{
if (!string.IsNullOrEmpty(addonVersion_new))
{
addonVersion_new = addonVersion_new.Trim();
}
if (addonVersion_new != G.Module.ModuleStateConfig.Json.ClientVersion)
{
G.Module.ModuleStateConfig.Json.ClientVersion = addonVersion_new;
G.g.packageTree.UpdateAllFileName();
return;
}
}
}
EditorGUILayout.EndHorizontal();
GUILayout.EndArea();
}
static void MenuCreateCameraBodyModel()
{
var icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, ScriptableObject.CreateInstance <DoCreateCameraBodyModel>(), "New Physically Based Camera Body.asset", icon, null);
}
private void ParamSection()
{
if (PaddedBoxGS == null)
{
PaddedBoxGS = new GUIStyle((GUIStyle)"HelpBox")
{
normal = ((GUIStyle)"GroupBox").normal, padding = new RectOffset(4, 4, 4, 4)
}
}
;
if (PaddedGS == null)
{
PaddedGS = new GUIStyle(PaddedBoxGS)
{
normal = ((GUIStyle)"MiniLabel").normal
}
}
;
t.useGlobalParamSettings = EditorGUILayout.ToggleLeft("Use Global Settings", t.useGlobalParamSettings);
showAdvancedParams[uid] = IndentedFoldout(new GUIContent("Adv. Parameter Settings"), showAdvancedParams[uid], 1);
if (showAdvancedParams[uid])
{
var indenthold = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.GetControlRect(GUILayout.MinWidth(COL1));
EditorGUILayout.LabelField(label_Interp, (GUIStyle)"MiniLabel", GUILayout.MaxWidth(COL2));
EditorGUILayout.LabelField(label_Extrap, (GUIStyle)"MiniLabel", GUILayout.MaxWidth(COL3));
EditorGUILayout.LabelField(label_Default, (GUIStyle)"MiniLabel", GUILayout.MaxWidth(COL4));
EditorGUILayout.EndHorizontal();
var defs = t.sharedParamDefaults;
if (t.useGlobalParamSettings)
{
EditorGUILayout.BeginHorizontal();
InspectorWidgets.MiniToggle(t, EditorGUILayout.GetControlRect(GUILayout.MinWidth(COL1)), new GUIContent("Ints"), ref defs.includeInts);
DrawInterp(AnimatorControllerParameterType.Int, ref defs.interpolateInts);
DrawExtrap(AnimatorControllerParameterType.Int, ref defs.extrapolateInts);
DrawDefaults(AnimatorControllerParameterType.Int, ref defs.defaultInt);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
InspectorWidgets.MiniToggle(t, EditorGUILayout.GetControlRect(GUILayout.MinWidth(COL1)), new GUIContent("Floats"), ref defs.includeFloats);
DrawInterp(AnimatorControllerParameterType.Float, ref defs.interpolateFloats);
DrawExtrap(AnimatorControllerParameterType.Float, ref defs.extrapolateFloats);
DrawDefaults(AnimatorControllerParameterType.Float, ref defs.defaultFloat);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
InspectorWidgets.MiniToggle(t, EditorGUILayout.GetControlRect(GUILayout.MinWidth(COL1)), new GUIContent("Bools"), ref defs.includeBools);
EditorGUILayout.GetControlRect(GUILayout.MaxWidth(COL2));
DrawExtrap(AnimatorControllerParameterType.Bool, ref defs.extrapolateBools);
DrawDefaults(AnimatorControllerParameterType.Bool, ref defs.defaultBool);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
var tr = EditorGUILayout.GetControlRect(GUILayout.MinWidth(COL1));
InspectorWidgets.MiniToggle(t, tr, triggerLabel, ref defs.includeTriggers);
if (t.sharedParamDefaults.includeTriggers)
{
GUI.DrawTexture(new Rect(tr)
{
x = 2, width = 16
}, EditorGUIUtility.FindTexture("console.warnicon"));
}
EditorGUILayout.GetControlRect(GUILayout.MaxWidth(COL2));
DrawExtrap(AnimatorControllerParameterType.Trigger, ref defs.extrapolateTriggers);
DrawDefaults(AnimatorControllerParameterType.Trigger, ref defs.defaultTrigger);
EditorGUILayout.EndHorizontal();
}
else
{
var names = ParameterSettings.RebuildParamSettings(a, ref t.sharedParamSettings, ref t.paramCount, t.sharedParamDefaults);
serializedObject.Update();
var pms = t.sharedParamSettings;
for (int i = 0; i < t.paramCount; ++i)
{
var pm = pms[i];
EditorGUILayout.BeginHorizontal();
// Type Letter Box (left vertical)
EditorGUILayout.BeginVertical(PaddedBoxGS, GUILayout.MaxWidth(8));
TypeLabel(EditorGUILayout.GetControlRect(GUILayout.MaxWidth(12)), pm.paramType);
EditorGUILayout.EndVertical();
// Main Vertical (Right)
EditorGUILayout.BeginVertical((pm.include) ? PaddedBoxGS : PaddedGS);
EditorGUILayout.BeginHorizontal();
InspectorWidgets.MiniToggle(t, EditorGUILayout.GetControlRect(GUILayout.MinWidth(COL1)), new GUIContent(names[i]), ref pm.include);
EditorGUI.BeginDisabledGroup(!pm.include);
DrawInterp(pm.paramType, ref pm.interpolate);
DrawExtrap(pm.paramType, ref pm.extrapolate);
DrawDefaults(pm.paramType, ref pm.defaultValue);
EditorGUI.EndDisabledGroup();
EditorGUILayout.EndHorizontal();
// Compression Row
if (pm.include)
{
if (pm.paramType == AnimatorControllerParameterType.Float || pm.paramType == AnimatorControllerParameterType.Int)
{
var sharedPSs = serializedObject.FindProperty("sharedParamSettings");
var ps = sharedPSs.GetArrayElementAtIndex(i);
var fcrusher = (pm.paramType == AnimatorControllerParameterType.Float) ? ps.FindPropertyRelative("fcrusher") : ps.FindPropertyRelative("icrusher");
var r = EditorGUILayout.GetControlRect(false, EditorGUI.GetPropertyHeight(fcrusher));
Rect rectCrusher = new Rect(r)
{
height = 16
};
EditorGUI.PropertyField(rectCrusher, fcrusher);
}
}
// End Right Vertical
EditorGUILayout.EndVertical();
// End Parameter
EditorGUILayout.EndHorizontal();
}
}
EditorGUI.indentLevel = indenthold;
}
}
// private float val = 0f;
void OnEnable()
{
this.trashTexture = EditorGUIUtility.FindTexture("d_TreeEditor.Trash");
this.plusTexture = EditorGUIUtility.FindTexture("Toolbar Plus");
}
private ReorderableList CreateAnimReorderableList()
{
ReorderableList reordList = new ReorderableList(m_target.DirectionalAnimController.GetAnimList(), typeof(DirectionalAnimData), true, true, true, true);
float elementHeight = m_target.DirectionalAnimController.DirectionsPerAnim <= 4 ? 64f : 128f;
reordList.displayAdd = reordList.displayRemove = false;
reordList.elementHeight = 0;
reordList.draggable = reordList.elementHeight > 0f;
reordList.drawHeaderCallback += (Rect rect) =>
{
EditorGUI.LabelField(new Rect(rect.x, rect.y, rect.width, EditorGUIUtility.singleLineHeight), "Animations", EditorStyles.boldLabel);
Texture2D btnTexture = reordList.elementHeight == 0f ? EditorGUIUtility.FindTexture("winbtn_win_max_h") : EditorGUIUtility.FindTexture("winbtn_win_min_h");
if (GUI.Button(new Rect(rect.x + rect.width - EditorGUIUtility.singleLineHeight, rect.y, EditorGUIUtility.singleLineHeight, EditorGUIUtility.singleLineHeight), btnTexture, EditorStyles.label))
{
reordList.elementHeight = reordList.elementHeight == 0f ? elementHeight : 0f;
reordList.draggable = reordList.elementHeight > 0f;
}
};
reordList.drawElementCallback += (Rect rect, int index, bool isActive, bool isFocused) =>
{
if (reordList.elementHeight == 0f)
{
return;
}
DirectionalAnimData anim = (DirectionalAnimData)reordList.list[index];
anim.name = GUI.TextField(new Rect(rect.x, rect.y, rect.width, EditorGUIUtility.singleLineHeight), anim.name);
int dirNb = m_target.DirectionalAnimController.DirectionsPerAnim;
float frameWidth = rect.width / Mathf.Min(4, dirNb);
int rowNb = 1 + (dirNb - 1) / 4;
float frameHeight = (rect.height - EditorGUIUtility.singleLineHeight) / rowNb;
for (int i = 0; i < dirNb; ++i)
{
Vector2 dir = Quaternion.Euler(Vector3.forward * (((float)i / dirNb) * 360f)) * Vector3.down;
Sprite sprite = m_target.DirectionalAnimController.GetPreviewAnimSprite(dir, index);
if (sprite)
{
float aspectRatio = sprite.rect.width / sprite.rect.height;
Rect uv = new Rect()
{
position = Vector2.Scale(sprite.rect.position, sprite.texture.texelSize), size = Vector2.Scale(sprite.rect.size, sprite.texture.texelSize)
};
Rect rAnim = new Rect(rect.x + frameWidth * (i % 4), rect.y + EditorGUIUtility.singleLineHeight + (i / 4) * frameHeight, frameHeight * aspectRatio, frameHeight);
GUI.DrawTextureWithTexCoords(rAnim, sprite.texture, uv);
}
else
{
Rect rBox = new Rect(rect.x + frameWidth * i, rect.y + EditorGUIUtility.singleLineHeight, frameWidth, rect.height - EditorGUIUtility.singleLineHeight);
GUI.Box(rBox, "");
}
}
};
reordList.onSelectCallback += (ReorderableList list) =>
{
m_target.AnimIndex = m_animReordList.index;
GUI.changed = true;
};
return(reordList);
}
public static void CreateStruct()
{
ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, new EndNameActions.SetFileName2FirstKeyWord(), "NewStruct.cs", EditorGUIUtility.FindTexture("cs Script Icon"), "CsSturct t:CsCodeTemplate");
}
private void OnScene(SceneView view)
{
if (EditorWindow.focusedWindow != view)
{
toSelect = null;
}
if (toSelect != null)
{
Selection.activeObject = toSelect;
}
using (HandleGUIDispose.BeginGUI()) {
// editMode = GUI.Toggle(new Rect(10, 10, 80, EditorGUIUtility.singleLineHeight), editMode, "Edit Tilemap", "Button");
RenderToolButtons();
if (mode == WorkingMode.Disable)
{
toSelect = null;
return;
}
if (mode == WorkingMode.Select)
{
SelectTilemap(view);
}
if (active == null && (int)mode >= 2)
{
mode = WorkingMode.Disable;
}
if (mode == WorkingMode.Paint)
{
int sel_x = selectedTile % active.TilesetWidth;
int sel_y = selectedTile / active.TilesetWidth;
GUI.DrawTextureWithTexCoords(new Rect(10, 50, 128, 128), active.TilesetMaterial.mainTexture, new Rect(sel_x * 1f / 16, 1 - (1 + sel_y) * 1 / 16f, 1 / 16f, 1 / 16f));
selectedTile = EditorGUI.IntField(new Rect(10 + 32, 50 + 8, 64, EditorGUIUtility.singleLineHeight), selectedTile);
if (GUI.Button(new Rect(10 - 8, 50 + 64 - 8, 16, 16), EditorGUIUtility.FindTexture("node1 hex")))
{
selectedTile = (active.TilesetWidth * active.TilesetHeight + selectedTile - 1) % (active.TilesetWidth * active.TilesetHeight);
}
if (GUI.Button(new Rect(10 - 8 + 128, 50 + 64 - 8, 16, 16), EditorGUIUtility.FindTexture("node1 hex")))
{
selectedTile = (active.TilesetWidth * active.TilesetHeight + selectedTile + 1) % (active.TilesetWidth * active.TilesetHeight);
}
if (GUI.Button(new Rect(10 + 64 - 8, 50 - 8, 16, 16), EditorGUIUtility.FindTexture("node1 hex")))
{
selectedTile = (active.TilesetWidth * active.TilesetHeight + selectedTile - active.TilesetWidth) % (active.TilesetWidth * active.TilesetHeight);
}
if (GUI.Button(new Rect(10 + 64 - 8, 50 + 120, 16, 16), EditorGUIUtility.FindTexture("node1 hex")))
{
selectedTile = (active.TilesetWidth * active.TilesetHeight + selectedTile + active.TilesetWidth) % (active.TilesetWidth * active.TilesetHeight);
}
}
}
if (mode == WorkingMode.Paint)
{
var planes = GeometryUtility.CalculateFrustumPlanes(view.camera);
var plane = new Plane(Vector3.forward, active.TilemapBounds.center);
float enter;
var ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
plane.Raycast(ray, out enter);
var hitpoint = ray.GetPoint(enter);
if (!active.TilemapBounds.Contains(hitpoint))
{
return;
}
var tilepos = (hitpoint - active.transform.position);
var tile_x = Mathf.RoundToInt(tilepos.x);
var tile_y = Mathf.RoundToInt(tilepos.y);
if (Handles.Button(new Vector3(tile_x, tile_y, 0) + active.transform.position, Quaternion.identity, active.TileSize / 2f, 1f, Handles.RectangleCap))
{
active.Tiles[tile_y * active.TileMapWidth + tile_x] = selectedTile;
active.OnValidate();
EditorUtility.SetDirty(active);
}
}
if (mode == WorkingMode.Modify)
{
#region Modify
var p = active.TilemapBounds.center;
var d = active.TilemapBounds.extents;
var dx = new Vector3(d.x, 0, 0);
var dy = new Vector3(0, d.y, 0);
var size = 0.25f;
Handles.color = Color.yellow;
EditorGUI.BeginChangeCheck();
var pos = Handles.FreeMoveHandle(p + dx, Quaternion.identity, 0.25f, Vector3.right, Handles.RectangleCap);
if (EditorGUI.EndChangeCheck())
{
var delta = pos - (p + dx);
if (delta.x > 0.75f * active.TileSize)
{
var rows = active.Tiles.Count / active.TileMapWidth;
for (int i = 0; i < rows; ++i)
{
active.Tiles.Insert(active.TileMapWidth * (i + 1) + i, 0);
}
active.TileMapWidth += 1;
}
else
if (delta.x < -0.75f * active.TileSize)
{
if (active.TileMapWidth < 2)
{
return;
}
var rows = active.Tiles.Count / active.TileMapWidth;
for (int r = 1; r < rows; ++r)
{
for (int i = 0; i < active.TileMapWidth; ++i)
{
active.Tiles[i - r + r * active.TileMapWidth] = active.Tiles[i + r * active.TileMapWidth];
}
}
active.Tiles.RemoveRange(active.Tiles.Count - 1 - rows, rows);
active.TileMapWidth -= 1;
}
active.OnValidate();
EditorUtility.SetDirty(active);
}
EditorGUI.BeginChangeCheck();
pos = Handles.FreeMoveHandle(p + dy, Quaternion.identity, 0.25f, Vector3.up, Handles.RectangleCap);
if (EditorGUI.EndChangeCheck())
{
var delta = pos - (p + dy);
if (delta.y > 0.75f * active.TileSize)
{
active.Tiles.AddRange(new int[StepUp(active.TileMapWidth, active.Tiles.Count) - active.Tiles.Count]);
}
if (delta.y < -0.75f * active.TileSize)
{
var n = StepDown(active.TileMapWidth, active.Tiles.Count);
active.Tiles.RemoveRange(n, active.Tiles.Count - n);
}
active.OnValidate();
EditorUtility.SetDirty(active);
}
#endregion
}
}
static void MenuCreateDiffusionProfile()
{
var icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, ScriptableObject.CreateInstance <DoCreateNewAssetDiffusionProfileSettings>(), "New Diffusion Profile.asset", icon, null);
}
/// <summary>
/// \~english Initialization of the class
/// </summary>
static MaterialTreeView()
{
s_FolderIcon = EditorGUIUtility.FindTexture("Folder Icon");
s_MaterialIcon = EditorGUIUtility.FindTexture("Material Icon");
s_toggleMixed = new GUIStyle("ToggleMixed");
}
public override void OnInspectorGUI()
{
serializedObject.Update();
EditorGUILayout.Space();
TileRenderer renderer = tileMap.GetComponent <TileRenderer>();
if (renderer == null)
{
Texture2D tex = EditorGUIUtility.FindTexture("console.erroricon");
if (GUILayout.Button(new GUIContent("No TileRenderer attached! Click here to add one.", tex), EditorStyles.helpBox))
{
GenericMenu menu = new GenericMenu();
foreach (Type type in Assembly.GetAssembly(typeof(TileRenderer)).GetTypes().Where(t => t.IsClass && !t.IsAbstract && t.IsSubclassOf(typeof(TileRenderer))))
{
menu.AddItem(new GUIContent(type.Name), false, () => { tileMap.gameObject.AddComponent(type); });
}
menu.ShowAsContext();
}
}
EditorGUILayout.Space();
EditorGUI.BeginChangeCheck();
tileMap.isInEditMode = GUILayout.Toggle(tileMap.isInEditMode, "", "Button", GUILayout.Height(EditorGUIUtility.singleLineHeight * 1.5f));
string toggleButtonText = (tileMap.isInEditMode ? "Exit" : "Enter") + " Edit Mode [TAB]";
GUI.Label(GUILayoutUtility.GetLastRect(), toggleButtonText, MyStyles.centerBoldLabel);
if (EditorGUI.EndChangeCheck())
{
if (tileMap.isInEditMode)
{
OnEnterEditMode();
}
else
{
OnExitEditMode();
}
}
EditorGUILayout.Space();
GUILayout.Label("Settings", MyStyles.leftBoldLabel);
int width = spWidth.intValue;
width = EditorGUILayout.IntField(spWidth.displayName, width);
int height = spHeight.intValue;
height = EditorGUILayout.IntField(spHeight.displayName, height);
if (width != spWidth.intValue || height != spHeight.intValue)
{
tileMap.Resize(width, height);
OnSceneGUI();
}
EditorGUILayout.Space();
GUILayout.Label("Tools", MyStyles.leftBoldLabel);
GUILayout.BeginHorizontal();
if (GUILayout.Button("Force Refresh"))
{
tileMap.UpdateTileMap();
}
GUI.color = new Color(1f, 0.5f, 0.5f);
if (GUILayout.Button("Clear All Tiles"))
{
if (EditorUtility.DisplayDialog("Are you sure?", "Do you really want to clear this tilemap without saving?", "Okay", "Cancel"))
{
tileMap.Reset();
SetTileMapDirty();
}
}
GUI.color = Color.white;
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
if (GUILayout.Button("Import"))
{
string path = EditorUtility.OpenFilePanelWithFilters("Select .tilemap File", "Assets", new string[] { "ScriptableObject", "asset" });
if (path != string.Empty)
{
int cutoffFrom = path.IndexOf("Assets");
path = path.Substring(cutoffFrom);
Debug.Log(path);
TileMapContainer container = AssetDatabase.LoadAssetAtPath <TileMapContainer>(path) as TileMapContainer;
if (EditorUtility.DisplayDialog("Are you sure?", "Importing this tilemap will override the current one without saving it.", "Okay", "Cancel"))
{
tileMap.Resize(container.width, container.height);
for (int x = 0; x < container.width; x++)
{
for (int y = 0; y < container.height; y++)
{
tileMap.SetTileAt(x, y, container.map[x + y * container.width]);
}
}
}
}
}
if (GUILayout.Button("Export"))
{
TileMapContainer container = ScriptableObjectUtility.CreateAsset <TileMapContainer>(tileMap.name + ".asset");
container.map = tileMap.Map;
container.width = tileMap.Width;
container.height = tileMap.Height;
}
GUILayout.EndHorizontal();
if (Event.current.type == EventType.KeyDown && Event.current.isKey && Event.current.keyCode == KeyCode.Tab)
{
tileMap.isInEditMode = !tileMap.isInEditMode;
}
if (Event.current.type == EventType.KeyDown && Event.current.isKey && Event.current.keyCode == KeyCode.Escape)
{
tileMap.isInEditMode = false;
}
serializedObject.ApplyModifiedProperties();
}
public void SetData(IEnumerable <ViewSystemVerifier.ViewSystemGameObjectMissingData> originalNotFoundItems, ViewSystemSaveData saveData, Action OnComplete)
{
titleContent = new GUIContent("Missing GameObject fixer");
this.icon = EditorGUIUtility.FindTexture("MetaFile Icon");
this.lable = "Select the GameObject Path your wish to fix";
fixerDatas = originalNotFoundItems.Select(m =>
new FixerData
{
originalNotFoundItem = m,
tempPath = m.viewSystemComponent.targetTransformPath
}).ToList();
OnAllClick += () =>
{
fixerDatas.All(x =>
{
x.fix = true;
return(true);
});
};
OnNoneClick += () =>
{
fixerDatas.All(x =>
{
x.fix = false;
return(true);
});
};
OnCancelClick += () =>
{
};
OnApplyClick += () =>
{
foreach (var item in fixerDatas)
{
if (item.fix == false)
{
continue;
}
if (item.delete == true)
{
foreach (var vp in saveData.viewPages)
{
foreach (var vpi in vp.viewPage.viewPageItems.Where(m => m.viewElement == item.originalNotFoundItem.viewElement))
{
vpi.overrideDatas.RemoveAll(
m => m.targetTransformPath == item.originalNotFoundItem.viewSystemComponent.targetTransformPath);
}
}
foreach (var vs in saveData.viewStates)
{
// foreach (var vpi in vs.viewState.viewPageItems)
// {
// vpi.overrideDatas.RemoveAll(m => m.targetComponentType == item.Key && m.targetPropertyName == item2.originalPropertyName);
// }
foreach (var vpi in vs.viewState.viewPageItems.Where(m => m.viewElement == item.originalNotFoundItem.viewElement))
{
vpi.overrideDatas.RemoveAll(
m => m.targetTransformPath == item.originalNotFoundItem.viewSystemComponent.targetTransformPath);
}
}
continue;
}
item.originalNotFoundItem.viewSystemComponent.targetTransformPath = item.tempPath;
}
// var f = fixerDatas.Where(m => m.fix);
// foreach (var item in f)
// {
// }
// var d = fixerDatas.Where(m => m.delete);
// foreach (var item in d)
// {
// item.originalNotFoundItem.viewSystemComponent.targetTransformPath = item.tempPath;
// }
};
}
private static bool PopupButtonClicked()
{
var buttonImage = EditorGUIUtility.FindTexture("_Popup");
return(GUILayout.Button(buttonImage, GUI.skin.GetStyle("Label"), GUILayout.MinWidth(20), GUILayout.Width(20)));
}
private static bool ShouldUseNewUI()
{
return(EditorGUIUtility.FindTexture("Folder Icon").width > 64);
}
internal void AddEntries(List <SearchTreeEntry> cache, IEnumerable <UdonNodeDefinition> definitions, int level,
bool stripToLastDot = false)
{
Texture2D icon = AssetPreview.GetMiniTypeThumbnail(typeof(GameObject));
Texture2D iconGetComponents = EditorGUIUtility.FindTexture("d_ViewToolZoom");
Texture2D iconOther = new Texture2D(1, 1);
iconOther.SetPixel(0, 0, new Color(0, 0, 0, 0));
iconOther.Apply();
Dictionary <string, UdonNodeDefinition> baseNodeDefinition = new Dictionary <string, UdonNodeDefinition>();
foreach (UdonNodeDefinition nodeDefinition in definitions.OrderBy(
s => UdonGraphExtensions.PrettyFullName(s)))
{
string baseIdentifier = nodeDefinition.fullName;
string[] splitBaseIdentifier = baseIdentifier.Split(new[] { "__" }, StringSplitOptions.None);
if (splitBaseIdentifier.Length >= 2)
{
baseIdentifier = $"{splitBaseIdentifier[0]}__{splitBaseIdentifier[1]}";
}
if (baseNodeDefinition.ContainsKey(baseIdentifier))
{
continue;
}
baseNodeDefinition.Add(baseIdentifier, nodeDefinition);
}
var nodesOfGetComponentType = new List <SearchTreeEntry>();
var nodesOfOtherType = new List <SearchTreeEntry>();
// add all subTypes
foreach (KeyValuePair <string, UdonNodeDefinition> nodeDefinitionsEntry in baseNodeDefinition)
{
string nodeName = UdonGraphExtensions.PrettyBaseName(nodeDefinitionsEntry.Key);
nodeName = nodeName.UppercaseFirst();
nodeName = nodeName.Replace("_", " ");
if (stripToLastDot)
{
int lastDotIndex = nodeName.LastIndexOf('.');
nodeName = nodeName.Substring(lastDotIndex + 1);
}
// Skip some nodes that should be added in other ways (variables and comments)
if (nodeName.StartsWithCached("Variable") || nodesToSkip.Contains(nodeDefinitionsEntry.Key))
{
continue;
}
if (nodeName.StartsWithCached("Object"))
{
nodeName = $"{nodeDefinitionsEntry.Value.type.Namespace}.{nodeName}";
}
if (nodeNamesGetComponentType.Contains(nodeName))
{
nodesOfGetComponentType.Add(new SearchTreeEntry(new GUIContent(nodeName, iconGetComponents))
{
level = level + 1, userData = nodeDefinitionsEntry.Value
});
continue;
}
// Only put 'Equals' in the 'Other' category if this definition is not an Enum
if (nodeNamesOtherType.Contains(nodeName) || nodeName == "Equals" && !nodeDefinitionsEntry.Value.type.IsEnum)
{
nodesOfOtherType.Add(new SearchTreeEntry(new GUIContent(nodeName, iconOther))
{
level = level + 1, userData = nodeDefinitionsEntry.Value
});
continue;
}
cache.Add(new SearchTreeEntry(new GUIContent(nodeName, icon))
{
level = level, userData = nodeDefinitionsEntry.Value
});
}
// add getComponents level
if (nodesOfGetComponentType.Count > 0)
{
cache.Add(new SearchTreeGroupEntry(new GUIContent("GetComponents"), level));
foreach (var entry in nodesOfGetComponentType)
{
cache.Add(entry);
}
}
// add other level
if (nodesOfOtherType.Count > 0)
{
cache.Add(new SearchTreeGroupEntry(new GUIContent("Other"), level));
foreach (var entry in nodesOfOtherType)
{
cache.Add(entry);
}
}
}
