public void Update(BlockColumnMeta update)
{
var rect = GetBlockRectangle(update.Position);
if (!BitmapBounds.Contains(rect))
{
Log.WarnFormat("Attemptedto draw block outside the tile bounds, Block: {2}, Rect: {0}, Bitmap Bounds : {1}", rect, BitmapBounds, update.Position);
return;
}
//using (var clip = new Region(rect))
//{
//Graphics.Clip = clip;
lock (_bitmapSync)
{
Layer.Renderer.DrawBlock(Graphics, rect, update);
foreach (var postProcessor in Layer.PostProcessors)
{
postProcessor.PostProcess(this, Graphics, update);
}
}
_updatedBlocks.Add(update.Position);
//Graphics.ResetClip();
//}
}
public void Update(BlockColumnMeta update)
{
var pos = update.Position;
if (!Position.GetBlockBounds().Contains(pos))
{
Log.InfoFormat("Region {0} with bounds {1} doesn't contain block {2}", Position, Position.GetBlockBounds(), pos);
return;
}
var x = pos.X % Size;
var z = pos.Z % Size;
x = x < 0 ? Size + x : x;
z = z < 0 ? Size + z : z;
lock (_ioSync)
{
//Log.InfoFormat("Updating block {0},{1} @ {2}", x, z, update.Position);
if (!Blocks.ContainsKey(x))
{
Blocks.Add(x, new Dictionary <int, BlockColumnMeta>());
}
Blocks[x][z] = update;
_isDirty = true;
}
}
public void DrawBlock(Graphics graphics, RectangleF bounds, BlockColumnMeta blockColumn)
{
var variant = GetBlockStateVariant(blockColumn);
if (variant == null)
{
return;
}
foreach (var model in variant.Select(m => m.Model))
{
foreach (var modelElement in model.Elements.OrderBy(e => e.To.Y))
{
var from = new PointF(modelElement.From.X, modelElement.From.Z);
var to = new PointF(modelElement.To.X, modelElement.To.Z);
var relativeBounds = new RectangleF(from, new System.Drawing.SizeF(to.X - from.X, to.Y - from.Y));
var rect = new RectangleF(bounds.X + relativeBounds.X, bounds.Y + relativeBounds.Y, relativeBounds.Width, relativeBounds.Height);
if (modelElement.Faces.TryGetValue(BlockFace.Up, out var face))
{
var srcRect = new Rectangle(face.UV.X1, face.UV.Y1, face.UV.X2 - face.UV.X1, face.UV.Y2 - face.UV.Y1);
using (var br = new TextureBrush(face.Texture, srcRect))
{
graphics.FillRectangle(br, rect);
}
}
}
}
}
public void PostProcess(MapRegionLayer layer, Graphics graphics, BlockColumnMeta block)
{
DrawShadow(layer, graphics, block,
Math.Max(GetHeightDiff(layer, block, 0, -1), 0),
Math.Max(GetHeightDiff(layer, block, -1, 0), 0),
Math.Max(GetHeightDiff(layer, block, 1, 0), 0),
Math.Max(GetHeightDiff(layer, block, 0, 1), 0));
}
public void DrawBlock(Graphics graphics, RectangleF bounds, BlockColumnMeta blockColumn)
{
var i = blockColumn.Height % Steps;
using (var brush = new SolidBrush(Colors[i]))
{
graphics.FillRectangle(brush, bounds);
}
}
public void DrawBlock(Graphics graphics, RectangleF bounds, BlockColumnMeta blockColumn)
{
var color = GetBiomeColor(blockColumn.BiomeId);
using (var b = new SolidBrush(color))
{
graphics.FillRectangle(b, bounds);
}
}
private BlockStateVariant GetBlockStateVariant(BlockColumnMeta blockColumnMeta)
{
if (ResourcePack.TryGetBlockState(blockColumnMeta.BlockId, blockColumnMeta.BlockMeta, out var blockStateVariant))
{
return(blockStateVariant);
}
return(null);
}
public void PostProcess(MapRegionLayer layer, Graphics graphics, BlockColumnMeta block)
{
var rect = layer.GetBlockRectangle(block.Position);
var alpha = (int)MathUtils.Clamp(MaxOverlayAlpha * ((MaxLightLevel - block.LightLevel) / MaxLightLevel), 0f, MaxOverlayAlpha);
using (var brush = new SolidBrush(Color.FromArgb(alpha, Color.Black)))
{
graphics.FillRectangle(brush, rect);
}
}
private int GetHeightDiff(MapRegionLayer regionLayer, BlockColumnMeta block, int xOffset, int zOffset)
{
var pos = new BlockPosition(block.Position.X + xOffset, block.Position.Z + zOffset);
BlockColumnMeta targetBlock = regionLayer.Layer.Map.GetRegionLayer(pos.GetRegionPosition()).GetBlockData(pos);
if (targetBlock != null)
{
return(targetBlock.Height - block.Height);
}
return(0);
}
public void DrawBlock(Graphics graphics, RectangleF bounds, BlockColumnMeta blockColumn)
{
var blockId = (byte)blockColumn.BlockId;
using (var texture = ResourcePack.GetTexture(blockId))
{
graphics.FillRectangle(texture, bounds);
if (FoilageBlocks.Contains(blockId))
{
var biome = BiomeUtils.GetBiome(blockColumn.BiomeId);
var c = Color.FromArgb(biome.Foliage);
var tint = Color.FromArgb(128, c.R, c.G, c.B);
using (var img = new SolidBrush(tint))
{
graphics.FillRectangle(img, bounds);
}
}
}
}
public void UpdateBlockColumn(BlockColumnMeta update)
{
//Log.InfoFormat("{0}", chunkPos);
BlockBounds.Min.X = Math.Min(update.Position.X, BlockBounds.Min.X);
BlockBounds.Min.Z = Math.Min(update.Position.Z, BlockBounds.Min.Z);
BlockBounds.Max.X = Math.Max(update.Position.X, BlockBounds.Max.X);
BlockBounds.Max.Z = Math.Max(update.Position.Z, BlockBounds.Max.Z);
var region = GetRegionLayer(update.Position.GetRegionPosition());
region.Update(update);
var layers = Layers;
if (layers.Length > 0)
{
foreach (var layer in layers)
{
layer.UpdateBlockColumn(update);
}
}
}
public void PostProcess(MapRegionLayer layer, Graphics graphics, BlockColumnMeta block)
{
var rect = layer.GetBlockRectangle(block.Position);
var chunkPos = block.Position.GetChunkPosition();
var chunkBounds = chunkPos.GetBlockBounds();
var chunkRect = layer.GetChunkRectangle(chunkPos);
var rX = block.Position.X % 16;
var rZ = block.Position.Z % 16;
if (rX == 15 && rZ == 15)
{
graphics.DrawRectangle(_chunkPen, chunkRect);
}
graphics.DrawRectangle(_gridPen, rect);
if (rX == 15 && rZ == 15)
{
DrawText(graphics, chunkPos.ToString(), chunkRect, _chunkCoordFont);
var min = chunkBounds.Min;
var max = chunkBounds.Max;
var tl = min;
var tr = new BlockPosition(min.X, max.Z);
var bl = new BlockPosition(max.X, min.Z);
var br = max;
DrawText(graphics, tl.ToString(), chunkRect, _coordFont, StringAlignment.Near, StringAlignment.Near);
DrawText(graphics, tr.ToString(), chunkRect, _coordFont, StringAlignment.Far, StringAlignment.Near);
DrawText(graphics, bl.ToString(), chunkRect, _coordFont, StringAlignment.Near, StringAlignment.Far);
DrawText(graphics, br.ToString(), chunkRect, _coordFont, StringAlignment.Far, StringAlignment.Far);
}
}
public void UpdateBlockColumn(BlockColumnMeta column)
{
_updates.Enqueue(MiMapJsonConvert.DeserializeObject <BlockColumnMeta>(MiMapJsonConvert.SerializeObject(column)));
}
private void DrawShadow(MapRegionLayer layer, Graphics graphics, BlockColumnMeta column, int sizeTop,
int sizeLeft, int sizeRight, int sizeBottom)
{
var rect = layer.GetBlockRectangle(column.Position);
int actSizeTop = 0, actSizeLeft = 0, actSizeRight = 0, actSizeBottom = 0;
if (sizeTop > 0)
{
actSizeTop = (int)MathUtils.Clamp(Math.Round(MaxShadowSize * (MathUtils.Clamp(sizeTop * ShadowSizeMultiplier, 0.25f, 1f))), 1f, MaxShadowSize);
for (int i = 0; i < actSizeTop; i++)
{
using (var pen = new Pen(Color.FromArgb((int)(MathUtils.Clamp(sizeTop * AlphaMultiplier, 64f, 255f) / actSizeTop) * (i + 1)
, Color.Black)))
{
graphics.DrawLine(pen, rect.Left, rect.Top + i, rect.Right, rect.Top + i);
}
}
}
if (sizeBottom > 0)
{
actSizeBottom = (int)MathUtils.Clamp(Math.Round(MaxShadowSize * (MathUtils.Clamp(sizeBottom * ShadowSizeMultiplier, 0.25f, 1f))), 1f, MaxShadowSize);
for (int i = 0; i < actSizeBottom; i++)
{
using (var pen =
new Pen(Color.FromArgb((int)(MathUtils.Clamp(sizeBottom * AlphaMultiplier, 64f, 255f) / actSizeBottom) * (i + 1),
Color.Black)))
{
graphics.DrawLine(pen, rect.Left, rect.Bottom - actSizeBottom + i, rect.Right, rect.Bottom - actSizeBottom + i);
}
}
}
if (sizeLeft > 0)
{
actSizeLeft = (int)MathUtils.Clamp(Math.Round(MaxShadowSize * (MathUtils.Clamp(sizeLeft * ShadowSizeMultiplier, 0.25f, 1f))), 1f, MaxShadowSize);
for (int i = 0; i < actSizeLeft; i++)
{
using (var pen = new Pen(Color.FromArgb((int)(MathUtils.Clamp(sizeLeft * AlphaMultiplier, 64f, 255f) / actSizeLeft) * (i + 1),
Color.Black)))
{
graphics.DrawLine(pen, rect.Left + i, rect.Top, rect.Left + i, rect.Bottom);
}
}
}
if (sizeRight > 0)
{
actSizeRight = (int)MathUtils.Clamp(Math.Round(MaxShadowSize * (MathUtils.Clamp(sizeRight * ShadowSizeMultiplier, 0.25f, 1f))), 1f, MaxShadowSize);
for (int i = 0; i < actSizeRight; i++)
{
using (var pen =
new Pen(Color.FromArgb((int)(MathUtils.Clamp(sizeRight * AlphaMultiplier, 64f, 255f) / actSizeRight) * (i + 1),
Color.Black)))
{
graphics.DrawLine(pen, rect.Right - actSizeRight + i, rect.Top, rect.Right - actSizeRight + i, rect.Bottom);
}
}
}
}
public void DrawBlock(Graphics graphics, RectangleF bounds, BlockColumnMeta blockColumn)
{
graphics.FillRectangle(GetBrush(blockColumn.BiomeId), bounds);
}
