/// <summary>
        /// Add Each Nif Geometry as an Instanced Meshes with World Matrix computed
        /// </summary>
        /// <param name="geometries">Collection of Nif Geometry</param>
        protected void AddNifInstancesYZSwapped(IEnumerable <NifGeometry> geometries)
        {
            var result = new List <KeyValuePair <int, Matrix> >();

            foreach (var geometry in geometries)
            {
                var trees     = TreeReplacement[geometry.FileName];
                var nifMatrix = ComputeWorldMatrix(geometry, UnitFactor);
                // Tree match, Compose Matrix
                if (trees.Length > 0)
                {
                    foreach (var tree in trees)
                    {
                        Matrix instance;
                        Matrix translate;
                        ZoneDrawingExtensions.CreateTranslation(tree.OffsetX * UnitFactor, tree.OffsetZ * UnitFactor, tree.OffsetY * UnitFactor, out instance);
                        ZoneDrawingExtensions.Mult(ref nifMatrix, ref instance, out translate);
                        nifMatrix = translate;
                    }
                }

                result.Add(new KeyValuePair <int, Matrix>(geometry.MeshID, nifMatrix));
            }

            InstancesMatrix = InstancesMatrix.Concat(result).ToArray();
        }
Пример #2
0
        public TerrainRenderer(int id, IEnumerable <FileInfo> files, ZoneType type, ClientDataWrapper wrapper)
            : base(id, files, type, wrapper)
        {
            // Init Terrain Height Calculator
            TerrainHeightCache = TerrainHeightCalculator;

            AddNifCache(TerrainNifs);
            AddNifInstancesYZSwapped(TerrainFixtures);

            // Store Terrain
            var terrain  = TerrainHeightMap;
            var vertices = new List <Vector3>();
            var indices  = new List <TriangleIndex>();

            for (int x = 0; x < terrain.Length; x++)
            {
                var yLength = terrain[x].Length;
                for (int y = 0; y < yLength; y++)
                {
                    var height = terrain[x][y];
                    vertices.Add(new Vector3(x, height, y));
                }
            }

            var width = terrain.Length;

            for (int x = 0; x < terrain.Length - 1; x++)
            {
                var yLength = terrain[x].Length;
                for (int y = 0; y < yLength - 1; y++)
                {
                    var tri1 = new TriangleIndex
                    {
                        A = (uint)((x + 1) * width + (y + 1)),
                        B = (uint)((x + 1) * width + y),
                        C = (uint)(x * width + y),
                    };
                    var tri2 = new TriangleIndex
                    {
                        A = (uint)((x + 1) * width + (y + 1)),
                        B = (uint)(x * width + y),
                        C = (uint)(x * width + (y + 1)),
                    };

                    indices.Add(tri1);
                    indices.Add(tri2);
                }
            }

            // Build Terrain object as a Primitive Nif
            var Terrain = new TriangleCollection
            {
                Vertices = vertices.ToArray(),
                Indices  = indices.ToArray(),
            };

            // Add Terrain like a Nif
            var insertid = 0;

            if (NifCache.Count > 0)
            {
                insertid = NifCache.Max(kv => kv.Key) + 1;
            }

            NifCache.Add(insertid, new ClientMesh("terrain", Terrain, Terrain, Terrain));
            InstancesMatrix = InstancesMatrix.Concat(new [] { new KeyValuePair <int, Matrix>(insertid, Matrix.Identity) }).ToArray();
        }