Example #1
0
        public void Draw(LogicState state, DrawingWindowState drawingWindowState)
        {
            _stopwatch.Restart();

            using (Bitmap.GetBitmapContext())
            {
                Bitmap.Clear();

                var renderer = new MapRenderer(16, 16);

                renderer.Render(state.Map, Bitmap, ImageProvider, drawingWindowState);
            }

            var elapsed = _stopwatch.ElapsedMilliseconds;

            if (elapsed > 150)
            {
                Logger.Write($"Drawing takes {elapsed}ms! Consider disabling it!");
            }
        }
Example #2
0
        public void Render <TNode>(IMap2D <TNode> map, WriteableBitmap target, ImageProvider <TNode> imageProvider, DrawingWindowState drawingWindowState)
        {
            if (drawingWindowState.Z >= 1200 - _minZoom * 1200.0)
            {
                drawingWindowState.Z = (int)(1200 - _minZoom * 1200.0);
            }

            if (drawingWindowState.Z < 0)
            {
                drawingWindowState.Z = 0;
            }

            var scale   = (1200 - drawingWindowState.Z) / 1200.0;
            var xOffset = drawingWindowState.X / (_cellWidth * scale);
            var yOffset = drawingWindowState.Y / (_cellHeight * scale);

            var cellWidth  = (int)(_cellWidth * scale);
            var cellHeight = (int)(_cellHeight * scale);

            var xCellsAmount = target.PixelWidth / cellWidth;
            var yCellsAmount = target.PixelHeight / cellHeight;

            var xPixelOffset = (int)((xOffset - Math.Truncate(xOffset)) * cellWidth);
            var yPixelOffset = (int)((yOffset - Math.Truncate(yOffset)) * cellHeight);

            var targetRect = new Rect(0, 0, cellWidth, cellHeight);

            for (var y = 0; y <= yCellsAmount; y++)
            {
                for (var x = 0; x <= xCellsAmount; x++)
                {
                    var node = map.SafeNodeAt(x - (int)xOffset, y - (int)yOffset);
                    if (ReferenceEquals(node, null))
                    {
                        continue;
                    }

                    targetRect.X = x * cellWidth + xPixelOffset;
                    targetRect.Y = y * cellHeight + yPixelOffset;
                    foreach (var image in imageProvider(node, x, y))
                    {
                        target.Blit(targetRect, image, _sourceRect);
                    }
                }
            }
        }