Exemplo n.º 1
0
        protected NavmeshTile BuildTileMesh(Voxelize vox, int x, int z, int threadIndex = 0)
        {
            vox.borderSize   = this.TileBorderSizeInVoxels;
            vox.forcedBounds = this.CalculateTileBoundsWithBorder(x, z);
            vox.width        = this.tileSizeX + vox.borderSize * 2;
            vox.depth        = this.tileSizeZ + vox.borderSize * 2;
            if (!this.useTiles && this.relevantGraphSurfaceMode == RecastGraph.RelevantGraphSurfaceMode.OnlyForCompletelyInsideTile)
            {
                vox.relevantGraphSurfaceMode = RecastGraph.RelevantGraphSurfaceMode.RequireForAll;
            }
            else
            {
                vox.relevantGraphSurfaceMode = this.relevantGraphSurfaceMode;
            }
            vox.minRegionSize = Mathf.RoundToInt(this.minRegionSize / (this.cellSize * this.cellSize));
            vox.Init();
            vox.VoxelizeInput(this.transform, this.CalculateTileBoundsWithBorder(x, z));
            vox.FilterLedges(vox.voxelWalkableHeight, vox.voxelWalkableClimb, vox.cellSize, vox.cellHeight);
            vox.FilterLowHeightSpans(vox.voxelWalkableHeight, vox.cellSize, vox.cellHeight);
            vox.BuildCompactField();
            vox.BuildVoxelConnections();
            vox.ErodeWalkableArea(this.CharacterRadiusInVoxels);
            vox.BuildDistanceField();
            vox.BuildRegions();
            VoxelContourSet cset = new VoxelContourSet();

            vox.BuildContours(this.contourMaxError, 1, cset, 5);
            VoxelMesh mesh;

            vox.BuildPolyMesh(cset, 3, out mesh);
            for (int i = 0; i < mesh.verts.Length; i++)
            {
                mesh.verts[i] *= 1000;
            }
            vox.transformVoxel2Graph.Transform(mesh.verts);
            return(this.CreateTile(vox, mesh, x, z, threadIndex));
        }
Exemplo n.º 2
0
        protected NavmeshTile BuildTileMesh(Voxelize vox, int x, int z, int threadIndex = 0)
        {
            AstarProfiler.StartProfile("Build Tile");
            AstarProfiler.StartProfile("Init");

            vox.borderSize   = TileBorderSizeInVoxels;
            vox.forcedBounds = CalculateTileBoundsWithBorder(x, z);
            vox.width        = tileSizeX + vox.borderSize * 2;
            vox.depth        = tileSizeZ + vox.borderSize * 2;

            if (!useTiles && relevantGraphSurfaceMode == RelevantGraphSurfaceMode.OnlyForCompletelyInsideTile)
            {
                // This best reflects what the user would actually want
                vox.relevantGraphSurfaceMode = RelevantGraphSurfaceMode.RequireForAll;
            }
            else
            {
                vox.relevantGraphSurfaceMode = relevantGraphSurfaceMode;
            }

            vox.minRegionSize = Mathf.RoundToInt(minRegionSize / (cellSize * cellSize));

            AstarProfiler.EndProfile("Init");


            // Init voxelizer
            vox.Init();
            vox.VoxelizeInput(transform, CalculateTileBoundsWithBorder(x, z));

            AstarProfiler.StartProfile("Filter Ledges");


            vox.FilterLedges(vox.voxelWalkableHeight, vox.voxelWalkableClimb, vox.cellSize, vox.cellHeight);

            AstarProfiler.EndProfile("Filter Ledges");

            AstarProfiler.StartProfile("Filter Low Height Spans");
            vox.FilterLowHeightSpans(vox.voxelWalkableHeight, vox.cellSize, vox.cellHeight);
            AstarProfiler.EndProfile("Filter Low Height Spans");

            vox.BuildCompactField();
            vox.BuildVoxelConnections();
            vox.ErodeWalkableArea(CharacterRadiusInVoxels);
            vox.BuildDistanceField();
            vox.BuildRegions();

            var cset = new VoxelContourSet();

            vox.BuildContours(contourMaxError, 1, cset, Voxelize.RC_CONTOUR_TESS_WALL_EDGES | Voxelize.RC_CONTOUR_TESS_TILE_EDGES);

            VoxelMesh mesh;

            vox.BuildPolyMesh(cset, 3, out mesh);

            AstarProfiler.StartProfile("Build Nodes");

            // Position the vertices correctly in graph space (all tiles are laid out on the xz plane with the (0,0) tile at the origin)
            for (int i = 0; i < mesh.verts.Length; i++)
            {
                mesh.verts[i] *= Int3.Precision;
            }
            vox.transformVoxel2Graph.Transform(mesh.verts);

            NavmeshTile tile = CreateTile(vox, mesh, x, z, threadIndex);

            AstarProfiler.EndProfile("Build Nodes");

            AstarProfiler.EndProfile("Build Tile");
            return(tile);
        }
Exemplo n.º 3
0
		public override void Scan () {
			AstarProfiler.Reset ();
			//AstarProfiler.StartProfile ("Base Scan");
			
			//base.Scan ();
			
			//AstarProfiler.EndProfile ("Base Scan");
			if (useCRecast) {
				ScanCRecast ();
				
			} else {
			
#if ASTARDEBUG
				Console.WriteLine ("Recast Graph -- Collecting Meshes");
#endif	
				AstarProfiler.StartProfile ("Collecting Meshes");
				
				AstarProfiler.StartProfile ("Collecting Meshes");
				MeshFilter[] filters;
				ExtraMesh[] extraMeshes;
				
				if (!CollectMeshes (out filters, out extraMeshes)) {
					nodes = new Node[0];
					return;
				}
				
				AstarProfiler.EndProfile ("Collecting Meshes");
				
#if ASTARDEBUG
				Console.WriteLine ("Recast Graph -- Creating Voxel Base");
#endif
				
				Voxelize vox = new Voxelize (cellHeight, cellSize, walkableClimb, walkableHeight, maxSlope);
				
				vox.maxEdgeLength = maxEdgeLength;
				vox.forcedBounds = forcedBounds;
				vox.includeOutOfBounds = includeOutOfBounds;
				
#if ASTARDEBUG
				Console.WriteLine ("Recast Graph -- Voxelizing");
#endif
				AstarProfiler.EndProfile ("Collecting Meshes");
				
				//g.GetComponent<Voxelize>();
				vox.VoxelizeMesh (filters, extraMeshes);
				
				/*bool[,] open = new bool[width,depth];
				int[,] visited = new int[width+1,depth+1];
				
				for (int z=0;z<depth;z++) {
					for (int x = 0;x < width;x++) {
						open[x,z] = graphNodes[z*width+x].walkable;
					}
				}*/
				
				/*for (int i=0;i<depth*width;i++) {
					open[i] = graphNodes[i].walkable;
				}
				
				
				int wd = width*depth;
				
				List<int> boundary = new List<int>();
				
				int p = 0;
				
				for (int i=0;i<wd;i++) {
					if (!open[i]) {
						boundary.Add (i);
						
						p = i;
						
						int backtrack = i-1;
						
						
					}*/

#if ASTARDEBUG
				Console.WriteLine ("Recast Graph -- Eroding");
#endif
				
				vox.ErodeWalkableArea (Mathf.CeilToInt (2*characterRadius/cellSize));
				
#if ASTARDEBUG
				Console.WriteLine ("Recast Graph -- Building Distance Field");
#endif
				
				vox.BuildDistanceField ();

#if ASTARDEBUG
				Console.WriteLine ("Recast Graph -- Building Regions");
#endif
				
				vox.BuildRegions ();
				
#if ASTARDEBUG
				Console.WriteLine ("Recast Graph -- Building Contours");
#endif
				
				VoxelContourSet cset = new VoxelContourSet ();
				
				vox.BuildContours (contourMaxError,1,cset,Voxelize.RC_CONTOUR_TESS_WALL_EDGES);
				
#if ASTARDEBUG
				Console.WriteLine ("Recast Graph -- Building Poly Mesh");
#endif
				
				VoxelMesh mesh;
				
				vox.BuildPolyMesh (cset,3,out mesh);
				
#if ASTARDEBUG
				Console.WriteLine ("Recast Graph -- Building Nodes");
#endif
				
				Vector3[] vertices = new Vector3[mesh.verts.Length];
				
				AstarProfiler.StartProfile ("Build Nodes");
				
				for (int i=0;i<vertices.Length;i++) {
					vertices[i] = (Vector3)mesh.verts[i];
				}
				
				matrix = Matrix4x4.TRS (vox.voxelOffset,Quaternion.identity,Int3.Precision*Voxelize.CellScale);
				//Int3.Precision*Voxelize.CellScale+(Int3)vox.voxelOffset
				
				//GenerateNodes (this,vectorVertices,triangles, out originalVertices, out _vertices);
				
#if ASTARDEBUG
				Console.WriteLine ("Recast Graph -- Generating Nodes");
#endif
				
				NavMeshGraph.GenerateNodes (this,vertices,mesh.tris, out _vectorVertices, out _vertices);
				
				AstarProfiler.EndProfile ("Build Nodes");
				
				AstarProfiler.PrintResults ();
				
#if ASTARDEBUG
				Console.WriteLine ("Recast Graph -- Done");
#endif
				
			}
		}
Exemplo n.º 4
0
        public override void Scan()
        {
            AstarProfiler.Reset();
            //AstarProfiler.StartProfile ("Base Scan");

            //base.Scan ();

            //AstarProfiler.EndProfile ("Base Scan");
            if (useCRecast)
            {
                ScanCRecast();
            }
            else
            {
                MeshFilter[] filters;
                ExtraMesh[]  extraMeshes;

                if (!CollectMeshes(out filters, out extraMeshes))
                {
                    nodes = new Node[0];
                    return;
                }

                Voxelize vox = new Voxelize(cellHeight, cellSize, walkableClimb, walkableHeight, maxSlope);

                vox.maxEdgeLength      = maxEdgeLength;
                vox.forcedBounds       = forcedBounds;
                vox.includeOutOfBounds = includeOutOfBounds;


                //g.GetComponent<Voxelize>();
                vox.VoxelizeMesh(filters, extraMeshes);

                /*bool[,] open = new bool[width,depth];
                 * int[,] visited = new int[width+1,depth+1];
                 *
                 * for (int z=0;z<depth;z++) {
                 *      for (int x = 0;x < width;x++) {
                 *              open[x,z] = graphNodes[z*width+x].walkable;
                 *      }
                 * }*/

                /*for (int i=0;i<depth*width;i++) {
                 *      open[i] = graphNodes[i].walkable;
                 * }
                 *
                 *
                 * int wd = width*depth;
                 *
                 * List<int> boundary = new List<int>();
                 *
                 * int p = 0;
                 *
                 * for (int i=0;i<wd;i++) {
                 *      if (!open[i]) {
                 *              boundary.Add (i);
                 *
                 *              p = i;
                 *
                 *              int backtrack = i-1;
                 *
                 *
                 *      }*/

                vox.ErodeWalkableArea(Mathf.CeilToInt(2 * characterRadius / cellSize));


                vox.BuildDistanceField();

                vox.BuildRegions();

                VoxelContourSet cset = new VoxelContourSet();

                vox.BuildContours(contourMaxError, 1, cset, Voxelize.RC_CONTOUR_TESS_WALL_EDGES);

                VoxelMesh mesh;

                vox.BuildPolyMesh(cset, 3, out mesh);


                Vector3[] vertices = new Vector3[mesh.verts.Length];

                AstarProfiler.StartProfile("Build Nodes");

                for (int i = 0; i < vertices.Length; i++)
                {
                    vertices[i] = (Vector3)mesh.verts[i];
                }

                matrix = Matrix4x4.TRS(vox.voxelOffset, Quaternion.identity, Int3.Precision * Voxelize.CellScale);
                //Int3.Precision*Voxelize.CellScale+(Int3)vox.voxelOffset

                //GenerateNodes (this,vectorVertices,triangles, out originalVertices, out _vertices);

                NavMeshGraph.GenerateNodes(this, vertices, mesh.tris, out _vectorVertices, out _vertices);

                AstarProfiler.EndProfile("Build Nodes");

                AstarProfiler.PrintResults();
            }
        }