示例#1
0
		private Bitmap generateColorMapImage(RGB[,] map)
		{
			int width = map.GetUpperBound(0) + 1;
			int height = map.GetUpperBound(1) + 1;
			
			byte[] buffer = new byte[width * height * 3];

			int i = 0;
			for (int y = height - 1; y >= 0; y--)
			{
				for (int x = 0; x < width; x++)
				{
					buffer[i++] = this.terrain.ColorMap[x, y].B;
					buffer[i++] = this.terrain.ColorMap[x, y].G;
					buffer[i++] = this.terrain.ColorMap[x, y].R;
				}
			}

			GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
			Bitmap bmp = new Bitmap(width, height, width * 3, System.Drawing.Imaging.PixelFormat.Format24bppRgb, handle.AddrOfPinnedObject());
			this.imageHandles.Add(handle); 
			return bmp;
		}
示例#2
0
        /// <summary>
        /// Writes the terrain to the specified stream.
        /// </summary>
        /// <param name="stream">The destination stream.</param>
        public void Write(Stream stream)
        {
            BinaryWriter writer = new BinaryWriter(stream);

            if (Version > 0)
            {
                writer.Write(0x52524554u); // 'TERR'
                if (Version < 4)
                {
                    writer.Write(0x00000003u); // version
                }
                else
                {
                    writer.Write(Version); // version
                }
                writer.Write(GridMinX);
                writer.Write(GridMinZ);
                writer.Write(GridMaxX);
                writer.Write(GridMaxZ);
            }

            for (int y = 0; y < this.Height; y += CLUSTER_SIZE)
            {
                for (int x = 0; x < this.Width; x += CLUSTER_SIZE)
                {
                    bool haveHeight = true;
                    bool haveColor  = true;
                    bool haveAlpha1 = true;
                    bool haveAlpha2 = true;
                    bool haveAlpha3 = true;
                    bool haveCell   = true;

                    if (Version >= 5)
                    {
                        haveHeight = false;
                        haveColor  = false;
                        haveAlpha1 = false;
                        haveAlpha2 = false;
                        haveAlpha3 = false;
                        haveCell   = false;

                        float    height = this.HeightMapFloat[x, y];
                        RGB      color  = this.ColorMap[x, y];
                        byte     alpha1 = this.AlphaMap1[x, y];
                        byte     alpha2 = this.AlphaMap2[x, y];
                        byte     alpha3 = this.AlphaMap3[x, y];
                        CellType cell   = this.CellMap[x, y];

                        for (int cy = 0; cy < CLUSTER_SIZE; cy++)
                        {
                            if (!haveHeight)
                            {
                                for (int cx = 0; cx < CLUSTER_SIZE; cx++)
                                {
                                    if (height != this.HeightMapFloat[x + cx, y + cy])
                                    {
                                        haveHeight = true;
                                        break;
                                    }
                                }
                            }
                        }

                        for (int cy = 0; cy < CLUSTER_SIZE; cy++)
                        {
                            if (!haveColor)
                            {
                                for (int cx = 0; cx < CLUSTER_SIZE; cx++)
                                {
                                    if (color.R != this.ColorMap[x + cx, y + cy].R ||
                                        color.G != this.ColorMap[x + cx, y + cy].G ||
                                        color.B != this.ColorMap[x + cx, y + cy].B)
                                    {
                                        haveColor = true;
                                        break;
                                    }
                                }
                            }
                        }

                        for (int cy = 0; cy < CLUSTER_SIZE; cy++)
                        {
                            if (!haveAlpha1)
                            {
                                for (int cx = 0; cx < CLUSTER_SIZE; cx++)
                                {
                                    if (alpha1 != this.AlphaMap1[x + cx, y + cy])
                                    {
                                        haveAlpha1 = true;
                                        break;
                                    }
                                }
                            }
                        }

                        for (int cy = 0; cy < CLUSTER_SIZE; cy++)
                        {
                            if (!haveAlpha2)
                            {
                                for (int cx = 0; cx < CLUSTER_SIZE; cx++)
                                {
                                    if (alpha2 != this.AlphaMap2[x + cx, y + cy])
                                    {
                                        haveAlpha2 = true;
                                        break;
                                    }
                                }
                            }
                        }

                        for (int cy = 0; cy < CLUSTER_SIZE; cy++)
                        {
                            if (!haveAlpha3)
                            {
                                for (int cx = 0; cx < CLUSTER_SIZE; cx++)
                                {
                                    if (alpha3 != this.AlphaMap3[x + cx, y + cy])
                                    {
                                        haveAlpha3 = true;
                                        break;
                                    }
                                }
                            }
                        }

                        for (int cy = 0; cy < CLUSTER_SIZE; cy++)
                        {
                            if (!haveCell)
                            {
                                for (int cx = 0; cx < CLUSTER_SIZE; cx++)
                                {
                                    if (cell != this.CellMap[x + cx, y + cy])
                                    {
                                        haveCell = true;
                                        break;
                                    }
                                }
                            }
                        }

                        byte Compression = 0;
                        if (haveHeight)
                        {
                            Compression += 1;
                        }
                        if (haveColor)
                        {
                            Compression += (1 << 1);
                        }
                        if (haveAlpha1)
                        {
                            Compression += (1 << 2);
                        }
                        if (haveAlpha2)
                        {
                            Compression += (1 << 3);
                        }
                        if (haveAlpha3)
                        {
                            Compression += (1 << 4);
                        }
                        if (haveCell)
                        {
                            Compression += (1 << 5);
                        }
                        writer.Write(Compression);
                    }

                    if (Version < 3)
                    {
                        for (int cy = 0; cy < (CLUSTER_SIZE + 1); cy++)
                        {
                            for (int cx = 0; cx < (CLUSTER_SIZE + 1); cx++)
                            {
                                int _cx = cx;
                                int _cy = cy;
                                if ((x + cx) == this.Width)
                                {
                                    _cx--;
                                }
                                if ((x + cy) == this.Width)
                                {
                                    _cy--;
                                }
                                writer.Write(this.HeightMap[x + _cx, y + _cy]);
                            }
                        }
                    }
                    else if (Version < 4)
                    {
                        // height map
                        for (int cy = 0; cy < CLUSTER_SIZE; cy++)
                        {
                            for (int cx = 0; cx < CLUSTER_SIZE; cx++)
                            {
                                writer.Write(this.HeightMap[x + cx, y + cy]);
                            }
                        }
                    }
                    else
                    {
                        // height map
                        if (haveHeight)
                        {
                            for (int cy = 0; cy < CLUSTER_SIZE; cy++)
                            {
                                for (int cx = 0; cx < CLUSTER_SIZE; cx++)
                                {
                                    writer.Write(this.HeightMapFloat[x + cx, y + cy]);
                                }
                            }
                        }
                        else
                        {
                            writer.Write(this.HeightMapFloat[x, y]);
                        }
                    }

                    if (Version < 3)
                    {
                        for (int cy = 0; cy < (CLUSTER_SIZE + 1); cy++)
                        {
                            for (int cx = 0; cx < (CLUSTER_SIZE + 1); cx++)
                            {
                                int _cx = cx;
                                int _cy = cy;
                                if ((x + cx) == this.Width)
                                {
                                    _cx--;
                                }
                                if ((x + cy) == this.Width)
                                {
                                    _cy--;
                                }
                                writer.Write(this.NormalMap[x + _cx, y + _cy]);
                            }
                        }
                    }
                    else if (Version < 4)
                    {
                        // normal map
                        for (int cy = 0; cy < CLUSTER_SIZE; cy++)
                        {
                            for (int cx = 0; cx < CLUSTER_SIZE; cx++)
                            {
                                writer.Write(this.NormalMap[x + cx, y + cy]);
                            }
                        }
                    }

                    // color map
                    if (Version < 3)
                    {
                        for (int cy = 0; cy < (CLUSTER_SIZE + 1); cy++)
                        {
                            for (int cx = 0; cx < (CLUSTER_SIZE + 1); cx++)
                            {
                                int _cx = cx;
                                int _cy = cy;
                                if ((x + cx) == this.Width)
                                {
                                    _cx--;
                                }
                                if ((x + cy) == this.Width)
                                {
                                    _cy--;
                                }
                                writer.Write(this.ColorMap[x + _cx, y + _cy].R);
                                writer.Write(this.ColorMap[x + _cx, y + _cy].G);
                                writer.Write(this.ColorMap[x + _cx, y + _cy].B);
                            }
                        }
                    }
                    else //if (Version < 4)
                    {
                        if (haveColor)
                        {
                            for (int cy = 0; cy < CLUSTER_SIZE; cy++)
                            {
                                for (int cx = 0; cx < CLUSTER_SIZE; cx++)
                                {
                                    writer.Write(this.ColorMap[x + cx, y + cy].R);
                                    writer.Write(this.ColorMap[x + cx, y + cy].G);
                                    writer.Write(this.ColorMap[x + cx, y + cy].B);
                                }
                            }
                        }
                        else
                        {
                            writer.Write(this.ColorMap[x, y].R);
                            writer.Write(this.ColorMap[x, y].G);
                            writer.Write(this.ColorMap[x, y].B);
                        }
                    }

                    // alpha map 1
                    if (Version < 3)
                    {
                        for (int cy = 0; cy < (CLUSTER_SIZE + 1); cy++)
                        {
                            for (int cx = 0; cx < (CLUSTER_SIZE + 1); cx++)
                            {
                                int _cx = cx;
                                int _cy = cy;
                                if ((x + cx) == this.Width)
                                {
                                    _cx--;
                                }
                                if ((x + cy) == this.Width)
                                {
                                    _cy--;
                                }
                                writer.Write(this.AlphaMap1[x + _cx, y + _cy]);
                            }
                        }
                    }
                    else //if (Version < 4)
                    {
                        if (haveAlpha1)
                        {
                            for (int cy = 0; cy < CLUSTER_SIZE; cy++)
                            {
                                for (int cx = 0; cx < CLUSTER_SIZE; cx++)
                                {
                                    writer.Write(this.AlphaMap1[x + cx, y + cy]);
                                }
                            }
                        }
                        else
                        {
                            writer.Write(this.AlphaMap1[x, y]);
                        }
                    }

                    // alpha map 2
                    if (Version < 3)
                    {
                        for (int cy = 0; cy < (CLUSTER_SIZE + 1); cy++)
                        {
                            for (int cx = 0; cx < (CLUSTER_SIZE + 1); cx++)
                            {
                                int _cx = cx;
                                int _cy = cy;
                                if ((x + cx) == this.Width)
                                {
                                    _cx--;
                                }
                                if ((x + cy) == this.Width)
                                {
                                    _cy--;
                                }
                                writer.Write(this.AlphaMap2[x + _cx, y + _cy]);
                            }
                        }
                    }
                    else //if (Version < 4)
                    {
                        if (haveAlpha2)
                        {
                            for (int cy = 0; cy < CLUSTER_SIZE; cy++)
                            {
                                for (int cx = 0; cx < CLUSTER_SIZE; cx++)
                                {
                                    writer.Write(this.AlphaMap2[x + cx, y + cy]);
                                }
                            }
                        }
                        else
                        {
                            writer.Write(this.AlphaMap2[x, y]);
                        }
                    }

                    // alpha map 3
                    if (Version < 3)
                    {
                        for (int cy = 0; cy < (CLUSTER_SIZE + 1); cy++)
                        {
                            for (int cx = 0; cx < (CLUSTER_SIZE + 1); cx++)
                            {
                                int _cx = cx;
                                int _cy = cy;
                                if ((x + cx) == this.Width)
                                {
                                    _cx--;
                                }
                                if ((x + cy) == this.Width)
                                {
                                    _cy--;
                                }
                                writer.Write(this.AlphaMap3[x + _cx, y + _cy]);
                            }
                        }
                    }
                    else //if (Version < 4)
                    {
                        if (haveAlpha3)
                        {
                            for (int cy = 0; cy < CLUSTER_SIZE; cy++)
                            {
                                for (int cx = 0; cx < CLUSTER_SIZE; cx++)
                                {
                                    writer.Write(this.AlphaMap3[x + cx, y + cy]);
                                }
                            }
                        }
                        else
                        {
                            writer.Write(this.AlphaMap3[x, y]);
                        }
                    }

                    // cliff map
                    if (Version < 3)
                    {
                        for (int cy = 0; cy < (CLUSTER_SIZE + 1); cy++)
                        {
                            for (int cx = 0; cx < (CLUSTER_SIZE + 1); cx++)
                            {
                                int _cx = cx;
                                int _cy = cy;
                                if ((x + cx) == this.Width)
                                {
                                    _cx--;
                                }
                                if ((x + cy) == this.Width)
                                {
                                    _cy--;
                                }
                                writer.Write((byte)this.CellMap[x + _cx, y + _cy]);
                            }
                        }
                    }
                    else //if (Version < 4)
                    {
                        if (haveCell)
                        {
                            for (int cy = 0; cy < CLUSTER_SIZE; cy++)
                            {
                                for (int cx = 0; cx < CLUSTER_SIZE; cx++)
                                {
                                    writer.Write((byte)this.CellMap[x + cx, y + cy]);
                                }
                            }
                        }
                        else
                        {
                            writer.Write((byte)this.CellMap[x, y]);
                        }
                    }

                    // info map
                    writer.Write(this.InfoMap[x / CLUSTER_SIZE, y / CLUSTER_SIZE]);

                    // ???
                    if (Version > 0)
                    {
                        if (Version < 3)
                        {
                            for (int i = 0; i < 25; i++)
                            {
                                writer.Write(0x00);
                            }
                        }
                        if (Version == 2)
                        {
                            writer.Write(0x00);
                        }
                    }
                }
            }
        }