示例#1
0
        protected override void LoadContent()
        {
            _adt = new ADT(_path);
            _adt.Read();

            _terrain = new GeometryDrawer();
            _terrain.Initialize(Game, Color.Green, _adt.MapChunks.Select(mc => mc.Vertices),
                                _adt.MapChunks.Select(mc => mc.Triangles));

            var firstVert = _adt.MapChunks[0].Vertices[0];
            meshDisplay.Game.Camera.Camera.Position = new Vector3(firstVert.Y, firstVert.Z, firstVert.X);

            if (_adt.DoodadHandler.Triangles != null)
            {
                _doodads = new GeometryDrawer();
                _doodads.Initialize(Game, Color.Yellow, _adt.DoodadHandler.Vertices, _adt.DoodadHandler.Triangles);
            }

            if (_adt.WorldModelHandler.Triangles != null)
            {
                _wmos = new GeometryDrawer();
                _wmos.Initialize(Game, Color.Red, _adt.WorldModelHandler.Vertices, _adt.WorldModelHandler.Triangles);
            }

            if (_adt.LiquidHandler.Triangles != null)
            {
                _liquid = new GeometryDrawer();
                _liquid.Initialize(Game, Color.Blue, _adt.LiquidHandler.Vertices, _adt.LiquidHandler.Triangles);
            }

            _effect = new BasicEffect(GraphicsDevice);
            _depthState = new DepthStencilState {DepthBufferEnable = true};
        }
        public WorldModelHandler(ADT source)
            : base(source)
        {
            if (!source.HasObjectData)
                return;

            ReadModelPaths();
            ReadDefinitions();
        }
示例#3
0
        public void TestGameAdt()
        {
            MpqManager.Initialize("S:\\WoW");
            var test = new ADT("World\\maps\\Northrend\\Northrend_43_29.adt");
            test.Read();

            Assert.AreEqual(test.MapChunks.Length, 16*16);
            Assert.IsNotNull(test.DoodadHandler.Vertices);
            Assert.IsNotNull(test.DoodadHandler.Triangles);
        }
示例#4
0
 public static ADT GetAdt(string world, int x, int y)
 {
     ADT adt = null;
     if (Cache.Adt.TryGetValue(new Tuple<int, int>(x, y), out adt))
         return adt;
     adt = new ADT(GetAdtPath(world, x, y));
     adt.Read();
     Cache.Adt.Add(new Tuple<int, int>(x, y), adt);
     return adt;
 }
示例#5
0
        public MapChunk(ADT adt, Chunk chunk)
        {
            ADT = adt;
            Source = chunk;
            var stream = chunk.GetStream();
            Header = new MapChunkHeader();
            Header.Read(stream);

            stream.Seek(chunk.Offset, SeekOrigin.Begin);
            GenerateVertices(stream);
        }
示例#6
0
        public WorldModelHandler(ADT source)
            : base(source)
        {
            if (!source.HasObjectData)
            {
                return;
            }

            ReadModelPaths();
            ReadDefinitions();
        }
示例#7
0
        public MapChunk(ADT adt, Chunk chunk)
        {
            ADT    = adt;
            Source = chunk;
            var stream = chunk.GetStream();

            Header = new MapChunkHeader();
            Header.Read(stream);

            stream.Seek(chunk.Offset, SeekOrigin.Begin);
            GenerateVertices(stream);
        }
示例#8
0
        public DoodadHandler(ADT adt)
            : base(adt)
        {
            if (!adt.HasObjectData)
                return;

            var mddf = adt.ObjectData.GetChunkByName("MDDF");
            if (mddf != null)
                ReadDoodadDefinitions(mddf);

            var mmid = adt.ObjectData.GetChunkByName("MMID");
            var mmdx = adt.ObjectData.GetChunkByName("MMDX");
            if (mmid != null && mmdx != null)
                ReadDoodadPaths(mmid, mmdx);
        }
示例#9
0
        public void AddAdt(ADT data)
        {
            foreach (var mc in data.MapChunks)
                AddData(mc.Vertices, mc.Triangles.Select(t => new Triangle<uint>(t.Type, t.V0, t.V1, t.V2)));

            if (data.DoodadHandler.Triangles != null)
                AddData(data.DoodadHandler.Vertices, data.DoodadHandler.Triangles);

            // terrain under water is marked now, so we can safely ignore the actual surface
            //if (data.LiquidHandler.Triangles != null)
            //    AddData(data.LiquidHandler.Vertices, data.LiquidHandler.Triangles);

            if (data.WorldModelHandler.Triangles != null)
                AddData(data.WorldModelHandler.Vertices, data.WorldModelHandler.Triangles);
        }
示例#10
0
        public DoodadHandler(ADT adt)
            : base(adt)
        {
            if (!adt.HasObjectData)
            {
                return;
            }

            var mddf = adt.ObjectData.GetChunkByName("MDDF");

            if (mddf != null)
            {
                ReadDoodadDefinitions(mddf);
            }

            var mmid = adt.ObjectData.GetChunkByName("MMID");
            var mmdx = adt.ObjectData.GetChunkByName("MMDX");

            if (mmid != null && mmdx != null)
            {
                ReadDoodadPaths(mmid, mmdx);
            }
        }
示例#11
0
        public LiquidHandler(ADT source)
        {
            Source = source;

            HandleNewLiquid();
        }
示例#12
0
        public LiquidHandler(ADT source)
        {
            Source = source;

            HandleNewLiquid();
        }
示例#13
0
        public byte[] Build(BaseLog log)
        {
            Log = log;
            Geometry = new Geometry {Transform = true};

            {
                var main = new ADT(GetAdtPath(World, X, Y));
                main.Read();
                Geometry.AddAdt(main);
            }

            if (Geometry.Vertices.Count == 0 && Geometry.Triangles.Count == 0)
                throw new InvalidOperationException("Can't build tile with empty geometry");

            float[] bbMin, bbMax;
            CalculateTileBounds(out bbMin, out bbMax);
            Geometry.CalculateMinMaxHeight(out bbMin[1], out bbMax[1]);

            // again, we load everything - wasteful but who cares
            for (int ty = Y - 1; ty <= Y + 1; ty++)
            {
                for (int tx = X - 1; tx <= X + 1; tx++)
                {
                    try
                    {
                        // don't load main tile again
                        if (tx == X && ty == Y)
                            continue;

                        var adt = new ADT(GetAdtPath(World, tx, ty));
                        adt.Read();
                        Geometry.AddAdt(adt);
                    }
                    catch (FileNotFoundException)
                    {
                        // don't care - no file means no geometry
                    }
                }
            }

            Context = new RecastContext();
            Context.SetContextHandler(Log);

            // get raw geometry - lots of slowness here
            float[] vertices;
            int[] triangles;
            byte[] areas;
            Geometry.GetRawData(out vertices, out triangles, out areas);
            Geometry.Triangles.Clear();
            Geometry.Vertices.Clear();

            // add border
            bbMin[0] -= Config.BorderSize*Config.CellSize;
            bbMin[2] -= Config.BorderSize*Config.CellSize;
            bbMax[0] += Config.BorderSize*Config.CellSize;
            bbMax[2] += Config.BorderSize*Config.CellSize;

            Heightfield hf;
            int width = Config.TileWidth + (Config.BorderSize*2);
            if (!Context.CreateHeightfield(out hf, width, width, bbMin, bbMax, Config.CellSize, Config.CellHeight))
                throw new OutOfMemoryException("CreateHeightfield ran out of memory");

            Context.ClearUnwalkableTriangles(Config.WalkableSlopeAngle, ref vertices, ref triangles, areas);
            Context.RasterizeTriangles(ref vertices, ref triangles, ref areas, hf, Config.WalkableClimb);

            // Once all geometry is rasterized, we do initial pass of filtering to
            // remove unwanted overhangs caused by the conservative rasterization
            // as well as filter spans where the character cannot possibly stand.
            Context.FilterLowHangingWalkableObstacles(Config.WalkableClimb, hf);
            Context.FilterLedgeSpans(Config.WalkableHeight, Config.WalkableClimb, hf);
            Context.FilterWalkableLowHeightSpans(Config.WalkableHeight, hf);

            // Compact the heightfield so that it is faster to handle from now on.
            // This will result in more cache coherent data as well as the neighbours
            // between walkable cells will be calculated.
            CompactHeightfield chf;
            if (!Context.BuildCompactHeightfield(Config.WalkableHeight, Config.WalkableClimb, hf, out chf))
                throw new OutOfMemoryException("BuildCompactHeightfield ran out of memory");

            hf.Delete();

            // Erode the walkable area by agent radius.
            if (!Context.ErodeWalkableArea(Config.WalkableRadius, chf))
                throw new OutOfMemoryException("ErodeWalkableArea ran out of memory");

            // Prepare for region partitioning, by calculating distance field along the walkable surface.
            if (!Context.BuildDistanceField(chf))
                throw new OutOfMemoryException("BuildDistanceField ran out of memory");

            // Partition the walkable surface into simple regions without holes.
            if (!Context.BuildRegions(chf, Config.BorderSize, Config.MinRegionArea, Config.MergeRegionArea))
                throw new OutOfMemoryException("BuildRegionsMonotone ran out of memory");

            // Create contours.
            ContourSet cset;
            if (!Context.BuildContours(chf, Config.MaxSimplificationError, Config.MaxEdgeLength, out cset))
                throw new OutOfMemoryException("BuildContours ran out of memory");

            // Build polygon navmesh from the contours.
            PolyMesh pmesh;
            if (!Context.BuildPolyMesh(cset, Config.MaxVertsPerPoly, out pmesh))
                throw new OutOfMemoryException("BuildPolyMesh ran out of memory");

            // Build detail mesh.
            PolyMeshDetail dmesh;
            if (
                !Context.BuildPolyMeshDetail(pmesh, chf, Config.DetailSampleDistance, Config.DetailSampleMaxError,
                                             out dmesh))
                throw new OutOfMemoryException("BuildPolyMeshDetail ran out of memory");

            chf.Delete();
            cset.Delete();

            // Remove padding from the polymesh data. (Remove this odditity)
            pmesh.RemovePadding(Config.BorderSize);

            // Set flags according to area types (e.g. Swim for Water)
            pmesh.MarkAll();

            // get original bounds
            float[] tilebMin, tilebMax;
            CalculateTileBounds(out tilebMin, out tilebMax);
            tilebMin[1] = bbMin[1];
            tilebMax[1] = bbMax[1];

            // build off mesh connections for flightmasters
            // bMax and bMin are switched here because of the coordinate system transformation
            var taxis = TaxiHelper.GetNodesInBBox(MapId, tilebMax.ToWoW(), tilebMin.ToWoW());
            var connections = new List<OffMeshConnection>();
            foreach (var taxi in taxis)
            {
                Log.Log(LogCategory.Warning,
                        "Flightmaster \"" + taxi.Name + "\", Id: " + taxi.Id + " Horde: " + taxi.IsHorde + " Alliance: " +
                        taxi.IsAlliance);

                var data = TaxiHelper.GetTaxiData(taxi);
                var from = taxi.Location.ToRecast().ToFloatArray();
                connections.AddRange(data.To.Select(to => new OffMeshConnection
                                                              {
                                                                  AreaId = PolyArea.Road,
                                                                  Flags = PolyFlag.FlightMaster,
                                                                  From = from,
                                                                  To = to.Value.Location.ToRecast().ToFloatArray(),
                                                                  Radius = Config.WorldWalkableRadius,
                                                                  Type = ConnectionType.OneWay,
                                                                  UserID = (uint) to.Key
                                                              }));

                foreach (var target in data.To)
                    Log.Log(LogCategory.Warning,
                            "\tPath to: \"" + target.Value.Name + "\" Id: " + target.Value.Id + " Path Id: " +
                            target.Key);
            }

            byte[] tileData;
            if (!Detour.CreateNavMeshData(out tileData, pmesh, dmesh,
                                          X, Y, tilebMin, tilebMax,
                                          Config.WorldWalkableHeight, Config.WorldWalkableRadius,
                                          Config.WorldWalkableClimb, Config.CellSize,
                                          Config.CellHeight, Config.TileWidth,
                                          connections.ToArray()))
            {
                pmesh.Delete();
                dmesh.Delete();
                return null;
            }

            pmesh.Delete();
            dmesh.Delete();
            Cache.Clear();
            GC.Collect();
            return tileData;
        }