UltimateZoneBuilder/Source/Core/Rendering/Plotter.cs

#region ================== Copyright (c) 2007 Pascal vd Heiden

/*
 * Copyright (c) 2007 Pascal vd Heiden, www.codeimp.com
 * This program is released under GNU General Public License
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 */

#endregion

#region ================== Namespaces

using System;
using CodeImp.DoomBuilder.Geometry;

#endregion

namespace CodeImp.DoomBuilder.Rendering
{
    internal unsafe sealed class Plotter : IDisposable
    {
        #region ================== Constants

        private const int DASH_INTERVAL = 16; //mxd

        #endregion

        #region ================== Variables

        // Memory
        private PixelColor[] pixels;
        private int width;
        private int height;
        private int visiblewidth;
        private int visibleheight;
        // GL
        public Texture Texture { get; private set; }

        #endregion

        #region ================== Properties

        public int VisibleWidth { get { return visiblewidth; } }
        public int VisibleHeight { get { return visibleheight; } }
        public int Width { get { return width; } }
        public int Height { get { return height; } }

        #endregion

        #region ================== Constructor / Disposer

        // Constructor
        public Plotter(int width, int height)
        {
            // Initialize
            Texture = new Texture(width, height, TextureFormat.Bgra8);
            this.pixels = new PixelColor[width*height];
            this.width = width;
            this.height = height;
            this.visiblewidth = width;
            this.visibleheight = height;
        }

        public void Dispose()
        {
            if (Texture != null)
            {
                Texture.Dispose();
                Texture = null;
            }
        }

        #endregion

        #region ================== Pixel Rendering

        private int TransformY(int y)
        {
            return height - y;
        }

        // This clears all pixels black
        public void Clear()
        {
            // Clear memory
            fixed(PixelColor* pixel = pixels)
            {
                uint* op = (uint*)pixel;
                for (int i = 0; i < pixels.Length; i++)
                {
                    *op = 0;
                    op++;
                }
            }
        }

        // This draws a pixel normally
        public void DrawPixelSolid(int x, int y, ref PixelColor c)
        {
            y = TransformY(y);

            // Draw pixel when within range
            if ((x >= 0) && (x < visiblewidth) && (y >= 0) && (y < visibleheight))
                pixels[y * width + x] = c;
        }

        // This draws a pixel normally
        public void DrawVertexSolid(int x, int y, int size, ref PixelColor c, ref PixelColor l, ref PixelColor d)
        {
            y = TransformY(y);

            int x1 = x - size;
            int x2 = x + size;
            int y1 = y - size;
            int y2 = y + size;

            // Do unchecked?
            if ((x1 >= 0) && (x2 < visiblewidth) && (y1 >= 0) && (y2 < visibleheight))
            {
                // Filled square
                for (int yp = y1; yp <= y2; yp++)
                    for (int xp = x1; xp <= x2; xp++)
                        pixels[yp * width + xp] = c;

                if (!General.Settings.FlatShadeVertices)
                {
                    // Vertical edges
                    for (int yp = y1 + 1; yp <= y2 - 1; yp++)
                    {
                        pixels[yp * width + x1] = l;
                        pixels[yp * width + x2] = d;
                    }

                    // Horizontal edges
                    for (int xp = x1 + 1; xp <= x2 - 1; xp++)
                    {
                        pixels[y1 * width + xp] = l;
                        pixels[y2 * width + xp] = d;
                    }

                    // Corners
                    pixels[y2 * width + x2] = d;
                    pixels[y1 * width + x1] = l;
                }
            }
            /*
			else
			{
				// Filled square
				for(yp = y - size; yp <= y + size; yp++)
					for(xp = x - size; xp <= x + size; xp++)
						DrawPixelSolid(xp, yp, c);

				// Vertical edges
				for(yp = y - size + 1; yp <= y + size - 1; yp++)
				{
					DrawPixelSolid(x - size, yp, l);
					DrawPixelSolid(x + size, yp, d);
				}

				// Horizontal edges
				for(xp = x - size + 1; xp <= x + size - 1; xp++)
				{
					DrawPixelSolid(xp, y - size, l);
					DrawPixelSolid(xp, y + size, d);
				}

				// Corners
				DrawPixelSolid(x + size, y + size, d);
				DrawPixelSolid(x - size, y - size, l);
			}
			*/
        }

        // This draws a dotted grid line horizontally
        public void DrawGridLineH(int y, int x1, int x2, ref PixelColor c)
        {
            y = TransformY(y);

            int numpixels = visiblewidth >> 1;
            int offset = y & 0x01;
            int ywidth = y * width;
            x1 = General.Clamp(x1 >> 1, 0, numpixels - 1);
            x2 = General.Clamp(x2 >> 1, 0, numpixels - 1);

            if ((y >= 0) && (y < height))
            {
                // Draw all pixels on this line
                for (int i = x1; i < x2; i++) pixels[ywidth + ((i << 1) | offset)] = c;
            }
        }

        // This draws a dotted grid line vertically
        public void DrawGridLineV(int x, int y1, int y2, ref PixelColor c)
        {
            y1 = TransformY(y1);
            y2 = TransformY(y2);

            int numpixels = visibleheight >> 1;
            int offset = x & 0x01;
            y1 = General.Clamp(y1 >> 1, 0, numpixels - 1);
            y2 = General.Clamp(y2 >> 1, 0, numpixels - 1);

            if ((x >= 0) && (x < width))
            {
                // Draw all pixels on this line
                for (int i = y2; i < y1; i++) pixels[((i << 1) | offset) * width + x] = c;
            }
        }

        // This draws a pixel alpha blended
        public void DrawPixelAlpha(int x, int y, ref PixelColor c)
        {
            y = TransformY(y);

            fixed (PixelColor* pixels = this.pixels)
            {
                // Draw only when within range
                if ((x >= 0) && (x < visiblewidth) && (y >= 0) && (y < visibleheight))
                {
                    // Get the target pixel
                    PixelColor* p = pixels + (y * width + x);

                    // Not drawn on target yet?
                    if (*(int*)p == 0)
                    {
                        // Simply apply color to pixel
                        *p = c;
                    }
                    else
                    {
                        // Blend with pixel
                        float a = c.a * 0.003921568627450980392156862745098f;
                        if (p->a + c.a > 255) p->a = 255; else p->a += c.a;
                        p->r = (byte)(p->r * (1f - a) + c.r * a);
                        p->g = (byte)(p->g * (1f - a) + c.g * a);
                        p->b = (byte)(p->b * (1f - a) + c.b * a);
                    }
                }
            }
        }

        // This draws a line normally
        // See: http://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm
        public void DrawLineSolid(int x1, int y1, int x2, int y2, ref PixelColor c, uint mask = 0xffffffff)
        {
            y1 = TransformY(y1);
            y2 = TransformY(y2);

            // Check if the line is outside the screen for sure.
            // This is quickly done by checking in which area both points are. When this
            // is above, below, right or left of the screen, then skip drawing the line.
            if (((x1 < 0) && (x2 < 0)) ||
               ((x1 > visiblewidth) && (x2 > visiblewidth)) ||
               ((y1 < 0) && (y2 < 0)) ||
               ((y1 > visibleheight) && (y2 > visibleheight))) return;

            // Distance of the line
            int dx = x2 - x1;
            int dy = y2 - y1;

            // Positive (absolute) distance
            int dxabs = Math.Abs(dx);
            int dyabs = Math.Abs(dy);

            // Half distance
            int x = dyabs >> 1;
            int y = dxabs >> 1;

            // Direction
            int sdx = Math.Sign(dx);
            int sdy = Math.Sign(dy);

            // Start position
            int px = x1;
            int py = y1;

            // When the line is completely inside screen,
            // then do an unchecked draw, because all of its pixels are
            // guaranteed to be within the memory range
            if ((x1 >= 0) && (x2 >= 0) && (x1 < visiblewidth) && (x2 < visiblewidth) &&
               (y1 >= 0) && (y2 >= 0) && (y1 < visibleheight) && (y2 < visibleheight))
            {
                // Draw first pixel
                pixels[py * width + px] = c;

                // Check if the line is more horizontal than vertical
                if (dxabs >= dyabs)
                {
                    for (int i = 0; i < dxabs; i++)
                    {
                        y += dyabs;
                        if (y >= dxabs)
                        {
                            y -= dxabs;
                            py += sdy;
                        }
                        px += sdx;

                        // Draw pixel
                        if ((mask & (1 << (i & 0x7))) != 0)
                        {
                            pixels[py * width + px] = c;
                        }
                    }
                }
                // Else the line is more vertical than horizontal
                else
                {
                    for (int i = 0; i < dyabs; i++)
                    {
                        x += dxabs;
                        if (x >= dyabs)
                        {
                            x -= dyabs;
                            px += sdx;
                        }
                        py += sdy;

                        // Draw pixel
                        if ((mask & (1 << (i & 0x7))) != 0)
                        {
                            pixels[py * width + px] = c;
                        }
                    }
                }
            }
            else
            {
                // Draw first pixel
                if ((px >= 0) && (px < visiblewidth) && (py >= 0) && (py < visibleheight))
                    pixels[py * width + px] = c;

                // Check if the line is more horizontal than vertical
                if (dxabs >= dyabs)
                {
                    for (int i = 0; i < dxabs; i++)
                    {
                        y += dyabs;
                        if (y >= dxabs)
                        {
                            y -= dxabs;
                            py += sdy;
                        }
                        px += sdx;

                        // Draw pixel
                        if ((mask & (1 << (i & 0x7))) != 0)
                        {
                            if ((px >= 0) && (px < visiblewidth) && (py >= 0) && (py < visibleheight))
                                pixels[py * width + px] = c;
                        }
                    }
                }
                // Else the line is more vertical than horizontal
                else
                {
                    for (int i = 0; i < dyabs; i++)
                    {
                        x += dxabs;
                        if (x >= dyabs)
                        {
                            x -= dyabs;
                            px += sdx;
                        }
                        py += sdy;

                        // Draw pixel
                        if ((mask & (1 << (i & 0x7))) != 0)
                        {
                            if ((px >= 0) && (px < visiblewidth) && (py >= 0) && (py < visibleheight))
                                pixels[py * width + px] = c;
                        }
                    }
                }
            }
        }

        //mxd
        public void DrawLine3DFloor(int x1, int y1, int x2, int y2, ref PixelColor c, PixelColor c2)
        {
			Line2D line = new Line2D(x1, y1, x2, y2);
			double length = line.GetLength();

            if (length < DASH_INTERVAL * 2)
            {
                DrawLineSolid(x1, y1, x2, y2, ref c2);
            }
            else
            {
				double d1 = DASH_INTERVAL / length;
				double d2 = 1.0f - d1;

				
				Vector2D p1 = line.GetCoordinatesAt(d1);
				Vector2D p2 = line.GetCoordinatesAt(d2);

                DrawLineSolid(x1, y1, (int)p1.x, (int)p1.y, ref c2);
                DrawLineSolid((int)p1.x, (int)p1.y, (int)p2.x, (int)p2.y, ref c);
                DrawLineSolid((int)p2.x, (int)p2.y, x2, y2, ref c2);
            }
        }

        #endregion

        #region ================== Drawing to rendertarget

        public void DrawContents(RenderDevice graphics)
        {
            // set pixels of texture
            // convert from pixelcolor to uint
            fixed (PixelColor* pixels = this.pixels)
            {
                uint* uintpixels = (uint*)pixels;
                uint* targetpixels = (uint*)graphics.MapPBO(Texture);
                for (int i = 0; i < this.pixels.Length; i++)
                    *targetpixels++ = *uintpixels++;
                graphics.UnmapPBO(Texture);
            }
        }

        #endregion
    }
}