//------------------------------------------------------------------------------------------------------------------
void Start()
{
//#if UNITY_EDITOR
// UnityEditor.SceneView.FocusWindowIfItsOpen(typeof(UnityEditor.SceneView));
//#endif
this.m_charProxy = GameObject.Find("GAMEOBJ_CharProxy");
this.m_mainPath = "Prefab/_Level_A/";
#if UNITY_EDITOR
LoadCrossPieces();
LoadCornerPieces();
LoadLinePieces();
LoadDeadEndPieces();
LoadTriplePieces();
LoadNonePiece();
CreateRandomDungeon();
MoveAllMapLinkedToFirstPiecePivot(0, 0);
ScrambleTileVersions();
ModifyTilePatterns();
PopulatePiecesAtDungeon();
PlaceAgentAtStartPointInNavmesh();
NavMeshBuilder.ClearAllNavMeshes();
NavMeshBuilder.BuildNavMesh();
#endif
}
void BuildAllNavMesh(float agentRadius)
{
map.SetActive(false);
ClearTmp();
SetAgentRadius(agentRadius);
xingzouceng.GetComponent <Renderer>().enabled = true;
if (feixingceng != null)
{
feixingceng.GetComponent <Renderer>().enabled = true;
}
if (qinggong != null)
{
qinggong.GetComponent <Renderer>().enabled = true;
}
NavMeshBuilder.ClearAllNavMeshes();
NavMeshBuilder.BuildNavMesh();
xingzouceng.GetComponent <Renderer>().enabled = false;
if (feixingceng != null)
{
feixingceng.GetComponent <Renderer>().enabled = false;
}
if (qinggong != null)
{
qinggong.GetComponent <Renderer>().enabled = false;
}
map.SetActive(true);
}
public override void Execute()
{
Retain();
NavMeshBuilder.ClearAllNavMeshes();
NavMeshBuilder.BuildNavMesh();
Release();
}
public void NavmeshOptionHandler()
{
if (ClearCache)
{
NavMeshBuilder.ClearAllNavMeshes();
Last_Clear = true;
}
else
{
Last_Clear = false;
}
}
void OnGUI()
{
GUILayout.BeginVertical();
// instructions
GUILayout.Label("Navigation2D by noobtuts.com\n");
GUILayout.Label("Instructions:", EditorStyles.boldLabel);
GUILayout.Label(" 1. Make Box/Circle-Collider2Ds Static");
GUILayout.Label(" 2. Press Bake and wait until it's done");
GUILayout.Label(" 3. Add NavMeshAgent2D to agents\n");
GUILayout.Label("Notes:", EditorStyles.boldLabel);
GUILayout.Label(" - Modify Window->Navigation->Agent Radius for path width");
GUILayout.Label(" - Use GroundScale to cover the outside of your level\n");
// options
groundScale = EditorGUILayout.Slider("Ground Scale", groundScale, 1, 100);
showNavMesh = EditorGUILayout.IntPopup("Show Navmesh", showNavMesh, new string[] { "Hide", "Wireframe", "Full" }, new int[] { 0, 1, 2 });
// repaint scene if showNavMesh option changed
if (GUI.changed)
{
SceneView.RepaintAll();
}
// buttons
GUILayout.BeginHorizontal();
if (GUILayout.Button("Clear"))
{
NavMeshBuilder.ClearAllNavMeshes();
if (gizmesh != null)
{
gizmesh.Clear();
}
}
if (NavMeshBuilder.isRunning)
{
if (GUILayout.Button("Cancel"))
{
NavMeshBuilder.Cancel();
}
}
else
{
if (GUILayout.Button("Bake"))
{
BakeNavMesh2D();
}
}
GUILayout.EndHorizontal();
GUILayout.EndVertical();
}
//------------------------------------------------------------------------------------------------------------------
void Update()
{
GameObject.Find("PREFAB_CameraMovement").transform.position = this.m_charProxy.transform.position;
//keep char_proxy at NavigationMesh
if (GameSystem.HeroControl.LeftMouseClick())
{
if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out m_hitPosition, 100))
{
//if (m_hitPosition.collider.gameObject.tag == "NavigationMesh")
{
NavMeshAgent agent = this.m_charProxy.GetComponent <NavMeshAgent>();
agent.destination = m_hitPosition.point;
agent.acceleration = 1000.0f;
agent.angularSpeed = 1000.0f;
agent.speed = 10.0f;
agent.updateRotation = true;
Debug.Log("clicked navmesh");
}
}
}
#if UNITY_EDITOR
if (Input.GetKeyDown(KeyCode.Space))
{
m_frameCount = Time.frameCount;
Debug.Log("space pressed");
NavMeshBuilder.ClearAllNavMeshes();
DestroyDungeon();
m_rebuildNavmesh = true;
}
if (m_frameCount < Time.frameCount && m_rebuildNavmesh)
{
CreateRandomDungeon();
MoveAllMapLinkedToFirstPiecePivot(0, 0);
ScrambleTileVersions();
ModifyTilePatterns();
PopulatePiecesAtDungeon();
PlaceAgentAtStartPointInNavmesh();
NavMeshBuilder.BuildNavMesh();
m_rebuildNavmesh = false;
}
#endif
}
static void BuildNaviMesh()
{
if (NavMeshBuilder.isRunning)
{
Debug.LogWarning("NaviMesh builder is already running! Aborted.");
return;
}
Debug.Log("Start building NaviMesh...");
NavMeshBuilder.ClearAllNavMeshes();
NavMeshBuilder.BuildNavMesh();
Debug.Log("NaviMesh building finished. Saving scene...");
EditorApplication.SaveScene();
}
private void GenerateNavMesh()
{
var map = (TilerMap)target;
var collectionSize = 1;
foreach (var cell in map.Cells)
{
foreach (var t in cell.Tiles)
{
var size = t.Collision.Length;
if (size > collectionSize)
{
collectionSize = size;
}
}
}
collectionSize = (int)Mathf.Sqrt(collectionSize);
foreach (var cell in map.Cells)
{
var tiles = cell.Tiles;
var goTrans = cell.transform.Find("navmesh");
if (goTrans != null)
{
DestroyImmediate(goTrans.gameObject);
}
goTrans = new GameObject("navmesh").transform;
goTrans.parent = cell.transform;
goTrans.localPosition = new Vector3();
var collection = new bool[map.TilesPerCell, map.TilesPerCell][];
for (var y = 0; y < map.TilesPerCell; y++)
{
for (var x = 0; x < map.TilesPerCell; x++)
{
collection[y, x] = tiles[y * map.TilesPerCell + x].Collision;
}
}
var merged = Util.MergeArrays(collection, collectionSize);
var c = new Combine();
var r = c.FindRect(merged);
var size = r.GetLength(0);
var sizePerCollider = map.CellSize / size;
var halfCellSize = map.CellSize / 2f;
var offset = sizePerCollider / 2f;
var p = new Point();
for (var y = 0; y < size; y++)
{
for (var x = 0; x < size; x++)
{
var start = r[y, x];
if (start != p)
{
var xx = (x + x + start.X - 1) / 2f;
var yy = (y + y - start.Y + 1) / 2f;
var posX = sizePerCollider * xx - (halfCellSize - offset);
var posY = sizePerCollider * yy - (halfCellSize - offset);
var go = GameObject.CreatePrimitive(PrimitiveType.Cube);
go.isStatic = true;
go.transform.parent = goTrans;
var goPos = new Vector3();
goPos.x = posX;
goPos.y = 0;
goPos.z = posY;
go.transform.localPosition = goPos;
go.transform.localScale = new Vector3(start.X * sizePerCollider, 1, start.Y * sizePerCollider);
GameObjectUtility.SetNavMeshLayer(go, 1);
}
}
}
}
NavMeshBuilder.ClearAllNavMeshes();
NavMeshBuilder.BuildNavMesh();
foreach (var cell in map.Cells)
{
var goTrans = cell.transform.Find("navmesh");
DestroyImmediate(goTrans.gameObject);
}
}
/// Exports the specific Sector into an external level file, deleting the current scene copy in the process. Safe to call from command line.
/// <param name="sector">The Sector to export.</param>
/// <returns>Returns true if Sector was successfully exported, false otherwise.</returns>
public static bool ExportToChunk(SECTR_Sector sector)
{
if (string.IsNullOrEmpty(EditorApplication.currentScene))
{
Debug.LogError("Scene must be saved befor export.");
return(false);
}
if (sector == null)
{
Debug.LogError("Cannot export null Sector.");
return(false);
}
if (!sector.gameObject.activeInHierarchy)
{
Debug.LogError("Cannot export inactive Sectors.");
return(false);
}
if (!sector.gameObject.isStatic)
{
Debug.Log("Skipping export of dynamic sector" + sector.name + ".");
return(true);
}
if (sector.Frozen)
{
// Already exported
Debug.Log("Skipping frozen sector " + sector.name);
return(true);
}
string sceneDir;
string sceneName;
string exportDir = SECTR_Asset.MakeExportFolder("Chunks", false, out sceneDir, out sceneName);
if (string.IsNullOrEmpty(exportDir))
{
Debug.LogError("Could not create Chunks folder.");
return(false);
}
// Delete the previous export, if there is one.
// Prevents duplicate names piling up.
SECTR_Chunk oldChunk = sector.GetComponent <SECTR_Chunk>();
if (oldChunk)
{
AssetDatabase.DeleteAsset(oldChunk.NodeName);
SECTR_VC.WaitForVC();
}
// Sectors are not guaranteed to be uniquely named, so always generate a unique name.
string originalSectorName = sector.name;
string newAssetPath = AssetDatabase.GenerateUniqueAssetPath(exportDir + sceneName + "_" + originalSectorName + ".unity");
sector.name = newAssetPath;
// Make sure the current scene is saved, preserving all changes.
EditorApplication.SaveScene();
SECTR_VC.WaitForVC();
string originalScene = EditorApplication.currentScene;
List <EditorBuildSettingsScene> sceneSettings = new List <EditorBuildSettingsScene>(EditorBuildSettings.scenes);
// SaveScene can cause crashes w/ version control, so we work around it with a copy.
AssetDatabase.CopyAsset(originalScene, newAssetPath);
SECTR_VC.WaitForVC();
EditorApplication.OpenScene(newAssetPath);
SECTR_VC.WaitForVC();
sector = _FindSectorByName(newAssetPath);
// Make sure to force update all members so that membership info is correct.
List <SECTR_Member> allMembers = FindAllOfType <SECTR_Member>();
for (int memberIndex = 0; memberIndex < allMembers.Count; ++memberIndex)
{
allMembers[memberIndex].ForceUpdate(true);
}
// Multi-sector members need to stay in the master scene.
foreach (SECTR_Member member in allMembers)
{
if (member.Sectors.Count > 1 && member.transform.IsChildOf(sector.transform))
{
bool unparentMember = true;
// Only affect the first member in the hierarchy below the sector
Transform parent = member.transform.parent;
while (parent != sector.transform)
{
if (parent.GetComponent <SECTR_Member>() != null)
{
unparentMember = false;
break;
}
parent = parent.parent;
}
if (unparentMember)
{
if (PrefabUtility.GetPrefabType(sector.gameObject) != PrefabType.None)
{
Debug.LogWarning("Export is unparenting shared member " + member.name + " from prefab Sector " + sector.name + ". This will break the prefab.");
}
member.transform.parent = null;
}
}
}
// Unparent the sector from anything
sector.transform.parent = null;
// Any children of this sector should be exported.
// The rest should be destroyed.
List <Transform> allXforms = FindAllOfType <Transform>();
#if !UNITY_STREAM_ENLIGHTEN
List <int> referencedLightmaps = new List <int>(LightmapSettings.lightmaps.Length);
#endif
foreach (Transform transform in allXforms)
{
if (transform && transform.IsChildOf(sector.transform))
{
#if !UNITY_STREAM_ENLIGHTEN
Renderer childRenderer = transform.GetComponent <Renderer>();
if (childRenderer && childRenderer.lightmapIndex >= 0 && !referencedLightmaps.Contains(childRenderer.lightmapIndex))
{
referencedLightmaps.Add(childRenderer.lightmapIndex);
}
Terrain childTerrain = transform.GetComponent <Terrain>();;
if (childTerrain && childTerrain.lightmapIndex >= 0 && !referencedLightmaps.Contains(childTerrain.lightmapIndex))
{
referencedLightmaps.Add(childTerrain.lightmapIndex);
}
#endif
}
else if (transform)
{
GameObject.DestroyImmediate(transform.gameObject);
}
}
#if !UNITY_STREAM_ENLIGHTEN
if (referencedLightmaps.Count > 0)
{
SECTR_LightmapRef newRef = sector.GetComponent <SECTR_LightmapRef>();
if (!newRef)
{
newRef = sector.gameObject.AddComponent <SECTR_LightmapRef>();
}
newRef.ReferenceLightmaps(referencedLightmaps);
}
// Nuke global data like nav meshes and lightmaps
// Lightmap indexes will be preserved on export.
NavMeshBuilder.ClearAllNavMeshes();
#if !UNITY_4
SerializedObject serialObj = new SerializedObject(GameObject.FindObjectOfType <LightmapSettings>());
SerializedProperty snapshotProp = serialObj.FindProperty("m_LightmapSnapshot");
snapshotProp.objectReferenceValue = null;
serialObj.ApplyModifiedProperties();
#endif
LightmapSettings.lightmaps = new LightmapData[0];
LightmapSettings.lightProbes = new LightProbes();
#endif
GameObject dummyParent = new GameObject(newAssetPath);
SECTR_ChunkRef chunkRef = dummyParent.AddComponent <SECTR_ChunkRef>();
chunkRef.RealSector = sector.transform;
sector.transform.parent = dummyParent.transform;
// If the sector has a chunk marked for re-use, perform some special work.
SECTR_Chunk originalChunk = sector.GetComponent <SECTR_Chunk>();
if (originalChunk && originalChunk.ExportForReuse)
{
chunkRef.Recentered = true;
sector.transform.localPosition = Vector3.zero;
sector.transform.localRotation = Quaternion.identity;
sector.transform.localScale = Vector3.one;
sector.gameObject.SetActive(false);
}
// Rename the real chunk root with a clear name.
sector.name = originalSectorName + "_Chunk";
// Strip off any functional objects that will be preserved in the root scene.
// Destroy the chunk first because it has dependencies on Sector.
GameObject.DestroyImmediate(originalChunk);
Component[] components = sector.GetComponents <Component>();
foreach (Component component in components)
{
if (component.GetType().IsSubclassOf(typeof(MonoBehaviour)) &&
component.GetType() != typeof(Terrain) && component.GetType() != typeof(SECTR_LightmapRef))
{
GameObject.DestroyImmediate(component);
}
}
// Re-add a member that will persist all of the references and save us work post load.
SECTR_Member refMember = chunkRef.RealSector.gameObject.AddComponent <SECTR_Member>();
refMember.NeverJoin = true;
refMember.BoundsUpdateMode = SECTR_Member.BoundsUpdateModes.Static;
refMember.ForceUpdate(true);
// Save scene and append it to the build settings.
EditorApplication.SaveScene();
SECTR_VC.WaitForVC();
EditorBuildSettingsScene sectorSceneSettings = new EditorBuildSettingsScene(newAssetPath, true);
bool sceneExists = false;
foreach (EditorBuildSettingsScene oldScene in sceneSettings)
{
if (oldScene.path == newAssetPath)
{
sceneExists = true;
oldScene.enabled = true;
break;
}
}
if (!sceneExists)
{
sceneSettings.Add(sectorSceneSettings);
}
string[] pathParts = newAssetPath.Split('/');
string sectorPath = pathParts[pathParts.Length - 1].Replace(".unity", "");
// Update the master scene with exported info.
EditorApplication.OpenScene(originalScene);
SECTR_VC.WaitForVC();
sector = _FindSectorByName(newAssetPath);
sector.name = originalSectorName;
DeleteExportedSector(sector);
// Make sure Sectors has a Chunk
SECTR_Chunk newChunk = sector.GetComponent <SECTR_Chunk>();
if (!newChunk)
{
newChunk = sector.gameObject.AddComponent <SECTR_Chunk>();
}
newChunk.ScenePath = sectorPath;
newChunk.NodeName = newAssetPath;
newChunk.enabled = true;
// Disable a TerrainComposer node if there is one.
MonoBehaviour terrainNeighbors = sector.GetComponent("TerrainNeighbors") as MonoBehaviour;
if (terrainNeighbors)
{
terrainNeighbors.enabled = false;
}
// Save off the accumulated build settings
EditorBuildSettings.scenes = sceneSettings.ToArray();
AssetDatabase.Refresh();
EditorApplication.SaveScene();
SECTR_VC.WaitForVC();
return(true);
}
public static void GeneratePathfindingPlatforms()
{
GameObject platformsGO = GameObject.Find("Pathfinding Platform");
if (platformsGO != null)
{
DestroyImmediate(platformsGO);
}
platformsGO = new GameObject("Pathfinding Platform");
MeshFilter platformMF = platformsGO.AddComponent <MeshFilter>();
MeshRenderer meshRend = platformsGO.AddComponent <MeshRenderer>();
platformsGO.AddComponent <MeshCollider>();
platformsGO.isStatic = true;
Mesh newMesh = new Mesh();
EdgeCollider2D[] allEdges = FindObjectsOfType <EdgeCollider2D>();
BoxCollider2D[] allBoxes = FindObjectsOfType <BoxCollider2D>();
List <Quad> quads = new List <Quad>();
float navMeshDepth = 4f;
Vector3 depthOffset = new Vector3(0f, 0f, PathfindingCharacterController.navMeshZ + navMeshDepth * 0.5f);
Vector3 negDepthOffset = new Vector3(0f, 0f, PathfindingCharacterController.navMeshZ - navMeshDepth * 0.5f);
foreach (EdgeCollider2D edge in allEdges)
{
Vector3 lastWorldPoint = Vector3.zero;
for (int p = 0; p < edge.points.Length; p++)
{
Vector3 worldPoint = edge.transform.TransformPoint(edge.points[p]);
if (lastWorldPoint != Vector3.zero)
{
quads.Add(new Quad(lastWorldPoint + negDepthOffset, worldPoint + negDepthOffset, worldPoint + depthOffset, lastWorldPoint + depthOffset));
}
lastWorldPoint = worldPoint;
}
}
foreach (BoxCollider2D box in allBoxes)
{
if (box.isTrigger)
{
continue;
}
float xMin = box.offset.x - box.size.x;
float xMax = box.offset.x + box.size.x;
float yTop = box.offset.y + box.size.y;
Vector3 left = box.transform.TransformPoint(xMin, yTop, 0f);
Vector3 right = box.transform.TransformPoint(xMax, yTop, 0f);
quads.Add(new Quad(left + negDepthOffset, right + negDepthOffset, right + depthOffset, left + depthOffset));
}
Vector3[] vertices = new Vector3[quads.Count * 4];
int[] tris = new int[quads.Count * 6];
for (int q = 0; q < quads.Count; q++)
{
// Debug.Log("Adding Quad " + q);
quads[q].Insert(vertices, q * 4, tris, q * 6);
}
newMesh.vertices = vertices;
newMesh.triangles = tris;
platformMF.mesh = newMesh;
NavMeshBuilder.ClearAllNavMeshes();
NavMeshBuilder.BuildNavMeshAsync();
meshRend.enabled = false;
}
public static void GenerateMapFromTMXFile()
{
var currentScene = SceneManager.GetActiveScene();
var mapData = ReadTMXFileForMapData(GetMapFilename(currentScene.name));
var worldParent = new GameObject("_World");
var index = 0;
var tilesetData = mapData.tilesetData;
for (var i = 0; i < mapData.height; i++)
{
for (var j = 0; j < mapData.width; j++)
{
var id = mapData.data[i][j];
var tilesetDataIndex = -1;
tilesetDataIndex = tilesetData.FindIndex(obj => id >= obj.firstgid && id <= (obj.firstgid + obj.tilecount - 1));
if (tilesetDataIndex == -1)
{
continue;
}
var isRoadPrefab = false; //required for nav mesh editor flag
id -= tilesetData[tilesetDataIndex].firstgid - 1;
var prefix = tilesetData[tilesetDataIndex].prefix;
var filename = prefix + id.ToString();
var scale = new Vector3(); //kenney pack 1 has different scaling compared to kenney pack 2
var filepath = GetFilepathForWorld(@"Prefabs/TowerDefense", filename, ref isRoadPrefab, ref scale);
if (filepath.Equals(string.Empty))
{
continue;
}
var asset = Resources.Load(filepath) as GameObject;
if (asset == null)
{
continue;
}
asset.transform.localScale = scale;
var tile = Instantiate(asset, new Vector3(j * Constants.TILE_SIZE.x, Constants.TILE_SIZE.x, -i * Constants.TILE_SIZE.y), Quaternion.identity) as GameObject;
tile.transform.parent = worldParent.transform;
tile.name = "go_" + index + asset.name;
GameObjectUtility.SetStaticEditorFlags(tile, StaticEditorFlags.BatchingStatic);
var children = tile.GetComponentsInChildren <Transform>();
for (var k = 0; k < children.Length; k++)
{
GameObjectUtility.SetStaticEditorFlags(children[k].gameObject,
isRoadPrefab ? StaticEditorFlags.NavigationStatic | StaticEditorFlags.BatchingStatic : StaticEditorFlags.BatchingStatic);
}
index++;
}
}
NavMeshBuilder.ClearAllNavMeshes();
NavMeshBuilder.BuildNavMesh();
UnityEditor.SceneManagement.EditorSceneManager.SaveScene(currentScene);
}
//创建平面的面片
void CreateFlatMesh()
{
lock (this)
{
BuildAllNavMesh(agentRadius);
BuildFloorNavMesh(agentRadius);
map.SetActive(false);
xingzouceng.GetComponent <Renderer>().enabled = false;
if (feixingceng != null)
{
feixingceng.GetComponent <Renderer>().enabled = false;
}
if (qinggong != null)
{
qinggong.GetComponent <Renderer>().enabled = false;
}
NavMeshTriangulation triangulatedNavMesh = NavMesh.CalculateTriangulation();
GameObject WalkAble = createOb(xingzouceng, "NavMesh_WalkAble", 1);
Vector3[] pathVertices = triangulatedNavMesh.vertices;
int[] triangles = triangulatedNavMesh.indices;
Mesh WalkMesh = WalkAble.GetComponent <MeshFilter>().sharedMesh;
Vector3[] vertexes = new Vector3[pathVertices.Length];
for (int i = 0; i < pathVertices.Length; i++)
{
float x = pathVertices[i].x;
float z = pathVertices[i].z;
vertexes[i] = new Vector3(x, 0, z);
}
WalkMesh.vertices = vertexes;
WalkMesh.triangles = triangles;
GameObject UnWalkAble = createOb(xingzouceng, "NavMesh_UnWalkAble", 0);
Mesh UnWalkMesh = UnWalkAble.GetComponent <MeshFilter>().sharedMesh;
UnWalkMesh.vertices = new Vector3[] {
new Vector3(startX, 0, startZ),
new Vector3(startX, 0, endZ),
new Vector3(endX, 0, endZ),
new Vector3(endX, 0, startZ)
};
UnWalkMesh.triangles = new int[] { 0, 1, 2, 0, 2, 3 };
SetAgentRadius(agentRadius);
NavMeshBuilder.ClearAllNavMeshes();
NavMeshBuilder.BuildNavMesh();
Object.DestroyImmediate(WalkAble);
Object.DestroyImmediate(UnWalkAble);
string path = System.Environment.CurrentDirectory.Replace("\\", "/") + "/Nav_build/";
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
StringBuilder sb = new StringBuilder("{");
sb.Append("\"mapID\":").Append(mapID);
sb.Append(",\"startX\":").Append(startX).Append(",\"startZ\":").Append(startZ);
sb.Append(",\"endX\":").Append(endX).Append(",\"endZ\":").Append(endZ);
string filename = path + mapID + ".navmesh";
triangulatedNavMesh = NavMesh.CalculateTriangulation();
string data = MeshToString(triangulatedNavMesh, true);
if (data.Length < 128)
{
alert("阻挡未打入！");
return;
}
sb.Append(",").Append(data);
BuildFloorNavMesh(agentRadius);
triangulatedNavMesh = NavMesh.CalculateTriangulation();
data = MeshToString(triangulatedNavMesh, false);
if (data.Length < 128)
{
alert("寻路未打入！");
return;
}
sb.Append(",").Append(data).Append("}");
MeshToFile(filename, sb.ToString());
BuildAllNavMesh(agentRadius);
map.SetActive(true);
alert("成功！");
property.endX = this.endX;
property.endZ = this.endZ;
property.agentRadius = this.agentRadius;
property.startX = this.startX;
property.startZ = this.startZ;
EditorSceneManager.SaveOpenScenes();
}
//Close();
}
void BuildNavMesh(float agentRadius)
{
SetAgentRadius(agentRadius);
NavMeshBuilder.ClearAllNavMeshes();
NavMeshBuilder.BuildNavMesh();
}
