/// <summary>
/// Converts rendered image to bitmap
/// </summary>
/// <returns></returns>
private D2D1.BitmapRenderTarget RenderBitmap()
{
using (var textureToBitmap = Texture2D.FromSwapChain <Texture2D>(_swapChain, 0)) {
using (var surface = textureToBitmap.QueryInterface <Surface>()) {
using (D2D1.Factory factory = new D2D1.Factory1()) {
var target = new D2D1.RenderTarget(
factory,
surface,
new D2D1.RenderTargetProperties(
new D2D1.PixelFormat(Format.B8G8R8A8_UNorm, D2D1.AlphaMode.Ignore)
)
);
D2D1.BitmapRenderTarget tes = null;
tes = new D2D1.BitmapRenderTarget(
target,
D2D1.CompatibleRenderTargetOptions.None,
new D2D1.PixelFormat(
Format.B8G8R8A8_UNorm,
D2D1.AlphaMode.Ignore));
target.Dispose();
return(tes);
}
}
}
}
public VisualBrushImpl(
VisualBrush brush,
SharpDX.Direct2D1.RenderTarget target,
Size targetSize)
{
var visual = brush.Visual;
if (visual == null)
{
return;
}
var layoutable = visual as ILayoutable;
if (layoutable?.IsArrangeValid == false)
{
layoutable.Measure(Size.Infinity);
layoutable.Arrange(new Rect(layoutable.DesiredSize));
}
var tileMode = brush.TileMode;
var sourceRect = brush.SourceRect.ToPixels(layoutable.Bounds.Size);
var destinationRect = brush.DestinationRect.ToPixels(targetSize);
var scale = brush.Stretch.CalculateScaling(destinationRect.Size, sourceRect.Size);
var translate = CalculateTranslate(brush, sourceRect, destinationRect, scale);
var intermediateSize = CalculateIntermediateSize(tileMode, targetSize, destinationRect.Size);
var brtOpts = CompatibleRenderTargetOptions.None;
// TODO: There are times where we don't need to draw an intermediate bitmap. Identify
// them and directly use 'image' in those cases.
using (var intermediate = new BitmapRenderTarget(target, brtOpts, intermediateSize))
{
Rect drawRect;
var transform = CalculateIntermediateTransform(
tileMode,
sourceRect,
destinationRect,
scale,
translate,
out drawRect);
var renderer = new RenderTarget(intermediate);
using (var ctx = renderer.CreateDrawingContext())
using (ctx.PushClip(drawRect))
using (ctx.PushPostTransform(transform))
{
intermediate.Clear(new Color4(0));
ctx.Render(visual);
}
this.PlatformBrush = new BitmapBrush(
target,
intermediate.Bitmap,
GetBitmapBrushProperties(brush),
GetBrushProperties(brush, destinationRect));
}
}
public VisualBrushImpl(
VisualBrush brush,
RenderTarget target,
Size targetSize)
{
var visual = brush.Visual;
var layoutable = visual as ILayoutable;
if (layoutable?.IsArrangeValid == false)
{
layoutable.Measure(Size.Infinity);
layoutable.Arrange(new Rect(layoutable.DesiredSize));
}
var sourceRect = brush.SourceRect.ToPixels(layoutable.Bounds.Size);
var destinationRect = brush.DestinationRect.ToPixels(targetSize);
var bitmapSize = brush.TileMode == TileMode.None ? targetSize : destinationRect.Size;
var scale = brush.Stretch.CalculateScaling(destinationRect.Size, sourceRect.Size);
var translate = CalculateTranslate(brush, sourceRect, destinationRect, scale);
var options = CompatibleRenderTargetOptions.None;
using (var brt = new BitmapRenderTarget(target, options, bitmapSize.ToSharpDX()))
{
var renderer = new Renderer(brt);
var transform = Matrix.CreateTranslation(-sourceRect.Position) *
Matrix.CreateScale(scale) *
Matrix.CreateTranslation(translate);
Rect drawRect;
if (brush.TileMode == TileMode.None)
{
drawRect = destinationRect;
transform *= Matrix.CreateTranslation(destinationRect.Position);
}
else
{
drawRect = new Rect(0, 0, destinationRect.Width, destinationRect.Height);
}
renderer.Render(visual, null, transform, drawRect);
var result = new BitmapBrush(brt, brt.Bitmap);
result.ExtendModeX = (brush.TileMode & TileMode.FlipX) != 0 ? ExtendMode.Mirror : ExtendMode.Wrap;
result.ExtendModeY = (brush.TileMode & TileMode.FlipY) != 0 ? ExtendMode.Mirror : ExtendMode.Wrap;
if (brush.TileMode != TileMode.None)
{
result.Transform = SharpDX.Matrix3x2.Translation(
(float)destinationRect.X,
(float)destinationRect.Y);
}
PlatformBrush = result;
}
}
public ImageBrushImpl(
ImageBrush brush,
SharpDX.Direct2D1.RenderTarget target,
Size targetSize)
{
if (brush.Source == null)
{
return;
}
var image = ((BitmapImpl)brush.Source.PlatformImpl).GetDirect2DBitmap(target);
var imageSize = new Size(brush.Source.PixelWidth, brush.Source.PixelHeight);
var tileMode = brush.TileMode;
var sourceRect = brush.SourceRect.ToPixels(imageSize);
var destinationRect = brush.DestinationRect.ToPixels(targetSize);
var scale = brush.Stretch.CalculateScaling(destinationRect.Size, sourceRect.Size);
var translate = CalculateTranslate(brush, sourceRect, destinationRect, scale);
var intermediateSize = CalculateIntermediateSize(tileMode, targetSize, destinationRect.Size);
var brtOpts = CompatibleRenderTargetOptions.None;
// TODO: There are times where we don't need to draw an intermediate bitmap. Identify
// them and directly use 'image' in those cases.
using (var intermediate = new BitmapRenderTarget(target, brtOpts, intermediateSize))
{
Rect drawRect;
var transform = CalculateIntermediateTransform(
tileMode,
sourceRect,
destinationRect,
scale,
translate,
out drawRect);
intermediate.BeginDraw();
intermediate.PushAxisAlignedClip(drawRect.ToDirect2D(), AntialiasMode.Aliased);
intermediate.Transform = transform.ToDirect2D();
intermediate.DrawBitmap(image, 1, BitmapInterpolationMode.Linear);
intermediate.PopAxisAlignedClip();
intermediate.EndDraw();
this.PlatformBrush = new BitmapBrush(
target,
intermediate.Bitmap,
GetBitmapBrushProperties(brush),
GetBrushProperties(brush, destinationRect));
}
}
/// <summary>
/// Unload content and cleanup unmanaged resources.
/// </summary>
public override void UnloadContent()
{
base.UnloadContent();
if (_state != null && !_state.IsDisposed)
{
_state.Dispose();
_state = null;
}
if (_font != null)
{
_font.Dispose();
}
_font = null;
if (_target != null)
{
_target.Dispose();
}
_target = null;
}
public TileBrushImpl(
TileBrush brush,
SharpDX.Direct2D1.RenderTarget target,
Size targetSize)
{
var helper = new TileBrushImplHelper(brush, targetSize);
if (!helper.IsValid)
return;
using (var intermediate = new BitmapRenderTarget(target, CompatibleRenderTargetOptions.None, helper.IntermediateSize.ToSharpDX()))
{
using (var ctx = new RenderTarget(intermediate).CreateDrawingContext())
helper.DrawIntermediate(ctx);
PlatformBrush = new BitmapBrush(
target,
intermediate.Bitmap,
GetBitmapBrushProperties(brush),
GetBrushProperties(brush, helper.DestinationRect));
}
}
/// <summary>
/// Load Content and initialize unmanaged resources.
/// </summary>
public override void LoadContent()
{
int width = 256;
int height = 256;
var size = Surface.RenderTarget2D.PixelSize;
var sizeV = new Vector2(size.Width, size.Height);
_start = sizeV - new Vector2(width, height) - new Vector2(10, 10);
_end = sizeV - new Vector2(10, 10);
_viewLocation = new SharpDX.RectangleF(_start.X, _start.Y, _end.X - _start.X, _end.Y - _start.Y);
base.LoadContent();
if (_font == null || _font.IsDisposed)
{
_font = Surface.Fonts.GetTextFormat(MM_Repository.OverallDisplay.NetworkMapFont, 5);
}
if (_target == null || _target.IsDisposed)
{
_target = Surface.CreateRenderTarget(width, height);
}
MM_Boundary State;
if (MM_Repository.Counties.TryGetValue("STATE", out State))
{
RawRectangleF bounds;
var geometry = Surface.CreateRegionPathGeometry(MM_Coordinates.ConvertPoints(State.Coordinates, 4).ToList(), out bounds, filled: true, simplify: true);
geometry.Dispose();
_scale = new Vector2(width / (bounds.Right - bounds.Left), height / (bounds.Bottom - bounds.Top));
var geometryScaled = Surface.CreateRegionPathGeometry(MM_Coordinates.ConvertPoints(State.Coordinates, 4).ToList(), out bounds, filled: true, compression: 0.001f, simplify: true, scaleX: _scale.X, scaleY: _scale.Y);
_location = new Vector2(bounds.Left, bounds.Top);
_state = new RegionProxy(geometryScaled, State.DisplayParameter.ForeColor, State.DisplayParameter.Width, bounds);
}
}
public SharpDX.Direct2D1.BitmapRenderTarget CreateRenderTarget(int height, int width)
{
var desc = new Texture2DDescription
{
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
Format = Format.R8G8B8A8_UNorm,
Height = height,
Width = width,
MipLevels = 1,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
OptionFlags = ResourceOptionFlags.None,
CpuAccessFlags = CpuAccessFlags.None,
ArraySize = 1
};
var texture = new Texture2D(Device, desc);
var d3DSurface = texture.QueryInterface <Surface>();
var rt2d = new RenderTarget(Factory2D, d3DSurface, new RenderTargetProperties(new PixelFormat(Format.R8G8B8A8_UNorm, AlphaMode.Premultiplied)));
var rt = new SharpDX.Direct2D1.BitmapRenderTarget(rt2d, CompatibleRenderTargetOptions.None);
rt.AntialiasMode = AntialiasMode;
return(rt);
}
/// <summary>
/// Sends bitmap to ViewModel through manager
/// </summary>
/// <param name="bitmapTarget"></param>
/// <param name="data"></param>
/// <param name="screenPoints"></param>
/// <param name="manager"></param>
private void DisplayBitmap(D2D1.BitmapRenderTarget bitmapTarget, byte[] data, List <List <windows.Point> > screenPoints, GraphView_StateManager manager)
{
if (bitmapTarget != null && data != null)
{
int height = 0;
int width = 0;
float dpiHeight = 0;
float dpiWidth = 0;
using (var bitmap = bitmapTarget.Bitmap) {
height = bitmap.PixelSize.Height;
width = bitmap.PixelSize.Width;
dpiHeight = bitmap.DotsPerInch.Height;
dpiWidth = bitmap.DotsPerInch.Width;
}
bitmapTarget.Dispose();
displayThread = new Thread(() => manager.SetupView(height, width, dpiHeight, dpiWidth, data, screenPoints));
displayThread.SetApartmentState(ApartmentState.STA);
displayThread.Start();
}
}
public void Start()
{
if (ProcessStarted != null)
ProcessStarted();
int index = 0;
var rendererUtil = new RendererUtil();
// obtain file list
var regionList = Directory.GetFiles(Path.Combine(worldLocation, "region"), "*.mca").ToList();
var regionEntries = new List<RegionEntry>();
foreach (string region in regionList)
{
try
{
// load the region
using (RegionFile regionFile = RegionFile.OpenRegion(File.OpenRead(region)))
{
var renderedChunks = new List<ChunkEntry>();
if (RegionLoaded != null)
RegionLoaded(regionFile);
Debug.WriteLine("Rendering region");
DateTime sTime = DateTime.Now;
#region Chunk render
using (var renderTarget = new BitmapRenderTarget(rendererUtil.D2DDeviceContext, CompatibleRenderTargetOptions.None, new DrawingSizeF(16, 16), new DrawingSize(16, 16), new PixelFormat(Format.R8G8B8A8_UNorm, AlphaMode.Premultiplied)))
{
foreach (var anvilChunk in regionFile.Content.Select(chunk => new Anvil(chunk)))
{
ChunkEntry entry;
RenderSegment(anvilChunk, renderTarget, out entry);
renderedChunks.Add(entry);
}
}
#endregion
#region Region compositor
using (var renderTarget = new BitmapRenderTarget(rendererUtil.D2DDeviceContext, CompatibleRenderTargetOptions.None, new DrawingSizeF(512, 512), new DrawingSize(512, 512), new PixelFormat(Format.R8G8B8A8_UNorm, AlphaMode.Premultiplied)))
{
renderTarget.BeginDraw();
renderTarget.Clear(Color.Transparent);
// compose the images
foreach (ChunkEntry chunk in renderedChunks)
{
int cxPos = chunk.XPos % 32;
int czPos = chunk.ZPos % 32;
if (cxPos < 0)
cxPos = 32 + cxPos;
if (czPos < 0)
czPos = 32 + czPos;
int xPos = cxPos * 16;
int zPos = czPos * 16;
renderTarget.Transform = Matrix3x2.Translation(xPos, zPos);
renderTarget.DrawBitmap(chunk.RenderedChunk, 1, BitmapInterpolationMode.Linear);
}
// ReSharper disable PossibleNullReferenceException
string[] info = Path.GetFileNameWithoutExtension(region).Split('.');
// ReSharper restore PossibleNullReferenceException
regionEntries.Add(new RegionEntry
{
RenderedRegion = renderTarget.Bitmap,
XPos = Convert.ToInt32(info[1]),
ZPos = Convert.ToInt32(info[2])
});
renderTarget.EndDraw();
}
#endregion
Debug.WriteLine("Render time is: " + (DateTime.Now - sTime).Seconds + " seconds.");
if (RegionRendered != null)
RegionRendered();
#region Cleanup
foreach (ChunkEntry chunk in renderedChunks)
chunk.RenderedChunk.Dispose();
renderedChunks.Clear();
#endregion
}
}
catch (Exception exception)
{
if (ProcessFailed != null)
ProcessFailed(exception.Message + "\nAt:\n" + exception);
}
if (ProgressChanged != null)
ProgressChanged(++index / (float)regionList.Count);
}
#region Extrema processor
int xMin = 0;
int zMin = 0;
int xMax = 0;
int zMax = 0;
foreach (RegionEntry entry in regionEntries)
{
if (xMin > entry.XPos)
xMin = entry.XPos;
if (xMax < entry.XPos)
xMax = entry.XPos;
if (zMin > entry.ZPos)
zMin = entry.ZPos;
if (zMax < entry.ZPos)
zMax = entry.ZPos;
}
int wSizeX = (xMax - xMin) * 512 + 512;
int wSizeZ = (zMax - zMin) * 512 + 512;
xMin = Math.Abs(xMin);
zMin = Math.Abs(zMin);
#endregion
#region World compositor
var ResultingBitmap = new Bitmap1(rendererUtil.D2DDeviceContext,
new DrawingSize(wSizeX, wSizeZ),
new BitmapProperties1
{
BitmapOptions = BitmapOptions.Target,
PixelFormat = new PixelFormat(Format.R8G8B8A8_UNorm, AlphaMode.Premultiplied)
});
rendererUtil.D2DDeviceContext.Target = ResultingBitmap;
rendererUtil.D2DDeviceContext.BeginDraw();
rendererUtil.D2DDeviceContext.Clear(Color.Transparent);
foreach (RegionEntry entry in regionEntries)
{
int xPos = ((xMin + entry.XPos) * 512);
int zPos = ((zMin + entry.ZPos) * 512);
rendererUtil.D2DDeviceContext.Transform = Matrix3x2.Translation(xPos, zPos);
rendererUtil.D2DDeviceContext.DrawBitmap(entry.RenderedRegion, 1, BitmapInterpolationMode.Linear);
}
rendererUtil.D2DDeviceContext.EndDraw();
#endregion
#region File save
FileStream file = File.OpenWrite(Path.GetFileName(worldLocation) + ".png");
var encoder = new PngBitmapEncoder(rendererUtil.ImagingFactory);
encoder.Initialize(file);
var frameEncode = new BitmapFrameEncode(encoder);
frameEncode.Initialize();
var imageEncoder = new ImageEncoder(rendererUtil.ImagingFactory, rendererUtil.D2DDevice);
imageEncoder.WriteFrame(ResultingBitmap,
frameEncode,
new ImageParameters(
new PixelFormat(Format.R8G8B8A8_UNorm, AlphaMode.Premultiplied),
96,
96,
0,
0,
wSizeX,
wSizeZ));
frameEncode.Commit();
encoder.Commit();
#endregion
#region Cleanup
file.Close();
file.Dispose();
foreach (RegionEntry bitmap in regionEntries)
{
bitmap.RenderedRegion.Dispose();
}
regionEntries.Clear();
rendererUtil.Dispose();
theBlocks.Dispose();
ResultingBitmap.Dispose();
#endregion
if (ProcessComplete != null)
ProcessComplete();
}
/// <summary>
/// Creates a new D2dBitmapGraphics with specified pixel size for use during intermediate offscreen drawing
/// that is compatible with the current D2dGraphics and has the same DPI, and pixel format
/// as the current D2dGraphics and with the specified options</summary>
/// <param name="pixelSize">The desired size of the new D2dGraphics in pixels</param>
/// <param name="options">Whether the new D2dBitmapGraphics must be compatible with GDI</param>
/// <returns>D2dBitmapGraphics with specified pixel size for use during intermediate offscreen drawing</returns>
public D2dBitmapGraphics CreateCompatibleGraphics(Size pixelSize, D2dCompatibleGraphicsOptions options)
{
var dsize = new Size2(pixelSize.Width, pixelSize.Height);
var rt = new BitmapRenderTarget(m_renderTarget, (CompatibleRenderTargetOptions)options, null, dsize, null);
return new D2dBitmapGraphics(this, rt);
}
/// <summary>
/// Creates a new D2dBitmapGraphics with specified DIP size for use during intermediate offscreen drawing
/// that is compatible with the current D2dGraphics and has the same DPI, and pixel format
/// as the current D2dGraphics and with the specified options</summary>
/// <param name="size">The desired size of the new D2dGraphics in pixels</param>
/// <param name="options">Whether the new D2dBitmapGraphics must be compatible with GDI</param>
/// <returns>D2dBitmapGraphics with specified DIP size for use during intermediate offscreen drawing</returns>
public D2dBitmapGraphics CreateCompatibleGraphics(SizeF size, D2dCompatibleGraphicsOptions options)
{
var rt = new BitmapRenderTarget(m_renderTarget, (CompatibleRenderTargetOptions)options, size.ToSharpDX(), null, null);
return new D2dBitmapGraphics(this, rt);
}
/// <summary>
/// Creates a new D2dBitmapGraphics for use during intermediate offscreen drawing
/// that is compatible with the current D2dGraphics and has the same size, DPI, and pixel format
/// as the current D2dGraphics</summary>
/// <returns>D2dBitmapGraphics for use during intermediate offscreen drawing</returns>
public D2dBitmapGraphics CreateCompatibleGraphics()
{
var rt = new BitmapRenderTarget(m_renderTarget, CompatibleRenderTargetOptions.None);
return new D2dBitmapGraphics(this, rt);
}
/// <summary>
/// Creates a new D2dBitmapGraphics for use during intermediate offscreen drawing
/// that is compatible with the current D2dGraphics and has the same size, DPI, and pixel format
/// as the current D2dGraphics and with the specified options</summary>
/// <param name="options">Whether the new D2dBitmapGraphics must be compatible with GDI</param>
/// <returns>D2dBitmapGraphics for use during intermediate offscreen drawing</returns>
public D2dBitmapGraphics CreateCompatibleGraphics(D2dCompatibleGraphicsOptions options)
{
var rt = new BitmapRenderTarget(m_renderTarget, (CompatibleRenderTargetOptions)options);
return new D2dBitmapGraphics(this, rt);
}
public RenderBitmap1(d2d.RenderTarget parentRenderTarget)
{
renderTarget = new d2d.BitmapRenderTarget(parentRenderTarget, d2d.CompatibleRenderTargetOptions.None);
}
internal D2dBitmapGraphics(BitmapRenderTarget renderTarget)
: base(renderTarget)
{
}
internal D2dBitmapGraphics(D2dGraphics owner,BitmapRenderTarget renderTarget)
: base(renderTarget)
{
m_owner = owner;
}
public override void Draw(DrawData dd)
{
// draw wave data
byte[] wavedata = dd.Song.WaveformData;
if (wavedata != null)
{
#if (MARKERS)
Markers.WriteFlag("Wave");
#endif
int fnd = -1;
for (int ndx = dd.LFT / Global.pxpersec; ndx < (dd.RIT + Global.pxpersec - 1) / Global.pxpersec; ndx++)
{
if (resources.Wave_Bmps[ndx] == null)
{
fnd = ndx;
break;
}
}
if (fnd == -1)
{
for (int ndx = 0; ndx < resources.Wave_Bmps.Length; ndx++)
{
if (resources.Wave_Bmps[ndx] == null)
{
fnd = ndx;
break;
}
}
}
if (fnd != -1)
{
var ht = Global.Wave_Height;
var half = ht >> 1;
using (var renderT = new SharpDX.Direct2D1.BitmapRenderTarget(dd.target, CompatibleRenderTargetOptions.None, new Size2F(Global.pxpersec, ht),
null, new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, AlphaMode.Premultiplied)))
{
renderT.BeginDraw();
renderT.Clear(SharpDX.Color.Black);
using (var path = new PathGeometry(Global.Instance.factory2D1))
{
var sink = path.Open();
sink.BeginFigure(new Vector2(Global.pxpersec, half + 1), FigureBegin.Hollow);
sink.AddLine(new Vector2(0, half + 1));
for (int ndx = 0, src = fnd * 2 * Global.pxpersec; ndx < Global.pxpersec && src < wavedata.Length; ndx++, src += 2)
{
sink.AddLine(new Vector2(ndx, half + 1 + wavedata[src]));
}
sink.EndFigure(FigureEnd.Open);
sink.Close();
renderT.DrawGeometry(path, resources.Wave_RedBrush);
}
using (var path = new PathGeometry(Global.Instance.factory2D1))
{
var sink = path.Open();
sink.BeginFigure(new Vector2(Global.pxpersec, half - 1), FigureBegin.Hollow);
sink.AddLine(new Vector2(0, half - 1));
for (int ndx = 0, src = fnd * 2 * Global.pxpersec + 1; ndx < Global.pxpersec && src < wavedata.Length; ndx++, src += 2)
{
sink.AddLine(new Vector2(ndx, half - 1 - wavedata[src]));
}
sink.EndFigure(FigureEnd.Open);
sink.Close();
renderT.DrawGeometry(path, resources.Wave_GreenBrush);
}
renderT.EndDraw();
resources.Wave_Bmps[fnd] = renderT.Bitmap;
}
}
for (int ndx = dd.LFT / Global.pxpersec, bgn = ndx * Global.pxpersec; ndx < resources.Wave_Bmps.Length && bgn <= dd.RIT; ndx++, bgn += Global.pxpersec)
{
var bmp = resources.Wave_Bmps[ndx];
if (bmp == null)
{
break;
}
dd.target.DrawBitmap(bmp, new RectangleF(bgn, Global.Wave_Channels, Global.pxpersec, Global.Wave_Height), 1.0f, BitmapInterpolationMode.NearestNeighbor,
new RectangleF(0, 0, Global.pxpersec, Global.Wave_Height));
}
#if (MARKERS)
Markers.WriteFlag("WaveEnd");
#endif
}
}
/// <summary>
/// Creates a new D2dBitmapGraphics with specified DIP size for use during intermediate offscreen drawing
/// that is compatible with the current D2dGraphics and has the same DPI, and pixel format
/// as the current D2dGraphics and with the specified options</summary>
/// <param name="size">The desired size of the new D2dGraphics in pixels</param>
/// <param name="options">Whether the new D2dBitmapGraphics must be compatible with GDI</param>
public D2dBitmapGraphics CreateCompatibleGraphics(SizeF size, D2dCompatibleGraphicsOptions options)
{
var dsize = new DrawingSizeF(size.Width, size.Height);
var rt = new BitmapRenderTarget(m_renderTarget, (CompatibleRenderTargetOptions)options, dsize, null, null);
return new D2dBitmapGraphics(rt);
}
public VisualBrushImpl(
VisualBrush brush,
RenderTarget target,
Size targetSize)
{
var visual = brush.Visual;
if (visual == null)
{
return;
}
var layoutable = visual as ILayoutable;
if (layoutable?.IsArrangeValid == false)
{
layoutable.Measure(Size.Infinity);
layoutable.Arrange(new Rect(layoutable.DesiredSize));
}
var tileMode = brush.TileMode;
var sourceRect = brush.SourceRect.ToPixels(layoutable.Bounds.Size);
var destinationRect = brush.DestinationRect.ToPixels(targetSize);
var scale = brush.Stretch.CalculateScaling(destinationRect.Size, sourceRect.Size);
var translate = CalculateTranslate(brush, sourceRect, destinationRect, scale);
var intermediateSize = CalculateIntermediateSize(tileMode, targetSize, destinationRect.Size);
var brtOpts = CompatibleRenderTargetOptions.None;
// TODO: There are times where we don't need to draw an intermediate bitmap. Identify
// them and directly use 'image' in those cases.
using (var intermediate = new BitmapRenderTarget(target, brtOpts, intermediateSize))
{
Rect drawRect;
var transform = CalculateIntermediateTransform(
tileMode,
sourceRect,
destinationRect,
scale,
translate,
out drawRect);
var renderer = new Renderer(intermediate);
renderer.Render(visual, null, transform, drawRect);
this.PlatformBrush = new BitmapBrush(
target,
intermediate.Bitmap,
GetBitmapBrushProperties(brush),
GetBrushProperties(brush, destinationRect));
}
//var sourceRect = brush.SourceRect.ToPixels(layoutable.Bounds.Size);
//var destinationRect = brush.DestinationRect.ToPixels(targetSize);
//var bitmapSize = brush.TileMode == TileMode.None ? targetSize : destinationRect.Size;
//var scale = brush.Stretch.CalculateScaling(destinationRect.Size, sourceRect.Size);
//var translate = CalculateTranslate(brush, sourceRect, destinationRect, scale);
//var options = CompatibleRenderTargetOptions.None;
//using (var brt = new BitmapRenderTarget(target, options, bitmapSize.ToSharpDX()))
//{
// var renderer = new Renderer(brt);
// var transform = Matrix.CreateTranslation(-sourceRect.Position) *
// Matrix.CreateScale(scale) *
// Matrix.CreateTranslation(translate);
// Rect drawRect;
// if (brush.TileMode == TileMode.None)
// {
// drawRect = destinationRect;
// transform *= Matrix.CreateTranslation(destinationRect.Position);
// }
// else
// {
// drawRect = new Rect(0, 0, destinationRect.Width, destinationRect.Height);
// }
// renderer.Render(visual, null, transform, drawRect);
// var result = new BitmapBrush(brt, brt.Bitmap);
// result.ExtendModeX = GetExtendModeX(brush.TileMode);
// result.ExtendModeY = GetExtendModeY(brush.TileMode);
// if (brush.TileMode != TileMode.None)
// {
// result.Transform = SharpDX.Matrix3x2.Translation(
// (float)destinationRect.X,
// (float)destinationRect.Y);
// }
// PlatformBrush = result;
//}
}
/// <summary>
/// Starts render loop
/// </summary>
/// <param name="manager"></param>
/// <param name="View"></param>
public void Render(GraphView_StateManager manager, View.GraphView_CurveView View)
{
var signature = CreateShaders("Smooth.fx");
//var signature = CreateShaders();
var layout = new InputLayout(_device, signature, new[] {
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
new InputElement("COLOR", 0, Format.R32G32B32A32_Float, 16, 0),
new InputElement("TEXCOORD", 0, Format.R32G32B32A32_Float, 32, 0)
});
SetSamplerState();
// Instantiate buffers
CreateVertexBuffer();
CreateConstantBuffer();
// Prepare Context
SetUpContext(layout);
// Prepare matrices
var view = Matrix.OrthoLH(_RenderForm.ClientSize.Width, _RenderForm.ClientSize.Width, 0.00f, 10000.0f);
Matrix proj = Matrix.Identity;
// Declare texture for rendering
bool userResized = true;
Texture2D backBuffer = null;
RenderTargetView renderView = null;
Texture2D depthBuffer = null;
DepthStencilView depthView = null;
var camera = ((ViewModel.CurveGraphViewModel)manager.ViewModel).Camera;
var rastDesc = new RasterizerStateDescription {
FillMode = FillMode.Solid,
CullMode = CullMode.None,
IsAntialiasedLineEnabled = true,
IsMultisampleEnabled = true
};
var viewPort = new Viewport(0, 0, _RenderForm.ClientSize.Width, _RenderForm.ClientSize.Height);
_RenderForm.UserResized += (sender, args) => userResized = true;
// Main loop
RenderLoop.Run(_RenderForm, () => {
//TODO: Check for if collectionchanged event has been raised and trigger vertex recalculation
if (IsViewModelChanged || !MessageQueue.IsEmpty || true)
{
CreateSwapChain();
IsViewModelChanged = false;
if (true)
{
if (WindowResized())
{
userResized = true;
}
SetSamplerState();
}
// If Form resized
if (userResized)
{
Console.WriteLine("resizing");
// Dispose all previous allocated resources
Utilities.Dispose(ref backBuffer);
Utilities.Dispose(ref renderView);
Utilities.Dispose(ref depthBuffer);
Utilities.Dispose(ref depthView);
// Resizing buffers
_swapChain.ResizeBuffers(
_SwapDesc.BufferCount,
//2048,
//1280,
_RenderForm.Width,
_RenderForm.Height,
Format.B8G8R8A8_UNorm,
SwapChainFlags.None
);
backBuffer = Texture2D.FromSwapChain <Texture2D>(_swapChain, 0);
renderView = new RenderTargetView(_device, backBuffer);
// Create the depth buffer
depthBuffer = new Texture2D(_device, new Texture2DDescription()
{
Format = Format.D32_Float_S8X24_UInt,
ArraySize = 1,
MipLevels = 1,
//Width = 2048,
//Height = 1280,
Width = _RenderForm.Width,
Height = _RenderForm.Height,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
});
// Create the depth buffer view
depthView = new DepthStencilView(_device, depthBuffer);
viewPort.Width = _RenderForm.ClientSize.Width;
viewPort.Height = _RenderForm.ClientSize.Height;
// Setup targets and viewport for rendering
_context.Rasterizer.SetViewport(viewPort);
_context.OutputMerger.SetTargets(depthView, renderView);
_context.Rasterizer.State = new RasterizerState(_device, rastDesc);
userResized = false;
}
Thread vertexThread = new Thread(() => CalculateQuads(manager));
vertexThread.Start();
// World Matrix
// The World Matrix translates the position of your vertices from model space to World space.
// That means it applies its position in the world and its rotation
var world = CalculateWorldTransform(camera);
// A view matrix tells the GPU the position of the camera, the point the camera is facing,
// and the up vector for the camera
view = Matrix.LookAtLH(new Vector3(0, 0, -100), new Vector3(0, 0, 0), Vector3.Up);
// A projection matrix tells the GPU the FOV, aspect ratio, and near and far clipping planes for the camera
//proj = Matrix.OrthoLH(1280, 720, 0.00f, 1000.0f);
proj = Matrix.OrthoLH(screenWidth, screenHeight, 0.00f, 1000.0f);
var viewProj = Matrix.Multiply(view, proj);
//var worldViewProj = Matrix.Multiply(world, proj);
var worldViewProj = Matrix.Multiply(world, viewProj);
// Clear views and set background as transparent
_context.ClearDepthStencilView(depthView, DepthStencilClearFlags.Depth, 1.0f, 0);
_context.ClearRenderTargetView(renderView, new SharpDX.Mathematics.Interop.RawColor4(0, 0, 0, 0.0f));
var screenPoints = PointToScreenSpace(manager, viewPort, worldViewProj);
worldViewProj.Transpose();
_context.UpdateSubresource(ref worldViewProj, _ConstantBuffer);
// Instantiate Vertex buffer from vertex data
vertexThread.Join();
CreateVertexBuffer();
SetUpContext(layout);
// Draw
_context.Draw(vertices.Length, 0);
// Convert backbuffer to texture, then to bitmap for display
D2D1.BitmapRenderTarget target = RenderBitmap();
// Get byte array for bitmap
byte[] data = CalculateBitmapBytes(backBuffer);
DisplayBitmap(target, data, screenPoints, manager);
// Dispose all previous allocated resources
_context.Flush();
screenPoints = null;
GC.Collect();
if (displayThread != null)
{
displayThread.Join();
}
mre.Reset();
mre.WaitOne();
}
// End of renderloop
});
// Release all resources
_context.ClearState();
_context.Flush();
DisposeResources();
signature.Dispose();
layout.Dispose();
depthBuffer.Dispose();
backBuffer.Dispose();
depthView.Dispose();
renderView.Dispose();
}
