示例#1
0
        public SurfaceRenderer(OutputHandler outputHandler, int screenWidth, int screenHeight, bool mesureTime = true)
        {
            OutputHandler = outputHandler;
            OutputHandler.Enable();

            this.screenWidth  = screenWidth;
            this.screenHeight = screenHeight;

            surface    = new ISurfaceItem[screenWidth, screenHeight];
            surfaceSet = new bool[screenWidth, screenHeight];

            if (mesureTime)
            {
                clcStopwatch = new Stopwatch();
                relStopwatch = new Stopwatch();
                wrtStopwatch = new Stopwatch();
                glbStopwatch = new Stopwatch();
            }
        }
示例#2
0
        private void ConsumerJob()
        {
            while (bufferQueue.Consume(out byte[] buffer))
            {
                if (buffer == null)
                {
                    continue;
                }

                BeginWrtRecord();

                OutputHandler.Write(buffer, buffer.Length);

                EndWrtRecord();
            }

            OutputHandler.EndWrite();

            EndRelRecord();

            EndGlbRecord();
            ExportRecord();
        }
示例#3
0
 public SimpleColorOnlySurfaceRenderer(OutputHandler outputHandler, int screenWidth, int screenHeight, bool mesureTime = true)
     : base(outputHandler, screenWidth, screenHeight, mesureTime)
 {
 }
示例#4
0
        public override void ReleaseSurface()
        {
            BeginRelRecord();

            int surfaceSize = screenWidth * screenHeight;

            byte[] buffer           = new byte[surfaceSize * 20];
            int    positionInBuffer = 0;

            int x = 0;
            int y = 0;

            int nx = 1;
            int ny = 0;

            for (int i = 0; i < surfaceSize; i++)
            {
                int count = 1;

                // count contiguous surface items
                while (
                    i < surfaceSize - 1 &&
                    ((!surfaceSet[x, y] && !surfaceSet[nx, ny]) ||
                     (surfaceSet[x, y] && surface[x, y].Equals(surface[nx, ny]))))
                {
                    i++;
                    count++;

                    x++;
                    if (x >= screenWidth)
                    {
                        x = 0;
                        y++;

                        nx = 1;
                        ny++;
                    }
                    else
                    {
                        nx = x + 1;
                        if (nx >= screenWidth)
                        {
                            nx = 0;
                            ny++;
                        }
                    }
                }

                byte[] surfaceItemSeq = surface[x, y].Bytes ?? RgbSurfaceItem.BaseColorSequence;
                // set to background
                surfaceItemSeq[2] = 52;

                // block copy color sequence
                Buffer.BlockCopy(surfaceItemSeq, 0, buffer, positionInBuffer, 19);
                // set chars in buffer
                Memset(buffer, positionInBuffer + 19, count, 32); // 32 -> white space

                positionInBuffer += 19 + count;

                x++;
                if (x >= screenWidth)
                {
                    x = 0;
                    y++;
                }
                else
                {
                    nx = x + 1;
                    if (nx >= screenWidth)
                    {
                        nx = 0;
                        ny++;
                    }
                }
            }

            EndRelRecord();
            BeginWrtRecord();

            Console.SetCursorPosition(0, 0);
            OutputHandler.Write(buffer, positionInBuffer);
            OutputHandler.EndWrite();

            EndWrtRecord();

            EndGlbRecord();
            ExportRecord();
        }
示例#5
0
 public QueuedSurfaceRenderer(OutputHandler outputHandler, int screenWidth, int screenHeight, bool mesureTime = true)
     : base(outputHandler, screenWidth, screenHeight, mesureTime)
 {
     bufferQueue = new ProducerConsumerQueue <byte[]>();
 }