|
public static GetControlRect ( ) : |
||
| return | ||
internal static void Ruler(int w = 2, int padding = 10)
{
var r = EGL.GetControlRect(Height(padding + w));
r.height = w; r.x -= 2; r.width += 6; r.y += padding / 2;
EditorGUI.DrawRect(r, lightGray);
}
public static bool Hr(int w = 2, int padding = 10, int count = 1)
{
for (int i = 0; i < count; i++)
{
var r = EGL.GetControlRect(Height(padding + w));
r.height = w; r.x -= 2; r.width += 6; r.y += padding / 2;
EditorGUI.DrawRect(r, lightGray);
}
return(true);
}
internal void DrawUIPane(IProfilerWindowController win)
{
if (Styles.backgroundStyle == null)
{
Styles.CreateStyles();
}
//make sure all background textures exist
Styles.CheckBackgroundTextures();
EditorGUILayout.BeginVertical();
var rect = EditorGUILayout.GetControlRect(GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
const int padding = 1;
Rect aggregateHeader = rect;
aggregateHeader.width = Mathf.Min(434, rect.width);
aggregateHeader.height = 34;
Rect aggregateData = aggregateHeader;
aggregateData.y += aggregateHeader.height + padding;
float aggregateBoxHeight = rect.height / 2 - aggregateHeader.height - padding * 2;
aggregateData.height = aggregateBoxHeight;
Rect infoBox = new Rect();
if (ProfilerDriver.GetStatisticsAvailabilityState(ProfilerArea.VirtualTexturing, win.GetActiveVisibleFrameIndex()) == 0)
{
GUI.Label(aggregateHeader, "No Virtual Texturing data was collected.");
EditorGUILayout.EndVertical();
return;
}
GUI.Box(rect, "", Styles.backgroundStyle);
using (RawFrameDataView frameDataView = ProfilerDriver.GetRawFrameDataView(win.GetActiveVisibleFrameIndex(), 0))
{
if (frameDataView.valid)
{
Assert.IsTrue(frameDataView.threadName == "Main Thread");
RawFrameDataView fRender = GetRenderThread(frameDataView);
//system statistics
var stringBuilder = new StringBuilder(1024);
int requiredTiles = (int)GetCounterValue(frameDataView, "Required Tiles");
stringBuilder.AppendLine($" Tiles required this frame: {requiredTiles}");
stringBuilder.AppendLine($" Max Cache Mip Bias: {GetCounterValueAsFloat(frameDataView, "Max Cache Mip Bias")}");
stringBuilder.AppendLine($" Max Cache Demand: {GetCounterValue(frameDataView, "Max Cache Demand")}%");
stringBuilder.AppendLine($" Total CPU Cache Size: {EditorUtility.FormatBytes(GetCounterValue(frameDataView, "Total CPU Cache Size"))}");
stringBuilder.AppendLine($" Total GPU Cache Size: {EditorUtility.FormatBytes(GetCounterValue(frameDataView, "Total GPU Cache Size"))}");
stringBuilder.AppendLine($" Atlases: {GetCounterValue(frameDataView, "Atlases")}");
string aggregatedText = stringBuilder.ToString();
float aggregateTextHeight = EditorStyles.wordWrappedLabel.CalcHeight(GUIContent.Temp(aggregatedText), rect.width);
float actualHeight = Mathf.Max(aggregateBoxHeight, aggregateTextHeight);
DrawScrollBackground(new Rect(aggregateData.width - 12, aggregateData.y, 14, aggregateData.height));
GUI.Box(aggregateHeader, " System Statistics", Styles.headerStyle);
m_SystemScroll = GUI.BeginScrollView(aggregateData, m_SystemScroll, new Rect(0, 0, aggregateData.width / 2, actualHeight));
GUI.Box(new Rect(0, 0, aggregateData.width, actualHeight), aggregatedText, Styles.statStyle);
GUI.EndScrollView();
//player build statistics
aggregateHeader.y += aggregateHeader.height + aggregateData.height + padding * 2;
aggregateData.y += aggregateHeader.height + aggregateData.height + padding * 2;
stringBuilder.Clear();
stringBuilder.AppendLine($" Missing Disk Data: {EditorUtility.FormatBytes(GetCounterValue(frameDataView, "Missing Disk Data"))}");
stringBuilder.AppendLine($" Missing Streaming Tiles: {GetCounterValue(frameDataView, "Missing Streaming Tiles")}");
stringBuilder.AppendLine($" Read From Disk: {EditorUtility.FormatBytes(GetCounterValue(frameDataView, "Read From Disk"))}");
aggregatedText = stringBuilder.ToString();
aggregateTextHeight = EditorStyles.wordWrappedLabel.CalcHeight(GUIContent.Temp(aggregatedText), rect.width);
actualHeight = Mathf.Max(aggregateBoxHeight, aggregateTextHeight);
DrawScrollBackground(new Rect(aggregateData.width - 12, aggregateData.y, 14, aggregateData.height));
GUI.Box(aggregateHeader, " Player Build Statistics", Styles.headerStyle);
m_PlayerScroll = GUI.BeginScrollView(aggregateData, m_PlayerScroll, new Rect(0, 0, aggregateData.width / 2, actualHeight));
GUI.Box(new Rect(0, 0, aggregateData.width, actualHeight), aggregatedText, Styles.statStyle);
GUI.EndScrollView();
//PER CACHE DATA
Rect perCacheHeader = rect;
perCacheHeader.width = rect.width - aggregateHeader.width - padding;
perCacheHeader.height = 34;
perCacheHeader.x += aggregateHeader.width + padding;
Rect formatBox = perCacheHeader;
formatBox.height = rect.height - perCacheHeader.height - padding;
formatBox.y += perCacheHeader.height + padding;
GUI.Box(perCacheHeader, " Per Cache Statistics", Styles.headerStyle);
if (m_Header == null || m_HeaderState == null)
{
Init();
}
//Keep using the last VT tick untill a new one is available.
if (requiredTiles > 0)
{
ReadFrameData(fRender);
}
if (m_SortingChanged)
{
SortFrameData();
}
DrawFormatData(formatBox);
if (fRender != frameDataView)
{
fRender.Dispose();
}
}
else
{
GUI.Label(aggregateData, "No frame data available");
}
}
EditorGUILayout.EndVertical();
infoBox.y = rect.y;
infoBox.x = rect.width - 33;
infoBox.width = 34;
infoBox.height = 34;
DrawDocLink(infoBox);
}
private void BakeSettings()
{
EditorGUILayout.LabelField(NavMeshEditorWindow.s_Styles.m_AgentSizeHeader, EditorStyles.boldLabel, new GUILayoutOption[0]);
this.DrawAgentDiagram(EditorGUILayout.GetControlRect(false, 120f, new GUILayoutOption[0]), this.m_AgentRadius.floatValue, this.m_AgentHeight.floatValue, this.m_AgentClimb.floatValue, this.m_AgentSlope.floatValue);
float num1 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentRadiusContent, this.m_AgentRadius.floatValue, new GUILayoutOption[0]);
if ((double)num1 >= 1.0 / 1000.0 && !Mathf.Approximately(num1 - this.m_AgentRadius.floatValue, 0.0f))
{
this.m_AgentRadius.floatValue = num1;
if (!this.m_ManualCellSize.boolValue)
{
this.m_CellSize.floatValue = (float)(2.0 * (double)this.m_AgentRadius.floatValue / 6.0);
}
}
if ((double)this.m_AgentRadius.floatValue < 0.0500000007450581 && !this.m_ManualCellSize.boolValue)
{
EditorGUILayout.HelpBox("The agent radius you've set is really small, this can slow down the build.\nIf you intended to allow the agent to move close to the borders and walls, please adjust voxel size in advaced settings to ensure correct bake.", MessageType.Warning);
}
float num2 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentHeightContent, this.m_AgentHeight.floatValue, new GUILayoutOption[0]);
if ((double)num2 >= 1.0 / 1000.0 && !Mathf.Approximately(num2 - this.m_AgentHeight.floatValue, 0.0f))
{
this.m_AgentHeight.floatValue = num2;
}
EditorGUILayout.Slider(this.m_AgentSlope, 0.0f, 60f, NavMeshEditorWindow.s_Styles.m_AgentSlopeContent, new GUILayoutOption[0]);
if ((double)this.m_AgentSlope.floatValue > 60.0)
{
EditorGUILayout.HelpBox("The maximum slope should be set to less than " + (object)60f + " degrees to prevent NavMesh build artifacts on slopes. ", MessageType.Warning);
}
float num3 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentClimbContent, this.m_AgentClimb.floatValue, new GUILayoutOption[0]);
if ((double)num3 >= 0.0 && !Mathf.Approximately(this.m_AgentClimb.floatValue - num3, 0.0f))
{
this.m_AgentClimb.floatValue = num3;
}
if ((double)this.m_AgentClimb.floatValue > (double)this.m_AgentHeight.floatValue)
{
EditorGUILayout.HelpBox("Step height should be less than agent height.\nClamping step height to " + (object)this.m_AgentHeight.floatValue + " internally when baking.", MessageType.Warning);
}
float floatValue = this.m_CellSize.floatValue;
float num4 = floatValue * 0.5f;
int num5 = (int)Mathf.Ceil(this.m_AgentClimb.floatValue / num4);
int num6 = (int)Mathf.Ceil(Mathf.Tan((float)((double)this.m_AgentSlope.floatValue / 180.0 * 3.14159274101257)) * floatValue * 2f / num4);
if (num6 > num5)
{
EditorGUILayout.HelpBox("Step Height conflicts with Max Slope. This makes some slopes unwalkable.\nConsider decreasing Max Slope to < " + ((float)((double)Mathf.Atan((float)((double)num5 * (double)num4 / ((double)floatValue * 2.0))) / 3.14159274101257 * 180.0)).ToString("0.0") + " degrees.\nOr, increase Step Height to > " + ((float)(num6 - 1) * num4).ToString("0.00") + ".", MessageType.Warning);
}
EditorGUILayout.Space();
EditorGUILayout.LabelField(NavMeshEditorWindow.s_Styles.m_OffmeshHeader, EditorStyles.boldLabel, new GUILayoutOption[0]);
float num7 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentDropContent, this.m_LedgeDropHeight.floatValue, new GUILayoutOption[0]);
if ((double)num7 >= 0.0 && !Mathf.Approximately(num7 - this.m_LedgeDropHeight.floatValue, 0.0f))
{
this.m_LedgeDropHeight.floatValue = num7;
}
float num8 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentJumpContent, this.m_MaxJumpAcrossDistance.floatValue, new GUILayoutOption[0]);
if ((double)num8 >= 0.0 && !Mathf.Approximately(num8 - this.m_MaxJumpAcrossDistance.floatValue, 0.0f))
{
this.m_MaxJumpAcrossDistance.floatValue = num8;
}
EditorGUILayout.Space();
this.m_Advanced = GUILayout.Toggle(this.m_Advanced, NavMeshEditorWindow.s_Styles.m_AdvancedHeader, EditorStyles.foldout, new GUILayoutOption[0]);
if (this.m_Advanced)
{
++EditorGUI.indentLevel;
bool flag1 = EditorGUILayout.Toggle(NavMeshEditorWindow.s_Styles.m_ManualCellSizeContent, this.m_ManualCellSize.boolValue, new GUILayoutOption[0]);
if (flag1 != this.m_ManualCellSize.boolValue)
{
this.m_ManualCellSize.boolValue = flag1;
if (!flag1)
{
this.m_CellSize.floatValue = (float)(2.0 * (double)this.m_AgentRadius.floatValue / 6.0);
}
}
EditorGUI.BeginDisabledGroup(!this.m_ManualCellSize.boolValue);
++EditorGUI.indentLevel;
float val2 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_CellSizeContent, this.m_CellSize.floatValue, new GUILayoutOption[0]);
if ((double)val2 > 0.0 && !Mathf.Approximately(val2 - this.m_CellSize.floatValue, 0.0f))
{
this.m_CellSize.floatValue = Math.Max(0.01f, val2);
}
if ((double)val2 < 0.00999999977648258)
{
EditorGUILayout.HelpBox("The voxel size should be larger than 0.01.", MessageType.Warning);
}
float num9 = (double)this.m_CellSize.floatValue <= 0.0 ? 0.0f : this.m_AgentRadius.floatValue / this.m_CellSize.floatValue;
EditorGUILayout.LabelField(" ", num9.ToString("0.00") + " voxels per agent radius", EditorStyles.miniLabel, new GUILayoutOption[0]);
if (this.m_ManualCellSize.boolValue)
{
if ((int)Mathf.Floor(this.m_AgentHeight.floatValue / (this.m_CellSize.floatValue * 0.5f)) > 250)
{
EditorGUILayout.HelpBox("The number of voxels per agent height is too high. This will reduce the accuracy of the navmesh. Consider using voxel size of at least " + ((float)((double)this.m_AgentHeight.floatValue / 250.0 / 0.5)).ToString("0.000") + ".", MessageType.Warning);
}
if ((double)num9 < 1.0)
{
EditorGUILayout.HelpBox("The number of voxels per agent radius is too small. The agent may not avoid walls and ledges properly. Consider using voxel size of at least " + (this.m_AgentRadius.floatValue / 2f).ToString("0.000") + " (2 voxels per agent radius).", MessageType.Warning);
}
else if ((double)num9 > 8.0)
{
EditorGUILayout.HelpBox("The number of voxels per agent radius is too high. It can cause excessive build times. Consider using voxel size closer to " + (this.m_AgentRadius.floatValue / 8f).ToString("0.000") + " (8 voxels per radius).", MessageType.Warning);
}
}
if (this.m_ManualCellSize.boolValue)
{
EditorGUILayout.HelpBox("Voxel size controls how accurately the navigation mesh is generated from the level geometry. A good voxel size is 2-4 voxels per agent radius. Making voxel size smaller will increase build time.", MessageType.None);
}
--EditorGUI.indentLevel;
EditorGUI.EndDisabledGroup();
EditorGUILayout.Space();
float num10 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_MinRegionAreaContent, this.m_MinRegionArea.floatValue, new GUILayoutOption[0]);
if ((double)num10 >= 0.0 && (double)num10 != (double)this.m_MinRegionArea.floatValue)
{
this.m_MinRegionArea.floatValue = num10;
}
EditorGUILayout.Space();
bool flag2 = EditorGUILayout.Toggle(NavMeshEditorWindow.s_Styles.m_AgentPlacementContent, this.m_AccuratePlacement.boolValue, new GUILayoutOption[0]);
if (flag2 != this.m_AccuratePlacement.boolValue)
{
this.m_AccuratePlacement.boolValue = flag2;
}
--EditorGUI.indentLevel;
}
if (!Unsupported.IsDeveloperBuild())
{
return;
}
EditorGUILayout.Space();
GUILayout.Label("Internal Bake Debug Options", EditorStyles.boldLabel, new GUILayoutOption[0]);
EditorGUILayout.HelpBox("Note: The debug visualization is build during bake, so you'll need to bake for these settings to take effect.", MessageType.None);
bool meshLinkSampling = NavMeshVisualizationSettings.showAutoOffMeshLinkSampling;
if (meshLinkSampling != EditorGUILayout.Toggle(new GUIContent("Show Auto-Off-MeshLink Sampling"), meshLinkSampling, new GUILayoutOption[0]))
{
NavMeshVisualizationSettings.showAutoOffMeshLinkSampling = !meshLinkSampling;
}
bool showVoxels = NavMeshVisualizationSettings.showVoxels;
if (showVoxels != EditorGUILayout.Toggle(new GUIContent("Show Voxels"), showVoxels, new GUILayoutOption[0]))
{
NavMeshVisualizationSettings.showVoxels = !showVoxels;
}
bool showWalkable = NavMeshVisualizationSettings.showWalkable;
if (showWalkable != EditorGUILayout.Toggle(new GUIContent("Show Walkable"), showWalkable, new GUILayoutOption[0]))
{
NavMeshVisualizationSettings.showWalkable = !showWalkable;
}
bool showRawContours = NavMeshVisualizationSettings.showRawContours;
if (showRawContours != EditorGUILayout.Toggle(new GUIContent("Show Raw Contours"), showRawContours, new GUILayoutOption[0]))
{
NavMeshVisualizationSettings.showRawContours = !showRawContours;
}
bool showContours = NavMeshVisualizationSettings.showContours;
if (showContours != EditorGUILayout.Toggle(new GUIContent("Show Contours"), showContours, new GUILayoutOption[0]))
{
NavMeshVisualizationSettings.showContours = !showContours;
}
bool showInputs = NavMeshVisualizationSettings.showInputs;
if (showInputs != EditorGUILayout.Toggle(new GUIContent("Show Inputs"), showInputs, new GUILayoutOption[0]))
{
NavMeshVisualizationSettings.showInputs = !showInputs;
}
if (GUILayout.Button("Clear Visualiation Data"))
{
NavMeshVisualizationSettings.ClearVisualizationData();
NavMeshEditorWindow.RepaintSceneAndGameViews();
}
EditorGUILayout.Space();
}
private void SceneBakeSettings()
{
ComponentBasedWorkflowButton();
if (m_SettingsObject == null || m_SettingsObject.targetObject == null)
{
InitSceneBakeSettings();
}
m_SettingsObject.Update();
EditorGUILayout.LabelField(s_Styles.m_AgentSizeHeader, EditorStyles.boldLabel);
// Draw image
const float kDiagramHeight = 120.0f;
Rect agentDiagramRect = EditorGUILayout.GetControlRect(false, kDiagramHeight);
NavMeshEditorHelpers.DrawAgentDiagram(agentDiagramRect, m_AgentRadius.floatValue, m_AgentHeight.floatValue, m_AgentClimb.floatValue, m_AgentSlope.floatValue);
//Agent Settings
var radius = EditorGUILayout.FloatField(s_Styles.m_AgentRadiusContent, m_AgentRadius.floatValue);
if (radius >= 0.001f && !Mathf.Approximately(radius - m_AgentRadius.floatValue, 0.0f))
{
m_AgentRadius.floatValue = radius;
// Update cellsize based on radius unless cellsize is set manually.
if (m_ManualCellSize.boolValue == false)
{
m_CellSize.floatValue = (2.0f * m_AgentRadius.floatValue) / 6.0f;
}
}
// If radius is really small warn the user about it and instruct common use case for small radius.
if (m_AgentRadius.floatValue < 0.05f && m_ManualCellSize.boolValue == false)
{
EditorGUILayout.HelpBox("The agent radius you've set is really small, this can slow down the build.\nIf you intended to allow the agent to move close to the borders and walls, please adjust voxel size in advaced settings to ensure correct bake.", MessageType.Warning);
}
var height = EditorGUILayout.FloatField(s_Styles.m_AgentHeightContent, m_AgentHeight.floatValue);
if (height >= 0.001f && !Mathf.Approximately(height - m_AgentHeight.floatValue, 0.0f))
{
m_AgentHeight.floatValue = height;
}
const float kMaxSlopeAngle = 60.0f;
EditorGUILayout.Slider(m_AgentSlope, 0.0f, kMaxSlopeAngle, s_Styles.m_AgentSlopeContent);
if (m_AgentSlope.floatValue > kMaxSlopeAngle)
{
EditorGUILayout.HelpBox("The maximum slope should be set to less than " + kMaxSlopeAngle + " degrees to prevent NavMesh build artifacts on slopes. ", MessageType.Warning);
}
//Step height
var newClimb = EditorGUILayout.FloatField(s_Styles.m_AgentClimbContent, m_AgentClimb.floatValue);
if (newClimb >= 0.0f && !Mathf.Approximately(m_AgentClimb.floatValue - newClimb, 0.0f))
{
m_AgentClimb.floatValue = newClimb;
}
if (m_AgentClimb.floatValue > m_AgentHeight.floatValue)
{
// Actual clamping happens in NavMeshBuilder.cpp ConfigureConfig()
EditorGUILayout.HelpBox("Step height should be less than agent height.\nClamping step height to " + m_AgentHeight.floatValue + " internally when baking.", MessageType.Warning);
}
// Detect when agent slope and step height conflict.
float cs = m_CellSize.floatValue;
float ch = cs * 0.5f; // From NavMeshBuilder.cpp:ConfigureConfig()
int walkableClimbVx = (int)Mathf.Ceil(m_AgentClimb.floatValue / ch);
// Recast treats voxels whose neighbours min/max height difference is more than step height.
float slopeHeightPerVoxel = Mathf.Tan(m_AgentSlope.floatValue / 180.0f * Mathf.PI) * cs;
int slopeVx = (int)Mathf.Ceil(slopeHeightPerVoxel * 2.0f / ch);
if (slopeVx > walkableClimbVx)
{
// Recommend new values.
float betterSlope = (walkableClimbVx * ch) / (cs * 2.0f);
float betterSlopeAngle = Mathf.Atan(betterSlope) / Mathf.PI * 180.0f;
float betterStep = (slopeVx - 1) * ch;
EditorGUILayout.HelpBox("Step Height conflicts with Max Slope. This makes some slopes unwalkable.\nConsider decreasing Max Slope to < " + betterSlopeAngle.ToString("0.0", CultureInfo.InvariantCulture.NumberFormat) + " degrees.\nOr, increase Step Height to > " + betterStep.ToString("0.00") + ".", MessageType.Warning);
}
EditorGUILayout.Space();
EditorGUILayout.LabelField(s_Styles.m_OffmeshHeader, EditorStyles.boldLabel);
//Drop height
var newDropHeight = EditorGUILayout.FloatField(s_Styles.m_AgentDropContent, m_LedgeDropHeight.floatValue);
if (newDropHeight >= 0.0f && !Mathf.Approximately(newDropHeight - m_LedgeDropHeight.floatValue, 0.0f))
{
m_LedgeDropHeight.floatValue = newDropHeight;
}
//Jump distance
var newJumpDistance = EditorGUILayout.FloatField(s_Styles.m_AgentJumpContent, m_MaxJumpAcrossDistance.floatValue);
if (newJumpDistance >= 0.0f && !Mathf.Approximately(newJumpDistance - m_MaxJumpAcrossDistance.floatValue, 0.0f))
{
m_MaxJumpAcrossDistance.floatValue = newJumpDistance;
}
EditorGUILayout.Space();
//Advanced Settings
m_Advanced = GUILayout.Toggle(m_Advanced, s_Styles.m_AdvancedHeader, EditorStyles.foldout);
if (m_Advanced)
{
EditorGUI.indentLevel++;
// Cell size
var manualCellSize = EditorGUILayout.Toggle(s_Styles.m_ManualCellSizeContent, m_ManualCellSize.boolValue);
if (manualCellSize != m_ManualCellSize.boolValue)
{
m_ManualCellSize.boolValue = manualCellSize;
// When unchecking the manual control, revert to automatic value.
if (!manualCellSize)
{
m_CellSize.floatValue = (2.0f * m_AgentRadius.floatValue) / 6.0f;
}
}
EditorGUI.indentLevel++;
using (new EditorGUI.DisabledScope(!m_ManualCellSize.boolValue))
{
var cellSize = EditorGUILayout.FloatField(s_Styles.m_CellSizeContent, m_CellSize.floatValue);
if (cellSize > 0.0f && !Mathf.Approximately(cellSize - m_CellSize.floatValue, 0.0f))
{
m_CellSize.floatValue = Math.Max(0.01f, cellSize);
}
if (cellSize < 0.01f)
{
EditorGUILayout.HelpBox("The voxel size should be larger than 0.01.", MessageType.Warning);
}
float voxelsPerRadius = m_CellSize.floatValue > 0 ? (m_AgentRadius.floatValue / m_CellSize.floatValue) : 0.0f;
EditorGUILayout.LabelField(" ", voxelsPerRadius.ToString("0.00", CultureInfo.InvariantCulture.NumberFormat) + " voxels per agent radius", EditorStyles.miniLabel);
if (m_ManualCellSize.boolValue)
{
// Make sure these calculations match the ones in NavMeshBuilder.cpp ConfigureConfig()
const float kCellSizeToHeightRatio = 0.5f;
float cellheight = m_CellSize.floatValue * kCellSizeToHeightRatio;
// Some places inside Recast store height as a byte, make sure the ratio between
// the agent height and cell height does not exceed this limit.
if ((int)Mathf.Floor(m_AgentHeight.floatValue / cellheight) > 250)
{
float goodValue = (m_AgentHeight.floatValue / 250.0f) / kCellSizeToHeightRatio;
EditorGUILayout.HelpBox("The number of voxels per agent height is too high. This will reduce the accuracy of the navmesh. Consider using voxel size of at least " + goodValue.ToString("0.000", CultureInfo.InvariantCulture.NumberFormat) + ".", MessageType.Warning);
}
if (voxelsPerRadius < 1.0f)
{
float goodValue = m_AgentRadius.floatValue / 2.0f;
EditorGUILayout.HelpBox("The number of voxels per agent radius is too small. The agent may not avoid walls and ledges properly. Consider using a voxel size less than " + goodValue.ToString("0.000", CultureInfo.InvariantCulture.NumberFormat) + " (2 voxels per agent radius).", MessageType.Warning);
}
else if (voxelsPerRadius > 8.0f)
{
float goodValue = m_AgentRadius.floatValue / 8.0f;
EditorGUILayout.HelpBox("The number of voxels per agent radius is too high. It can cause excessive build times. Consider using voxel size closer to " + goodValue.ToString("0.000", CultureInfo.InvariantCulture.NumberFormat) + " (8 voxels per radius).", MessageType.Warning);
}
}
if (m_ManualCellSize.boolValue)
{
EditorGUILayout.HelpBox("Voxel size controls how accurately the navigation mesh is generated from the level geometry. A good voxel size is 2-4 voxels per agent radius. Making voxel size smaller will increase build time.", MessageType.None);
}
}
EditorGUI.indentLevel--;
EditorGUILayout.Space();
// Min region area
var minRegionArea = EditorGUILayout.FloatField(s_Styles.m_MinRegionAreaContent, m_MinRegionArea.floatValue);
if (minRegionArea >= 0.0f && minRegionArea != m_MinRegionArea.floatValue)
{
m_MinRegionArea.floatValue = minRegionArea;
}
EditorGUILayout.Space();
//Height mesh
var accurate = EditorGUILayout.Toggle(s_Styles.m_AgentPlacementContent, m_AccuratePlacement.boolValue);
if (accurate != m_AccuratePlacement.boolValue)
{
m_AccuratePlacement.boolValue = accurate;
}
EditorGUI.indentLevel--;
}
m_SettingsObject.ApplyModifiedProperties();
BakeButtons();
}
internal static Rect DrawHeaderGUI(Editor editor, string header, float leftMargin)
{
if (s_Styles == null)
{
s_Styles = new Styles();
}
GUILayout.BeginHorizontal(s_Styles.inspectorBig, new GUILayoutOption[0]);
GUILayout.Space(38f);
GUILayout.BeginVertical(new GUILayoutOption[0]);
GUILayout.Space(19f);
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
if (leftMargin > 0f)
{
GUILayout.Space(leftMargin);
}
if (editor != null)
{
editor.OnHeaderControlsGUI();
}
else
{
EditorGUILayout.GetControlRect(new GUILayoutOption[0]);
}
GUILayout.EndHorizontal();
GUILayout.EndVertical();
GUILayout.EndHorizontal();
Rect lastRect = GUILayoutUtility.GetLastRect();
Rect r = new Rect(lastRect.x + leftMargin, lastRect.y, lastRect.width - leftMargin, lastRect.height);
Rect iconRect = new Rect(r.x + 6f, r.y + 6f, 32f, 32f);
if (editor != null)
{
editor.OnHeaderIconGUI(iconRect);
}
else
{
GUI.Label(iconRect, AssetPreview.GetMiniTypeThumbnail(typeof(Object)), s_Styles.centerStyle);
}
Rect titleRect = new Rect(r.x + 44f, r.y + 6f, ((r.width - 44f) - 38f) - 4f, 16f);
if (editor != null)
{
editor.OnHeaderTitleGUI(titleRect, header);
}
else
{
GUI.Label(titleRect, header, EditorStyles.largeLabel);
}
if (editor != null)
{
editor.DrawHeaderHelpAndSettingsGUI(r);
}
Event current = Event.current;
if ((((editor != null) && !editor.IsEnabled()) && ((current.type == EventType.MouseDown) && (current.button == 1))) && r.Contains(current.mousePosition))
{
EditorUtility.DisplayObjectContextMenu(new Rect(current.mousePosition.x, current.mousePosition.y, 0f, 0f), editor.targets, 0);
current.Use();
}
return(lastRect);
}
Rect GetControlRectForSingleLine()
{
const float extraSpacing = 2f; // The shader properties needs a little more vertical spacing due to the mini texture field (looks cramped without)
return(EditorGUILayout.GetControlRect(true, EditorGUI.kSingleLineHeight + extraSpacing, EditorStyles.layerMaskField));
}
internal static void ShaderErrorListUI(UnityEngine.Object shader, ShaderError[] errors, ref Vector2 scrollPosition)
{
int num = errors.Length;
GUILayout.Space(5f);
GUILayout.Label(string.Format("Errors ({0}):", num), EditorStyles.boldLabel, new GUILayoutOption[0]);
int controlID = GUIUtility.GetControlID(CustomShaderInspector.kErrorViewHash, FocusType.Passive);
float minHeight = Mathf.Min(( float )num * 20f + 40f, 150f);
scrollPosition = GUILayout.BeginScrollView(scrollPosition, GUISkinEx.GetCurrentSkin().box, new GUILayoutOption[]
{
GUILayout.MinHeight(minHeight)
});
EditorGUIUtility.SetIconSize(new Vector2(16f, 16f));
float height = CustomShaderInspector.Styles.messageStyle.CalcHeight(EditorGUIUtilityEx.TempContent(CustomShaderInspector.Styles.errorIcon), 100f);
Event current = Event.current;
for (int i = 0; i < num; i++)
{
Rect controlRect = EditorGUILayout.GetControlRect(false, height, new GUILayoutOption[0]);
string message = errors[i].message;
string platform = errors[i].platform;
bool flag = errors[i].warning != 0;
string lastPathNameComponent = FileUtilEx.GetLastPathNameComponent(errors[i].file);
int line = errors[i].line;
if (current.type == EventType.MouseDown && current.button == 0 && controlRect.Contains(current.mousePosition))
{
GUIUtility.keyboardControl = controlID;
if (current.clickCount == 2)
{
string file = errors[i].file;
UnityEngine.Object @object = (!string.IsNullOrEmpty(file)) ? AssetDatabase.LoadMainAssetAtPath(file) : null;
AssetDatabase.OpenAsset(@object ?? shader, line);
GUIUtility.ExitGUI();
}
current.Use();
}
if (current.type == EventType.ContextClick && controlRect.Contains(current.mousePosition))
{
current.Use();
GenericMenu genericMenu = new GenericMenu();
int errorIndex = i;
genericMenu.AddItem(new GUIContent("Copy error text"), false, delegate
{
string text = errors[errorIndex].message;
if (!string.IsNullOrEmpty(errors[errorIndex].messageDetails))
{
text += '\n';
text += errors[errorIndex].messageDetails;
}
EditorGUIUtility.systemCopyBuffer = text;
});
genericMenu.ShowAsContext();
}
if (current.type == EventType.Repaint && (i & 1) == 0)
{
GUIStyle evenBackground = CustomShaderInspector.Styles.evenBackground;
evenBackground.Draw(controlRect, false, false, false, false);
}
Rect rect = controlRect;
rect.xMin = rect.xMax;
if (line > 0)
{
GUIContent content;
if (string.IsNullOrEmpty(lastPathNameComponent))
{
content = EditorGUIUtilityEx.TempContent(line.ToString(System.Globalization.CultureInfo.InvariantCulture));
}
else
{
content = EditorGUIUtilityEx.TempContent(lastPathNameComponent + ":" + line.ToString(System.Globalization.CultureInfo.InvariantCulture));
}
Vector2 vector = EditorStyles.miniLabel.CalcSize(content);
rect.xMin -= vector.x;
GUI.Label(rect, content, EditorStyles.miniLabel);
rect.xMin -= 2f;
if (rect.width < 30f)
{
rect.xMin = rect.xMax - 30f;
}
}
Rect position = rect;
position.width = 0f;
if (platform.Length > 0)
{
GUIContent content2 = EditorGUIUtilityEx.TempContent(platform);
Vector2 vector2 = EditorStyles.miniLabel.CalcSize(content2);
position.xMin -= vector2.x;
Color contentColor = GUI.contentColor;
GUI.contentColor = new Color(1f, 1f, 1f, 0.5f);
GUI.Label(position, content2, EditorStyles.miniLabel);
GUI.contentColor = contentColor;
position.xMin -= 2f;
}
Rect position2 = controlRect;
position2.xMax = position.xMin;
GUI.Label(position2, EditorGUIUtilityEx.TempContent(message, (!flag) ? CustomShaderInspector.Styles.errorIcon : CustomShaderInspector.Styles.warningIcon), CustomShaderInspector.Styles.messageStyle);
}
EditorGUIUtility.SetIconSize(Vector2.zero);
GUILayout.EndScrollView();
}
private void BakeSettings()
{
EditorGUILayout.LabelField(NavMeshEditorWindow.s_Styles.m_AgentSizeHeader, EditorStyles.boldLabel, new GUILayoutOption[0]);
Rect controlRect = EditorGUILayout.GetControlRect(false, 120f, new GUILayoutOption[0]);
this.DrawAgentDiagram(controlRect, this.m_AgentRadius.floatValue, this.m_AgentHeight.floatValue, this.m_AgentClimb.floatValue, this.m_AgentSlope.floatValue);
float num = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentRadiusContent, this.m_AgentRadius.floatValue, new GUILayoutOption[0]);
if (num >= 0.001f && !Mathf.Approximately(num - this.m_AgentRadius.floatValue, 0f))
{
this.m_AgentRadius.floatValue = num;
if (!this.m_ManualCellSize.boolValue)
{
this.m_CellSize.floatValue = 2f * this.m_AgentRadius.floatValue / 6f;
}
}
if (this.m_AgentRadius.floatValue < 0.05f && !this.m_ManualCellSize.boolValue)
{
EditorGUILayout.HelpBox("The agent radius you've set is really small, this can slow down the build.\nIf you intended to allow the agent to move close to the borders and walls, please adjust voxel size in advaced settings to ensure correct bake.", MessageType.Warning);
}
float num2 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentHeightContent, this.m_AgentHeight.floatValue, new GUILayoutOption[0]);
if (num2 >= 0.001f && !Mathf.Approximately(num2 - this.m_AgentHeight.floatValue, 0f))
{
this.m_AgentHeight.floatValue = num2;
}
EditorGUILayout.Slider(this.m_AgentSlope, 0f, 60f, NavMeshEditorWindow.s_Styles.m_AgentSlopeContent, new GUILayoutOption[0]);
if (this.m_AgentSlope.floatValue > 60f)
{
EditorGUILayout.HelpBox("The maximum slope should be set to less than " + 60f + " degrees to prevent NavMesh build artifacts on slopes. ", MessageType.Warning);
}
float num3 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentClimbContent, this.m_AgentClimb.floatValue, new GUILayoutOption[0]);
if (num3 >= 0f && !Mathf.Approximately(this.m_AgentClimb.floatValue - num3, 0f))
{
this.m_AgentClimb.floatValue = num3;
}
if (this.m_AgentClimb.floatValue >= this.m_AgentHeight.floatValue)
{
EditorGUILayout.HelpBox("Step height should be less than agent height.\nClamping step height to " + this.m_AgentHeight.floatValue + ".", MessageType.Warning);
}
float floatValue = this.m_CellSize.floatValue;
float num4 = floatValue * 0.5f;
int num5 = (int)Mathf.Ceil(this.m_AgentClimb.floatValue / num4);
float num6 = Mathf.Tan(this.m_AgentSlope.floatValue / 180f * 3.14159274f) * floatValue;
int num7 = (int)Mathf.Ceil(num6 * 2f / num4);
if (num7 > num5)
{
float f = (float)num5 * num4 / (floatValue * 2f);
float num8 = Mathf.Atan(f) / 3.14159274f * 180f;
float num9 = (float)(num7 - 1) * num4;
EditorGUILayout.HelpBox(string.Concat(new string[]
{
"Step Height conflicts with Max Slope. This makes some slopes unwalkable.\nConsider decreasing Max Slope to < ",
num8.ToString("0.0"),
" degrees.\nOr, increase Step Height to > ",
num9.ToString("0.00"),
"."
}), MessageType.Warning);
}
EditorGUILayout.Space();
EditorGUILayout.LabelField(NavMeshEditorWindow.s_Styles.m_OffmeshHeader, EditorStyles.boldLabel, new GUILayoutOption[0]);
bool flag = !InternalEditorUtility.HasProFeaturesEnabled();
if (flag)
{
EditorGUILayout.HelpBox("This is only available in the Pro version of Unity.", MessageType.Warning);
if (this.m_LedgeDropHeight.floatValue != 0f)
{
this.m_LedgeDropHeight.floatValue = 0f;
}
if (this.m_MaxJumpAcrossDistance.floatValue != 0f)
{
this.m_MaxJumpAcrossDistance.floatValue = 0f;
}
GUI.enabled = false;
}
float num10 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentDropContent, this.m_LedgeDropHeight.floatValue, new GUILayoutOption[0]);
if (num10 >= 0f && !Mathf.Approximately(num10 - this.m_LedgeDropHeight.floatValue, 0f))
{
this.m_LedgeDropHeight.floatValue = num10;
}
float num11 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentJumpContent, this.m_MaxJumpAcrossDistance.floatValue, new GUILayoutOption[0]);
if (num11 >= 0f && !Mathf.Approximately(num11 - this.m_MaxJumpAcrossDistance.floatValue, 0f))
{
this.m_MaxJumpAcrossDistance.floatValue = num11;
}
if (flag)
{
GUI.enabled = true;
}
EditorGUILayout.Space();
this.m_Advanced = GUILayout.Toggle(this.m_Advanced, NavMeshEditorWindow.s_Styles.m_AdvancedHeader, EditorStyles.foldout, new GUILayoutOption[0]);
if (this.m_Advanced)
{
EditorGUI.indentLevel++;
bool flag2 = EditorGUILayout.Toggle(NavMeshEditorWindow.s_Styles.m_ManualCellSizeContent, this.m_ManualCellSize.boolValue, new GUILayoutOption[0]);
if (flag2 != this.m_ManualCellSize.boolValue)
{
this.m_ManualCellSize.boolValue = flag2;
if (!flag2)
{
this.m_CellSize.floatValue = 2f * this.m_AgentRadius.floatValue / 6f;
}
}
EditorGUI.BeginDisabledGroup(!this.m_ManualCellSize.boolValue);
EditorGUI.indentLevel++;
float num12 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_CellSizeContent, this.m_CellSize.floatValue, new GUILayoutOption[0]);
if (num12 > 0f && !Mathf.Approximately(num12 - this.m_CellSize.floatValue, 0f))
{
this.m_CellSize.floatValue = Math.Max(0.01f, num12);
}
if (num12 < 0.01f)
{
EditorGUILayout.HelpBox("The voxel size should be larger than 0.01.", MessageType.Warning);
}
float num13 = (this.m_CellSize.floatValue <= 0f) ? 0f : (this.m_AgentRadius.floatValue / this.m_CellSize.floatValue);
EditorGUILayout.LabelField(" ", num13.ToString("0.00") + " voxels per agent radius", EditorStyles.miniLabel, new GUILayoutOption[0]);
if (this.m_ManualCellSize.boolValue)
{
float num14 = this.m_CellSize.floatValue * 0.5f;
if ((int)Mathf.Floor(this.m_AgentHeight.floatValue / num14) > 250)
{
EditorGUILayout.HelpBox("The number of voxels per agent height is too high. This will reduce the accuracy of the navmesh. Consider using voxel size of at least " + (this.m_AgentHeight.floatValue / 250f / 0.5f).ToString("0.000") + ".", MessageType.Warning);
}
if (num13 < 1f)
{
EditorGUILayout.HelpBox("The number of voxels per agent radius is too small. The agent may not avoid walls and ledges properly. Consider using voxel size of at least " + (this.m_AgentRadius.floatValue / 2f).ToString("0.000") + " (2 voxels per agent radius).", MessageType.Warning);
}
else
{
if (num13 > 8f)
{
EditorGUILayout.HelpBox("The number of voxels per agent radius is too high. It can cause excessive build times. Consider using voxel size closer to " + (this.m_AgentRadius.floatValue / 8f).ToString("0.000") + " (8 voxels per radius).", MessageType.Warning);
}
}
}
if (this.m_ManualCellSize.boolValue)
{
EditorGUILayout.HelpBox("Voxel size controls how accurately the navigation mesh is generated from the level geometry. A good voxel size is 2-4 voxels per agent radius. Making voxel size smaller will increase build time.", MessageType.None);
}
EditorGUI.indentLevel--;
EditorGUI.EndDisabledGroup();
EditorGUILayout.Space();
float num15 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_MinRegionAreaContent, this.m_MinRegionArea.floatValue, new GUILayoutOption[0]);
if (num15 >= 0f && num15 != this.m_MinRegionArea.floatValue)
{
this.m_MinRegionArea.floatValue = num15;
}
EditorGUILayout.Space();
bool flag3 = EditorGUILayout.Toggle(NavMeshEditorWindow.s_Styles.m_AgentPlacementContent, this.m_AccuratePlacement.boolValue, new GUILayoutOption[0]);
if (flag3 != this.m_AccuratePlacement.boolValue)
{
this.m_AccuratePlacement.boolValue = flag3;
}
EditorGUI.indentLevel--;
}
}
internal static Rect DrawHeaderGUI(Editor editor, string header, float leftMargin)
{
GUILayout.BeginHorizontal(Styles.inspectorBig);
GUILayout.Space(kImageSectionWidth - 6);
GUILayout.BeginVertical();
GUILayout.Space(19);
GUILayout.BeginHorizontal();
if (leftMargin > 0f)
{
GUILayout.Space(leftMargin);
}
if (editor)
{
editor.OnHeaderControlsGUI();
}
else
{
EditorGUILayout.GetControlRect();
}
GUILayout.EndHorizontal();
GUILayout.EndVertical();
GUILayout.EndHorizontal();
Rect fullRect = GUILayoutUtility.GetLastRect();
// Content rect
Rect r = new Rect(fullRect.x + leftMargin, fullRect.y, fullRect.width - leftMargin, fullRect.height);
// Icon
Rect iconRect = new Rect(r.x + 6, r.y + 6, 32, 32);
if (editor)
{
editor.OnHeaderIconGUI(iconRect);
}
else
{
GUI.Label(iconRect, AssetPreview.GetMiniTypeThumbnail(typeof(UnityObject)), Styles.centerStyle);
}
if (editor)
{
editor.DrawPostIconContent(iconRect);
}
// Title
Rect titleRect = new Rect(r.x + kImageSectionWidth, r.y + 6, r.width - kImageSectionWidth - 38 - 4, 16);
if (editor)
{
editor.OnHeaderTitleGUI(titleRect, header);
}
else
{
GUI.Label(titleRect, header, EditorStyles.largeLabel);
}
// Help and Settings
if (editor)
{
editor.DrawHeaderHelpAndSettingsGUI(r);
}
// Context Menu
Event evt = Event.current;
if (editor != null && evt.type == EventType.MouseDown && evt.button == 1 && r.Contains(evt.mousePosition))
{
EditorUtility.DisplayObjectContextMenu(new Rect(evt.mousePosition.x, evt.mousePosition.y, 0, 0), editor.targets, 0);
evt.Use();
}
return(fullRect);
}
public void RotationField(bool disabled)
{
Transform transform = this.targets[0] as Transform;
Vector3 localEulerAngles = transform.GetLocalEulerAngles(transform.rotationOrder);
if (((this.m_OldEulerAngles.x != localEulerAngles.x) || (this.m_OldEulerAngles.y != localEulerAngles.y)) || ((this.m_OldEulerAngles.z != localEulerAngles.z) || (this.m_OldRotationOrder != transform.rotationOrder)))
{
this.m_EulerAngles = transform.GetLocalEulerAngles(transform.rotationOrder);
this.m_OldRotationOrder = transform.rotationOrder;
}
bool flag = false;
bool flag2 = false;
for (int i = 1; i < this.targets.Length; i++)
{
Transform transform2 = this.targets[i] as Transform;
Vector3 vector2 = transform2.GetLocalEulerAngles(transform2.rotationOrder);
flag |= ((vector2.x != localEulerAngles.x) || (vector2.y != localEulerAngles.y)) || !(vector2.z == localEulerAngles.z);
flag2 |= transform2.rotationOrder != transform.rotationOrder;
}
Rect totalPosition = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight * (!EditorGUIUtility.wideMode ? ((float)2) : ((float)1)), new GUILayoutOption[0]);
GUIContent label = EditorGUI.BeginProperty(totalPosition, this.rotationContent, this.m_Rotation);
EditorGUI.showMixedValue = flag;
EditorGUI.BeginChangeCheck();
int id = GUIUtility.GetControlID(s_FoldoutHash, FocusType.Keyboard, totalPosition);
string str = "";
if (UnityEditor.AnimationMode.InAnimationMode() && (transform.rotationOrder != RotationOrder.OrderZXY))
{
if (flag2)
{
str = "Mixed";
}
else
{
str = transform.rotationOrder.ToString();
str = str.Substring(str.Length - 3);
}
label.text = label.text + " (" + str + ")";
}
totalPosition = EditorGUI.MultiFieldPrefixLabel(totalPosition, id, label, 3);
totalPosition.height = EditorGUIUtility.singleLineHeight;
using (new EditorGUI.DisabledScope(disabled))
{
this.m_EulerAngles = EditorGUI.Vector3Field(totalPosition, GUIContent.none, this.m_EulerAngles);
}
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObjects(this.targets, "Inspector");
foreach (Transform transform3 in this.targets)
{
transform3.SetLocalEulerAngles(this.m_EulerAngles, transform3.rotationOrder);
if (transform3.parent != null)
{
transform3.SendTransformChangedScale();
}
}
this.m_Rotation.serializedObject.SetIsDifferentCacheDirty();
}
EditorGUI.showMixedValue = false;
if (flag2)
{
EditorGUILayout.HelpBox("Transforms have different rotation orders, keyframes saved will have the same value but not the same local rotation", MessageType.Warning);
}
EditorGUI.EndProperty();
}
public void DrawProjection()
{
ProjectionType projectionType = orthographic.boolValue ? ProjectionType.Orthographic : ProjectionType.Perspective;
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = orthographic.hasMultipleDifferentValues;
projectionType = (ProjectionType)EditorGUILayout.EnumPopup(Styles.projection, projectionType);
EditorGUI.showMixedValue = false;
if (EditorGUI.EndChangeCheck())
{
orthographic.boolValue = (projectionType == ProjectionType.Orthographic);
}
if (!orthographic.hasMultipleDifferentValues)
{
if (projectionType == ProjectionType.Orthographic)
{
EditorGUILayout.PropertyField(orthographicSize, Styles.size);
}
else
{
float fovCurrentValue;
bool multipleDifferentFovValues = false;
bool isPhysicalCamera = projectionMatrixMode.intValue == (int)Camera.ProjectionMatrixMode.PhysicalPropertiesBased;
var rect = EditorGUILayout.GetControlRect();
var guiContent = EditorGUI.BeginProperty(rect, Styles.FOVAxisMode, fovAxisMode);
EditorGUI.showMixedValue = fovAxisMode.hasMultipleDifferentValues;
EditorGUI.BeginChangeCheck();
var fovAxisNewVal = (int)(Camera.FieldOfViewAxis)EditorGUI.EnumPopup(rect, guiContent, (Camera.FieldOfViewAxis)fovAxisMode.intValue);
if (EditorGUI.EndChangeCheck())
{
fovAxisMode.intValue = fovAxisNewVal;
}
EditorGUI.EndProperty();
bool fovAxisVertical = fovAxisMode.intValue == 0;
if (!fovAxisVertical && !fovAxisMode.hasMultipleDifferentValues)
{
var targets = m_SerializedObject.targetObjects;
var camera0 = targets[0] as Camera;
float aspectRatio = isPhysicalCamera ? sensorSize.vector2Value.x / sensorSize.vector2Value.y : camera0.aspect;
// camera.aspect is not serialized so we have to check all targets.
fovCurrentValue = Camera.VerticalToHorizontalFieldOfView(camera0.fieldOfView, aspectRatio);
if (m_SerializedObject.targetObjectsCount > 1)
{
foreach (Camera camera in targets)
{
if (camera.fieldOfView != fovCurrentValue)
{
multipleDifferentFovValues = true;
break;
}
}
}
}
else
{
fovCurrentValue = verticalFOV.floatValue;
multipleDifferentFovValues = fovAxisMode.hasMultipleDifferentValues;
}
EditorGUI.showMixedValue = multipleDifferentFovValues;
var content = EditorGUI.BeginProperty(EditorGUILayout.BeginHorizontal(), Styles.fieldOfView, verticalFOV);
EditorGUI.BeginDisabled(projectionMatrixMode.hasMultipleDifferentValues || isPhysicalCamera && (sensorSize.hasMultipleDifferentValues || fovAxisMode.hasMultipleDifferentValues));
EditorGUI.BeginChangeCheck();
var fovNewValue = EditorGUILayout.Slider(content, fovCurrentValue, 0.00001f, 179f);
var fovChanged = EditorGUI.EndChangeCheck();
EditorGUI.EndDisabled();
EditorGUILayout.EndHorizontal();
EditorGUI.EndProperty();
EditorGUI.showMixedValue = false;
content = EditorGUI.BeginProperty(EditorGUILayout.BeginHorizontal(), Styles.physicalCamera, projectionMatrixMode);
EditorGUI.showMixedValue = projectionMatrixMode.hasMultipleDifferentValues;
EditorGUI.BeginChangeCheck();
isPhysicalCamera = EditorGUILayout.Toggle(content, isPhysicalCamera);
if (EditorGUI.EndChangeCheck())
{
projectionMatrixMode.intValue = isPhysicalCamera ? (int)Camera.ProjectionMatrixMode.PhysicalPropertiesBased : (int)Camera.ProjectionMatrixMode.Implicit;
}
EditorGUILayout.EndHorizontal();
EditorGUI.EndProperty();
EditorGUI.showMixedValue = false;
if (isPhysicalCamera && !projectionMatrixMode.hasMultipleDifferentValues)
{
using (new EditorGUI.IndentLevelScope())
{
using (var horizontal = new EditorGUILayout.HorizontalScope())
using (new EditorGUI.PropertyScope(horizontal.rect, Styles.focalLength, focalLength))
using (var checkScope = new EditorGUI.ChangeCheckScope())
{
EditorGUI.showMixedValue = focalLength.hasMultipleDifferentValues;
float sensorLength = fovAxisVertical ? sensorSize.vector2Value.y : sensorSize.vector2Value.x;
float focalLengthVal = fovChanged ? Camera.FieldOfViewToFocalLength(fovNewValue, sensorLength) : focalLength.floatValue;
focalLengthVal = EditorGUILayout.FloatField(Styles.focalLength, focalLengthVal);
if (checkScope.changed || fovChanged)
{
focalLength.floatValue = focalLengthVal;
}
}
EditorGUI.showMixedValue = sensorSize.hasMultipleDifferentValues;
EditorGUI.BeginChangeCheck();
int filmGateIndex = Array.IndexOf(k_ApertureFormatValues, new Vector2((float)Math.Round(sensorSize.vector2Value.x, 3), (float)Math.Round(sensorSize.vector2Value.y, 3)));
if (filmGateIndex == -1)
{
filmGateIndex = EditorGUILayout.Popup(Styles.cameraType, k_ApertureFormatNames.Length - 1, k_ApertureFormatNames);
}
else
{
filmGateIndex = EditorGUILayout.Popup(Styles.cameraType, filmGateIndex, k_ApertureFormatNames);
}
EditorGUI.showMixedValue = false;
if (EditorGUI.EndChangeCheck() && filmGateIndex < k_ApertureFormatValues.Length)
{
sensorSize.vector2Value = k_ApertureFormatValues[filmGateIndex];
}
EditorGUILayout.PropertyField(sensorSize, Styles.sensorSize);
EditorGUILayout.PropertyField(lensShift, Styles.lensShift);
using (var horizontal = new EditorGUILayout.HorizontalScope())
using (var propertyScope = new EditorGUI.PropertyScope(horizontal.rect, Styles.gateFit, gateFit))
using (var checkScope = new EditorGUI.ChangeCheckScope())
{
int gateValue = (int)(Camera.GateFitMode)EditorGUILayout.EnumPopup(propertyScope.content, (Camera.GateFitMode)gateFit.intValue);
if (checkScope.changed)
{
gateFit.intValue = gateValue;
}
}
}
}
else if (fovChanged)
{
verticalFOV.floatValue = fovAxisVertical ? fovNewValue : Camera.HorizontalToVerticalFieldOfView(fovNewValue, (m_SerializedObject.targetObjects[0] as Camera).aspect);
}
EditorGUILayout.Space();
}
}
}
private void DoTimeline()
{
if (!m_ValidTransition)
{
return;
}
// get local durations
float srcStateDuration = (m_LeftStateTimeB - m_LeftStateTimeA) / (m_LeftStateWeightB - m_LeftStateWeightA);
float dstStateDuration = (m_RightStateTimeB - m_RightStateTimeA) / (m_RightStateWeightB - m_RightStateWeightA);
float transitionDuration = m_Transition.duration * (m_RefTransition.hasFixedDuration ? 1.0f : srcStateDuration);
// Set the timeline values
m_Timeline.SrcStartTime = 0f;
m_Timeline.SrcStopTime = srcStateDuration;
m_Timeline.SrcName = m_RefSrcState.name;
m_Timeline.HasExitTime = m_RefTransition.hasExitTime;
m_Timeline.srcLoop = m_SrcMotion ? m_SrcMotion.isLooping : false;
m_Timeline.dstLoop = m_DstMotion ? m_DstMotion.isLooping : false;
m_Timeline.TransitionStartTime = m_RefTransition.exitTime * srcStateDuration;
m_Timeline.TransitionStopTime = m_Timeline.TransitionStartTime + transitionDuration;
m_Timeline.Time = m_AvatarPreview.timeControl.currentTime;
m_Timeline.DstStartTime = m_Timeline.TransitionStartTime - m_RefTransition.offset * dstStateDuration;
m_Timeline.DstStopTime = m_Timeline.DstStartTime + dstStateDuration;
m_Timeline.SampleStopTime = m_AvatarPreview.timeControl.stopTime;
if (m_Timeline.TransitionStopTime == Mathf.Infinity)
{
m_Timeline.TransitionStopTime = Mathf.Min(m_Timeline.DstStopTime, m_Timeline.SrcStopTime);
}
m_Timeline.DstName = m_RefDstState.name;
m_Timeline.SrcPivotList = m_SrcPivotList;
m_Timeline.DstPivotList = m_DstPivotList;
// Do the timeline
Rect previewRect = EditorGUILayout.GetControlRect(false, 150, EditorStyles.label);
EditorGUI.BeginChangeCheck();
bool changedData = m_Timeline.DoTimeline(previewRect);
if (EditorGUI.EndChangeCheck())
{
if (changedData)
{
Undo.RegisterCompleteObjectUndo(m_RefTransition, "Edit Transition");
m_RefTransition.exitTime = m_Timeline.TransitionStartTime / m_Timeline.SrcDuration;
m_RefTransition.duration = m_Timeline.TransitionDuration / (m_RefTransition.hasFixedDuration ? 1.0f : m_Timeline.SrcDuration);
m_RefTransition.offset = (m_Timeline.TransitionStartTime - m_Timeline.DstStartTime) / m_Timeline.DstDuration;
}
m_AvatarPreview.timeControl.nextCurrentTime = Mathf.Clamp(m_Timeline.Time, 0, m_AvatarPreview.timeControl.stopTime);
}
}
public void RotationField(bool disabled)
{
Transform transform0 = targets[0] as Transform;
Vector3 eulerAngles0 = transform0.GetLocalEulerAngles(transform0.rotationOrder);
int differentRotationMask = 0b000;
bool differentRotationOrder = false;
for (int i = 1; i < targets.Length; i++)
{
Transform otherTransform = (targets[i] as Transform);
if (differentRotationMask != 0b111)
{
Vector3 otherLocalEuler = otherTransform.GetLocalEulerAngles(otherTransform.rotationOrder);
for (int j = 0; j < 3; j++)
{
if (otherLocalEuler[j] != eulerAngles0[j])
{
differentRotationMask |= 1 << j;
}
}
}
differentRotationOrder |= otherTransform.rotationOrder != transform0.rotationOrder;
}
Rect r = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight * (EditorGUIUtility.wideMode ? 1 : 2));
GUIContent label = EditorGUI.BeginProperty(r, rotationContent, m_Rotation);
m_EulerFloats[0].doubleVal = eulerAngles0.x;
m_EulerFloats[1].doubleVal = eulerAngles0.y;
m_EulerFloats[2].doubleVal = eulerAngles0.z;
int id = GUIUtility.GetControlID(s_FoldoutHash, FocusType.Keyboard, r);
if (AnimationMode.InAnimationMode() && transform0.rotationOrder != RotationOrder.OrderZXY)
{
string rotationLabel = differentRotationOrder ? "Mixed" : transform0.rotationOrder.ToString().Substring(RotationOrder.OrderXYZ.ToString().Length - 3);
label.text = label.text + " (" + rotationLabel + ")";
}
// Using manual 3 float fields here instead of MultiFloatField or Vector3Field
// since we want to query expression validity of each individually, and
// so that the label and the fields can be disabled separately, similar to
// regular property fields. Also want to avoid superfluous label, which
// creates a focus target even when there's no content (Case 953241).
r = EditorGUI.MultiFieldPrefixLabel(r, id, label, 3);
r.height = EditorGUIUtility.singleLineHeight;
int eulerChangedMask = 0;
using (new EditorGUI.DisabledScope(disabled))
{
var eCount = m_EulerFloats.Length;
float w = (r.width - (eCount - 1) * EditorGUI.kSpacingSubLabel) / eCount;
Rect nr = new Rect(r)
{
width = w
};
var prevWidth = EditorGUIUtility.labelWidth;
var prevIndent = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0;
for (int i = 0; i < m_EulerFloats.Length; i++)
{
EditorGUIUtility.labelWidth = EditorGUI.GetLabelWidth(s_XYZLabels[i]);
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = (differentRotationMask & (1 << i)) != 0;
EditorGUI.FloatField(nr, s_XYZLabels[i], ref m_EulerFloats[i]);
if (EditorGUI.EndChangeCheck() && m_EulerFloats[i].hasResult)
{
eulerChangedMask |= 1 << i;
}
if (Event.current.type == EventType.ContextClick && nr.Contains(Event.current.mousePosition))
{
var childProperty = m_Rotation.Copy();
childProperty.Next(true);
int childPropertyIndex = i;
while (childPropertyIndex > 0)
{
childProperty.Next(false);
childPropertyIndex--;
}
EditorGUI.DoPropertyContextMenu(childProperty);
Event.current.Use();
}
nr.x += w + EditorGUI.kSpacingSubLabel;
}
EditorGUIUtility.labelWidth = prevWidth;
EditorGUI.indentLevel = prevIndent;
}
if (eulerChangedMask != 0)
{
eulerAngles0 = new Vector3(
MathUtils.ClampToFloat(m_EulerFloats[0].doubleVal),
MathUtils.ClampToFloat(m_EulerFloats[1].doubleVal),
MathUtils.ClampToFloat(m_EulerFloats[2].doubleVal));
Undo.RecordObjects(targets, "Inspector"); // Generic undo title as remove duplicates will discard the name.
Undo.SetCurrentGroupName(string.Format("Set Rotation"));
for (var idx = 0; idx < targets.Length; ++idx)
{
var tr = targets[idx] as Transform;
if (tr == null)
{
continue;
}
var trEuler = tr.GetLocalEulerAngles(tr.rotationOrder);
// if we have any per-object expressions just entered, we need to evaluate
// it for each object with their own individual input value
for (int c = 0; c < 3; ++c)
{
if ((eulerChangedMask & (1 << c)) != 0)
{
if (m_EulerFloats[c].expression != null)
{
double trEulerComp = eulerAngles0[c];
if (m_EulerFloats[c].expression.Evaluate(ref trEulerComp, idx, targets.Length))
{
trEuler[c] = MathUtils.ClampToFloat(trEulerComp);
}
}
else
{
trEuler[c] = MathUtils.ClampToFloat(eulerAngles0[c]);
}
}
}
tr.SetLocalEulerAngles(trEuler, tr.rotationOrder);
if (tr.parent != null)
{
tr.SendTransformChangedScale(); // force scale update, needed if tr has non-uniformly scaled parent.
}
}
m_Rotation.serializedObject.SetIsDifferentCacheDirty();
}
EditorGUI.showMixedValue = false;
if (differentRotationOrder)
{
EditorGUILayout.HelpBox("Transforms have different rotation orders, keyframes saved will have the same value but not the same local rotation", MessageType.Warning);
}
EditorGUI.EndProperty();
}
// shared by compute shader inspector too
internal static void ShaderErrorListUI(Object shader, ShaderError[] errors, ref Vector2 scrollPosition)
{
int n = errors.Length;
GUILayout.Space(kSpace);
GUILayout.Label(string.Format("Errors ({0}):", n), EditorStyles.boldLabel);
int errorListID = GUIUtility.GetControlID(kErrorViewHash, FocusType.Passive);
float height = Mathf.Min(n * 20f + 40f, 150f);
scrollPosition = GUILayout.BeginScrollView(scrollPosition, GUISkin.current.box, GUILayout.MinHeight(height));
EditorGUIUtility.SetIconSize(new Vector2(16.0f, 16.0f));
float lineHeight = Styles.messageStyle.CalcHeight(EditorGUIUtility.TempContent(Styles.errorIcon), 100);
Event e = Event.current;
for (int i = 0; i < n; ++i)
{
Rect r = EditorGUILayout.GetControlRect(false, lineHeight);
string err = errors[i].message;
string plat = errors[i].platform;
bool warn = errors[i].warning != 0;
string fileName = FileUtil.GetLastPathNameComponent(errors[i].file);
int line = errors[i].line;
// Double click opens shader file at error line
if (e.type == EventType.MouseDown && e.button == 0 && r.Contains(e.mousePosition))
{
GUIUtility.keyboardControl = errorListID;
if (e.clickCount == 2)
{
string filePath = errors[i].file;
Object asset = string.IsNullOrEmpty(filePath) ? null : AssetDatabase.LoadMainAssetAtPath(filePath);
// if we don't have an asset and the filePath is an absolute path, it's an error in a system
// cginc - open that instead
if (asset == null && System.IO.Path.IsPathRooted(filePath))
{
ShaderUtil.OpenSystemShaderIncludeError(filePath, line);
}
else
{
AssetDatabase.OpenAsset(asset ?? shader, line);
}
GUIUtility.ExitGUI();
}
e.Use();
}
// Context menu, "Copy"
if (e.type == EventType.ContextClick && r.Contains(e.mousePosition))
{
e.Use();
var menu = new GenericMenu();
// need to copy current value to be used in delegate
// (C# closures close over variables, not their values)
var errorIndex = i;
menu.AddItem(EditorGUIUtility.TrTextContent("Copy error text"), false, delegate {
string errMsg = errors[errorIndex].message;
if (!string.IsNullOrEmpty(errors[errorIndex].messageDetails))
{
errMsg += '\n';
errMsg += errors[errorIndex].messageDetails;
}
EditorGUIUtility.systemCopyBuffer = errMsg;
});
menu.ShowAsContext();
}
// background
if (e.type == EventType.Repaint)
{
if ((i & 1) == 0)
{
GUIStyle st = Styles.evenBackground;
st.Draw(r, false, false, false, false);
}
}
// error location on the right side
Rect locRect = r;
locRect.xMin = locRect.xMax;
if (line > 0)
{
GUIContent gc;
if (string.IsNullOrEmpty(fileName))
{
gc = EditorGUIUtility.TempContent(line.ToString(CultureInfo.InvariantCulture));
}
else
{
gc = EditorGUIUtility.TempContent(fileName + ":" + line.ToString(CultureInfo.InvariantCulture));
}
// calculate size so we can right-align it
Vector2 size = EditorStyles.miniLabel.CalcSize(gc);
locRect.xMin -= size.x;
GUI.Label(locRect, gc, EditorStyles.miniLabel);
locRect.xMin -= 2;
// ensure some minimum width so that platform field next will line up
if (locRect.width < 30)
{
locRect.xMin = locRect.xMax - 30;
}
}
// platform to the left of it
Rect platRect = locRect;
platRect.width = 0;
if (plat.Length > 0)
{
GUIContent gc = EditorGUIUtility.TempContent(plat);
// calculate size so we can right-align it
Vector2 size = EditorStyles.miniLabel.CalcSize(gc);
platRect.xMin -= size.x;
// draw platform in dimmer color; it's often not very important information
Color oldColor = GUI.contentColor;
GUI.contentColor = new Color(1, 1, 1, 0.5f);
GUI.Label(platRect, gc, EditorStyles.miniLabel);
GUI.contentColor = oldColor;
platRect.xMin -= 2;
}
// error message
Rect msgRect = r;
msgRect.xMax = platRect.xMin;
GUI.Label(msgRect, EditorGUIUtility.TempContent(err, warn ? Styles.warningIcon : Styles.errorIcon), Styles.messageStyle);
}
EditorGUIUtility.SetIconSize(Vector2.zero);
GUILayout.EndScrollView();
}
internal override void ShowFreezeAxesControl()
{
Rect drawRect = EditorGUILayout.GetControlRect(true, EditorGUI.GetPropertyHeight(SerializedPropertyType.Vector3, s_Style.FreezeAxes), EditorStyles.toggle);
EditorGUI.MultiPropertyField(drawRect, s_Style.Axes, serializedObject.FindProperty("m_AffectScalingX"), s_Style.FreezeAxes);
}
public override void OnInspectorGUI()
{
serializedObject.Update();
// GUI.enabled hack because we don't want some controls to be disabled if the EditorSettings.asset is locked
// since some of the controls are not dependent on the Editor Settings asset. Unfortunately, this assumes
// that the editor will only be disabled because of version control locking which may change in the future.
var editorEnabled = GUI.enabled;
// Remove Settings are taken from preferences and NOT from the EditorSettings Asset.
// Only show them when editing the "global" settings
if (m_IsGlobalSettings)
{
ShowUnityRemoteGUI(editorEnabled);
}
bool collabEnabled = Collab.instance.IsCollabEnabledForCurrentProject();
GUILayout.Space(10);
int index = m_SerializationMode.intValue;
using (new EditorGUI.DisabledScope(!collabEnabled))
{
GUI.enabled = !collabEnabled;
GUILayout.Label(Content.assetSerialization, EditorStyles.boldLabel);
GUI.enabled = editorEnabled && !collabEnabled;
CreatePopupMenu("Mode", serializationPopupList, index, SetAssetSerializationMode);
}
if (collabEnabled)
{
EditorGUILayout.HelpBox("Asset Serialization is forced to Text when using Collaboration feature.", MessageType.Warning);
}
if (m_SerializationMode.intValue != (int)SerializationMode.ForceBinary)
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(m_SerializeInlineMappingsOnOneLine);
if (EditorGUI.EndChangeCheck() && m_IsGlobalSettings)
{
EditorSettings.serializeInlineMappingsOnOneLine = m_SerializeInlineMappingsOnOneLine.boolValue;
}
}
GUILayout.Space(10);
GUI.enabled = true;
GUILayout.Label(Content.defaultBehaviorMode, EditorStyles.boldLabel);
GUI.enabled = editorEnabled;
index = Mathf.Clamp(m_DefaultBehaviorMode.intValue, 0, behaviorPopupList.Length - 1);
CreatePopupMenu(Content.mode.text, behaviorPopupList, index, SetDefaultBehaviorMode);
// CacheServer is part asset and preferences. Only show UI in case of Global Settings editing.
if (m_IsGlobalSettings)
{
var wasEnabled = GUI.enabled;
GUI.enabled = true;
DoCacheServerSettings();
GUI.enabled = wasEnabled;
}
GUILayout.Space(10);
GUI.enabled = true;
GUILayout.Label("Prefab Editing Environments", EditorStyles.boldLabel);
GUI.enabled = editorEnabled;
{
EditorGUI.BeginChangeCheck();
var scene = m_PrefabRegularEnvironment.objectReferenceValue as SceneAsset;
scene = (SceneAsset)EditorGUILayout.ObjectField("Regular Environment", scene, typeof(SceneAsset), false);
if (EditorGUI.EndChangeCheck())
{
m_PrefabRegularEnvironment.objectReferenceValue = scene;
if (m_IsGlobalSettings)
{
EditorSettings.prefabRegularEnvironment = scene;
}
}
}
{
EditorGUI.BeginChangeCheck();
var scene = m_PrefabUIEnvironment.objectReferenceValue as SceneAsset;
scene = (SceneAsset)EditorGUILayout.ObjectField("UI Environment", scene, typeof(SceneAsset), false);
if (EditorGUI.EndChangeCheck())
{
m_PrefabUIEnvironment.objectReferenceValue = scene;
if (m_IsGlobalSettings)
{
EditorSettings.prefabUIEnvironment = scene;
}
}
}
GUILayout.Space(10);
GUI.enabled = true;
GUILayout.Label(Content.graphics, EditorStyles.boldLabel);
GUI.enabled = editorEnabled;
if (m_IsGlobalSettings)
{
EditorGUI.BeginChangeCheck();
bool showRes = LightmapVisualization.showResolution;
showRes = EditorGUILayout.Toggle(Content.showLightmapResolutionOverlay, showRes);
if (EditorGUI.EndChangeCheck())
{
LightmapVisualization.showResolution = showRes;
}
}
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(m_UseLegacyProbeSampleCount, Content.useLegacyProbeSampleCount);
if (EditorGUI.EndChangeCheck())
{
if (m_IsGlobalSettings)
{
EditorSettings.useLegacyProbeSampleCount = m_UseLegacyProbeSampleCount.boolValue;
}
EditorApplication.RequestRepaintAllViews();
}
var rect = EditorGUILayout.GetControlRect();
EditorGUI.BeginProperty(rect, Content.enableCookiesInLightmapper, m_DisableCookiesInLightmapper);
EditorGUI.BeginChangeCheck();
bool enableCookiesInLightmapperValue = !m_DisableCookiesInLightmapper.boolValue;
enableCookiesInLightmapperValue = EditorGUI.Toggle(rect, Content.enableCookiesInLightmapper, enableCookiesInLightmapperValue);
if (EditorGUI.EndChangeCheck())
{
m_DisableCookiesInLightmapper.boolValue = !enableCookiesInLightmapperValue;
if (m_IsGlobalSettings)
{
EditorSettings.enableCookiesInLightmapper = enableCookiesInLightmapperValue;
}
EditorApplication.RequestRepaintAllViews();
}
EditorGUI.EndProperty();
GUILayout.Space(10);
GUI.enabled = true;
GUILayout.Label(Content.spritePacker, EditorStyles.boldLabel);
GUI.enabled = editorEnabled;
// Legacy Packer has been deprecated.
index = Mathf.Clamp(m_SpritePackerMode.intValue - spritePackDeprecatedEnums, 0, spritePackerPopupList.Length - 1);
CreatePopupMenu(Content.mode.text, spritePackerPopupList, index, SetSpritePackerMode);
if (m_SpritePackerMode.intValue == (int)SpritePackerMode.SpriteAtlasV2)
{
var message = "Sprite Atlas V2 (Experimental) supports CacheServer with Importer workflow. Please take a backup of your project before switching to V2.";
EditorGUILayout.HelpBox(message, MessageType.Info, true);
}
DoProjectGenerationSettings();
DoEtcTextureCompressionSettings();
DoLineEndingsSettings();
DoStreamingSettings();
DoShaderCompilationSettings();
DoEnterPlayModeSettings();
serializedObject.ApplyModifiedProperties();
}
internal void DrawRenderUI()
{
var previewRect = EditorGUILayout.GetControlRect(GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
GUI.Box(previewRect, GUIContent.none);
m_ZoomablePreview.BeginViewGUI();
bool first = true;
if (m_UGUIProfilerTreeViewState != null && Event.current.type == EventType.Repaint)
{
IList <int> selection = m_TreeViewControl.GetSelection();
if (selection.Count > 0)
{
IList <TreeViewItem> selectedRows = m_TreeViewControl.GetRowsFromIDs(selection);
foreach (TreeViewItem row in selectedRows)
{
Texture2D image = null;
var batch = row as UISystemProfilerTreeView.BatchTreeViewItem;
var previewRenderMode = PreviewRenderMode;
if (m_RenderService == null)
{
m_RenderService = new UISystemProfilerRenderService();
}
if (batch != null)
{
image = m_RenderService.GetThumbnail(currentFrame, batch.renderDataIndex, 1, previewRenderMode != Styles.RenderMode.Standard);
}
var canvas = row as UISystemProfilerTreeView.CanvasTreeViewItem;
if (canvas != null)
{
image = m_RenderService.GetThumbnail(currentFrame, canvas.info.renderDataIndex, canvas.info.renderDataCount,
previewRenderMode != Styles.RenderMode.Standard);
}
if (previewRenderMode == Styles.RenderMode.CompositeOverdraw)
{
if (m_CompositeOverdrawMaterial == null)
{
Shader shader = Shader.Find("Hidden/UI/CompositeOverdraw");
if (shader)
{
m_CompositeOverdrawMaterial = new Material(shader);
}
}
}
if (image)
{
float w = image.width;
float h = image.height;
float scaleFactor = Math.Min(previewRect.width / w, previewRect.height / h);
w *= scaleFactor;
h *= scaleFactor;
var imageRect = new Rect(previewRect.x + (previewRect.width - w) / 2, previewRect.y + (previewRect.height - h) / 2,
w,
h);
if (first)
{
first = false;
m_ZoomablePreview.rect = imageRect;
var previewBackground = PreviewBackground;
if (previewBackground == Styles.PreviewBackgroundType.Checkerboard)
{
EditorGUI.DrawTransparencyCheckerTexture(m_ZoomablePreview.drawRect, ScaleMode.ScaleAndCrop, 0f);
}
else
{
EditorGUI.DrawRect(m_ZoomablePreview.drawRect,
previewBackground == Styles.PreviewBackgroundType.Black ? Color.black : Color.white);
}
}
Graphics.DrawTexture(m_ZoomablePreview.drawRect, image, m_ZoomablePreview.shownArea, 0, 0, 0, 0,
previewRenderMode == Styles.RenderMode.CompositeOverdraw ? m_CompositeOverdrawMaterial : EditorGUI.transparentMaterial);
}
if (previewRenderMode != Styles.RenderMode.Standard)
{
break;
}
UnityEngine.Object.DestroyImmediate(image);
}
}
}
if (first && Event.current.type == EventType.Repaint)
{
m_ZoomablePreview.rect = previewRect;
}
m_ZoomablePreview.EndViewGUI();
}
public void RotationField(bool disabled)
{
Transform t = targets[0] as Transform;
Vector3 localEuler = t.GetLocalEulerAngles(t.rotationOrder);
if (
m_OldEulerAngles.x != localEuler.x ||
m_OldEulerAngles.y != localEuler.y ||
m_OldEulerAngles.z != localEuler.z ||
m_OldRotationOrder != t.rotationOrder
)
{
m_EulerAngles = t.GetLocalEulerAngles(t.rotationOrder);
m_OldRotationOrder = t.rotationOrder;
}
var targetRotationOrder = t.rotationOrder;
bool differentRotation = false;
bool differentRotationOrder = false;
for (int i = 1; i < targets.Length; i++)
{
Transform otherTransform = (targets[i] as Transform);
if (!differentRotation)
{
Vector3 otherLocalEuler = otherTransform.GetLocalEulerAngles(otherTransform.rotationOrder);
differentRotation = (otherLocalEuler.x != localEuler.x || otherLocalEuler.y != localEuler.y || otherLocalEuler.z != localEuler.z);
}
differentRotationOrder |= otherTransform.rotationOrder != targetRotationOrder;
}
Rect r = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight * (EditorGUIUtility.wideMode ? 1 : 2));
GUIContent label = EditorGUI.BeginProperty(r, rotationContent, m_Rotation);
m_EulerFloats[0] = m_EulerAngles.x;
m_EulerFloats[1] = m_EulerAngles.y;
m_EulerFloats[2] = m_EulerAngles.z;
EditorGUI.showMixedValue = differentRotation;
EditorGUI.BeginChangeCheck();
int id = GUIUtility.GetControlID(s_FoldoutHash, FocusType.Keyboard, r);
string rotationLabel = "";
if (AnimationMode.InAnimationMode() && t.rotationOrder != RotationOrder.OrderZXY)
{
if (differentRotationOrder)
{
rotationLabel = "Mixed";
}
else
{
rotationLabel = (t.rotationOrder).ToString();
rotationLabel = rotationLabel.Substring(rotationLabel.Length - 3);
}
label.text = label.text + " (" + rotationLabel + ")";
}
// Using MultiFieldPrefixLabel/MultiFloatField here instead of Vector3Field
// so that the label and the float fields can be disabled separately,
// similar to other property-driven controls
// Using MultiFloatField instead of Vector3Field to avoid superfluous label
// (which creates a focus target even when there's no content (Case 953241))
r = EditorGUI.MultiFieldPrefixLabel(r, id, label, 3);
r.height = EditorGUIUtility.singleLineHeight;
using (new EditorGUI.DisabledScope(disabled))
EditorGUI.MultiFloatField(r, s_XYZLabels, m_EulerFloats);
if (EditorGUI.EndChangeCheck())
{
m_EulerAngles = new Vector3(m_EulerFloats[0], m_EulerFloats[1], m_EulerFloats[2]);
Undo.RecordObjects(targets, "Inspector"); // Generic undo title to be consistent with Position and Scale changes.
foreach (Transform tr in targets)
{
tr.SetLocalEulerAngles(m_EulerAngles, tr.rotationOrder);
if (tr.parent != null)
{
tr.SendTransformChangedScale(); // force scale update, needed if tr has non-uniformly scaled parent.
}
}
m_Rotation.serializedObject.SetIsDifferentCacheDirty();
}
EditorGUI.showMixedValue = false;
if (differentRotationOrder)
{
EditorGUILayout.HelpBox("Transforms have different rotation orders, keyframes saved will have the same value but not the same local rotation", MessageType.Warning);
}
EditorGUI.EndProperty();
}
internal void DrawUIPane(ProfilerWindow win, ProfilerArea profilerArea, UISystemProfilerChart detailsChart)
{
InitIfNeeded(win);
EditorGUILayout.BeginVertical();
if (m_DetachedPreview != null && !m_DetachedPreview)
{
m_DetachedPreview = null;
}
bool detachPreview = m_DetachedPreview;
if (!detachPreview)
{
GUILayout.BeginHorizontal(); // Horizontal render
SplitterGUILayout.BeginHorizontalSplit(m_TreePreviewHorizontalSplitState);
}
var treeRect = EditorGUILayout.GetControlRect(GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
treeRect.yMin -= EditorGUIUtility.standardVerticalSpacing;
var newVisibleFrame = win.GetActiveVisibleFrameIndex();
if (m_TreeViewControl.property == null || (m_UGUIProfilerTreeViewState != null && m_UGUIProfilerTreeViewState.lastFrame != newVisibleFrame))
{
if (m_TreeViewControl.property != null)
{
m_TreeViewControl.property.Dispose();
}
m_TreeViewControl.property = win.CreateProperty();
m_UGUIProfilerTreeViewState.lastFrame = newVisibleFrame;
currentFrame = ProfilerDriver.lastFrameIndex - newVisibleFrame;
m_TreeViewControl.Reload();
}
if (m_TreeViewControl.property != null && !m_TreeViewControl.property.frameDataReady)
{
m_TreeViewControl.property.Dispose();
m_TreeViewControl.property = null;
GUI.Label(treeRect, Styles.noData);
}
else
{
m_TreeViewControl.OnGUI(treeRect);
}
if (!detachPreview)
{
using (new EditorGUILayout.VerticalScope())
{
using (new EditorGUILayout.HorizontalScope(EditorStyles.toolbar, GUILayout.ExpandWidth(true)))
{
detachPreview = GUILayout.Button(Styles.contentDetachRender, EditorStyles.toolbarButton, GUILayout.Width(75));
if (detachPreview)
{
m_DetachedPreview = EditorWindow.GetWindow <UISystemPreviewWindow>();
m_DetachedPreview.profiler = this;
m_DetachedPreview.Show();
}
DrawPreviewToolbarButtons();
}
DrawRenderUI();
}
GUILayout.EndHorizontal(); // Horizontal render
SplitterGUILayout.EndHorizontalSplit(); // m_TreePreviewHorizontalSplitState
// Draw separator
EditorGUI.DrawRect(
new Rect(m_TreePreviewHorizontalSplitState.realSizes[0] + treeRect.xMin, treeRect.y, 1, treeRect.height),
Styles.separatorColor);
}
EditorGUILayout.EndVertical();
if (m_DetachedPreview)
{
m_DetachedPreview.Repaint();
}
}
internal static Rect DrawHeaderGUI(Editor editor, string header, float leftMargin)
{
GUILayout.BeginHorizontal(BaseStyles.inspectorBig);
GUILayout.Space(kImageSectionWidth - 6);
GUILayout.BeginVertical();
GUILayout.Space(k_HeaderHeight);
GUILayout.BeginHorizontal();
if (leftMargin > 0f)
GUILayout.Space(leftMargin);
if (editor)
editor.OnHeaderControlsGUI();
else
EditorGUILayout.GetControlRect();
GUILayout.EndHorizontal();
GUILayout.EndVertical();
GUILayout.EndHorizontal();
Rect fullRect = GUILayoutUtility.GetLastRect();
// Content rect
Rect r = new Rect(fullRect.x + leftMargin, fullRect.y, fullRect.width - leftMargin, fullRect.height);
// Icon
Rect iconRect = new Rect(r.x + 6, r.y + 6, 32, 32);
if (editor)
editor.OnHeaderIconGUI(iconRect);
else
GUI.Label(iconRect, AssetPreview.GetMiniTypeThumbnail(typeof(UnityObject)), BaseStyles.centerStyle);
if (editor)
editor.DrawPostIconContent(iconRect);
// Help and Settings
Rect titleRect;
var titleHeight = EditorGUI.lineHeight;
if (editor)
{
Rect helpAndSettingsRect = editor.DrawHeaderHelpAndSettingsGUI(r);
float rectX = r.x + kImageSectionWidth;
titleRect = new Rect(rectX, r.y + 6, (helpAndSettingsRect.x - rectX) - 4, titleHeight);
}
else
titleRect = new Rect(r.x + kImageSectionWidth, r.y + 6, r.width - kImageSectionWidth, titleHeight);
// Title
if (editor)
editor.OnHeaderTitleGUI(titleRect, header);
else
GUI.Label(titleRect, header, EditorStyles.largeLabel);
// Context Menu; process event even for disabled UI
var wasEnabled = GUI.enabled;
GUI.enabled = true;
Event evt = Event.current;
var showMenu = editor != null && evt.type == EventType.MouseDown && evt.button == 1 && r.Contains(evt.mousePosition);
GUI.enabled = wasEnabled;
if (showMenu)
{
EditorUtility.DisplayObjectContextMenu(new Rect(evt.mousePosition.x, evt.mousePosition.y, 0, 0), editor.targets, 0);
evt.Use();
}
return fullRect;
}
void MixedLightingGUI()
{
if (!SupportedRenderingFeatures.IsLightmapBakeTypeSupported(LightmapBakeType.Baked))
{
return;
}
m_ShowMixedLightsSettings = EditorGUILayout.FoldoutTitlebar(m_ShowMixedLightsSettings, Styles.MixedLightsLabel, true);
if (m_ShowMixedLightsSettings)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_EnabledBakedGI, Styles.EnableBaked);
if (!m_EnabledBakedGI.boolValue)
{
EditorGUILayout.HelpBox(Styles.BakedGIDisabledInfo.text, MessageType.Info);
}
using (new EditorGUI.DisabledScope(!m_EnabledBakedGI.boolValue))
{
bool mixedGISupported = SupportedRenderingFeatures.IsLightmapBakeTypeSupported(LightmapBakeType.Mixed);
using (new EditorGUI.DisabledScope(!mixedGISupported))
{
var rect = EditorGUILayout.GetControlRect();
EditorGUI.BeginProperty(rect, Styles.MixedLightMode, m_MixedBakeMode);
rect = EditorGUI.PrefixLabel(rect, Styles.MixedLightMode);
int index = Math.Max(0, Array.IndexOf(Styles.MixedModeValues, m_MixedBakeMode.intValue));
if (EditorGUI.DropdownButton(rect, Styles.MixedModeStrings[index], FocusType.Passive))
{
var menu = new GenericMenu();
for (int i = 0; i < Styles.MixedModeValues.Length; i++)
{
int value = Styles.MixedModeValues[i];
bool selected = (value == m_MixedBakeMode.intValue);
if (!SupportedRenderingFeatures.IsMixedLightingModeSupported((MixedLightingMode)value))
{
menu.AddDisabledItem(Styles.MixedModeStrings[i], selected);
}
else
{
menu.AddItem(Styles.MixedModeStrings[i], selected, OnMixedModeSelected, value);
}
}
menu.DropDown(rect);
}
EditorGUI.EndProperty();
if (mixedGISupported)
{
if (!SupportedRenderingFeatures.IsMixedLightingModeSupported((MixedLightingMode)m_MixedBakeMode.intValue))
{
string fallbackMode = Styles.MixedModeStrings[(int)SupportedRenderingFeatures.FallbackMixedLightingMode()].text;
EditorGUILayout.HelpBox(Styles.MixedModeNotSupportedWarning.text + fallbackMode, MessageType.Warning);
}
else if (m_EnabledBakedGI.boolValue)
{
EditorGUILayout.HelpBox(Styles.HelpStringsMixed[m_MixedBakeMode.intValue].text, MessageType.Info);
}
}
if (m_MixedBakeMode.intValue == (int)MixedLightingMode.Subtractive)
{
EditorGUILayout.PropertyField(m_SubtractiveShadowColor, Styles.SubtractiveShadowColor);
m_RenderSettingsSO.ApplyModifiedProperties();
EditorGUILayout.Space();
}
}
}
EditorGUI.indentLevel--;
EditorGUILayout.Space();
}
}
public override void OnInspectorGUI()
{
if (!target)
{
return;
}
if (m_CustomUI != null && m_CustomUITerrain != null &&
m_CustomUI.OnTerrainLayerGUI(target as TerrainLayer, m_CustomUITerrain))
{
return;
}
serializedObject.Update();
var curMaskMap = m_MaskMapTexture.objectReferenceValue as Texture2D;
bool maskMapUsed = m_MaskMapUsed || curMaskMap != null;
var r = EditorGUILayout.GetControlRect(true, EditorGUI.kObjectFieldThumbnailHeight);
var diffuseLabel = m_ShowMaskMap ? (maskMapUsed ? m_DiffuseMapMaskMapEnabledText : m_DiffuseMapText) : s_Styles.diffuseTexture;
EditorGUI.BeginProperty(r, diffuseLabel, m_DiffuseTexture);
EditorGUI.BeginChangeCheck();
var diffuseTexture = EditorGUI.ObjectField(r, diffuseLabel, m_DiffuseTexture.objectReferenceValue as Texture2D, typeof(Texture2D), false) as Texture2D;
if (EditorGUI.EndChangeCheck())
{
m_DiffuseTexture.objectReferenceValue = diffuseTexture;
}
EditorGUI.EndProperty();
TerrainLayerUtility.ValidateDiffuseTextureUI(diffuseTexture);
r = EditorGUILayout.GetControlRect(true, EditorGUI.kObjectFieldThumbnailHeight);
EditorGUI.BeginProperty(r, s_Styles.normalMapTexture, m_NormalMapTexture);
EditorGUI.BeginChangeCheck();
var normalMapTexture = EditorGUI.ObjectField(r, s_Styles.normalMapTexture, m_NormalMapTexture.objectReferenceValue as Texture2D, typeof(Texture2D), false) as Texture2D;
if (EditorGUI.EndChangeCheck())
{
m_NormalMapTexture.objectReferenceValue = normalMapTexture;
m_NormalMapHasCorrectTextureType = TerrainLayerUtility.CheckNormalMapTextureType(normalMapTexture);
}
EditorGUI.EndProperty();
TerrainLayerUtility.ValidateNormalMapTextureUI(normalMapTexture, m_NormalMapHasCorrectTextureType);
if (normalMapTexture != null)
{
++EditorGUI.indentLevel;
EditorGUILayout.PropertyField(m_NormalScale);
--EditorGUI.indentLevel;
EditorGUILayout.Space();
}
if (m_ShowMaskMap)
{
r = EditorGUILayout.GetControlRect(true, EditorGUI.kObjectFieldThumbnailHeight);
EditorGUI.BeginProperty(r, m_MaskMapText, m_MaskMapTexture);
EditorGUI.BeginChangeCheck();
var maskMapTexture = EditorGUI.ObjectField(r, m_MaskMapText, curMaskMap, typeof(Texture2D), false) as Texture2D;
if (EditorGUI.EndChangeCheck())
{
m_MaskMapTexture.objectReferenceValue = maskMapTexture;
}
EditorGUI.EndProperty();
TerrainLayerUtility.ValidateMaskMapTextureUI(maskMapTexture);
if (maskMapUsed)
{
++EditorGUI.indentLevel;
m_ShowMaskRemap = EditorGUILayout.Foldout(m_ShowMaskRemap, s_Styles.channelRemapping);
if (m_ShowMaskRemap)
{
DoMinMaxLabels(s_Styles.min, s_Styles.max, EditorStyles.miniLabel);
DoMinMaxFloatFields(m_MaskRemapRText, EditorStyles.miniLabel, m_MaskRemapMinR, m_MaskRemapMaxR, EditorStyles.miniTextField);
DoMinMaxFloatFields(m_MaskRemapGText, EditorStyles.miniLabel, m_MaskRemapMinG, m_MaskRemapMaxG, EditorStyles.miniTextField);
DoMinMaxFloatFields(m_MaskRemapBText, EditorStyles.miniLabel, m_MaskRemapMinB, m_MaskRemapMaxB, EditorStyles.miniTextField);
DoMinMaxFloatFields(m_MaskRemapAText, EditorStyles.miniLabel, m_MaskRemapMinA, m_MaskRemapMaxA, EditorStyles.miniTextField);
}
--EditorGUI.indentLevel;
}
}
EditorGUILayout.Space();
EditorGUILayout.PropertyField(m_Specular);
EditorGUILayout.Slider(m_Metallic, 0.0f, 1.0f);
EditorGUILayout.Slider(m_Smoothness, 0.0f, 1.0f);
EditorGUILayout.Space();
TerrainLayerUtility.TilingSettingsUI(m_TileSize, m_TileOffset);
serializedObject.ApplyModifiedProperties();
}
protected void DisplayFoldout()
{
Dictionary <Transform, bool> bones = modelBones;
EditorGUIUtility.SetIconSize(Vector2.one * 16);
// Legend
EditorGUILayout.BeginHorizontal();
GUI.color = Color.grey;
GUILayout.Label(styles.dotFrameDotted.image, GUILayout.ExpandWidth(false));
GUI.color = Color.white;
GUILayout.Label("Optional Bone", GUILayout.ExpandWidth(true));
EditorGUILayout.EndHorizontal();
// Avatar body part has nothing to show
for (int i = 1; i < m_BodyPartToggle.Length; i++)
{
if (m_BodyPartToggle[i])
{
// Unfold body part ui whenever a new selection is made.
if ((s_DirtySelection == true) && (m_BodyPartFoldout[i] == false))
{
for (int j = 0; j < m_BodyPartHumanBone[i].Length; j++)
{
int boneIndex = m_BodyPartHumanBone[i][j];
if (s_SelectedBoneIndex == boneIndex)
{
m_BodyPartFoldout[i] = true;
}
}
}
m_BodyPartFoldout[i] = GUILayout.Toggle(m_BodyPartFoldout[i], styles.BodyPartMapping[i], EditorStyles.foldout);
EditorGUI.indentLevel++;
if (m_BodyPartFoldout[i])
{
for (int j = 0; j < m_BodyPartHumanBone[i].Length; j++)
{
int boneIndex = m_BodyPartHumanBone[i][j];
if (boneIndex == -1)
{
continue;
}
AvatarSetupTool.BoneWrapper bone = m_Bones[boneIndex];
string displayBoneName = bone.humanBoneName;
// @TODO@MECANIM: do properly
if ((BodyPart)i == BodyPart.RightArm || (BodyPart)i == BodyPart.RightFingers || (BodyPart)i == BodyPart.RightLeg)
{
displayBoneName = displayBoneName.Replace("Right", "");
}
if ((BodyPart)i == BodyPart.LeftArm || (BodyPart)i == BodyPart.LeftFingers || (BodyPart)i == BodyPart.LeftLeg)
{
displayBoneName = displayBoneName.Replace("Left", "");
}
displayBoneName = ObjectNames.NicifyVariableName(displayBoneName);
Rect r = EditorGUILayout.GetControlRect();
Rect selectRect = r;
selectRect.width -= 15;
Rect rect = new Rect(r.x + EditorGUI.indent, r.y - 1, AvatarSetupTool.BoneWrapper.kIconSize, AvatarSetupTool.BoneWrapper.kIconSize);
bone.BoneDotGUI(rect, selectRect, boneIndex, true, false, true, serializedObject, this);
r.xMin += AvatarSetupTool.BoneWrapper.kIconSize;
Transform newBoneTransform = EditorGUI.ObjectField(r, new GUIContent(displayBoneName), bone.bone, typeof(Transform), true) as Transform;
if (newBoneTransform != bone.bone)
{
Undo.RegisterCompleteObjectUndo(this, "Avatar mapping modified");
bone.bone = newBoneTransform;
bone.Serialize(m_HumanBoneArray);
// User adding a bone manually, if it not in the modelBones dict, we must explictly add it
if (newBoneTransform != null && !bones.ContainsKey(newBoneTransform))
{
bones[newBoneTransform] = true;
}
}
if (!string.IsNullOrEmpty(bone.error))
{
GUILayout.BeginHorizontal();
GUILayout.Space(EditorGUI.indent + AvatarSetupTool.BoneWrapper.kIconSize + 4);
GUILayout.Label(bone.error, s_Styles.errorLabel);
GUILayout.EndHorizontal();
}
}
}
EditorGUI.indentLevel--;
}
}
s_DirtySelection = false;
EditorGUIUtility.SetIconSize(Vector2.zero);
}
internal void RenderLightProbeUsage(int selectionCount, Renderer renderer, bool useMiniStyle, bool lightProbeAllowed)
{
using (new EditorGUI.DisabledScope(!lightProbeAllowed))
{
if (lightProbeAllowed)
{
// LightProbeUsage has non-sequential enum values. Extra care is to be taken.
if (useMiniStyle)
{
EditorGUI.BeginChangeCheck();
var newValue = ModuleUI.GUIEnumPopup(m_LightProbeUsageStyle, (LightProbeUsage)m_LightProbeUsage.intValue, m_LightProbeUsage);
if (EditorGUI.EndChangeCheck())
{
m_LightProbeUsage.intValue = (int)(LightProbeUsage)newValue;
}
}
else
{
Rect r = EditorGUILayout.GetControlRect(true, EditorGUI.kSingleLineHeight, EditorStyles.popup);
EditorGUI.BeginProperty(r, m_LightProbeUsageStyle, m_LightProbeUsage);
EditorGUI.BeginChangeCheck();
var newValue = EditorGUI.EnumPopup(r, m_LightProbeUsageStyle, (LightProbeUsage)m_LightProbeUsage.intValue);
if (EditorGUI.EndChangeCheck())
{
m_LightProbeUsage.intValue = (int)(LightProbeUsage)newValue;
}
EditorGUI.EndProperty();
}
if (!m_LightProbeUsage.hasMultipleDifferentValues)
{
if (m_LightProbeUsage.intValue == (int)LightProbeUsage.UseProxyVolume &&
SupportedRenderingFeatures.active.lightProbeProxyVolumes)
{
EditorGUI.indentLevel++;
if (useMiniStyle)
{
ModuleUI.GUIObject(m_LightProbeVolumeOverrideStyle, m_LightProbeVolumeOverride);
}
else
{
EditorGUILayout.PropertyField(m_LightProbeVolumeOverride, m_LightProbeVolumeOverrideStyle);
}
EditorGUI.indentLevel--;
}
else if (m_LightProbeUsage.intValue == (int)LightProbeUsage.CustomProvided)
{
EditorGUI.indentLevel++;
if (!Application.isPlaying)
{
EditorGUILayout.HelpBox(m_LightProbeCustomNote.text, MessageType.Info);
}
else if (!renderer.HasPropertyBlock())
{
EditorGUILayout.HelpBox(m_LightProbeCustomNote.text, MessageType.Error);
}
EditorGUI.indentLevel--;
}
}
}
else
{
if (useMiniStyle)
{
ModuleUI.GUIEnumPopup(m_LightProbeUsageStyle, LightProbeUsage.Off, m_LightProbeUsage);
}
else
{
EditorGUILayout.EnumPopup(m_LightProbeUsageStyle, LightProbeUsage.Off);
}
}
}
var tree = renderer.GetComponent <Tree>();
if ((tree != null) && (m_LightProbeUsage.intValue == (int)LightProbeUsage.UseProxyVolume))
{
EditorGUI.indentLevel++;
EditorGUILayout.HelpBox(m_LightProbeVolumeUnsupportedOnTreesNote.text, MessageType.Warning);
EditorGUI.indentLevel--;
}
}
private void BakeSettings()
{
EditorGUILayout.LabelField(NavMeshEditorWindow.s_Styles.m_AgentSizeHeader, EditorStyles.boldLabel, new GUILayoutOption[0]);
Rect controlRect = EditorGUILayout.GetControlRect(false, 120f, new GUILayoutOption[0]);
this.DrawAgentDiagram(controlRect, this.m_AgentRadius.floatValue, this.m_AgentHeight.floatValue, this.m_AgentClimb.floatValue, this.m_AgentSlope.floatValue);
float num = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentRadiusContent, this.m_AgentRadius.floatValue, new GUILayoutOption[0]);
if (num >= 0.001f && !Mathf.Approximately(num - this.m_AgentRadius.floatValue, 0f))
{
this.m_AgentRadius.floatValue = num;
if (!this.m_ManualCellSize.boolValue)
{
this.m_CellSize.floatValue = 2f * this.m_AgentRadius.floatValue / 6f;
}
}
if (this.m_AgentRadius.floatValue < 0.05f && !this.m_ManualCellSize.boolValue)
{
EditorGUILayout.HelpBox("The agent radius you've set is really small, this can slow down the build.\nIf you intended to allow the agent to move close to the borders and walls, please adjust voxel size in advaced settings to ensure correct bake.", MessageType.Warning);
}
float num2 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentHeightContent, this.m_AgentHeight.floatValue, new GUILayoutOption[0]);
if (num2 >= 0.001f && !Mathf.Approximately(num2 - this.m_AgentHeight.floatValue, 0f))
{
this.m_AgentHeight.floatValue = num2;
}
EditorGUILayout.Slider(this.m_AgentSlope, 0f, 60f, NavMeshEditorWindow.s_Styles.m_AgentSlopeContent, new GUILayoutOption[0]);
if (this.m_AgentSlope.floatValue > 60f)
{
EditorGUILayout.HelpBox("The maximum slope should be set to less than " + 60f + " degrees to prevent NavMesh build artifacts on slopes. ", MessageType.Warning);
}
float num3 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentClimbContent, this.m_AgentClimb.floatValue, new GUILayoutOption[0]);
if (num3 >= 0f && !Mathf.Approximately(this.m_AgentClimb.floatValue - num3, 0f))
{
this.m_AgentClimb.floatValue = num3;
}
if (this.m_AgentClimb.floatValue > this.m_AgentHeight.floatValue)
{
EditorGUILayout.HelpBox("Step height should be less than agent height.\nClamping step height to " + this.m_AgentHeight.floatValue + " internally when baking.", MessageType.Warning);
}
float floatValue = this.m_CellSize.floatValue;
float num4 = floatValue * 0.5f;
int num5 = (int)Mathf.Ceil(this.m_AgentClimb.floatValue / num4);
float num6 = Mathf.Tan(this.m_AgentSlope.floatValue / 180f * 3.14159274f) * floatValue;
int num7 = (int)Mathf.Ceil(num6 * 2f / num4);
if (num7 > num5)
{
float f = (float)num5 * num4 / (floatValue * 2f);
float num8 = Mathf.Atan(f) / 3.14159274f * 180f;
float num9 = (float)(num7 - 1) * num4;
EditorGUILayout.HelpBox(string.Concat(new string[]
{
"Step Height conflicts with Max Slope. This makes some slopes unwalkable.\nConsider decreasing Max Slope to < ",
num8.ToString("0.0"),
" degrees.\nOr, increase Step Height to > ",
num9.ToString("0.00"),
"."
}), MessageType.Warning);
}
EditorGUILayout.Space();
EditorGUILayout.LabelField(NavMeshEditorWindow.s_Styles.m_OffmeshHeader, EditorStyles.boldLabel, new GUILayoutOption[0]);
float num10 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentDropContent, this.m_LedgeDropHeight.floatValue, new GUILayoutOption[0]);
if (num10 >= 0f && !Mathf.Approximately(num10 - this.m_LedgeDropHeight.floatValue, 0f))
{
this.m_LedgeDropHeight.floatValue = num10;
}
float num11 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentJumpContent, this.m_MaxJumpAcrossDistance.floatValue, new GUILayoutOption[0]);
if (num11 >= 0f && !Mathf.Approximately(num11 - this.m_MaxJumpAcrossDistance.floatValue, 0f))
{
this.m_MaxJumpAcrossDistance.floatValue = num11;
}
EditorGUILayout.Space();
this.m_Advanced = GUILayout.Toggle(this.m_Advanced, NavMeshEditorWindow.s_Styles.m_AdvancedHeader, EditorStyles.foldout, new GUILayoutOption[0]);
if (this.m_Advanced)
{
EditorGUI.indentLevel++;
bool flag = EditorGUILayout.Toggle(NavMeshEditorWindow.s_Styles.m_ManualCellSizeContent, this.m_ManualCellSize.boolValue, new GUILayoutOption[0]);
if (flag != this.m_ManualCellSize.boolValue)
{
this.m_ManualCellSize.boolValue = flag;
if (!flag)
{
this.m_CellSize.floatValue = 2f * this.m_AgentRadius.floatValue / 6f;
}
}
EditorGUI.BeginDisabledGroup(!this.m_ManualCellSize.boolValue);
EditorGUI.indentLevel++;
float num12 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_CellSizeContent, this.m_CellSize.floatValue, new GUILayoutOption[0]);
if (num12 > 0f && !Mathf.Approximately(num12 - this.m_CellSize.floatValue, 0f))
{
this.m_CellSize.floatValue = Math.Max(0.01f, num12);
}
if (num12 < 0.01f)
{
EditorGUILayout.HelpBox("The voxel size should be larger than 0.01.", MessageType.Warning);
}
float num13 = (this.m_CellSize.floatValue <= 0f) ? 0f : (this.m_AgentRadius.floatValue / this.m_CellSize.floatValue);
EditorGUILayout.LabelField(" ", num13.ToString("0.00") + " voxels per agent radius", EditorStyles.miniLabel, new GUILayoutOption[0]);
if (this.m_ManualCellSize.boolValue)
{
float num14 = this.m_CellSize.floatValue * 0.5f;
if ((int)Mathf.Floor(this.m_AgentHeight.floatValue / num14) > 250)
{
EditorGUILayout.HelpBox("The number of voxels per agent height is too high. This will reduce the accuracy of the navmesh. Consider using voxel size of at least " + (this.m_AgentHeight.floatValue / 250f / 0.5f).ToString("0.000") + ".", MessageType.Warning);
}
if (num13 < 1f)
{
EditorGUILayout.HelpBox("The number of voxels per agent radius is too small. The agent may not avoid walls and ledges properly. Consider using voxel size of at least " + (this.m_AgentRadius.floatValue / 2f).ToString("0.000") + " (2 voxels per agent radius).", MessageType.Warning);
}
else if (num13 > 8f)
{
EditorGUILayout.HelpBox("The number of voxels per agent radius is too high. It can cause excessive build times. Consider using voxel size closer to " + (this.m_AgentRadius.floatValue / 8f).ToString("0.000") + " (8 voxels per radius).", MessageType.Warning);
}
}
if (this.m_ManualCellSize.boolValue)
{
EditorGUILayout.HelpBox("Voxel size controls how accurately the navigation mesh is generated from the level geometry. A good voxel size is 2-4 voxels per agent radius. Making voxel size smaller will increase build time.", MessageType.None);
}
EditorGUI.indentLevel--;
EditorGUI.EndDisabledGroup();
EditorGUILayout.Space();
float num15 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_MinRegionAreaContent, this.m_MinRegionArea.floatValue, new GUILayoutOption[0]);
if (num15 >= 0f && num15 != this.m_MinRegionArea.floatValue)
{
this.m_MinRegionArea.floatValue = num15;
}
EditorGUILayout.Space();
bool flag2 = EditorGUILayout.Toggle(NavMeshEditorWindow.s_Styles.m_AgentPlacementContent, this.m_AccuratePlacement.boolValue, new GUILayoutOption[0]);
if (flag2 != this.m_AccuratePlacement.boolValue)
{
this.m_AccuratePlacement.boolValue = flag2;
}
EditorGUI.indentLevel--;
}
if (Unsupported.IsDeveloperBuild())
{
EditorGUILayout.Space();
GUILayout.Label("Internal Bake Debug Options", EditorStyles.boldLabel, new GUILayoutOption[0]);
EditorGUILayout.HelpBox("Note: The debug visualization is build during bake, so you'll need to bake for these settings to take effect.", MessageType.None);
bool showAutoOffMeshLinkSampling = NavMeshVisualizationSettings.showAutoOffMeshLinkSampling;
if (showAutoOffMeshLinkSampling != EditorGUILayout.Toggle(new GUIContent("Show Auto-Off-MeshLink Sampling"), showAutoOffMeshLinkSampling, new GUILayoutOption[0]))
{
NavMeshVisualizationSettings.showAutoOffMeshLinkSampling = !showAutoOffMeshLinkSampling;
}
bool showVoxels = NavMeshVisualizationSettings.showVoxels;
if (showVoxels != EditorGUILayout.Toggle(new GUIContent("Show Voxels"), showVoxels, new GUILayoutOption[0]))
{
NavMeshVisualizationSettings.showVoxels = !showVoxels;
}
bool showWalkable = NavMeshVisualizationSettings.showWalkable;
if (showWalkable != EditorGUILayout.Toggle(new GUIContent("Show Walkable"), showWalkable, new GUILayoutOption[0]))
{
NavMeshVisualizationSettings.showWalkable = !showWalkable;
}
bool showRawContours = NavMeshVisualizationSettings.showRawContours;
if (showRawContours != EditorGUILayout.Toggle(new GUIContent("Show Raw Contours"), showRawContours, new GUILayoutOption[0]))
{
NavMeshVisualizationSettings.showRawContours = !showRawContours;
}
bool showContours = NavMeshVisualizationSettings.showContours;
if (showContours != EditorGUILayout.Toggle(new GUIContent("Show Contours"), showContours, new GUILayoutOption[0]))
{
NavMeshVisualizationSettings.showContours = !showContours;
}
bool showInputs = NavMeshVisualizationSettings.showInputs;
if (showInputs != EditorGUILayout.Toggle(new GUIContent("Show Inputs"), showInputs, new GUILayoutOption[0]))
{
NavMeshVisualizationSettings.showInputs = !showInputs;
}
if (GUILayout.Button("Clear Visualiation Data", new GUILayoutOption[0]))
{
NavMeshVisualizationSettings.ClearVisualizationData();
NavMeshEditorWindow.RepaintSceneAndGameViews();
}
EditorGUILayout.Space();
}
}
public void RenderSettings(bool showLightmapSettings)
{
if (m_SerializedObject == null || m_GameObjectsSerializedObject == null || m_GameObjectsSerializedObject.targetObjectsCount == 0)
{
return;
}
var settings = Lightmapping.GetLightingSettingsOrDefaultsFallback();
var lightmapper = settings.lightmapper;
bool bakedGI = settings.bakedGI;
bool realtimeGI = settings.realtimeGI;
m_GameObjectsSerializedObject.Update();
ReceiveGI receiveGI = (ReceiveGI)m_ReceiveGI.intValue;
bool contributeGI = isPreset ? true : (m_StaticEditorFlags.intValue & (int)StaticEditorFlags.ContributeGI) != 0;
bool showEnlightenSettings = isPreset || isPrefabAsset || realtimeGI || (bakedGI && lightmapper == LightingSettings.Lightmapper.Enlighten);
// m_ReceiveGI might still be set to Lightmaps, but LightProbes is shown in the inspector since the contributeGI if off.
// In this case we still have to mark it as "multiple values" even though both have "Lightmaps" as the value, but one is showing a grayed out "Light Probes" in the UI
bool showMixedGIValue = m_ReceiveGI.hasMultipleDifferentValues || (isPreset ? false : ((m_StaticEditorFlags.hasMultipleDifferentValuesBitwise & (int)StaticEditorFlags.ContributeGI) != 0));
showLightingSettings.value = EditorGUILayout.BeginFoldoutHeaderGroup(showLightingSettings.value, Styles.lightingSettings);
if (showLightingSettings.value)
{
EditorGUI.indentLevel += 1;
EditorGUILayout.PropertyField(m_CastShadows, Styles.castShadows, true);
bool isDeferredRenderingPath = SceneView.IsUsingDeferredRenderingPath();
if (SupportedRenderingFeatures.active.receiveShadows)
{
using (new EditorGUI.DisabledScope(isDeferredRenderingPath))
EditorGUILayout.PropertyField(m_ReceiveShadows, Styles.receiveShadows, true);
}
if (!showLightmapSettings)
{
EditorGUI.indentLevel -= 1;
EditorGUILayout.EndFoldoutHeaderGroup();
return;
}
using (new EditorGUI.DisabledScope(isPreset))
contributeGI = ContributeGISettings();
if (isPreset)
{
EditorGUILayout.HelpBox(Styles.isPresetInfo.text, MessageType.Info);
}
if (!(bakedGI || realtimeGI) && contributeGI && !isPrefabAsset && !isPreset)
{
EditorGUILayout.HelpBox(Styles.giNotEnabledInfo.text, MessageType.Info);
EditorGUI.indentLevel -= 1;
EditorGUILayout.EndFoldoutHeaderGroup();
return;
}
if (contributeGI)
{
var rect = EditorGUILayout.GetControlRect();
EditorGUI.BeginProperty(rect, Styles.receiveGITitle, m_ReceiveGI);
EditorGUI.BeginChangeCheck();
receiveGI = (ReceiveGI)EditorGUI.IntPopup(rect, Styles.receiveGITitle, (int)receiveGI, Styles.receiveGILightmapStrings, Styles.receiveGILightmapValues);
if (EditorGUI.EndChangeCheck())
{
m_ReceiveGI.intValue = (int)receiveGI;
}
EditorGUI.EndProperty();
if (showEnlightenSettings)
{
EditorGUILayout.PropertyField(m_ImportantGI, Styles.importantGI);
}
if (receiveGI == ReceiveGI.LightProbes && !showMixedGIValue)
{
LightmapScaleGUI(true, Styles.albedoScale, true);
}
}
else
{
using (new EditorGUI.DisabledScope(true))
{
EditorGUI.showMixedValue = showMixedGIValue;
receiveGI = (ReceiveGI)EditorGUILayout.IntPopup(Styles.receiveGITitle, (int)ReceiveGI.LightProbes, Styles.receiveGILightmapStrings, Styles.receiveGILightmapValues);
EditorGUI.showMixedValue = false;
}
}
EditorGUI.indentLevel -= 1;
}
EditorGUILayout.EndFoldoutHeaderGroup();
if (showLightmapSettings && contributeGI && receiveGI == ReceiveGI.Lightmaps && !showMixedGIValue)
{
this.showLightmapSettings.value = EditorGUILayout.BeginFoldoutHeaderGroup(this.showLightmapSettings.value, Styles.lightmapSettings);
if (this.showLightmapSettings.value)
{
EditorGUI.indentLevel += 1;
bool showProgressiveSettings = isPreset || isPrefabAsset || (bakedGI && lightmapper != LightingSettings.Lightmapper.Enlighten);
LightmapScaleGUI(true, Styles.scaleInLightmap, false);
if (showProgressiveSettings)
{
EditorGUILayout.PropertyField(m_StitchLightmapSeams, Styles.stitchLightmapSeams);
}
LightmapParametersGUI(m_LightmapParameters, Styles.lightmapParameters);
if (showEnlightenSettings)
{
RendererUVSettings();
}
if ((m_Renderers != null) && (m_Renderers.Length > 0))
{
ShowAtlasGUI(m_Renderers[0].GetInstanceID(), true);
ShowRealtimeLMGUI(m_Renderers[0]);
if (Lightmapping.HasZeroAreaMesh(m_Renderers[0]))
{
EditorGUILayout.HelpBox(Styles.zeroAreaPackingMesh.text, MessageType.Warning);
}
DisplayMeshWarning();
if (showEnlightenSettings)
{
if (Lightmapping.HasClampedResolution(m_Renderers[0]))
{
EditorGUILayout.HelpBox(Styles.clampedPackingResolution.text, MessageType.Warning);
}
}
if (showProgressiveSettings)
{
if (Lightmapping.HasUVOverlaps(m_Renderers[0]))
{
EditorGUILayout.HelpBox(Styles.uvOverlap.text, MessageType.Warning);
}
}
}
EditorGUI.indentLevel -= 1;
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
}
internal override void ShowFreezeAxesControl()
{
Rect controlRect = EditorGUILayout.GetControlRect(true, EditorGUI.GetPropertyHeight(SerializedPropertyType.Vector3, RotationConstraintEditor.s_Style.FreezeAxes), EditorStyles.toggle, new GUILayoutOption[0]);
EditorGUI.MultiPropertyField(controlRect, RotationConstraintEditor.s_Style.Axes, base.serializedObject.FindProperty("m_AffectRotationX"), RotationConstraintEditor.s_Style.FreezeAxes);
}
public override void OnInspectorGUI()
{
EditorGUILayout.LabelField(Styles.sketchUpLabel, EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_GenerateBackFace, Styles.generateBackFaceLabel);
EditorGUILayout.PropertyField(m_MergeCoplanarFaces, Styles.mergeCoplanarFaces);
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel(Styles.fileUnitLabel);
var oldIndent = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0;
GUILayout.Label("1");
EditorGUILayout.Popup(m_FileUnit, Styles.measurementOptions, GUIContent.Temp(""), GUILayout.MaxWidth(100));
lengthToUnit = ConvertGlobalScaleToUnit((EFileUnit)m_FileUnit.intValue, m_GlobalScale.floatValue);
GUILayout.Label("=");
lengthToUnit = EditorGUILayout.FloatField(lengthToUnit);
m_GlobalScale.floatValue = CovertUnitToGlobalScale((EFileUnit)m_FileUnit.intValue, lengthToUnit);
EditorGUI.indentLevel = oldIndent;
EditorGUILayout.EndHorizontal();
using (new EditorGUI.DisabledScope(true))
{
EditorGUILayout.FloatField(Styles.longitudeLabel, m_Longitude.floatValue);
EditorGUILayout.FloatField(Styles.latitudeLabel, m_Latitude.floatValue);
EditorGUILayout.FloatField(Styles.northCorrectionLabel, m_NorthCorrection.floatValue);
}
if (assetTarget == null)
{
EditorGUILayout.PropertyField(m_SelectedNodes);
}
else
{
EditorGUILayout.BeginHorizontal();
var size = GUI.skin.button.CalcSize(Styles.selectNodeButton);
var rect = EditorGUI.IndentedRect(EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight, GUI.skin.button, GUILayout.Width(size.x + EditorGUI.indent)));
if (GUI.Button(rect, Styles.selectNodeButton))
{
SketchUpNodeInfo[] nodes = m_Target.GetNodes();
SketchUpImportDlg.Launch(nodes, this);
GUIUtility.ExitGUI();
}
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.PropertyField(m_ImportCameras, ModelImporterModelEditor.Styles.ImportCameras);
MeshesGUI();
EditorGUILayout.LabelField(ModelImporterModelEditor.Styles.Geometry, EditorStyles.boldLabel);
using (var horizontal = new EditorGUILayout.HorizontalScope())
{
using (var prop = new EditorGUI.PropertyScope(horizontal.rect, ModelImporterModelEditor.Styles.IndexFormatLabel, m_IndexFormat))
{
EditorGUI.BeginChangeCheck();
var newValue = (int)(ModelImporterIndexFormat)EditorGUILayout.EnumPopup(prop.content, (ModelImporterIndexFormat)m_IndexFormat.intValue);
if (EditorGUI.EndChangeCheck())
{
m_IndexFormat.intValue = newValue;
}
}
}
UvsGUI();
}
public override void OnInspectorGUI()
{
serializedObject.Update();
AgentTypePopupInternal(m_AgentTypeID);
EditorGUILayout.PropertyField(m_BaseOffset, Styles.BaseOffset);
EditorGUILayout.Space();
EditorGUILayout.LabelField(Styles.AgentSteeringHeader, EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_Speed, Styles.Speed);
EditorGUILayout.PropertyField(m_AngularSpeed, Styles.AngularSpeed);
EditorGUILayout.PropertyField(m_Acceleration, Styles.Acceleration);
EditorGUILayout.PropertyField(m_StoppingDistance, Styles.StoppingDistance);
EditorGUILayout.PropertyField(m_AutoBraking, Styles.AutoBraking);
EditorGUILayout.Space();
EditorGUILayout.LabelField(Styles.AgentAvoidanceHeader, EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_Radius, Styles.Radius);
EditorGUILayout.PropertyField(m_Height, Styles.Height);
EditorGUILayout.PropertyField(m_ObstacleAvoidanceType, Styles.Quality);
EditorGUILayout.PropertyField(m_AvoidancePriority, Styles.Priority);
EditorGUILayout.Space();
EditorGUILayout.LabelField(Styles.AgentPathFindingHeader, EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_AutoTraverseOffMeshLink, Styles.AutoTraverseOffMeshLink);
EditorGUILayout.PropertyField(m_AutoRepath, Styles.AutoRepath);
//Initially needed data
var areaNames = GameObjectUtility.GetNavMeshAreaNames();
var currentMask = m_WalkableMask.longValue;
var compressedMask = 0;
if (currentMask == 0xffffffff)
{
compressedMask = ~0;
}
else
{
//Need to find the index as the list of names will compress out empty areas
for (var i = 0; i < areaNames.Length; i++)
{
var areaIndex = GameObjectUtility.GetNavMeshAreaFromName(areaNames[i]);
if (((1 << areaIndex) & currentMask) != 0)
{
compressedMask = compressedMask | (1 << i);
}
}
}
var position = EditorGUILayout.GetControlRect();
EditorGUI.BeginProperty(position, GUIContent.none, m_WalkableMask);
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = m_WalkableMask.hasMultipleDifferentValues;
var areaMask = EditorGUI.MaskField(position, Styles.AreaMask, compressedMask, areaNames, EditorStyles.layerMaskField);
EditorGUI.showMixedValue = false;
if (EditorGUI.EndChangeCheck())
{
if (areaMask == ~0)
{
m_WalkableMask.longValue = 0xffffffff;
}
else
{
uint newMask = 0;
for (var i = 0; i < areaNames.Length; i++)
{
//If the bit has been set in the compacted mask
if (((areaMask >> i) & 1) != 0)
{
//Find out the 'real' layer from the name, then set it in the new mask
newMask = newMask | (uint)(1 << GameObjectUtility.GetNavMeshAreaFromName(areaNames[i]));
}
}
m_WalkableMask.longValue = newMask;
}
}
EditorGUI.EndProperty();
serializedObject.ApplyModifiedProperties();
}
