private void AgentSettings()
{
if (m_Agents == null)
{
InitAgents();
}
m_NavMeshProjectSettingsObject.Update();
if (m_AgentsList.index < 0)
{
m_AgentsList.index = 0;
}
using (new GUILayout.VerticalScope(EditorStyles.defaultContentMargins))
{
m_AgentsList.DoLayoutList();
}
if (m_AgentsList.index >= 0 && m_AgentsList.index < m_Agents.arraySize)
{
SerializedProperty nameProp = m_SettingNames.GetArrayElementAtIndex(m_AgentsList.index);
SerializedProperty selectedAgent = m_Agents.GetArrayElementAtIndex(m_AgentsList.index);
SerializedProperty radiusProp = selectedAgent.FindPropertyRelative("agentRadius");
SerializedProperty heightProp = selectedAgent.FindPropertyRelative("agentHeight");
SerializedProperty stepHeightProp = selectedAgent.FindPropertyRelative("agentClimb");
SerializedProperty maxSlopeProp = selectedAgent.FindPropertyRelative("agentSlope");
const float kDiagramHeight = 120.0f;
Rect agentDiagramRect = EditorGUILayout.GetControlRect(false, kDiagramHeight);
NavMeshEditorHelpers.DrawAgentDiagram(agentDiagramRect, radiusProp.floatValue, heightProp.floatValue, stepHeightProp.floatValue, maxSlopeProp.floatValue);
EditorGUILayout.PropertyField(nameProp, EditorGUIUtility.TempContent("Name"));
EditorGUILayout.PropertyField(radiusProp, EditorGUIUtility.TempContent("Radius"));
EditorGUILayout.PropertyField(heightProp, EditorGUIUtility.TempContent("Height"));
EditorGUILayout.PropertyField(stepHeightProp, EditorGUIUtility.TempContent("Step Height"));
const float kMaxSlopeAngle = 60.0f;
EditorGUILayout.Slider(maxSlopeProp, 0.0f, kMaxSlopeAngle, EditorGUIUtility.TempContent("Max Slope"));
}
EditorGUILayout.Space();
m_NavMeshProjectSettingsObject.ApplyModifiedProperties();
}
private static void AgentTypePopupInternal(string labelName, SerializedProperty agentTypeID)
{
int num = -1;
int settingsCount = NavMesh.GetSettingsCount();
string[] array = new string[settingsCount + 2];
for (int i = 0; i < settingsCount; i++)
{
int agentTypeID2 = NavMesh.GetSettingsByIndex(i).agentTypeID;
string settingsNameFromID = NavMesh.GetSettingsNameFromID(agentTypeID2);
array[i] = settingsNameFromID;
if (agentTypeID2 == agentTypeID.intValue)
{
num = i;
}
}
array[settingsCount] = "";
array[settingsCount + 1] = "Open Agent Settings...";
if (num == -1)
{
EditorGUILayout.HelpBox("Agent Type invalid.", MessageType.Warning);
}
Rect controlRect = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight, new GUILayoutOption[0]);
EditorGUI.BeginProperty(controlRect, GUIContent.none, agentTypeID);
EditorGUI.BeginChangeCheck();
num = EditorGUI.Popup(controlRect, labelName, num, array);
if (EditorGUI.EndChangeCheck())
{
if (num >= 0 && num < settingsCount)
{
int agentTypeID3 = NavMesh.GetSettingsByIndex(num).agentTypeID;
agentTypeID.intValue = agentTypeID3;
}
else if (num == settingsCount + 1)
{
NavMeshEditorHelpers.OpenAgentSettings(-1);
}
}
EditorGUI.EndProperty();
}
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") + " 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") + " 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") + ".", 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") + " (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") + " (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();
}
private void SceneBakeSettings()
{
if (this.m_SettingsObject == null || this.m_SettingsObject.targetObject == null)
{
this.InitSceneBakeSettings();
}
this.m_SettingsObject.Update();
EditorGUILayout.LabelField(NavMeshEditorWindow.s_Styles.m_AgentSizeHeader, EditorStyles.boldLabel, new GUILayoutOption[0]);
Rect controlRect = EditorGUILayout.GetControlRect(false, 120f, new GUILayoutOption[0]);
NavMeshEditorHelpers.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.indentLevel++;
using (new EditorGUI.DisabledScope(!this.m_ManualCellSize.boolValue))
{
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--;
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--;
}
this.m_SettingsObject.ApplyModifiedProperties();
}