public void OnGUI()
{
base.ClearBackground();
EditorGUIUtility.ResetGUIState();
SplitView parent = base.parent as SplitView;
if ((Event.current.type == EventType.Repaint) && (parent != null))
{
View child = this;
while (parent != null)
{
int controlID = parent.controlID;
if ((controlID == GUIUtility.hotControl) || (GUIUtility.hotControl == 0))
{
int num2 = parent.IndexOfChild(child);
if (parent.vertical)
{
if (num2 != 0)
{
EditorGUIUtility.AddCursorRect(new Rect(0f, 0f, base.position.width, 5f), MouseCursor.SplitResizeUpDown, controlID);
}
if (num2 != (parent.children.Length - 1))
{
EditorGUIUtility.AddCursorRect(new Rect(0f, base.position.height - 5f, base.position.width, 5f), MouseCursor.SplitResizeUpDown, controlID);
}
}
else
{
if (num2 != 0)
{
EditorGUIUtility.AddCursorRect(new Rect(0f, 0f, 5f, base.position.height), MouseCursor.SplitResizeLeftRight, controlID);
}
if (num2 != (parent.children.Length - 1))
{
EditorGUIUtility.AddCursorRect(new Rect(base.position.width - 5f, 0f, 5f, base.position.height), MouseCursor.SplitResizeLeftRight, controlID);
}
}
}
child = parent;
parent = parent.parent as SplitView;
}
parent = base.parent as SplitView;
}
bool flag = false;
if (base.window.mainView.GetType() != typeof(MainWindow))
{
flag = true;
if (base.windowPosition.y == 0f)
{
base.background = "dockareaStandalone";
}
else
{
base.background = "dockarea";
}
}
else
{
base.background = "dockarea";
}
if (parent != null)
{
Event event2;
event2 = new Event(Event.current)
{
mousePosition = event2.mousePosition + new Vector2(base.position.x, base.position.y)
};
parent.SplitGUI(event2);
if (event2.type == EventType.Used)
{
Event.current.Use();
}
}
GUIStyle style = "dockareaoverlay";
Rect position = base.background.margin.Remove(new Rect(0f, 0f, base.position.width, base.position.height));
position.x = base.background.margin.left;
position.y = base.background.margin.top;
Rect windowPosition = base.windowPosition;
float num3 = 2f;
if (windowPosition.x == 0f)
{
position.x -= num3;
position.width += num3;
}
if (windowPosition.xMax == base.window.position.width)
{
position.width += num3;
}
if (windowPosition.yMax == base.window.position.height)
{
position.height += !flag ? 2f : 2f;
}
GUI.Box(position, GUIContent.none, base.background);
if (this.tabStyle == null)
{
this.tabStyle = "dragtab";
}
this.DragTab(new Rect(position.x + 1f, position.y, position.width - 40f, 17f), this.tabStyle);
this.tabStyle = "dragtab";
base.ShowGenericMenu();
base.DoWindowDecorationStart();
if (this.m_Panes.Count > 0)
{
if (this.m_Panes[this.selected] is GameView)
{
GUI.Box(position, GUIContent.none, style);
}
BeginOffsetArea(new Rect(position.x + 2f, position.y + 17f, position.width - 4f, (position.height - 17f) - 2f), GUIContent.none, "TabWindowBackground");
Vector2 vector = GUIUtility.GUIToScreenPoint(Vector2.zero);
Rect rect3 = base.borderSize.Remove(base.position);
rect3.x = vector.x;
rect3.y = vector.y;
this.m_Panes[this.selected].m_Pos = rect3;
EditorGUIUtility.ResetGUIState();
try
{
base.Invoke("OnGUI");
}
catch (TargetInvocationException exception)
{
throw exception.InnerException;
}
EditorGUIUtility.ResetGUIState();
if (((base.actualView != null) && (base.actualView.m_FadeoutTime != 0f)) && ((Event.current != null) && (Event.current.type == EventType.Repaint)))
{
base.actualView.DrawNotification();
}
EndOffsetArea();
}
base.DoWindowDecorationEnd();
GUI.Box(position, GUIContent.none, style);
EditorGUI.ShowRepaints();
Highlighter.ControlHighlightGUI(this);
}
private void OnGUI()
{
using (var rgv = new RenderingGameView(this))
{
if (position.size * EditorGUIUtility.pixelsPerPoint != m_LastWindowPixelSize) // pixelsPerPoint only reliable in OnGUI()
{
UpdateZoomAreaAndParent();
}
DoToolbarGUI();
// This isn't ideal. Custom Cursors set by editor extensions for other windows can leak into the game view.
// To fix this we should probably stop using the global custom cursor (intended for runtime) for custom editor cursors.
// This has been noted for Cursors tech debt.
EditorGUIUtility.AddCursorRect(viewInWindow, MouseCursor.CustomCursor);
EventType type = Event.current.type;
// Gain mouse lock when clicking on game view content
if (type == EventType.MouseDown && viewInWindow.Contains(Event.current.mousePosition))
{
AllowCursorLockAndHide(true);
}
// Lose mouse lock when pressing escape
else if (type == EventType.KeyDown && Event.current.keyCode == KeyCode.Escape)
{
AllowCursorLockAndHide(false);
}
// We hide sliders when playing, and also when we are zoomed out beyond canvas edges
var playing = EditorApplication.isPlaying && !EditorApplication.isPaused;
var targetInContentCached = targetInContent;
m_ZoomArea.hSlider = !playing && m_ZoomArea.shownArea.width < targetInContentCached.width;
m_ZoomArea.vSlider = !playing && m_ZoomArea.shownArea.height < targetInContentCached.height;
m_ZoomArea.enableMouseInput = !playing;
ConfigureZoomArea();
// We don't want controls inside the GameView (e.g. the toolbar) to have keyboard focus while playing.
// The game should get the keyboard events.
if (playing)
{
EditorGUIUtility.keyboardControl = 0;
}
GUI.color = Color.white; // Get rid of play mode tint
var originalEventType = Event.current.type;
m_ZoomArea.BeginViewGUI();
// Setup game view dimensions, so that player loop can use it for input
var gameViewTarget = GUIClip.UnclipToWindow(m_ZoomArea.drawRect);
if (m_Parent)
{
var zoomedTarget = new Rect(targetInView.position + gameViewTarget.position, targetInView.size);
SetParentGameViewDimensions(zoomedTarget, gameViewTarget, targetSize);
}
var editorMousePosition = Event.current.mousePosition;
var gameMousePosition = (editorMousePosition + gameMouseOffset) * gameMouseScale;
if (type == EventType.Repaint)
{
GUI.Box(m_ZoomArea.drawRect, GUIContent.none, Styles.gameViewBackgroundStyle);
Vector2 oldOffset = GUIUtility.s_EditorScreenPointOffset;
GUIUtility.s_EditorScreenPointOffset = Vector2.zero;
SavedGUIState oldState = SavedGUIState.Create();
ConfigureTargetTexture((int)targetSize.x, (int)targetSize.y);
if (m_ClearInEditMode && !EditorApplication.isPlaying)
{
ClearTargetTexture();
}
var currentTargetDisplay = 0;
if (ModuleManager.ShouldShowMultiDisplayOption())
{
// Display Targets can have valid targets from 0 to 7.
System.Diagnostics.Debug.Assert(m_TargetDisplay < 8, "Display Target is Out of Range");
currentTargetDisplay = m_TargetDisplay;
}
if (m_TargetTexture.IsCreated())
{
var sendInput = true;
EditorGUIUtility.RenderGameViewCamerasInternal(m_TargetTexture, currentTargetDisplay, GUIClip.Unclip(viewInWindow), gameMousePosition, m_Gizmos, sendInput);
oldState.ApplyAndForget();
GUIUtility.s_EditorScreenPointOffset = oldOffset;
GUI.BeginGroup(m_ZoomArea.drawRect);
// Actually draw the game view to the screen, without alpha blending
Rect drawRect = deviceFlippedTargetInView;
drawRect.x = Mathf.Round(drawRect.x);
drawRect.y = Mathf.Round(drawRect.y);
Graphics.DrawTexture(drawRect, m_TargetTexture, new Rect(0, 0, 1, 1), 0, 0, 0, 0, GUI.color, GUI.blitMaterial);
GUI.EndGroup();
}
}
else if (type != EventType.Layout && type != EventType.Used)
{
if (Event.current.isKey && (!EditorApplication.isPlaying || EditorApplication.isPaused))
{
return;
}
bool mousePosInGameViewRect = viewInWindow.Contains(Event.current.mousePosition);
// MouseDown events outside game view rect are not send to scripts but MouseUp events are (see below)
if (Event.current.rawType == EventType.MouseDown && !mousePosInGameViewRect)
{
return;
}
var originalDisplayIndex = Event.current.displayIndex;
// Transform events into local space, so the mouse position is correct
// Then queue it up for playback during playerloop
Event.current.mousePosition = gameMousePosition;
Event.current.displayIndex = m_TargetDisplay;
EditorGUIUtility.QueueGameViewInputEvent(Event.current);
bool useEvent = true;
// Do not use mouse UP event if mousepos is outside game view rect (fix for case 380995: Gameview tab's context menu is not appearing on right click)
// Placed after event queueing above to ensure scripts can react on mouse up events.
if (Event.current.rawType == EventType.MouseUp && !mousePosInGameViewRect)
{
useEvent = false;
}
// Don't use command events, or they won't be sent to other views.
if (type == EventType.ExecuteCommand || type == EventType.ValidateCommand)
{
useEvent = false;
}
if (useEvent)
{
Event.current.Use();
}
else
{
Event.current.mousePosition = editorMousePosition;
}
// Reset display index
Event.current.displayIndex = originalDisplayIndex;
}
m_ZoomArea.EndViewGUI();
if (originalEventType == EventType.ScrollWheel && Event.current.type == EventType.Used)
{
EditorApplication.update -= SnapZoomDelayed;
EditorApplication.update += SnapZoomDelayed;
s_LastScrollTime = EditorApplication.timeSinceStartup;
}
EnforceZoomAreaConstraints();
if (m_TargetTexture)
{
if (m_ZoomArea.scale.y < 1f)
{
m_TargetTexture.filterMode = FilterMode.Bilinear;
}
else
{
m_TargetTexture.filterMode = FilterMode.Point;
}
}
if (m_NoCameraWarning && !EditorGUIUtility.IsDisplayReferencedByCameras(m_TargetDisplay))
{
GUI.Label(warningPosition, GUIContent.none, EditorStyles.notificationBackground);
var displayName = ModuleManager.ShouldShowMultiDisplayOption() ? DisplayUtility.GetDisplayNames()[m_TargetDisplay].text : string.Empty;
var cameraWarning = string.Format("{0}\nNo cameras rendering", displayName);
EditorGUI.DoDropShadowLabel(warningPosition, EditorGUIUtility.TempContent(cameraWarning), EditorStyles.notificationText, .3f);
}
if (m_Stats)
{
GameViewGUI.GameViewStatsGUI();
}
}
}
public void OnGUI(int windowID)
{
if (m_LookDevView == null)
{
return;
}
List <CubemapInfo> cubemapList = m_LookDevView.envLibrary.hdriList;
// Enable the ScrollView component only if there is enough HDRI (else HDRI will display on top of a scrollbar when moved)
bool drawScrollBar = LookDevEnvironmentWindow.m_HDRIHeight * cubemapList.Count > m_PositionInLookDev.height;
if (drawScrollBar)
{
m_ScrollPosition = EditorGUILayout.BeginScrollView(m_ScrollPosition);
}
else
{
m_ScrollPosition = new Vector2(0.0f, 0.0f);
}
if (cubemapList.Count == 1)
{
// Draw text
Color oldColor = GUI.color;
GUI.color = Color.gray;
Vector2 textSize = GUI.skin.label.CalcSize(styles.sDragAndDropHDRIText);
Rect labelRect = new Rect(m_PositionInLookDev.width * .5f - textSize.x * .5f, m_PositionInLookDev.height * .5f - textSize.y * .5f, textSize.x, textSize.y);
GUI.Label(labelRect, styles.sDragAndDropHDRIText);
GUI.color = oldColor;
}
{
for (int i = 0; i < cubemapList.Count; ++i)
{
CubemapInfo infos = cubemapList[i];
ShadowInfo shadowInfos = infos.shadowInfo;
int firstSelectionIndex = m_LookDevView.config.GetIntProperty(LookDevProperty.HDRI, LookDevEditionContext.Left);
int secondSelectionIndex = m_LookDevView.config.GetIntProperty(LookDevProperty.HDRI, LookDevEditionContext.Right);
// Disable the drawing of second selection if we are in single view
if (m_LookDevView.config.lookDevMode == LookDevMode.Single1 || m_LookDevView.config.lookDevMode == LookDevMode.Single2)
{
secondSelectionIndex = -1;
}
bool isSelection = (i == firstSelectionIndex || i == secondSelectionIndex);
Color selectionColor1 = Color.black;
Color selectionColor2 = Color.black;
GUIStyle selectionLabelStyle = EditorStyles.miniLabel;
if (isSelection)
{
if (i == firstSelectionIndex)
{
selectionColor1 = LookDevView.m_FirstViewGizmoColor;
selectionColor2 = LookDevView.m_FirstViewGizmoColor;
selectionLabelStyle = styles.sLabelStyleFirstContext;
}
else if (i == secondSelectionIndex)
{
selectionColor1 = LookDevView.m_SecondViewGizmoColor;
selectionColor2 = LookDevView.m_SecondViewGizmoColor;
selectionLabelStyle = styles.sLabelStyleSecondContext;
}
if (firstSelectionIndex == secondSelectionIndex)
{
selectionColor1 = LookDevView.m_FirstViewGizmoColor;
selectionColor2 = LookDevView.m_SecondViewGizmoColor;
selectionLabelStyle = styles.sLabelStyleBothContext;
}
}
Rect textureRect;
Rect lightIconRect;
Rect lightIconSelectionRect;
Rect frameTextureRect;
Rect shadowTextureRect;
GUILayout.BeginVertical(GUILayout.Width(m_HDRIWidth));
{
// Find index of current selection if it exist
int selectedCubeMapIndex = cubemapList.FindIndex(x => x == m_SelectedCubemapInfo);
// User is dragging another environment, we need to show the space for insertion
if ((m_SelectedCubemap != null || m_DragBeingPerformed) && GetInsertionRect(i).Contains(Event.current.mousePosition)
// Following test allow to not propose a slot that is neutral, i.e current position or next one
&& (((selectedCubeMapIndex - i) != 0 && (selectedCubeMapIndex - i) != -1) || selectedCubeMapIndex == -1)
)
{
GUILayout.Label(GUIContent.none, styles.sSeparatorStyle);
GUILayoutUtility.GetRect(m_HDRIWidth, EditorGUI.kSingleLineHeight);
}
// Header for one HDRI: label + remove button
GUILayout.Label(GUIContent.none, styles.sSeparatorStyle);
GUILayout.BeginHorizontal(GUILayout.Width(m_HDRIWidth), GUILayout.Height(m_HDRIHeaderHeight));
{
StringBuilder sb = new StringBuilder();
sb.Append(i.ToString());
sb.Append(" - ");
sb.Append(infos.cubemap.name);
GUILayout.Label(sb.ToString(), selectionLabelStyle, GUILayout.Height(m_HDRIHeaderHeight), GUILayout.MaxWidth(m_HDRIWidth - 75));
GUILayout.FlexibleSpace();
if (GUILayout.Button(styles.sEnvControlIcon, LookDevView.styles.sToolBarButton))
{
Rect rect = GUILayoutUtility.topLevel.GetLast();
PopupWindow.Show(rect, new EnvSettingsWindow(m_LookDevView, infos));
GUIUtility.ExitGUI();
}
using (new EditorGUI.DisabledScope(infos.cubemap == LookDevResources.m_DefaultHDRI))
{
if (GUILayout.Button(styles.sCloseIcon, LookDevView.styles.sToolBarButton))
{
m_LookDevView.envLibrary.RemoveHDRI(infos.cubemap);
}
}
}
GUILayout.EndHorizontal();
// We don't want to handle any control inside the label, following code disable mouseDown event in this case.
Rect lastRect = GUILayoutUtility.GetLastRect();
if (Event.current.type == EventType.MouseDown && lastRect.Contains(Event.current.mousePosition))
{
Event.current.Use(); // Avoid camera movement and focus change in main view
}
textureRect = GUILayoutUtility.GetRect(m_HDRIWidth, m_latLongHeight);
textureRect.width = m_HDRIWidth + 3; // Sometimes GUILayoutUtility.GetRect returns width as m_HDRIWidth, sometimes at m_HDRIWidth + 3 ...
float iconSize = 24.0f;
float iconHalfSize = iconSize * 0.5f;
// Convert from latlong to normalized coordinate to pixel coordinates.
float latitude = shadowInfos.latitude;
float longitude = shadowInfos.longitude;
Vector2 iconPosition = LatLongToPosition(latitude, longitude + infos.angleOffset) * 0.5f + new Vector2(0.5f, 0.5f);
lightIconRect = textureRect;
lightIconRect.x = lightIconRect.x + iconPosition.x * textureRect.width - iconHalfSize;
lightIconRect.y = lightIconRect.y + (1.0f - iconPosition.y) * textureRect.height - iconHalfSize; // Coordinates start from the bottom
lightIconRect.width = iconSize;
lightIconRect.height = iconSize;
// Selection rect of light is a bit smaller than the texture
lightIconSelectionRect = textureRect;
lightIconSelectionRect.x = lightIconSelectionRect.x + iconPosition.x * textureRect.width - iconHalfSize * 0.5f;
lightIconSelectionRect.y = lightIconSelectionRect.y + (1.0f - iconPosition.y) * textureRect.height - iconHalfSize * 0.5f; // Coordinates start from the bottom
lightIconSelectionRect.width = iconSize * 0.5f;
lightIconSelectionRect.height = iconSize * 0.5f;
GetFrameAndShadowTextureRect(textureRect, out frameTextureRect, out shadowTextureRect);
if (m_LookDevView.config.enableShadowCubemap)
{
EditorGUIUtility.AddCursorRect(lightIconSelectionRect, MouseCursor.Pan);
}
if (Event.current.type == EventType.MouseDown && textureRect.Contains(Event.current.mousePosition))
{
// Left Button
if ((!Event.current.control && Event.current.button == 0) && m_SelectedCubeMapOffsetIndex == -1)
{
// Light icon handling - it is higher priority then shadowTexture thumbnail selection
if (m_LookDevView.config.enableShadowCubemap && lightIconSelectionRect.Contains(Event.current.mousePosition))
{
m_SelectedLightIconIndex = i;
m_SelectedShadowInfo = shadowInfos;
// We want to avoid to record object when draging the light icon, so save location here.
// However the record need to be aware about what will change, so we perform an insignificant modification
// to the lat/long position so it is record by the undo
Undo.RecordObject(m_LookDevView.envLibrary, "Light Icon selection");
m_SelectedShadowInfo.latitude = m_SelectedShadowInfo.latitude + 0.0001f;
m_SelectedShadowInfo.longitude = m_SelectedShadowInfo.longitude + 0.0001f;
}
// Environment selection handling
if (m_SelectedShadowInfo == null)
{
Rect resetShadowIconRect;
// All values are taken from the LookDevShadowFrame.png (hard coded)
resetShadowIconRect = frameTextureRect;
resetShadowIconRect.x = resetShadowIconRect.x + 100.0f;
resetShadowIconRect.y = resetShadowIconRect.y + 4.0f;
resetShadowIconRect.width = 11;
resetShadowIconRect.height = 11f;
// Close icon handling
if (m_LookDevView.config.enableShadowCubemap && resetShadowIconRect.Contains(Event.current.mousePosition))
{
// Reset Shadow Cubemap
Undo.RecordObject(m_LookDevView.envLibrary, "Update shadow cubemap");
cubemapList[i].SetCubemapShadowInfo(cubemapList[i]);
m_LookDevView.envLibrary.dirty = true;
}
else
{
// If we have selected the shadowTexture, let's swap the index of the current selected map
if (m_LookDevView.config.enableShadowCubemap && shadowTextureRect.Contains(Event.current.mousePosition))
{
m_SelectedShadowCubemapOwnerInfo = cubemapList[i];
// Current selected cubemap is the one without sun
m_SelectedCubemapInfo = m_SelectedShadowCubemapOwnerInfo.cubemapShadowInfo;
}
else
{
m_SelectedCubemapInfo = cubemapList[i];
}
m_SelectedPositionOffset = Event.current.mousePosition - new Vector2(textureRect.x, textureRect.y);
m_RenderOverlayThumbnailOnce = true;
}
}
}
// Left button with Ctrl - Rotate environment
else if ((Event.current.control && Event.current.button == 0) && m_SelectedCubemapInfo == null && m_SelectedShadowInfo == null)
{
m_SelectedCubeMapOffsetIndex = i;
m_SelectedCubeMapOffsetValue = infos.angleOffset - ComputeAngleOffsetFromMouseCoord(Event.current.mousePosition);
}
GUIUtility.hotControl = m_LookDevView.hotControl;
Event.current.Use(); // Avoid camera movement and focus change in main view
}
if (Event.current.GetTypeForControl(m_LookDevView.hotControl) == EventType.MouseDrag)
{
if (m_SelectedShadowInfo == shadowInfos && m_SelectedLightIconIndex == i)
{
Vector2 newLightPosition = Event.current.mousePosition;
newLightPosition.x = (newLightPosition.x - textureRect.x) / textureRect.width * 2.0f - 1.0f;
newLightPosition.y = (1.0f - (newLightPosition.y - textureRect.y) / textureRect.height) * 2.0f - 1.0f;
Vector2 newLatLongPos = PositionToLatLong(newLightPosition);
m_SelectedShadowInfo.latitude = newLatLongPos.x;
m_SelectedShadowInfo.longitude = newLatLongPos.y - infos.angleOffset;
m_LookDevView.envLibrary.dirty = true;
}
}
if (Event.current.type == EventType.Repaint)
{
// Draw the latlong thumbnail
DrawLatLongThumbnail(infos, infos.angleOffset, 1.0f, 1.0f, textureRect);
if (m_LookDevView.config.enableShadowCubemap)
{
// Draw the shadow cubemap thumbnail if either:
if ((infos.cubemapShadowInfo != infos) || // Shadows are enabled on this environment and shadow cubemap is not self
(m_HoveringCubeMapIndex == i && m_SelectedCubemapInfo != infos) // user is dragging over the environment that is not itself
)
{
// By default, we want to display the shadow cubemap associated with the current environment
CubemapInfo cubemapShadowInfo = infos.cubemapShadowInfo;
// If we are dragging another environment we want to display instead of the current one unless we are dragging a cubemap over itself
if (m_HoveringCubeMapIndex == i && m_SelectedCubemapInfo != infos)
{
cubemapShadowInfo = m_SelectedCubemapInfo;
}
float alpha = 1.0f;
if (m_SelectedShadowInfo == shadowInfos) // We need to fade the thumbnail almost completely to see where we move the light
{
alpha = 0.1f;
}
else if (m_HoveringCubeMapIndex == i && m_SelectedCubemapInfo != infos && infos.cubemapShadowInfo != m_SelectedCubemapInfo) // Visual transparent feedback to show where you are going to drop your cubemap
{
alpha = 0.5f;
}
DrawLatLongThumbnail(cubemapShadowInfo, infos.angleOffset, 0.3f, alpha, shadowTextureRect);
GUI.DrawTexture(frameTextureRect, styles.sLatlongFrameTexture);
}
GUI.DrawTexture(lightIconRect, styles.sLightTexture);
}
if (isSelection)
{
DrawSelectionFeedback(textureRect, selectionColor1, selectionColor2);
}
}
}
GUILayout.EndVertical();
}
// Last vertical slot when drag and drop HDRI
GUILayout.BeginVertical(GUILayout.Width(m_HDRIWidth));
{
// User is dragging another environment, we need to show the space for insertion
if ((m_SelectedCubemap != null || m_DragBeingPerformed) && GetInsertionRect(cubemapList.Count).Contains(Event.current.mousePosition))
{
GUILayout.Label(GUIContent.none, styles.sSeparatorStyle);
GUILayoutUtility.GetRect(m_HDRIWidth, EditorGUI.kSingleLineHeight);
GUILayout.Label(GUIContent.none, styles.sSeparatorStyle);
}
}
GUILayout.EndVertical();
}
if (drawScrollBar)
{
EditorGUILayout.EndScrollView();
}
HandleMouseInput();
RenderOverlayThumbnailIfNeeded();
if (Event.current.type == EventType.Repaint)
{
if (m_SelectedCubemap != null)
{
m_LookDevView.Repaint();
}
}
}
public void OnGUI()
{
LoadLogos();
GUILayout.Space(10);
GUILayout.BeginHorizontal();
GUILayout.Space(5);
GUILayout.BeginVertical();
GUILayout.FlexibleSpace();
GUILayout.Label(s_Header, GUIStyle.none);
ListenForSecretCodes();
var licenseTypeString = "";
if (InternalEditorUtility.HasFreeLicense())
{
licenseTypeString = " Personal";
}
if (InternalEditorUtility.HasEduLicense())
{
licenseTypeString = " Edu";
}
GUILayout.BeginHorizontal();
GUILayout.Space(52f); // Ident version information
string extensionVersion = FormatExtensionVersionString();
m_ShowDetailedVersion |= Event.current.alt;
if (m_ShowDetailedVersion)
{
int t = InternalEditorUtility.GetUnityVersionDate();
DateTime dt = new DateTime(1970, 1, 1, 0, 0, 0, 0);
string branch = InternalEditorUtility.GetUnityBuildBranch();
EditorGUILayout.SelectableLabel(
string.Format("Version: {0}{1}{2}\nRevision: {3} {4}\nBuilt: {5:r}",
InternalEditorUtility.GetUnityDisplayVersionVerbose(), licenseTypeString, extensionVersion,
branch, InternalEditorUtility.GetUnityBuildHash(), dt.AddSeconds(t)),
GUILayout.Width(550), GUILayout.Height(50));
m_TextInitialYPos = 120 - 12;
}
else
{
GUILayout.Label(string.Format("Version {0}{1}{2}", InternalEditorUtility.GetUnityDisplayVersion(), licenseTypeString, extensionVersion));
}
if (Event.current.type == EventType.ValidateCommand)
{
return;
}
GUILayout.EndHorizontal();
GUILayout.Space(4);
GUILayout.EndVertical();
GUILayout.EndHorizontal();
GUILayout.FlexibleSpace();
float creditsWidth = position.width - 10;
float chunkOffset = m_TextYPos;
Rect scrollAreaRect = GUILayoutUtility.GetRect(10, m_TextInitialYPos);
GUI.BeginGroup(scrollAreaRect);
foreach (string nameChunk in AboutWindowNames.Names(null, true))
{
chunkOffset = DoCreditsNameChunk(nameChunk, creditsWidth, chunkOffset);
}
chunkOffset = DoCreditsNameChunk(kSpecialThanksNames, creditsWidth, chunkOffset);
m_TotalCreditsHeight = chunkOffset - m_TextYPos;
GUI.EndGroup();
HandleScrollEvents(scrollAreaRect);
GUILayout.FlexibleSpace();
GUILayout.BeginHorizontal();
GUILayout.Label(s_MonoLogo);
GUILayout.Label("Scripting powered by The Mono Project.\n\n(c) 2011 Novell, Inc.", "MiniLabel", GUILayout.Width(210));
GUILayout.Label(s_AgeiaLogo);
GUILayout.Label("Physics powered by PhysX.\n\n(c) 2019 NVIDIA Corporation.", "MiniLabel", GUILayout.Width(200));
GUILayout.EndHorizontal();
GUILayout.FlexibleSpace();
GUILayout.BeginHorizontal();
GUILayout.Space(5);
GUILayout.BeginVertical();
GUILayout.FlexibleSpace();
var specialThanksRect = GUILayoutUtility.GetRect(Styles.thanksContent, Styles.thanksStyle);
if (GUI.Button(specialThanksRect, Styles.thanksContent, Styles.thanksStyle))
{
Process.Start(Styles.thanksUri.AbsoluteUri);
}
EditorGUIUtility.AddCursorRect(specialThanksRect, MouseCursor.Link);
var VSTUlabel = UnityVSSupport.GetAboutWindowLabel();
if (VSTUlabel.Length > 0)
{
GUILayout.Label(VSTUlabel, "MiniLabel");
}
GUILayout.Label(InternalEditorUtility.GetUnityCopyright(), "MiniLabel");
GUILayout.EndVertical();
GUILayout.Space(10);
GUILayout.FlexibleSpace();
GUILayout.BeginVertical();
GUILayout.FlexibleSpace();
GUILayout.Label(InternalEditorUtility.GetLicenseInfo(), "AboutWindowLicenseLabel");
GUILayout.EndVertical();
GUILayout.Space(5);
GUILayout.EndHorizontal();
GUILayout.Space(5);
}
public void DoEffectGUI(int effectIndex, AudioMixerGroupController group, List <AudioMixerGroupController> allGroups, Dictionary <AudioMixerEffectController, AudioMixerGroupController> effectMap, ref int highlightEffectIndex)
{
Event evt = Event.current;
AudioMixerController controller = group.controller;
AudioMixerEffectController effect = group.effects[effectIndex];
MixerParameterDefinition[] paramDefs = MixerEffectDefinitions.GetEffectParameters(effect.effectName);
// This rect is valid after every layout event
Rect totalRect = EditorGUILayout.BeginVertical();
bool hovering = totalRect.Contains(evt.mousePosition);
EventType evtType = evt.GetTypeForControl(m_EffectDragging.dragControlID);
if (evtType == EventType.MouseMove && hovering && highlightEffectIndex != effectIndex)
{
highlightEffectIndex = effectIndex;
AudioMixerUtility.RepaintAudioMixerAndInspectors();
}
// Header
const float colorCodeWidth = 6f;
var gearSize = EditorStyles.iconButton.CalcSize(EditorGUI.GUIContents.titleSettingsIcon);
Rect headerRect = GUILayoutUtility.GetRect(1, 17f);
Rect colorCodeRect = new Rect(headerRect.x + 6f, headerRect.y + 5f, colorCodeWidth, colorCodeWidth);
Rect labelRect = new Rect(headerRect.x + 8f + colorCodeWidth, headerRect.y, headerRect.width - 8f - colorCodeWidth - gearSize.x - 5f, headerRect.height);
Rect gearRect = new Rect(labelRect.xMax, headerRect.y, gearSize.x, gearSize.y);
Rect dragRect = new Rect(headerRect.x, headerRect.y, headerRect.width - gearSize.x - 5f, headerRect.height);
{
bool showCPU = EditorPrefs.GetBool(AudioMixerGroupEditor.kPrefKeyForShowCpuUsage, false) && EditorUtility.audioProfilingEnabled;
float val = EditorGUIUtility.isProSkin ? 0.1f : 1.0f;
Color headerColor = new Color(val, val, val, 0.2f);
Color origColor = GUI.color;
GUI.color = headerColor;
GUI.DrawTexture(headerRect, EditorGUIUtility.whiteTexture);
GUI.color = origColor;
Color effectColorCode = AudioMixerDrawUtils.GetEffectColor(effect);
EditorGUI.DrawRect(colorCodeRect, effectColorCode);
GUI.Label(labelRect, showCPU ? effect.effectName + string.Format(Texts.cpuFormatString, effect.GetCPUUsage(controller)) : effect.effectName, EditorStyles.boldLabel);
if (EditorGUI.DropdownButton(gearRect, EditorGUI.GUIContents.titleSettingsIcon, FocusType.Passive, EditorStyles.iconButton))
{
ShowEffectContextMenu(group, effect, effectIndex, controller, gearRect);
}
// Show context menu if right clicking in header rect (for convenience)
if (evt.type == EventType.ContextClick && headerRect.Contains(evt.mousePosition))
{
ShowEffectContextMenu(group, effect, effectIndex, controller, new Rect(evt.mousePosition.x, headerRect.y, 1, headerRect.height));
evt.Use();
}
if (evtType == EventType.Repaint)
{
EditorGUIUtility.AddCursorRect(dragRect, MouseCursor.ResizeVertical, m_EffectDragging.dragControlID);
}
}
using (new EditorGUI.DisabledScope(effect.bypass || group.bypassEffects))
{
EditorGUILayout.BeginVertical(EditorStyles.inspectorDefaultMargins);
if (effect.IsAttenuation())
{
EditorGUILayout.BeginVertical();
float value = group.GetValueForVolume(controller, controller.TargetSnapshot);
if (AudioMixerEffectGUI.Slider(Texts.volume, ref value, 1.0f, 1.0f, Texts.dB, AudioMixerController.kMinVolume, AudioMixerController.GetMaxVolume(), controller, new AudioGroupParameterPath(group, group.GetGUIDForVolume())))
{
Undo.RecordObject(controller.TargetSnapshot, "Change Volume Fader");
group.SetValueForVolume(controller, controller.TargetSnapshot, value);
AudioMixerUtility.RepaintAudioMixerAndInspectors();
}
//FIXME
// 1) The VUMeter used is not in the same style that fits the rest of the Audio UI
// 2) The layout of the VU meters is hacked together and a lot of magic numbers are used.
int numChannels = 0;
float[] vuinfo_level = new float[9];
float[] vuinfo_peak = new float[9];
numChannels = group.controller.GetGroupVUInfo(group.groupID, true, vuinfo_level, vuinfo_peak);
if (evt.type == EventType.Layout)
{
m_LastNumChannels = numChannels;
}
else
{
if (numChannels != m_LastNumChannels)
{
HandleUtility.Repaint(); // Repaint to ensure correct rendered num channels
}
// Ensure same num channels as in layout event to not break IMGUI controlID handling
numChannels = m_LastNumChannels;
}
GUILayout.Space(4f);
for (int c = 0; c < numChannels; ++c)
{
float level = 1 - AudioMixerController.VolumeToScreenMapping(Mathf.Clamp(vuinfo_level[c], AudioMixerController.kMinVolume, AudioMixerController.GetMaxVolume()), 1, true);
float peak = 1 - AudioMixerController.VolumeToScreenMapping(Mathf.Clamp(vuinfo_peak[c], AudioMixerController.kMinVolume, AudioMixerController.GetMaxVolume()), 1, true);
EditorGUILayout.VUMeterHorizontal(level, peak, GUILayout.Height(10));
//This allows the meters to drop to 0 after PlayMode has stopped.
if (!EditorApplication.isPlaying && peak > 0.0F)
{
AudioMixerUtility.RepaintAudioMixerAndInspectors();
}
}
GUILayout.Space(4f);
EditorGUILayout.EndVertical();
}
if (effect.IsSend())
{
Rect buttonRect;
GUIContent buttonContent = (effect.sendTarget == null) ? Texts.none : GUIContent.Temp(effect.GetSendTargetDisplayString(effectMap));
if (AudioMixerEffectGUI.PopupButton(Texts.bus, buttonContent, EditorStyles.popup, out buttonRect))
{
ShowBusPopupMenu(effectIndex, @group, allGroups, effectMap, effect, buttonRect);
}
if (effect.sendTarget != null)
{
float wetLevel = effect.GetValueForMixLevel(controller, controller.TargetSnapshot);
if (AudioMixerEffectGUI.Slider(Texts.sendLevel, ref wetLevel, 1.0f, 1.0f, Texts.dB, AudioMixerController.kMinVolume, AudioMixerController.kMaxEffect, controller, new AudioGroupParameterPath(group, group.GetGUIDForSend())))
{
Undo.RecordObject(controller.TargetSnapshot, "Change Send Level");
effect.SetValueForMixLevel(controller, controller.TargetSnapshot, wetLevel);
AudioMixerUtility.RepaintAudioMixerAndInspectors();
}
}
}
if (MixerEffectDefinitions.EffectCanBeSidechainTarget(effect))
{
bool anyTargetsFound = false;
foreach (var g in allGroups)
{
foreach (var e in g.effects)
{
if (e.IsSend() && e.sendTarget == effect)
{
anyTargetsFound = true;
break;
}
}
if (anyTargetsFound)
{
break;
}
}
if (!anyTargetsFound)
{
GUILayout.Label(EditorGUIUtility.TrTextContent("No Send sources connected.", EditorGUIUtility.warningIcon));
}
}
// Wet mix
if (effect.enableWetMix && !effect.IsReceive() && !effect.IsDuckVolume() && !effect.IsAttenuation() && !effect.IsSend())
{
float wetLevel = effect.GetValueForMixLevel(controller, controller.TargetSnapshot);
if (AudioMixerEffectGUI.Slider(Texts.wet, ref wetLevel, 1.0f, 1.0f, Texts.dB, AudioMixerController.kMinVolume, AudioMixerController.kMaxEffect, controller, new AudioEffectParameterPath(group, effect, effect.GetGUIDForMixLevel())))
{
Undo.RecordObject(controller.TargetSnapshot, "Change Mix Level");
effect.SetValueForMixLevel(controller, controller.TargetSnapshot, wetLevel);
AudioMixerUtility.RepaintAudioMixerAndInspectors();
}
}
// All other effects
bool drawDefaultGUI = true;
if (m_CustomEffectGUIs.ContainsKey(effect.effectName))
{
var customGUI = m_CustomEffectGUIs[effect.effectName];
m_SharedPlugin.m_Controller = controller;
m_SharedPlugin.m_Effect = effect;
m_SharedPlugin.m_ParamDefs = paramDefs;
drawDefaultGUI = customGUI.OnGUI(m_SharedPlugin);
}
if (drawDefaultGUI)
{
foreach (var p in paramDefs)
{
float value = effect.GetValueForParameter(controller, controller.TargetSnapshot, p.name);
if (AudioMixerEffectGUI.Slider(GUIContent.Temp(p.name, p.description), ref value, p.displayScale, p.displayExponent, p.units, p.minRange, p.maxRange, controller, new AudioEffectParameterPath(group, effect, effect.GetGUIDForParameter(p.name))))
{
Undo.RecordObject(controller.TargetSnapshot, "Change " + p.name);
effect.SetValueForParameter(controller, controller.TargetSnapshot, p.name, value);
}
}
if (paramDefs.Length > 0)
{
GUILayout.Space(6f);
}
}
}
m_EffectDragging.HandleDragElement(effectIndex, totalRect, dragRect, group, allGroups);
EditorGUILayout.EndVertical(); // indented effect contents
EditorGUILayout.EndVertical(); // calc total size
AudioMixerDrawUtils.DrawSplitter();
}
private void DragTitleBar(Rect titleBarRect)
{
int id = GUIUtility.GetControlID(FocusType.Passive);
Event evt = Event.current;
switch (evt.GetTypeForControl(id))
{
case EventType.Repaint:
if (m_DraggingNativeTitleBarCaption)
{
m_DraggingNativeTitleBarCaption = false;
}
EditorGUIUtility.AddCursorRect(titleBarRect, MouseCursor.Arrow);
break;
case EventType.MouseDown:
// If the mouse is inside the title bar rect, we say that we're the hot control
if (titleBarRect.Contains(evt.mousePosition) && GUIUtility.hotControl == 0 && evt.button == 0)
{
Event.current.Use();
m_DraggingNativeTitleBarCaption = true;
SendCaptionEvent(m_DraggingNativeTitleBarCaption);
}
break;
case EventType.MouseUp:
if (m_DraggingNativeTitleBarCaption)
{
break;
}
if (GUIUtility.hotControl == id)
{
GUIUtility.hotControl = 0;
Event.current.Use();
Unsupported.SetAllowCursorLock(true, Unsupported.DisallowCursorLockReasons.SizeMove);
}
break;
case EventType.MouseDrag:
if (m_DraggingNativeTitleBarCaption)
{
break;
}
if (GUIUtility.hotControl == id)
{
Vector2 mousePos = evt.mousePosition;
if (startDragDpi != GUIUtility.pixelsPerPoint)
{
// We ignore this mouse event when changing screens in multi monitor setups with
// different dpi scalings as funky things might/will happen
startDragDpi = GUIUtility.pixelsPerPoint;
s_LastDragMousePos = mousePos;
}
else
{
Vector2 movement = mousePos - s_LastDragMousePos;
float minimumDelta = 1.0f / GUIUtility.pixelsPerPoint;
if (Mathf.Abs(movement.x) >= minimumDelta || Mathf.Abs(movement.y) >= minimumDelta)
{
Rect dragPosition = position;
dragPosition.x += movement.x;
dragPosition.y += movement.y;
position = dragPosition;
GUI.changed = true;
}
}
}
break;
}
}
protected override void OldOnGUI()
{
ClearBackground();
// Call reset GUI state as first thing so GUI.color is correct when drawing window decoration.
EditorGUIUtility.ResetGUIState();
// Exit if the window was destroyed after entering play mode or on domain-reload.
if (window == null)
{
return;
}
// Add CursorRects
SplitView sp = parent as SplitView;
if (Event.current.type == EventType.Repaint && sp)
{
View view = this;
while (sp)
{
int id = sp.controlID;
if (id == GUIUtility.hotControl || GUIUtility.hotControl == 0)
{
int idx = sp.IndexOfChild(view);
if (sp.vertical)
{
if (idx != 0)
{
EditorGUIUtility.AddCursorRect(new Rect(0, 0, position.width, SplitView.kGrabDist), MouseCursor.SplitResizeUpDown, id);
}
if (idx != sp.children.Length - 1)
{
EditorGUIUtility.AddCursorRect(
new Rect(0, position.height - SplitView.kGrabDist, position.width, SplitView.kGrabDist),
MouseCursor.SplitResizeUpDown, id);
}
}
else // horizontal
{
if (idx != 0)
{
EditorGUIUtility.AddCursorRect(new Rect(0, 0, SplitView.kGrabDist, position.height), MouseCursor.SplitResizeLeftRight,
id);
}
if (idx != sp.children.Length - 1)
{
EditorGUIUtility.AddCursorRect(
new Rect(position.width - SplitView.kGrabDist, 0, SplitView.kGrabDist, position.height),
MouseCursor.SplitResizeLeftRight, id);
}
}
}
view = sp;
sp = sp.parent as SplitView;
}
// reset
sp = parent as SplitView;
}
bool customBorder = false;
if (window.rootView.GetType() != typeof(MainView))
{
customBorder = true;
if (windowPosition.y == 0)
{
background = "dockareaStandalone";
}
else
{
background = "dockarea";
}
}
else
{
background = "dockarea";
}
if (sp)
{
Event e = new Event(Event.current);
e.mousePosition += new Vector2(position.x, position.y);
sp.SplitGUI(e);
if (e.type == EventType.Used)
{
Event.current.Use();
}
}
Rect r = background.margin.Remove(new Rect(0, 0, position.width, position.height));
r.x = background.margin.left;
r.y = background.margin.top;
Rect wPos = windowPosition;
Rect containerWindowPosition = window.position;
containerWindowPosition.width = Mathf.FloorToInt(containerWindowPosition.width);
containerWindowPosition.height = Mathf.FloorToInt(containerWindowPosition.height);
float sideBorder = kSideBorders;
if (wPos.x == 0)
{
r.x -= sideBorder;
r.width += sideBorder;
}
if (wPos.xMax == containerWindowPosition.width)
{
r.width += sideBorder;
}
if (wPos.yMax == containerWindowPosition.height)
{
r.height += customBorder ? 2f : kBottomBorders;
}
if (Event.current.type == EventType.Repaint)
{
background.Draw(r, GUIContent.none, 0);
}
if (tabStyle == null)
{
tabStyle = "dragtab";
}
if (m_Panes.Count > 0)
{
// Set up the pane's position, so its GUI can use this
// Contents:
// scroll it by -1, -1 so we top & left 1px gets culled (they are drawn already by the us, so we want to
// not have them here (thing that the default skin relies on)
BeginOffsetArea(new Rect(r.x + 2, r.y + kTabHeight, r.width - 4, r.height - kTabHeight - 2), GUIContent.none, "TabWindowBackground");
Vector2 basePos = GUIUtility.GUIToScreenPoint(Vector2.zero);
Rect p = borderSize.Remove(position);
p.x = basePos.x;
p.y = basePos.y;
if (selected >= 0 && selected < m_Panes.Count)
{
m_Panes[selected].m_Pos = p;
}
EndOffsetArea();
}
DragTab(new Rect(r.x + 1, r.y, r.width - kWindowButtonsWidth, kTabHeight), tabStyle);
// TODO: Make this nice - right now this is meant to be overridden by Panes in Layout if they want something else. Inspector does this
tabStyle = "dragtab";
ShowGenericMenu();
if (m_Panes.Count > 0)
{
RenderToHMDIfNecessary(r);
InvokeOnGUI(r);
}
EditorGUI.ShowRepaints();
Highlighter.ControlHighlightGUI(this);
}
private static void DrawLODButton(LODInfo currentLOD)
{
// Make the lod button areas a horizonal resizer
EditorGUIUtility.AddCursorRect(currentLOD.m_ButtonPosition, MouseCursor.ResizeHorizontal);
}
public override void OnGUI(Rect rect)
{
if (FlexibleMenu.s_Styles == null)
{
FlexibleMenu.s_Styles = new FlexibleMenu.Styles();
}
Event current = Event.current;
Rect viewRect = new Rect(0f, 0f, 1f, this.CalcSize().y);
this.m_ScrollPosition = GUI.BeginScrollView(rect, this.m_ScrollPosition, viewRect);
float num = 0f;
for (int i = 0; i <= this.maxIndex; i++)
{
int num2 = i + 1000000;
Rect rect2 = new Rect(0f, num, rect.width, 18f);
bool flag = Array.IndexOf <int>(this.m_SeperatorIndices, i) >= 0;
if (this.m_ShowAddNewPresetItem && i == this.m_ItemProvider.Count())
{
this.CreateNewItemButton(rect2);
}
else
{
if (this.m_ShowEditWindowForIndex == i)
{
this.m_ShowEditWindowForIndex = -1;
this.EditExistingItem(rect2, i);
}
EventType type = current.type;
switch (type)
{
case EventType.MouseDown:
if (current.button == 0 && rect2.Contains(current.mousePosition))
{
GUIUtility.hotControl = num2;
if (!this.IsDeleteModiferPressed() && current.clickCount == 1)
{
GUIUtility.hotControl = 0;
this.SelectItem(i);
base.editorWindow.Close();
current.Use();
}
}
goto IL_3B9;
case EventType.MouseUp:
if (GUIUtility.hotControl == num2)
{
GUIUtility.hotControl = 0;
if (current.button == 0 && rect2.Contains(current.mousePosition))
{
if (this.AllowDeleteClick(i))
{
this.DeleteItem(i);
current.Use();
}
}
}
goto IL_3B9;
case EventType.MouseMove:
if (rect2.Contains(current.mousePosition))
{
if (this.m_HoverIndex != i)
{
this.m_HoverIndex = i;
this.Repaint();
}
}
else if (this.m_HoverIndex == i)
{
this.m_HoverIndex = -1;
this.Repaint();
}
goto IL_3B9;
case EventType.MouseDrag:
case EventType.KeyDown:
case EventType.KeyUp:
case EventType.ScrollWheel:
IL_114:
if (type != EventType.ContextClick)
{
goto IL_3B9;
}
if (rect2.Contains(current.mousePosition))
{
current.Use();
if (this.m_ModifyItemUI != null && this.m_ItemProvider.IsModificationAllowed(i))
{
FlexibleMenu.ItemContextMenu.Show(i, this);
}
}
goto IL_3B9;
case EventType.Repaint:
{
bool isHover = false;
if (this.m_HoverIndex == i)
{
if (rect2.Contains(current.mousePosition))
{
isHover = true;
}
else
{
this.m_HoverIndex = -1;
}
}
if (this.m_ModifyItemUI != null && this.m_ModifyItemUI.IsShowing())
{
isHover = (this.m_ItemProvider.GetItem(i) == this.m_ModifyItemUI.m_Object);
}
FlexibleMenu.s_Styles.menuItem.Draw(rect2, GUIContent.Temp(this.m_ItemProvider.GetName(i)), isHover, false, i == this.selectedIndex, false);
if (flag)
{
Rect rect3 = new Rect(rect2.x + 4f, rect2.y + rect2.height + 4f, rect2.width - 8f, 1f);
FlexibleMenu.DrawRect(rect3, (!EditorGUIUtility.isProSkin) ? new Color(0.6f, 0.6f, 0.6f, 1.333f) : new Color(0.32f, 0.32f, 0.32f, 1.333f));
}
if (this.AllowDeleteClick(i))
{
EditorGUIUtility.AddCursorRect(rect2, MouseCursor.ArrowMinus);
}
goto IL_3B9;
}
}
goto IL_114;
IL_3B9:
num += 18f;
if (flag)
{
num += 8f;
}
}
}
GUI.EndScrollView();
}
// This is the slider behavior for resizing the preview area
public static float PixelPreciseCollapsibleSlider(int id, Rect position, float value, float min, float max, ref bool expanded)
{
Event evt = Event.current;
if (evt.type == EventType.Layout)
{
return(value);
}
var mousePosition = GUIClip.UnclipToWindow(evt.mousePosition);
mousePosition.y -= Editor.k_HeaderHeight;
switch (evt.GetTypeForControl(id))
{
case EventType.MouseDown:
if (GUIUtility.hotControl == 0 && evt.button == 0 && position.Contains(mousePosition))
{
GUIUtility.hotControl = id;
s_MouseDownLocation = mousePosition.y;
s_MouseDownValue = value;
s_MouseDragged = false;
evt.Use();
}
break;
case EventType.MouseDrag:
if (GUIUtility.hotControl == id)
{
value = Mathf.Clamp(mousePosition.y - s_MouseDownLocation + s_MouseDownValue, min, max - 1);
GUI.changed = true;
s_MouseDragged = true;
evt.Use();
}
break;
case EventType.MouseUp:
if (GUIUtility.hotControl == id)
{
GUIUtility.hotControl = 0;
if (!s_MouseDragged)
{
expanded = !expanded;
}
evt.Use();
}
break;
case EventType.Repaint:
const float x = 0f;
const float y = 0f;
if (GUIUtility.hotControl == 0)
{
EditorGUIUtility.AddCursorRect(new Rect(x, y, position.width, position.height), MouseCursor.SplitResizeUpDown);
}
if (GUIUtility.hotControl == id)
{
const int yMove = 100;
const int heightMove = yMove * 2;
EditorGUIUtility.AddCursorRect(new Rect(x, y - yMove, position.width, position.height + heightMove), MouseCursor.SplitResizeUpDown);
}
break;
}
return(value);
}
/**
* Static function to handle the GUI and User input related to the cascade slider.
*
* @param normalizedCascadePartition The array of partition sizes in the range 0.0f - 1.0f; expects ONE entry if cascades = 2, and THREE if cascades=4
* The last entry will be automatically determined by summing up the array, and doing 1.0f - sum
*/
public static void HandleCascadeSliderGUI(ref float[] normalizedCascadePartitions)
{
GUILayout.Label("Cascade splits");
// get the inspector width since we need it while drawing the partition rects.
// Only way currently is to reserve the block in the layout using GetRect(), and then immediately drawing the empty box
// to match the call to GetRect.
// From this point on, we move to non-layout based code.
var sliderRect = GUILayoutUtility.GetRect(GUIContent.none
, s_CascadeSliderBG
, GUILayout.Height(kSliderbarTopMargin + kSliderbarHeight + kSliderbarBottomMargin)
, GUILayout.ExpandWidth(true));
GUI.Box(sliderRect, GUIContent.none);
float currentX = sliderRect.x;
float cascadeBoxStartY = sliderRect.y + kSliderbarTopMargin;
float cascadeSliderWidth = sliderRect.width - (normalizedCascadePartitions.Length * kPartitionHandleWidth);
Color origTextColor = GUI.color;
Color origBackgroundColor = GUI.backgroundColor;
int colorIndex = -1;
// setup the array locally with the last partition
float[] adjustedCascadePartitions = new float[normalizedCascadePartitions.Length + 1];
Array.Copy(normalizedCascadePartitions, adjustedCascadePartitions, normalizedCascadePartitions.Length);
adjustedCascadePartitions[adjustedCascadePartitions.Length - 1] = 1.0f - normalizedCascadePartitions.Sum();
// check for user input on any of the partition handles
// this mechanism gets the current event in the queue... make sure that the mouse is over our control before consuming the event
int sliderControlId = GUIUtility.GetControlID(s_CascadeSliderId, FocusType.Passive);
Event currentEvent = Event.current;
int hotPartitionHandleIndex = -1; // the index of any partition handle that we are hovering over or dragging
// draw each cascade partition
for (int i = 0; i < adjustedCascadePartitions.Length; ++i)
{
float currentPartition = adjustedCascadePartitions[i];
colorIndex = (colorIndex + 1) % kCascadeColors.Length;
GUI.backgroundColor = kCascadeColors[colorIndex];
float boxLength = (cascadeSliderWidth * currentPartition);
// main cascade box
Rect partitionRect = new Rect(currentX, cascadeBoxStartY, boxLength, kSliderbarHeight);
GUI.Box(partitionRect, GUIContent.none, s_CascadeSliderBG);
currentX += boxLength;
// cascade box percentage text
GUI.color = Color.white;
Rect textRect = partitionRect;
var cascadeText = string.Format("{0}\n{1:F1}%", i, currentPartition * 100.0f);
GUI.Label(textRect, GUIContent.Temp(cascadeText, cascadeText), s_TextCenteredStyle);
// no need to draw the partition handle for last box
if (i == adjustedCascadePartitions.Length - 1)
{
break;
}
// partition handle
GUI.backgroundColor = Color.black;
Rect handleRect = partitionRect;
handleRect.x = currentX;
handleRect.width = kPartitionHandleWidth;
GUI.Box(handleRect, GUIContent.none, s_CascadeSliderBG);
// we want a thin handle visually (since wide black bar looks bad), but a slightly larger
// hit area for easier manipulation
Rect handleHitRect = handleRect;
handleHitRect.xMin -= kPartitionHandleExtraHitAreaWidth;
handleHitRect.xMax += kPartitionHandleExtraHitAreaWidth;
if (handleHitRect.Contains(currentEvent.mousePosition))
{
hotPartitionHandleIndex = i;
}
// add regions to slider where the cursor changes to Resize-Horizontal
if (s_DragCache == null)
{
EditorGUIUtility.AddCursorRect(handleHitRect, MouseCursor.ResizeHorizontal, sliderControlId);
}
currentX += kPartitionHandleWidth;
}
GUI.color = origTextColor;
GUI.backgroundColor = origBackgroundColor;
EventType eventType = currentEvent.GetTypeForControl(sliderControlId);
switch (eventType)
{
case EventType.MouseDown:
if (hotPartitionHandleIndex >= 0)
{
s_DragCache = new DragCache(hotPartitionHandleIndex, normalizedCascadePartitions[hotPartitionHandleIndex], currentEvent.mousePosition);
if (GUIUtility.hotControl == 0)
{
GUIUtility.hotControl = sliderControlId;
}
currentEvent.Use();
// Switch active scene view into shadow cascades visualization mode, once we start
// tweaking cascade splits.
if (s_RestoreSceneView == null)
{
s_RestoreSceneView = SceneView.lastActiveSceneView;
if (s_RestoreSceneView != null)
{
s_OldSceneDrawMode = s_RestoreSceneView.cameraMode;
s_OldSceneLightingMode = s_RestoreSceneView.m_SceneLighting;
s_RestoreSceneView.cameraMode = SceneView.GetBuiltinCameraMode(DrawCameraMode.ShadowCascades);
}
}
}
break;
case EventType.MouseUp:
// mouseUp event anywhere should release the hotcontrol (if it belongs to us), drags (if any)
if (GUIUtility.hotControl == sliderControlId)
{
GUIUtility.hotControl = 0;
currentEvent.Use();
}
s_DragCache = null;
// Restore previous scene view drawing mode once we stop tweaking cascade splits.
if (s_RestoreSceneView != null)
{
s_RestoreSceneView.cameraMode = s_OldSceneDrawMode;
s_RestoreSceneView.m_SceneLighting = s_OldSceneLightingMode;
s_RestoreSceneView = null;
}
break;
case EventType.MouseDrag:
if (GUIUtility.hotControl != sliderControlId)
{
break;
}
// convert the mouse movement to normalized cascade width. Make sure that we are safe to apply the delta before using it.
float delta = (currentEvent.mousePosition - s_DragCache.m_LastCachedMousePosition).x / cascadeSliderWidth;
bool isLeftPartitionHappy = ((adjustedCascadePartitions[s_DragCache.m_ActivePartition] + delta) > 0.0f);
bool isRightPartitionHappy = ((adjustedCascadePartitions[s_DragCache.m_ActivePartition + 1] - delta) > 0.0f);
if (isLeftPartitionHappy && isRightPartitionHappy)
{
s_DragCache.m_NormalizedPartitionSize += delta;
normalizedCascadePartitions[s_DragCache.m_ActivePartition] = s_DragCache.m_NormalizedPartitionSize;
if (s_DragCache.m_ActivePartition < normalizedCascadePartitions.Length - 1)
{
normalizedCascadePartitions[s_DragCache.m_ActivePartition + 1] -= delta;
}
GUI.changed = true;
}
s_DragCache.m_LastCachedMousePosition = currentEvent.mousePosition;
currentEvent.Use();
break;
}
}
public void OnGUI(int windowID)
{
if (this.m_LookDevView != null)
{
List <CubemapInfo> hdriList = this.m_LookDevView.envLibrary.hdriList;
bool flag = (146f * hdriList.Count) > this.m_PositionInLookDev.height;
if (flag)
{
this.m_ScrollPosition = EditorGUILayout.BeginScrollView(this.m_ScrollPosition, new GUILayoutOption[0]);
}
else
{
this.m_ScrollPosition = new Vector2(0f, 0f);
}
if (hdriList.Count == 1)
{
Color color = GUI.color;
GUI.color = Color.gray;
Vector2 vector = GUI.skin.label.CalcSize(styles.sDragAndDropHDRIText);
Rect position = new Rect((this.m_PositionInLookDev.width * 0.5f) - (vector.x * 0.5f), (this.m_PositionInLookDev.height * 0.5f) - (vector.y * 0.5f), vector.x, vector.y);
GUI.Label(position, styles.sDragAndDropHDRIText);
GUI.color = color;
}
for (int i = 0; i < hdriList.Count; i++)
{
Rect rect5;
Rect rect6;
CubemapInfo infos = hdriList[i];
ShadowInfo shadowInfo = infos.shadowInfo;
int intProperty = this.m_LookDevView.config.GetIntProperty(LookDevProperty.HDRI, LookDevEditionContext.Left);
int num3 = this.m_LookDevView.config.GetIntProperty(LookDevProperty.HDRI, LookDevEditionContext.Right);
if ((this.m_LookDevView.config.lookDevMode == LookDevMode.Single1) || (this.m_LookDevView.config.lookDevMode == LookDevMode.Single2))
{
num3 = -1;
}
bool flag2 = (i == intProperty) || (i == num3);
Color black = Color.black;
Color firstViewGizmoColor = Color.black;
GUIStyle miniLabel = EditorStyles.miniLabel;
if (flag2)
{
if (i == intProperty)
{
black = (Color)LookDevView.m_FirstViewGizmoColor;
firstViewGizmoColor = (Color)LookDevView.m_FirstViewGizmoColor;
miniLabel = styles.sLabelStyleFirstContext;
}
else if (i == num3)
{
black = (Color)LookDevView.m_SecondViewGizmoColor;
firstViewGizmoColor = (Color)LookDevView.m_SecondViewGizmoColor;
miniLabel = styles.sLabelStyleSecondContext;
}
if (intProperty == num3)
{
black = (Color)LookDevView.m_FirstViewGizmoColor;
firstViewGizmoColor = (Color)LookDevView.m_SecondViewGizmoColor;
miniLabel = styles.sLabelStyleBothContext;
}
}
GUILayoutOption[] optionArray1 = new GUILayoutOption[] { GUILayout.Width(250f) };
GUILayout.BeginVertical(optionArray1);
int num4 = hdriList.FindIndex(x => x == this.m_SelectedCubemapInfo);
if ((((this.m_SelectedCubemap != null) || this.m_DragBeingPerformed) && this.GetInsertionRect(i).Contains(Event.current.mousePosition)) && ((((num4 - i) != 0) && ((num4 - i) != -1)) || (num4 == -1)))
{
GUILayout.Label(GUIContent.none, styles.sSeparatorStyle, new GUILayoutOption[0]);
GUILayoutUtility.GetRect((float)250f, (float)16f);
}
GUILayout.Label(GUIContent.none, styles.sSeparatorStyle, new GUILayoutOption[0]);
GUILayoutOption[] optionArray2 = new GUILayoutOption[] { GUILayout.Width(250f), GUILayout.Height(18f) };
GUILayout.BeginHorizontal(optionArray2);
StringBuilder builder = new StringBuilder();
builder.Append(i.ToString());
builder.Append(" - ");
builder.Append(infos.cubemap.name);
GUILayoutOption[] optionArray3 = new GUILayoutOption[] { GUILayout.Height(18f), GUILayout.MaxWidth(175f) };
GUILayout.Label(builder.ToString(), miniLabel, optionArray3);
GUILayout.FlexibleSpace();
if (GUILayout.Button(styles.sEnvControlIcon, LookDevView.styles.sToolBarButton, new GUILayoutOption[0]))
{
PopupWindow.Show(GUILayoutUtility.topLevel.GetLast(), new EnvSettingsWindow(this.m_LookDevView, infos));
GUIUtility.ExitGUI();
}
using (new EditorGUI.DisabledScope(infos.cubemap == LookDevResources.m_DefaultHDRI))
{
if (GUILayout.Button(styles.sCloseIcon, LookDevView.styles.sToolBarButton, new GUILayoutOption[0]))
{
this.m_LookDevView.envLibrary.RemoveHDRI(infos.cubemap);
}
}
GUILayout.EndHorizontal();
Rect lastRect = GUILayoutUtility.GetLastRect();
if ((Event.current.type == EventType.MouseDown) && lastRect.Contains(Event.current.mousePosition))
{
Event.current.Use();
}
Rect rect = GUILayoutUtility.GetRect((float)250f, (float)125f);
rect.width = 253f;
float num5 = 24f;
float num6 = num5 * 0.5f;
float latitude = shadowInfo.latitude;
float longitude = shadowInfo.longitude;
Vector2 vector2 = ((Vector2)(this.LatLongToPosition(latitude, longitude + infos.angleOffset) * 0.5f)) + new Vector2(0.5f, 0.5f);
Rect rect3 = rect;
rect3.x = (rect3.x + (vector2.x * rect.width)) - num6;
rect3.y = (rect3.y + ((1f - vector2.y) * rect.height)) - num6;
rect3.width = num5;
rect3.height = num5;
Rect rect4 = rect;
rect4.x = (rect4.x + (vector2.x * rect.width)) - (num6 * 0.5f);
rect4.y = (rect4.y + ((1f - vector2.y) * rect.height)) - (num6 * 0.5f);
rect4.width = num5 * 0.5f;
rect4.height = num5 * 0.5f;
this.GetFrameAndShadowTextureRect(rect, out rect5, out rect6);
if (this.m_LookDevView.config.enableShadowCubemap)
{
EditorGUIUtility.AddCursorRect(rect4, MouseCursor.Pan);
}
if ((Event.current.type == EventType.MouseDown) && rect.Contains(Event.current.mousePosition))
{
if ((!Event.current.control && (Event.current.button == 0)) && (this.m_SelectedCubeMapOffsetIndex == -1))
{
if (this.m_LookDevView.config.enableShadowCubemap && rect4.Contains(Event.current.mousePosition))
{
this.m_SelectedLightIconIndex = i;
this.m_SelectedShadowInfo = shadowInfo;
Undo.RecordObject(this.m_LookDevView.envLibrary, "Light Icon selection");
this.m_SelectedShadowInfo.latitude += 0.0001f;
this.m_SelectedShadowInfo.longitude += 0.0001f;
}
if (this.m_SelectedShadowInfo == null)
{
Rect rect10 = rect5;
rect10.x += 100f;
rect10.y += 4f;
rect10.width = 11f;
rect10.height = 11f;
if (this.m_LookDevView.config.enableShadowCubemap && rect10.Contains(Event.current.mousePosition))
{
Undo.RecordObject(this.m_LookDevView.envLibrary, "Update shadow cubemap");
hdriList[i].SetCubemapShadowInfo(hdriList[i]);
this.m_LookDevView.envLibrary.dirty = true;
}
else
{
if (this.m_LookDevView.config.enableShadowCubemap && rect6.Contains(Event.current.mousePosition))
{
this.m_SelectedShadowCubemapOwnerInfo = hdriList[i];
this.m_SelectedCubemapInfo = this.m_SelectedShadowCubemapOwnerInfo.cubemapShadowInfo;
}
else
{
this.m_SelectedCubemapInfo = hdriList[i];
}
this.m_SelectedPositionOffset = Event.current.mousePosition - new Vector2(rect.x, rect.y);
this.m_RenderOverlayThumbnailOnce = true;
}
}
}
else if ((Event.current.control && (Event.current.button == 0)) && ((this.m_SelectedCubemapInfo == null) && (this.m_SelectedShadowInfo == null)))
{
this.m_SelectedCubeMapOffsetIndex = i;
this.m_SelectedCubeMapOffsetValue = infos.angleOffset - this.ComputeAngleOffsetFromMouseCoord(Event.current.mousePosition);
}
GUIUtility.hotControl = this.m_LookDevView.hotControl;
Event.current.Use();
}
if ((Event.current.GetTypeForControl(this.m_LookDevView.hotControl) == EventType.MouseDrag) && ((this.m_SelectedShadowInfo == shadowInfo) && (this.m_SelectedLightIconIndex == i)))
{
Vector2 mousePosition = Event.current.mousePosition;
mousePosition.x = (((mousePosition.x - rect.x) / rect.width) * 2f) - 1f;
mousePosition.y = ((1f - ((mousePosition.y - rect.y) / rect.height)) * 2f) - 1f;
Vector2 vector4 = PositionToLatLong(mousePosition);
this.m_SelectedShadowInfo.latitude = vector4.x;
this.m_SelectedShadowInfo.longitude = vector4.y - infos.angleOffset;
this.m_LookDevView.envLibrary.dirty = true;
}
if (Event.current.type == EventType.Repaint)
{
this.DrawLatLongThumbnail(infos, infos.angleOffset, 1f, 1f, rect);
if (this.m_LookDevView.config.enableShadowCubemap)
{
if ((infos.cubemapShadowInfo != infos) || ((this.m_HoveringCubeMapIndex == i) && (this.m_SelectedCubemapInfo != infos)))
{
CubemapInfo cubemapShadowInfo = infos.cubemapShadowInfo;
if ((this.m_HoveringCubeMapIndex == i) && (this.m_SelectedCubemapInfo != infos))
{
cubemapShadowInfo = this.m_SelectedCubemapInfo;
}
float alpha = 1f;
if (this.m_SelectedShadowInfo == shadowInfo)
{
alpha = 0.1f;
}
else if (((this.m_HoveringCubeMapIndex == i) && (this.m_SelectedCubemapInfo != infos)) && (infos.cubemapShadowInfo != this.m_SelectedCubemapInfo))
{
alpha = 0.5f;
}
this.DrawLatLongThumbnail(cubemapShadowInfo, infos.angleOffset, 0.3f, alpha, rect6);
GL.sRGBWrite = QualitySettings.activeColorSpace == ColorSpace.Linear;
GUI.DrawTexture(rect5, styles.sLatlongFrameTexture);
GL.sRGBWrite = false;
}
GL.sRGBWrite = QualitySettings.activeColorSpace == ColorSpace.Linear;
GUI.DrawTexture(rect3, styles.sLightTexture);
GL.sRGBWrite = false;
}
if (flag2)
{
this.DrawSelectionFeedback(rect, black, firstViewGizmoColor);
}
}
GUILayout.EndVertical();
}
GUILayoutOption[] options = new GUILayoutOption[] { GUILayout.Width(250f) };
GUILayout.BeginVertical(options);
if (((this.m_SelectedCubemap != null) || this.m_DragBeingPerformed) && this.GetInsertionRect(hdriList.Count).Contains(Event.current.mousePosition))
{
GUILayout.Label(GUIContent.none, styles.sSeparatorStyle, new GUILayoutOption[0]);
GUILayoutUtility.GetRect((float)250f, (float)16f);
GUILayout.Label(GUIContent.none, styles.sSeparatorStyle, new GUILayoutOption[0]);
}
GUILayout.EndVertical();
if (flag)
{
EditorGUILayout.EndScrollView();
}
this.HandleMouseInput();
this.RenderOverlayThumbnailIfNeeded();
if ((Event.current.type == EventType.Repaint) && (this.m_SelectedCubemap != null))
{
this.m_LookDevView.Repaint();
}
}
}
private void HandleMouseInput()
{
List <CubemapInfo> hdriList = this.m_LookDevView.envLibrary.hdriList;
Vector2 pos = new Vector2(Event.current.mousePosition.x, Event.current.mousePosition.y + this.m_ScrollPosition.y);
Event current = Event.current;
EventType typeForControl = current.GetTypeForControl(this.m_LookDevView.hotControl);
switch (typeForControl)
{
case EventType.MouseUp:
if (this.m_SelectedCubemap != null)
{
Rect gUIRect = this.m_GUIRect;
gUIRect.yMax += 16f;
if (!gUIRect.Contains(Event.current.mousePosition))
{
break;
}
int insertionIndex = this.IsPositionInInsertionArea(pos);
if (insertionIndex == -1)
{
int num2 = this.IsPositionInThumbnailArea(pos);
if ((num2 != -1) && this.m_LookDevView.config.enableShadowCubemap)
{
Undo.RecordObject(this.m_LookDevView.envLibrary, "Update shadow cubemap");
CubemapInfo info2 = this.m_LookDevView.envLibrary.hdriList[num2];
if (info2 != this.m_SelectedCubemapInfo)
{
info2.SetCubemapShadowInfo(this.m_SelectedCubemapInfo);
}
this.m_LookDevView.envLibrary.dirty = true;
}
}
else
{
this.ResetShadowCubemap();
this.m_LookDevView.envLibrary.InsertHDRI(this.m_SelectedCubemap, insertionIndex);
}
this.CancelSelection();
}
break;
case EventType.MouseDrag:
if (this.m_SelectedCubeMapOffsetIndex != -1)
{
Undo.RecordObject(this.m_LookDevView.envLibrary, "");
CubemapInfo info = hdriList[this.m_SelectedCubeMapOffsetIndex];
info.angleOffset = this.ComputeAngleOffsetFromMouseCoord(pos) + this.m_SelectedCubeMapOffsetValue;
this.m_LookDevView.envLibrary.dirty = true;
Event.current.Use();
}
if (this.m_SelectedCubemapInfo != null)
{
if (this.IsPositionInInsertionArea(pos) == -1)
{
this.m_HoveringCubeMapIndex = this.IsPositionInThumbnailArea(pos);
}
else
{
this.m_HoveringCubeMapIndex = -1;
}
}
this.m_LookDevView.Repaint();
return;
case EventType.KeyDown:
if (Event.current.keyCode == KeyCode.Escape)
{
this.CancelSelection();
this.m_LookDevView.Repaint();
}
return;
case EventType.Repaint:
if (this.m_SelectedCubeMapOffsetIndex != -1)
{
EditorGUIUtility.AddCursorRect(this.m_displayRect, MouseCursor.SlideArrow);
}
return;
case EventType.DragUpdated:
{
bool flag = false;
foreach (UnityEngine.Object obj3 in DragAndDrop.objectReferences)
{
Cubemap cubemap2 = obj3 as Cubemap;
if (cubemap2 != null)
{
flag = true;
}
}
DragAndDrop.visualMode = !flag ? DragAndDropVisualMode.Rejected : DragAndDropVisualMode.Link;
if (flag)
{
this.m_DragBeingPerformed = true;
}
current.Use();
return;
}
case EventType.DragPerform:
{
int num3 = this.IsPositionInInsertionArea(pos);
foreach (UnityEngine.Object obj2 in DragAndDrop.objectReferences)
{
Cubemap cubemap = obj2 as Cubemap;
if (cubemap != null)
{
this.m_LookDevView.envLibrary.InsertHDRI(cubemap, num3);
}
}
DragAndDrop.AcceptDrag();
this.m_DragBeingPerformed = false;
current.Use();
return;
}
default:
if (typeForControl == EventType.DragExited)
{
}
return;
}
this.m_LookDevView.Repaint();
if ((this.m_SelectedCubeMapOffsetIndex != -1) && (Mathf.Abs(hdriList[this.m_SelectedCubeMapOffsetIndex].angleOffset) <= 10f))
{
Undo.RecordObject(this.m_LookDevView.envLibrary, "");
hdriList[this.m_SelectedCubeMapOffsetIndex].angleOffset = 0f;
this.m_LookDevView.envLibrary.dirty = true;
}
this.m_SelectedCubemapInfo = null;
this.m_SelectedShadowCubemapOwnerInfo = null;
this.m_SelectedLightIconIndex = -1;
this.m_SelectedShadowInfo = null;
this.m_SelectedCubeMapOffsetIndex = -1;
this.m_HoveringCubeMapIndex = -1;
this.m_SelectedCubeMapOffsetValue = 0f;
GUIUtility.hotControl = 0;
}
public override void OnInspectorGUI()
{
if (AssetStoreAssetInspector.styles == null)
{
AssetStoreAssetInspector.s_SharedAssetStoreAssetInspector = this;
AssetStoreAssetInspector.styles = new AssetStoreAssetInspector.Styles();
}
AssetStoreAsset firstAsset = AssetStoreAssetSelection.GetFirstAsset();
AssetStoreAsset.PreviewInfo previewInfo = null;
if (firstAsset != null)
{
previewInfo = firstAsset.previewInfo;
}
if (firstAsset != null)
{
this.target.name = string.Format("Asset Store: {0}", firstAsset.name);
}
else
{
this.target.name = "Asset Store";
}
EditorGUILayout.BeginVertical(new GUILayoutOption[0]);
bool enabled = GUI.enabled;
GUI.enabled = (firstAsset != null && firstAsset.packageID != 0);
if (AssetStoreAssetInspector.OfflineNoticeEnabled)
{
Color color = GUI.color;
GUI.color = Color.yellow;
GUILayout.Label("Network is offline", new GUILayoutOption[0]);
GUI.color = color;
}
if (firstAsset != null)
{
string label = (firstAsset.className != null) ? firstAsset.className.Split(new char[]
{
' '
}, 2)[0] : string.Empty;
bool flag = firstAsset.id == -firstAsset.packageID;
if (flag)
{
label = "Package";
}
if (firstAsset.HasLivePreview)
{
label = firstAsset.Preview.GetType().Name;
}
EditorGUILayout.LabelField("Type", label, new GUILayoutOption[0]);
if (flag)
{
this.packageInfoShown = true;
}
else
{
EditorGUILayout.Separator();
this.packageInfoShown = EditorGUILayout.Foldout(this.packageInfoShown, "Part of package");
}
if (this.packageInfoShown)
{
EditorGUILayout.LabelField("Name", (previewInfo != null) ? previewInfo.packageName : "-", new GUILayoutOption[0]);
EditorGUILayout.LabelField("Version", (previewInfo != null) ? previewInfo.packageVersion : "-", new GUILayoutOption[0]);
string label2 = (previewInfo != null) ? ((firstAsset.price == null || !(firstAsset.price != string.Empty)) ? "free" : firstAsset.price) : "-";
EditorGUILayout.LabelField("Price", label2, new GUILayoutOption[0]);
string label3 = (previewInfo == null || previewInfo.packageRating < 0) ? "-" : (previewInfo.packageRating.ToString() + " of 5");
EditorGUILayout.LabelField("Rating", label3, new GUILayoutOption[0]);
EditorGUILayout.LabelField("Size", (previewInfo != null) ? AssetStoreAssetInspector.intToSizeString(previewInfo.packageSize) : "-", new GUILayoutOption[0]);
string label4 = (previewInfo == null || previewInfo.packageAssetCount < 0) ? "-" : previewInfo.packageAssetCount.ToString();
EditorGUILayout.LabelField("Asset count", label4, new GUILayoutOption[0]);
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
EditorGUILayout.PrefixLabel("Web page");
bool flag2 = previewInfo != null && previewInfo.packageShortUrl != null && previewInfo.packageShortUrl != string.Empty;
bool enabled2 = GUI.enabled;
GUI.enabled = flag2;
if (GUILayout.Button((!flag2) ? EditorGUIUtility.TempContent("-") : new GUIContent(previewInfo.packageShortUrl, "View in browser"), AssetStoreAssetInspector.styles.link, new GUILayoutOption[0]))
{
Application.OpenURL(previewInfo.packageShortUrl);
}
if (GUI.enabled)
{
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
}
GUI.enabled = enabled2;
GUILayout.EndHorizontal();
EditorGUILayout.LabelField("Publisher", (previewInfo != null) ? previewInfo.publisherName : "-", new GUILayoutOption[0]);
}
if (firstAsset.id != 0)
{
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
GUILayout.FlexibleSpace();
string text;
if (previewInfo != null && previewInfo.isDownloadable)
{
text = "Import package";
}
else
{
text = "Buy for " + firstAsset.price;
}
bool enabled3 = GUI.enabled;
bool flag3 = previewInfo != null && previewInfo.buildProgress >= 0f;
bool flag4 = previewInfo != null && previewInfo.downloadProgress >= 0f;
if (flag3 || flag4 || previewInfo == null)
{
text = string.Empty;
GUI.enabled = false;
}
if (GUILayout.Button(text, new GUILayoutOption[]
{
GUILayout.Height(40f),
GUILayout.Width(120f)
}))
{
if (previewInfo.isDownloadable)
{
this.ImportPackage(firstAsset);
}
else
{
this.InitiateBuySelected();
}
GUIUtility.ExitGUI();
}
if (Event.current.type == EventType.Repaint)
{
Rect lastRect = GUILayoutUtility.GetLastRect();
lastRect.height -= 4f;
float width = lastRect.width;
lastRect.width = lastRect.height;
lastRect.y += 2f;
lastRect.x += 2f;
if (flag3 || flag4)
{
lastRect.width = width - lastRect.height - 4f;
lastRect.x += lastRect.height;
EditorGUI.ProgressBar(lastRect, (!flag4) ? previewInfo.buildProgress : previewInfo.downloadProgress, (!flag4) ? "Building" : "Downloading");
}
}
GUI.enabled = enabled3;
GUILayout.Space(4f);
if (GUILayout.Button("Open Asset Store", new GUILayoutOption[]
{
GUILayout.Height(40f),
GUILayout.Width(120f)
}))
{
AssetStoreAssetInspector.OpenItemInAssetStore(firstAsset);
GUIUtility.ExitGUI();
}
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
}
GUILayout.FlexibleSpace();
}
EditorWrapper previewEditor = this.previewEditor;
if (previewEditor != null && firstAsset != null && firstAsset.HasLivePreview)
{
previewEditor.OnAssetStoreInspectorGUI();
}
GUI.enabled = enabled;
EditorGUILayout.EndVertical();
}
internal static void DoMinMaxSlider(Rect position, int id, ref float value, ref float size, float visualStart, float visualEnd, float startLimit, float endLimit, GUIStyle slider, GUIStyle thumb, bool horiz)
{
Event evt = Event.current;
bool usePageScrollbars = size == 0;
float minVisual = Mathf.Min(visualStart, visualEnd);
float maxVisual = Mathf.Max(visualStart, visualEnd);
float minLimit = Mathf.Min(startLimit, endLimit);
float maxLimit = Mathf.Max(startLimit, endLimit);
MinMaxSliderState state = s_MinMaxSliderState;
if (GUIUtility.hotControl == id && state != null)
{
minVisual = state.dragStartLimit;
minLimit = state.dragStartLimit;
maxVisual = state.dragEndLimit;
maxLimit = state.dragEndLimit;
}
float minSize = 0;
float displayValue = Mathf.Clamp(value, minVisual, maxVisual);
float displaySize = Mathf.Clamp(value + size, minVisual, maxVisual) - displayValue;
float sign = visualStart > visualEnd ? -1 : 1;
if (slider == null || thumb == null)
{
return;
}
// Figure out the rects
float pixelsPerValue;
float mousePosition;
Rect thumbRect;
Rect thumbMinRect, thumbMaxRect;
Rect contentRect = thumb.margin.Remove(slider.padding.Remove(position));
float thumbSize = ThumbSize(horiz, thumb);
if (horiz)
{
float thumbHeight = (thumb.fixedHeight != 0 ? thumb.fixedHeight : contentRect.height);
pixelsPerValue = (position.width - slider.padding.horizontal - thumbSize) / (maxVisual - minVisual);
thumbRect = new Rect(
(displayValue - minVisual) * pixelsPerValue + contentRect.x,
contentRect.y,
displaySize * pixelsPerValue + thumbSize,
thumbHeight);
thumbMinRect = new Rect(thumbRect.x, thumbRect.y, thumb.padding.left, thumbRect.height);
thumbMaxRect = new Rect(thumbRect.xMax - thumb.padding.right, thumbRect.y, thumb.padding.right, thumbRect.height);
mousePosition = evt.mousePosition.x - position.x;
}
else
{
float thumbWidth = (thumb.fixedWidth != 0 ? thumb.fixedWidth : contentRect.width);
pixelsPerValue = (position.height - slider.padding.vertical - thumbSize) / (maxVisual - minVisual);
thumbRect = new Rect(
contentRect.x,
(displayValue - minVisual) * pixelsPerValue + contentRect.y,
thumbWidth,
displaySize * pixelsPerValue + thumbSize);
thumbMinRect = new Rect(thumbRect.x, thumbRect.y, thumbRect.width, thumb.padding.top);
thumbMaxRect = new Rect(thumbRect.x, thumbRect.yMax - thumb.padding.bottom, thumbRect.width, thumb.padding.bottom);
mousePosition = evt.mousePosition.y - position.y;
}
float mousePos;
float thumbPos;
switch (evt.GetTypeForControl(id))
{
case EventType.MouseDown:
// if the click is outside this control, just bail out...
if (evt.button != 0 || !position.Contains(evt.mousePosition) || minVisual - maxVisual == 0)
{
return;
}
if (state == null)
{
state = s_MinMaxSliderState = new MinMaxSliderState();
}
// These are required to be set whenever we grab hotcontrol, regardless of if we actually drag or not. (case 585577)
state.dragStartLimit = startLimit;
state.dragEndLimit = endLimit;
if (thumbRect.Contains(evt.mousePosition))
{
// We have a mousedown on the thumb
// Record where we're draging from, so the user can get back.
state.dragStartPos = mousePosition;
state.dragStartValue = value;
state.dragStartSize = size;
state.dragStartValuesPerPixel = pixelsPerValue;
if (thumbMinRect.Contains(evt.mousePosition))
{
state.whereWeDrag = 1;
}
else if (thumbMaxRect.Contains(evt.mousePosition))
{
state.whereWeDrag = 2;
}
else
{
state.whereWeDrag = 0;
}
GUIUtility.hotControl = id;
evt.Use();
return;
}
else
{
// We're outside the thumb, but inside the trough.
// If we have no background, we just bail out.
if (slider == GUIStyle.none)
{
return;
}
// If we have a scrollSize, we do pgup/pgdn style movements
// if not, we just snap to the current position and begin tracking
if (size != 0 && usePageScrollbars)
{
if (horiz)
{
if (mousePosition > thumbRect.xMax - position.x)
{
value += size * sign * .9f;
}
else
{
value -= size * sign * .9f;
}
}
else
{
if (mousePosition > thumbRect.yMax - position.y)
{
value += size * sign * .9f;
}
else
{
value -= size * sign * .9f;
}
}
state.whereWeDrag = 0;
GUI.changed = true;
s_NextScrollStepTime = System.DateTime.Now.AddMilliseconds(kFirstScrollWait);
mousePos = horiz ? evt.mousePosition.x : evt.mousePosition.y;
thumbPos = horiz ? thumbRect.x : thumbRect.y;
state.whereWeDrag = mousePos > thumbPos ? 4 : 3;
}
else
{
if (horiz)
{
value = ((float)mousePosition - thumbRect.width * .5f) / pixelsPerValue + minVisual - size * .5f;
}
else
{
value = ((float)mousePosition - thumbRect.height * .5f) / pixelsPerValue + minVisual - size * .5f;
}
state.dragStartPos = mousePosition;
state.dragStartValue = value;
state.dragStartSize = size;
state.dragStartValuesPerPixel = pixelsPerValue;
state.whereWeDrag = 0;
GUI.changed = true;
}
GUIUtility.hotControl = id;
value = Mathf.Clamp(value, minLimit, maxLimit - size);
evt.Use();
return;
}
case EventType.MouseDrag:
if (GUIUtility.hotControl != id)
{
return;
}
// Recalculate the value from the mouse position. this has the side effect that values are relative to the
// click point - no matter where inside the trough the original value was. Also means user can get back original value
// if he drags back to start position.
float deltaVal = (mousePosition - state.dragStartPos) / state.dragStartValuesPerPixel;
switch (state.whereWeDrag)
{
case 0: // normal drag
value = Mathf.Clamp(state.dragStartValue + deltaVal, minLimit, maxLimit - size);
break;
case 1: // min size drag
value = state.dragStartValue + deltaVal;
size = state.dragStartSize - deltaVal;
if (value < minLimit)
{
size -= minLimit - value;
value = minLimit;
}
if (size < minSize)
{
value -= minSize - size;
size = minSize;
}
break;
case 2: // max size drag
size = state.dragStartSize + deltaVal;
if (value + size > maxLimit)
{
size = maxLimit - value;
}
if (size < minSize)
{
size = minSize;
}
break;
}
GUI.changed = true;
evt.Use();
break;
case EventType.MouseUp:
if (GUIUtility.hotControl == id)
{
evt.Use();
GUIUtility.hotControl = 0;
}
break;
case EventType.Repaint:
slider.Draw(position, GUIContent.none, id);
thumb.Draw(thumbRect, GUIContent.none, id);
EditorGUIUtility.AddCursorRect(thumbMinRect, horiz ? MouseCursor.ResizeHorizontal : MouseCursor.ResizeVertical, state != null && state.whereWeDrag == 1 ? id : -1);
EditorGUIUtility.AddCursorRect(thumbMaxRect, horiz ? MouseCursor.ResizeHorizontal : MouseCursor.ResizeVertical, state != null && state.whereWeDrag == 2 ? id : -1);
// if the mouse is outside this control, just bail out...
if (GUIUtility.hotControl != id ||
!position.Contains(evt.mousePosition) || minVisual - maxVisual == 0)
{
return;
}
if (thumbRect.Contains(evt.mousePosition))
{
if (state != null && (state.whereWeDrag == 3 || state.whereWeDrag == 4)) // if was scrolling with "through" and the thumb reached mouse - sliding action over
{
GUIUtility.hotControl = 0;
}
return;
}
if (System.DateTime.Now < s_NextScrollStepTime)
{
return;
}
mousePos = horiz ? evt.mousePosition.x : evt.mousePosition.y;
thumbPos = horiz ? thumbRect.x : thumbRect.y;
int currentSide = mousePos > thumbPos ? 4 : 3;
if (state != null && currentSide != state.whereWeDrag)
{
return;
}
// If we have a scrollSize, we do pgup/pgdn style movements
if (size != 0 && usePageScrollbars)
{
if (horiz)
{
if (mousePosition > thumbRect.xMax - position.x)
{
value += size * sign * .9f;
}
else
{
value -= size * sign * .9f;
}
}
else
{
if (mousePosition > thumbRect.yMax - position.y)
{
value += size * sign * .9f;
}
else
{
value -= size * sign * .9f;
}
}
if (state != null)
{
state.whereWeDrag = -1;
}
GUI.changed = true;
}
value = Mathf.Clamp(value, minLimit, maxLimit - size);
s_NextScrollStepTime = System.DateTime.Now.AddMilliseconds(kScrollWait);
break;
}
}
public static void HandleCascadeSliderGUI(ref float[] normalizedCascadePartitions)
{
GUILayout.Label("Cascade splits", new GUILayoutOption[0]);
GUILayoutOption[] options = new GUILayoutOption[] { GUILayout.Height(28f), GUILayout.ExpandWidth(true) };
Rect position = GUILayoutUtility.GetRect(GUIContent.none, s_CascadeSliderBG, options);
GUI.Box(position, GUIContent.none);
float x = position.x;
float y = position.y + 2f;
float num3 = position.width - (normalizedCascadePartitions.Length * 2);
Color color = GUI.color;
Color backgroundColor = GUI.backgroundColor;
int index = -1;
float[] destinationArray = new float[normalizedCascadePartitions.Length + 1];
Array.Copy(normalizedCascadePartitions, destinationArray, normalizedCascadePartitions.Length);
destinationArray[destinationArray.Length - 1] = 1f - normalizedCascadePartitions.Sum();
int controlID = GUIUtility.GetControlID(s_CascadeSliderId, FocusType.Passive);
Event current = Event.current;
int activePartition = -1;
for (int i = 0; i < destinationArray.Length; i++)
{
float num8 = destinationArray[i];
index = (index + 1) % kCascadeColors.Length;
GUI.backgroundColor = kCascadeColors[index];
float width = num3 * num8;
Rect rect2 = new Rect(x, y, width, 24f);
GUI.Box(rect2, GUIContent.none, s_CascadeSliderBG);
x += width;
GUI.color = Color.white;
Rect rect3 = rect2;
string t = $"{i}
{num8 * 100f:F1}%";
GUI.Label(rect3, GUIContent.Temp(t, t), s_TextCenteredStyle);
if (i == (destinationArray.Length - 1))
{
break;
}
GUI.backgroundColor = Color.black;
Rect rect4 = rect2;
rect4.x = x;
rect4.width = 2f;
GUI.Box(rect4, GUIContent.none, s_CascadeSliderBG);
Rect rect5 = rect4;
rect5.xMin -= 2f;
rect5.xMax += 2f;
if (rect5.Contains(current.mousePosition))
{
activePartition = i;
}
if (s_DragCache == null)
{
EditorGUIUtility.AddCursorRect(rect5, MouseCursor.ResizeHorizontal, controlID);
}
x += 2f;
}
GUI.color = color;
GUI.backgroundColor = backgroundColor;
EventType typeForControl = current.GetTypeForControl(controlID);
if (typeForControl == EventType.MouseDown)
{
if (activePartition >= 0)
{
s_DragCache = new DragCache(activePartition, normalizedCascadePartitions[activePartition], current.mousePosition);
if (GUIUtility.hotControl == 0)
{
GUIUtility.hotControl = controlID;
}
current.Use();
if (s_RestoreSceneView == null)
{
s_RestoreSceneView = SceneView.lastActiveSceneView;
if (s_RestoreSceneView != null)
{
s_OldSceneDrawMode = s_RestoreSceneView.renderMode;
s_OldSceneLightingMode = s_RestoreSceneView.m_SceneLighting;
s_RestoreSceneView.renderMode = DrawCameraMode.ShadowCascades;
}
}
}
}
else if (typeForControl == EventType.MouseUp)
{
if (GUIUtility.hotControl == controlID)
{
GUIUtility.hotControl = 0;
current.Use();
}
s_DragCache = null;
if (s_RestoreSceneView != null)
{
s_RestoreSceneView.renderMode = s_OldSceneDrawMode;
s_RestoreSceneView.m_SceneLighting = s_OldSceneLightingMode;
s_RestoreSceneView = null;
}
}
else if ((typeForControl == EventType.MouseDrag) && (GUIUtility.hotControl == controlID))
{
Vector2 vector = current.mousePosition - s_DragCache.m_LastCachedMousePosition;
float num10 = vector.x / num3;
bool flag = (destinationArray[s_DragCache.m_ActivePartition] + num10) > 0f;
bool flag2 = (destinationArray[s_DragCache.m_ActivePartition + 1] - num10) > 0f;
if (flag && flag2)
{
s_DragCache.m_NormalizedPartitionSize += num10;
normalizedCascadePartitions[s_DragCache.m_ActivePartition] = s_DragCache.m_NormalizedPartitionSize;
if (s_DragCache.m_ActivePartition < (normalizedCascadePartitions.Length - 1))
{
normalizedCascadePartitions[s_DragCache.m_ActivePartition + 1] -= num10;
}
GUI.changed = true;
}
s_DragCache.m_LastCachedMousePosition = current.mousePosition;
current.Use();
}
}
private void OnGUI()
{
if (base.position.size * EditorGUIUtility.pixelsPerPoint != this.m_LastWindowPixelSize)
{
this.UpdateZoomAreaAndParent();
}
this.DoToolbarGUI();
this.CopyDimensionsToParentView();
EditorGUIUtility.AddCursorRect(this.viewInWindow, MouseCursor.CustomCursor);
EventType type = Event.current.type;
if (type == EventType.MouseDown && this.viewInWindow.Contains(Event.current.mousePosition))
{
this.AllowCursorLockAndHide(true);
}
else if (type == EventType.KeyDown && Event.current.keyCode == KeyCode.Escape)
{
Unsupported.SetAllowCursorLock(false);
}
bool flag = !EditorApplication.isPlaying || EditorApplication.isPaused;
this.m_ZoomArea.hSlider = (flag && this.m_ZoomArea.shownArea.width < this.targetInContent.width);
this.m_ZoomArea.vSlider = (flag && this.m_ZoomArea.shownArea.height < this.targetInContent.height);
this.m_ZoomArea.enableMouseInput = flag;
this.ConfigureZoomArea();
Vector2 mousePosition = Event.current.mousePosition;
Vector2 mousePosition2 = this.WindowToGameMousePosition(mousePosition);
GUI.color = Color.white;
EventType type2 = Event.current.type;
this.m_ZoomArea.BeginViewGUI();
if (type == EventType.Repaint)
{
GUI.Box(this.m_ZoomArea.drawRect, GUIContent.none, GameView.Styles.gameViewBackgroundStyle);
Vector2 s_EditorScreenPointOffset = GUIUtility.s_EditorScreenPointOffset;
GUIUtility.s_EditorScreenPointOffset = Vector2.zero;
SavedGUIState savedGUIState = SavedGUIState.Create();
this.ConfigureTargetTexture((int)this.targetSize.x, (int)this.targetSize.y);
if (!EditorApplication.isPlaying)
{
this.ClearTargetTexture();
}
int targetDisplay = 0;
if (this.ShouldShowMultiDisplayOption())
{
targetDisplay = this.m_TargetDisplay;
}
if (this.m_TargetTexture.IsCreated())
{
EditorGUIUtility.RenderGameViewCamerasInternal(this.m_TargetTexture, targetDisplay, GUIClip.Unclip(this.viewInWindow), mousePosition2, this.m_Gizmos);
savedGUIState.ApplyAndForget();
GUIUtility.s_EditorScreenPointOffset = s_EditorScreenPointOffset;
GUI.BeginGroup(this.m_ZoomArea.drawRect);
GL.sRGBWrite = (this.m_CurrentColorSpace == ColorSpace.Linear);
GUI.DrawTexture(this.deviceFlippedTargetInView, this.m_TargetTexture, ScaleMode.StretchToFill, false);
GL.sRGBWrite = false;
GUI.EndGroup();
}
}
else if (type != EventType.Layout && type != EventType.Used)
{
if (WindowLayout.s_MaximizeKey.activated && (!EditorApplication.isPlaying || EditorApplication.isPaused))
{
return;
}
bool flag2 = this.viewInWindow.Contains(Event.current.mousePosition);
if (Event.current.rawType == EventType.MouseDown && !flag2)
{
return;
}
Event.current.mousePosition = mousePosition2;
Event.current.displayIndex = this.m_TargetDisplay;
EditorGUIUtility.QueueGameViewInputEvent(Event.current);
bool flag3 = true;
if (Event.current.rawType == EventType.MouseUp && !flag2)
{
flag3 = false;
}
if (type == EventType.ExecuteCommand || type == EventType.ValidateCommand)
{
flag3 = false;
}
if (flag3)
{
Event.current.Use();
}
else
{
Event.current.mousePosition = mousePosition;
}
}
this.m_ZoomArea.EndViewGUI();
if (type2 == EventType.ScrollWheel && Event.current.type == EventType.Used)
{
EditorApplication.update = (EditorApplication.CallbackFunction)Delegate.Remove(EditorApplication.update, new EditorApplication.CallbackFunction(this.SnapZoomDelayed));
EditorApplication.update = (EditorApplication.CallbackFunction)Delegate.Combine(EditorApplication.update, new EditorApplication.CallbackFunction(this.SnapZoomDelayed));
GameView.s_LastScrollTime = EditorApplication.timeSinceStartup;
}
this.EnforceZoomAreaConstraints();
if (this.m_TargetTexture)
{
if (this.m_ZoomArea.scale.y < 1f)
{
this.m_TargetTexture.filterMode = FilterMode.Bilinear;
}
else
{
this.m_TargetTexture.filterMode = FilterMode.Point;
}
}
if (!EditorGUIUtility.IsDisplayReferencedByCameras(this.m_TargetDisplay))
{
GUI.Label(this.warningPosition, GUIContent.none, EditorStyles.notificationBackground);
string arg = (!this.ShouldShowMultiDisplayOption()) ? string.Empty : DisplayUtility.GetDisplayNames()[this.m_TargetDisplay].text;
string t = string.Format("{0}\nNo cameras rendering", arg);
EditorGUI.DoDropShadowLabel(this.warningPosition, EditorGUIUtility.TempContent(t), EditorStyles.notificationText, 0.3f);
}
if (this.m_Stats)
{
GameViewGUI.GameViewStatsGUI();
}
}
public void OnGUI()
{
var evt = Event.current;
var mainLayoutWidth = position.width - Styles.mainLayout.margin.horizontal;
using (new GUILayout.VerticalScope(Styles.mainLayout))
{
GUILayout.Label(Styles.HeaderLogo, Styles.HeaderLayout);
using (new GUILayout.HorizontalScope(Styles.versionLayout))
{
ListenForSecretCodes();
string extensionVersion = FormatExtensionVersionString();
m_ShowDetailedVersion |= evt.alt;
if (m_ShowDetailedVersion)
{
int t = InternalEditorUtility.GetUnityVersionDate();
DateTime dt = new DateTime(1970, 1, 1, 0, 0, 0, 0);
string branch = InternalEditorUtility.GetUnityBuildBranch();
EditorGUILayout.SelectableLabel(
string.Format("{0}{1}\nRevision: {2} {3}\nBuilt: {4:r}",
InternalEditorUtility.GetUnityDisplayVersionVerbose(), extensionVersion,
branch, InternalEditorUtility.GetUnityBuildHash(), dt.AddSeconds(t)),
Styles.versionStyle, GUILayout.MaxWidth(mainLayoutWidth), GUILayout.Height(38f));
}
else
{
GUILayout.Label(string.Format("{0}{1}", InternalEditorUtility.GetUnityDisplayVersion(), extensionVersion), Styles.versionStyle);
}
if (evt.type == EventType.ValidateCommand)
{
return;
}
}
using (new GUILayout.HorizontalScope(Styles.creditsLayout))
{
float chunkOffset = m_TextYPos;
Rect scrollAreaRect = GUILayoutUtility.GetRect(0, mainLayoutWidth, 75f, position.height, GUILayout.ExpandHeight(true));
GUI.BeginGroup(scrollAreaRect);
foreach (string nameChunk in AboutWindowNames.Names(null, true))
{
chunkOffset = DoCreditsNameChunk(nameChunk, mainLayoutWidth, chunkOffset);
}
chunkOffset = DoCreditsNameChunk(kSpecialThanksNames, mainLayoutWidth, chunkOffset);
m_TotalCreditsHeight = chunkOffset - m_TextYPos;
GUI.EndGroup();
HandleScrollEvents(evt, scrollAreaRect);
}
using (new GUILayout.HorizontalScope(Styles.poweredLayout))
{
var poweredBySectionMaxWidth = (mainLayoutWidth - Styles.poweredSectionLayout.margin.horizontal * 2) / 2f;
using (new GUILayout.VerticalScope(Styles.poweredSectionLayout, GUILayout.MaxWidth(poweredBySectionMaxWidth)))
{
GUILayout.Label("Scripting powered by The Mono Project.\n\u00A9 2011 Novell, Inc.", Styles.aboutWindowLicenseLabel);
GUILayout.FlexibleSpace();
GUILayout.Label(Styles.MonoLogo, Styles.MonoLogoLayout);
GUILayout.FlexibleSpace();
if (!InternalEditorUtility.IsUnityBeta())
{
var specialThanksRect = GUILayoutUtility.GetRect(Styles.thanksContent, Styles.thanksStyle);
if (GUI.Button(specialThanksRect, Styles.thanksContent, Styles.thanksStyle))
{
Process.Start(Styles.thanksUri.AbsoluteUri);
}
EditorGUIUtility.AddCursorRect(specialThanksRect, MouseCursor.Link);
}
GUILayout.Label(InternalEditorUtility.GetUnityCopyright().Replace("(c)", "\u00A9"), Styles.aboutWindowLicenseLabel);
}
GUILayout.FlexibleSpace();
using (new GUILayout.VerticalScope(Styles.poweredSectionLayout, GUILayout.MaxWidth(poweredBySectionMaxWidth)))
{
GUILayout.Label("Physics powered by PhysX.\n\u00A9 2019 NVIDIA Corporation.", Styles.aboutWindowLicenseLabel);
GUILayout.FlexibleSpace();
GUILayout.Label(Styles.AgeiaLogo, Styles.AgeiaLogoLayout);
GUILayout.FlexibleSpace();
GUILayout.Label(InternalEditorUtility.GetLicenseInfo().Replace("(c)", "\u00A9"), Styles.aboutWindowLicenseLabel);
}
}
}
}
private static void DrawLODButton(LODInfo currentLOD)
{
EditorGUIUtility.AddCursorRect(currentLOD.m_ButtonPosition, MouseCursor.ResizeHorizontal);
}
private void HandleSplitView()
{
// Add CursorRects
SplitView sp = parent as SplitView;
if (Event.current.type == EventType.Repaint && sp)
{
View view = this;
while (sp)
{
int id = sp.controlID;
if (id == GUIUtility.hotControl || GUIUtility.hotControl == 0)
{
int idx = sp.IndexOfChild(view);
if (sp.vertical)
{
if (idx != 0)
{
EditorGUIUtility.AddCursorRect(new Rect(0, 0, position.width, SplitView.kGrabDist), MouseCursor.SplitResizeUpDown, id);
}
if (idx != sp.children.Length - 1)
{
EditorGUIUtility.AddCursorRect(
new Rect(0, position.height - SplitView.kGrabDist, position.width, SplitView.kGrabDist),
MouseCursor.SplitResizeUpDown, id);
}
}
else // horizontal
{
if (idx != 0)
{
EditorGUIUtility.AddCursorRect(new Rect(0, 0, SplitView.kGrabDist, position.height), MouseCursor.SplitResizeLeftRight,
id);
}
if (idx != sp.children.Length - 1)
{
EditorGUIUtility.AddCursorRect(
new Rect(position.width - SplitView.kGrabDist, 0, SplitView.kGrabDist, position.height),
MouseCursor.SplitResizeLeftRight, id);
}
}
}
view = sp;
sp = sp.parent as SplitView;
}
// reset
sp = (SplitView)parent;
}
if (sp)
{
Event e = new Event(Event.current);
e.mousePosition += new Vector2(position.x, position.y);
sp.SplitGUI(e);
if (e.type == EventType.Used)
{
Event.current.Use();
}
}
}
public override void OnInspectorGUI()
{
if (styles == null)
{
// Set the singleton in case the DrawEditors() has created this window
s_SharedAssetStoreAssetInspector = this;
styles = new Styles();
}
AssetStoreAsset activeAsset = AssetStoreAssetSelection.GetFirstAsset();
AssetStoreAsset.PreviewInfo info = null;
if (activeAsset != null)
{
info = activeAsset.previewInfo;
}
if (activeAsset != null)
{
target.name = string.Format("Asset Store: {0}", activeAsset.name);
}
else
{
target.name = "Asset Store";
}
EditorGUILayout.BeginVertical();
bool guiEnabled = GUI.enabled;
GUI.enabled = activeAsset != null && activeAsset.packageID != 0;
if (OfflineNoticeEnabled)
{
Color col = GUI.color;
GUI.color = Color.yellow;
GUILayout.Label("Network is offline");
GUI.color = col;
}
if (activeAsset != null)
{
string typeName = activeAsset.className == null ? "" : activeAsset.className.Split(new char[] { ' ' }, 2)[0];
bool isPackage = activeAsset.id == -activeAsset.packageID;
if (isPackage)
{
typeName = "Package";
}
if (activeAsset.HasLivePreview)
{
typeName = activeAsset.Preview.GetType().Name;
}
EditorGUILayout.LabelField("Type", typeName);
if (isPackage)
{
packageInfoShown = true;
}
else
{
EditorGUILayout.Separator();
packageInfoShown = EditorGUILayout.Foldout(packageInfoShown, "Part of package", true);
}
if (packageInfoShown)
{
EditorGUILayout.LabelField("Name", info == null ? "-" : info.packageName);
EditorGUILayout.LabelField("Version", info == null ? "-" : info.packageVersion);
string price = info == null ? "-" : (activeAsset.price != null && activeAsset.price != "" ? activeAsset.price : "free");
EditorGUILayout.LabelField("Price", price);
string rating = info != null && info.packageRating >= 0 ? info.packageRating.ToString() + " of 5" : "-";
EditorGUILayout.LabelField("Rating", rating);
EditorGUILayout.LabelField("Size", info == null ? "-" : intToSizeString(info.packageSize));
string assetCount = info != null && info.packageAssetCount >= 0 ? info.packageAssetCount.ToString() : "-";
EditorGUILayout.LabelField("Asset count", assetCount);
GUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("Web page");
bool hasPageUrl = info != null && info.packageShortUrl != null && info.packageShortUrl != "";
bool guiBefore = GUI.enabled;
GUI.enabled = hasPageUrl;
if (GUILayout.Button(hasPageUrl ? new GUIContent(info.packageShortUrl, "View in browser") : EditorGUIUtility.TempContent("-"), styles.link))
{
Application.OpenURL(info.packageShortUrl);
}
if (GUI.enabled)
{
EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
}
GUI.enabled = guiBefore;
GUILayout.EndHorizontal();
EditorGUILayout.LabelField("Publisher", info == null ? "-" : info.publisherName);
}
if (activeAsset.id != 0)
{
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
string actionLabel;
if (info != null && info.isDownloadable)
{
actionLabel = "Import package";
}
else
{
actionLabel = "Buy for " + activeAsset.price;
}
bool lastEnabled = GUI.enabled;
bool building = info != null && info.buildProgress >= 0;
bool downloading = info != null && info.downloadProgress >= 0;
if (building || downloading || info == null)
{
actionLabel = "";
GUI.enabled = false;
}
if (GUILayout.Button(actionLabel, GUILayout.Height(40), GUILayout.Width(120)))
{
if (info.isDownloadable)
{
ImportPackage(activeAsset);
}
else
{
InitiateBuySelected();
}
GUIUtility.ExitGUI();
}
Rect r;
if (Event.current.type == EventType.Repaint)
{
r = GUILayoutUtility.GetLastRect();
r.height -= 4;
float width = r.width;
r.width = r.height;
r.y += 2;
r.x += 2;
if (building || downloading)
{
r.width = width - r.height - 4;
r.x += r.height;
EditorGUI.ProgressBar(r,
downloading ? info.downloadProgress : info.buildProgress,
downloading ? "Downloading" : "Building");
}
}
GUI.enabled = lastEnabled;
GUILayout.Space(4);
if (GUILayout.Button("Open Asset Store", GUILayout.Height(40), GUILayout.Width(120)))
{
OpenItemInAssetStore(activeAsset);
GUIUtility.ExitGUI();
}
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
}
GUILayout.FlexibleSpace();
}
EditorWrapper editor = previewEditor;
if (editor != null && activeAsset != null && activeAsset.HasLivePreview)
{
editor.OnAssetStoreInspectorGUI();
}
GUI.enabled = guiEnabled;
EditorGUILayout.EndVertical();
}
void ListArea(Rect rect, PresetLibrary lib, object newPresetObject)
{
if (lib == null)
{
return;
}
Event evt = Event.current;
if (m_PresetLibraryFileLocation == PresetFileLocation.ProjectFolder && evt.type == EventType.Repaint)
{
m_IsOpenForEdit = AssetDatabase.IsOpenForEdit(pathWithExtension, StatusQueryOptions.UseCachedIfPossible);
}
else if (m_PresetLibraryFileLocation == PresetFileLocation.PreferencesFolder)
{
m_IsOpenForEdit = true;
}
if (!m_IsOpenForEdit)
{
Rect versionControlRect = new Rect(rect.x, rect.yMax - versionControlAreaHeight, rect.width, versionControlAreaHeight);
VersionControlArea(versionControlRect);
rect.height -= versionControlAreaHeight;
}
// To ensure we setup grid to visible rect we need to run once to check if scrollbar is taking up screen estate.
// To optimize the first width is based on the last frame and we therefore most likely will only run once.
for (int i = 0; i < 2; i++)
{
gridWidth = m_ShowedScrollBarLastFrame ? rect.width - 17 : rect.width;
SetupGrid(gridWidth, lib.Count());
bool isShowingScrollBar = m_Grid.height > rect.height;
if (isShowingScrollBar == m_ShowedScrollBarLastFrame)
{
break;
}
else
{
m_ShowedScrollBarLastFrame = isShowingScrollBar;
}
}
// Draw horizontal lines for scrollview content to clip against
if ((m_ShowedScrollBarLastFrame || alwaysShowScrollAreaHorizontalLines) && Event.current.type == EventType.Repaint)
{
Rect scrollEdgeRect = new RectOffset(1, 1, 1, 1).Add(rect);
scrollEdgeRect.height = 1;
EditorGUI.DrawRect(scrollEdgeRect, new Color(0, 0, 0, 0.3f));
scrollEdgeRect.y += rect.height + 1;
EditorGUI.DrawRect(scrollEdgeRect, new Color(0, 0, 0, 0.3f));
}
Rect contentRect = new Rect(0, 0, 1, m_Grid.height);
m_State.m_ScrollPosition = GUI.BeginScrollView(rect, m_State.m_ScrollPosition, contentRect);
{
int startIndex, endIndex;
float yOffset = 0f;
int maxIndex = m_ShowAddNewPresetItem ? lib.Count() : lib.Count() - 1;
bool isGridVisible = m_Grid.IsVisibleInScrollView(rect.height, m_State.m_ScrollPosition.y, yOffset, maxIndex, out startIndex, out endIndex);
bool drawDragInsertionMarker = false;
if (isGridVisible)
{
// Handle renaming overlay before item handling because its needs mouse input first to end renaming if clicked outside
if (GetRenameOverlay().IsRenaming() && !GetRenameOverlay().isWaitingForDelay)
{
if (!m_State.m_RenameOverlay.OnGUI())
{
EndRename();
evt.Use();
}
Repaint();
}
for (int i = startIndex; i <= endIndex; ++i)
{
int itemControlID = i + 1000000;
Rect itemRect = m_Grid.CalcRect(i, yOffset);
Rect previewRect = itemRect;
Rect labelRect = itemRect;
switch (m_State.itemViewMode)
{
case PresetLibraryEditorState.ItemViewMode.List:
previewRect.width = m_State.m_PreviewHeight * m_PreviewAspect;
labelRect.x += previewRect.width + 8f;
labelRect.width -= previewRect.width + 10f;
labelRect.height = kGridLabelHeight;
labelRect.y = itemRect.yMin + (itemRect.height - kGridLabelHeight) * 0.5f;
break;
case PresetLibraryEditorState.ItemViewMode.Grid:
// only preview is shown: no label
break;
}
// Add new preset button
if (m_ShowAddNewPresetItem && i == lib.Count())
{
CreateNewPresetButton(previewRect, newPresetObject, lib, m_IsOpenForEdit);
continue;
}
// Rename overlay
bool isRenamingThisItem = IsRenaming(i);
if (isRenamingThisItem)
{
Rect renameRect = labelRect;
renameRect.y -= 1f; renameRect.x -= 1f; // adjustment to fit perfectly
m_State.m_RenameOverlay.editFieldRect = renameRect;
}
// Handle event
switch (evt.type)
{
case EventType.Repaint:
if (m_State.m_HoverIndex == i)
{
if (itemRect.Contains(evt.mousePosition))
{
// TODO: We need a better hover effect so disabling for now...
//if (!GetRenameOverlay().IsRenaming ())
// DrawHoverEffect (itemRect, false);
}
else
{
m_State.m_HoverIndex = -1;
}
}
if (m_DragState.draggingIndex == i || GUIUtility.hotControl == itemControlID)
{
DrawHoverEffect(itemRect, false);
}
lib.Draw(previewRect, i);
if (!isRenamingThisItem && drawLabels)
{
GUI.Label(labelRect, GUIContent.Temp(lib.GetName(i)));
}
if (m_DragState.dragUponIndex == i && m_DragState.draggingIndex != m_DragState.dragUponIndex)
{
drawDragInsertionMarker = true;
}
// We delete presets on alt-click
if (GUIUtility.hotControl == 0 && Event.current.alt && m_IsOpenForEdit)
{
EditorGUIUtility.AddCursorRect(itemRect, MouseCursor.ArrowMinus);
}
break;
case EventType.MouseDown:
if (evt.button == 0 && itemRect.Contains(evt.mousePosition))
{
GUIUtility.hotControl = itemControlID;
if (evt.clickCount == 1)
{
m_ItemClickedCallback(evt.clickCount, lib.GetPreset(i));
evt.Use();
}
}
break;
case EventType.MouseDrag:
if (GUIUtility.hotControl == itemControlID && m_IsOpenForEdit)
{
DragAndDropDelay delay = (DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), itemControlID);
if (delay.CanStartDrag())
{
// Start drag
DragAndDrop.PrepareStartDrag();
DragAndDrop.SetGenericData("DraggingPreset", i);
DragAndDrop.StartDrag("");
m_DragState.draggingIndex = i;
m_DragState.dragUponIndex = i;
GUIUtility.hotControl = 0;
}
evt.Use();
}
break;
case EventType.DragUpdated:
case EventType.DragPerform:
{
Rect dragRect = GetDragRect(itemRect);
if (dragRect.Contains(evt.mousePosition))
{
m_DragState.dragUponIndex = i;
m_DragState.dragUponRect = itemRect;
if (m_State.itemViewMode == PresetLibraryEditorState.ItemViewMode.List)
{
m_DragState.insertAfterIndex = ((evt.mousePosition.y - dragRect.y) / dragRect.height) > 0.5f;
}
else
{
m_DragState.insertAfterIndex = ((evt.mousePosition.x - dragRect.x) / dragRect.width) > 0.5f;
}
bool perform = evt.type == EventType.DragPerform;
if (perform)
{
if (m_DragState.draggingIndex >= 0)
{
MovePreset(m_DragState.draggingIndex, m_DragState.dragUponIndex, m_DragState.insertAfterIndex);
DragAndDrop.AcceptDrag();
}
ClearDragState();
}
DragAndDrop.visualMode = DragAndDropVisualMode.Move;
evt.Use();
}
}
break;
case EventType.DragExited:
if (m_DragState.IsDragging())
{
ClearDragState();
evt.Use();
}
break;
case EventType.MouseUp:
if (GUIUtility.hotControl == itemControlID)
{
GUIUtility.hotControl = 0;
if (evt.button == 0 && itemRect.Contains(evt.mousePosition))
{
if (Event.current.alt && m_IsOpenForEdit)
{
DeletePreset(i);
evt.Use();
}
}
}
break;
case EventType.ContextClick:
if (itemRect.Contains(evt.mousePosition))
{
PresetContextMenu.Show(m_IsOpenForEdit, i, newPresetObject, this);
evt.Use();
}
break;
case EventType.MouseMove:
if (itemRect.Contains(evt.mousePosition))
{
if (m_State.m_HoverIndex != i)
{
m_State.m_HoverIndex = i;
Repaint();
}
}
else if (m_State.m_HoverIndex == i)
{
m_State.m_HoverIndex = -1;
Repaint();
}
break;
}
} // end foreach item
// Draw above all items
if (drawDragInsertionMarker)
{
DrawDragInsertionMarker();
}
}
} GUI.EndScrollView();
}
private void HandleMouseInput()
{
List <CubemapInfo> cubemapList = m_LookDevView.envLibrary.hdriList;
Vector2 scrollFixedPosition = new Vector2(Event.current.mousePosition.x, Event.current.mousePosition.y + m_ScrollPosition.y);
Event evt = Event.current;
switch (evt.GetTypeForControl(m_LookDevView.hotControl))
{
// Update overlay position for next repaint event
case EventType.MouseDrag:
{
if (m_SelectedCubeMapOffsetIndex != -1)
{
Undo.RecordObject(m_LookDevView.envLibrary, "");
CubemapInfo info = cubemapList[m_SelectedCubeMapOffsetIndex];
info.angleOffset = ComputeAngleOffsetFromMouseCoord(scrollFixedPosition) + m_SelectedCubeMapOffsetValue;
m_LookDevView.envLibrary.dirty = true;
Event.current.Use();
}
if (m_SelectedCubemapInfo != null)
{
if (IsPositionInInsertionArea(scrollFixedPosition) == -1)
{
m_HoveringCubeMapIndex = IsPositionInThumbnailArea(scrollFixedPosition);
}
else
{
m_HoveringCubeMapIndex = -1;
}
}
m_LookDevView.Repaint();
break;
}
// Handles environment drop
case EventType.MouseUp:
{
if (m_SelectedCubemap != null)
{
// The rect needs to include an extra slot when moving to last position
Rect extendedGUIRect = m_GUIRect;
extendedGUIRect.yMax += EditorGUI.kSingleLineHeight;
if (extendedGUIRect.Contains(Event.current.mousePosition))
{
int insertionRectIndex = IsPositionInInsertionArea(scrollFixedPosition);
if (insertionRectIndex != -1)
{
// Must be called before we do any modification to HDRI list
ResetShadowCubemap();
m_LookDevView.envLibrary.InsertHDRI(m_SelectedCubemap, insertionRectIndex);
}
else
{
int thumbnailRectIndex = IsPositionInThumbnailArea(scrollFixedPosition);
if (thumbnailRectIndex != -1 && m_LookDevView.config.enableShadowCubemap)
{
Undo.RecordObject(m_LookDevView.envLibrary, "Update shadow cubemap");
CubemapInfo cubemapInfo = m_LookDevView.envLibrary.hdriList[thumbnailRectIndex];
// We don't want the user to drop a cubemap on itself and reset the shadows (it would happen all the time by mistake)
if (cubemapInfo != m_SelectedCubemapInfo)
{
cubemapInfo.SetCubemapShadowInfo(m_SelectedCubemapInfo);
}
m_LookDevView.envLibrary.dirty = true;
}
}
CancelSelection();
}
}
m_LookDevView.Repaint();
if (m_SelectedCubeMapOffsetIndex != -1)
{
// Fall back to zero when near the center
if (Mathf.Abs(cubemapList[m_SelectedCubeMapOffsetIndex].angleOffset) <= 10.0f)
{
Undo.RecordObject(m_LookDevView.envLibrary, "");
cubemapList[m_SelectedCubeMapOffsetIndex].angleOffset = 0.0f;
m_LookDevView.envLibrary.dirty = true;
}
}
m_SelectedCubemapInfo = null;
m_SelectedShadowCubemapOwnerInfo = null;
m_SelectedLightIconIndex = -1;
m_SelectedShadowInfo = null;
m_SelectedCubeMapOffsetIndex = -1;
m_HoveringCubeMapIndex = -1;
m_SelectedCubeMapOffsetValue = 0.0f;
GUIUtility.hotControl = 0;
break;
}
// Escape closes the window
case EventType.KeyDown:
{
if (Event.current.keyCode == KeyCode.Escape)
{
CancelSelection();
m_LookDevView.Repaint();
}
break;
}
case EventType.DragPerform:
{
int insertionIndex = IsPositionInInsertionArea(scrollFixedPosition);
foreach (UnityEngine.Object o in DragAndDrop.objectReferences)
{
Cubemap cubemap = o as Cubemap;
if (cubemap)
{
// When insertion outside the list the index is -1 which mean in InsertHDRI that it will be add at the end
m_LookDevView.envLibrary.InsertHDRI(cubemap, insertionIndex);
}
}
DragAndDrop.AcceptDrag();
m_DragBeingPerformed = false;
evt.Use();
break;
}
case EventType.DragUpdated:
{
bool hasCubemap = false;
foreach (UnityEngine.Object o in DragAndDrop.objectReferences)
{
Cubemap cubemap = o as Cubemap;
if (cubemap)
{
hasCubemap = true;
}
}
DragAndDrop.visualMode = hasCubemap ? DragAndDropVisualMode.Link : DragAndDropVisualMode.Rejected;
if (hasCubemap)
{
m_DragBeingPerformed = true;
}
evt.Use();
}
break;
case EventType.DragExited:
break;
case EventType.Repaint:
if (m_SelectedCubeMapOffsetIndex != -1)
{
EditorGUIUtility.AddCursorRect(m_displayRect, MouseCursor.SlideArrow);
}
break;
}
}