public async Task Render_SimpleText_SimpleSingleColor()
{
await TestUtilities.InitializeWithGraphicsAsync();
using (var solidBrush = new SolidBrushResource(Color4.RedColor))
using (var textFormat = new TextFormatResource("Arial", 70))
using (var memRenderTarget = new MemoryRenderTarget(1024, 1024))
{
// Perform rendering
memRenderTarget.ClearColor = Color4.CornflowerBlue;
await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync(graphics =>
{
// 2D rendering is made here
graphics.DrawText(
$"Just a dummy text ;){Environment.NewLine}Just a dummy text ;)",
textFormat,
new RectangleF(10, 10, 512, 512),
solidBrush);
});
await memRenderTarget.AwaitRenderAsync();
// Take screenshot
var screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
// TestUtilities.DumpToDesktop(screenshot, "Blub.png");
// Calculate and check difference
var diff = BitmapComparison.CalculatePercentageDifference(
screenshot, TestUtilities.LoadBitmapFromResource("Drawing2D", "SimpleText_SingleColor.png"));
Assert.IsTrue(diff < 0.2, "Difference to reference image is to big!");
}
}
public async Task Render_SimpleGeometry_Ellipse()
{
await TestUtilities.InitializeWithGraphicsAsync();
using (var solidBrush = new SolidBrushResource(Color4.LightGray))
using (var solidBrushBorder = new SolidBrushResource(Color4.Gray))
using (var ellipseGeometry = new EllipseGeometryResource(new Vector2(512, 512), 400f, 300f))
using (var memRenderTarget = new MemoryRenderTarget(1024, 1024))
{
// Perform rendering
memRenderTarget.ClearColor = Color4.CornflowerBlue;
await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync(graphics =>
{
// 2D rendering is made here
graphics.DrawGeometry(ellipseGeometry, solidBrushBorder, 3f);
graphics.FillGeometry(ellipseGeometry, solidBrush);
});
await memRenderTarget.AwaitRenderAsync();
// Take screenshot
var screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
// TestUtilities.DumpToDesktop(screenshot, "Blub.png");
// Calculate and check difference
var diff = BitmapComparison.CalculatePercentageDifference(
screenshot, TestUtilities.LoadBitmapFromResource("Drawing2D", "SimpleGeometry2D_Ellipse.png"));
Assert.IsTrue(diff < 0.2, "Difference to reference image is to big!");
}
}
public async Task Render_SimpleBitmap_WithTransparency()
{
await TestUtilities.InitializeWithGraphicsAsync();
using (var solidBrush = new SolidBrushResource(Color4.LightGray))
using (var bitmap = new StandardBitmapResource(new AssemblyResourceLink(this.GetType(), "Resources.Bitmaps.Logo.png")))
using (var memRenderTarget = new MemoryRenderTarget(1024, 1024))
{
// Perform rendering
memRenderTarget.ClearColor = Color4.CornflowerBlue;
await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync(graphics =>
{
// 2D rendering is made here
graphics.FillRectangle(graphics.ScreenBounds, solidBrush);
graphics.DrawBitmap(bitmap, new Vector2(100f, 100f));
});
await memRenderTarget.AwaitRenderAsync();
// Take screenshot
var screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
// TestUtilities.DumpToDesktop(screenshot, "Blub.png");
// Calculate and check difference
var diff = BitmapComparison.CalculatePercentageDifference(
screenshot, TestUtilities.LoadBitmapFromResource("Drawing2D", "SimpleBitmap_Transparency.png"));
Assert.IsTrue(diff < 0.02, "Difference to reference image is to big!");
}
}
public async Task Render_SimpleRoundedRect_Filled_Solid()
{
await TestUtilities.InitializeWithGraphicsAsync();
using (var solidBrush = new SolidBrushResource(Color4.Gray))
using (var memRenderTarget = new MemoryRenderTarget(1024, 1024))
{
// Perform rendering
memRenderTarget.ClearColor = Color4.CornflowerBlue;
await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync(graphics =>
{
// 2D rendering is made here
graphics.FillRoundedRectangle(
new RectangleF(10, 10, 512, 512), 30, 30,
solidBrush);
});
await memRenderTarget.AwaitRenderAsync();
// Take screenshot
var screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
// TestUtilities.DumpToDesktop(screenshot, "Blub.png");
// Calculate and check difference
var diff = BitmapComparison.CalculatePercentageDifference(
screenshot, TestUtilities.LoadBitmapFromResource("Drawing2D", "SimpleRoundedRectFilled.png"));
Assert.IsTrue(diff < 0.2, "Difference to reference image is to big!");
}
}
public async Task Render_SimpleRoundedRect_Filled_Over3D()
{
await TestUtilities.InitializeWithGraphicsAsync();
var brushColor = Color4.Gray;
brushColor.ChangeAlphaTo(0.5f);
using (var solidBrush = new SolidBrushResource(brushColor))
using (var memRenderTarget = new MemoryRenderTarget(1024, 1024))
{
memRenderTarget.ClearColor = Color4.CornflowerBlue;
// Get and configure the camera
var camera = (PerspectiveCamera3D)memRenderTarget.Camera;
camera.Position = new Vector3(0f, 5f, -5f);
camera.Target = new Vector3(0f, 1f, 0f);
camera.UpdateCamera();
// Define scene
await memRenderTarget.Scene.ManipulateSceneAsync(manipulator =>
{
// Define object
var resGeometry = manipulator.AddResource(
_ => new GeometryResource(new CubeGeometryFactory()));
var resMaterial = manipulator.AddResource(
_ => new StandardMaterialResource(enableShaderGeneratedBorder: true));
var newMesh = manipulator.AddMeshObject(resGeometry, resMaterial);
newMesh.RotationEuler = new Vector3(0f, EngineMath.RAD_90DEG / 2f, 0f);
newMesh.Scaling = new Vector3(2f, 2f, 2f);
newMesh.Color = Color4.Goldenrod;
});
// Define 2D overlay
await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync(graphics =>
{
// 2D rendering is made here
graphics.FillRoundedRectangle(
new RectangleF(10, 10, 512, 512), 30, 30,
solidBrush);
});
await memRenderTarget.AwaitRenderAsync();
// Take screenshot
var screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
// TestUtilities.DumpToDesktop(screenshot, "Blub.png");
// Calculate and check difference
var diff = BitmapComparison.CalculatePercentageDifference(
screenshot, TestUtilities.LoadBitmapFromResource("Drawing2D", "RoundedRectOver3D.png"));
Assert.IsTrue(diff < 0.2, "Difference to reference image is to big!");
}
// Finishing checks
Assert.IsTrue(GraphicsCore.Current.MainLoop !.RegisteredRenderLoopCount == 0, "RenderLoops where not disposed correctly!");
}
public void BitmapComparison_Negative_BlackWhite()
{
using (var leftBitmap = TestUtilities.LoadBitmapFromResource("BitmapComparison", "WhiteScreen.png"))
using (var rightBitmap = TestUtilities.LoadBitmapFromResource("BitmapComparison", "BlackScreen.png"))
{
var comparisonResult = BitmapComparison.CalculatePercentageDifference(leftBitmap, rightBitmap);
Assert.IsTrue(EngineMath.EqualsWithTolerance(comparisonResult, 1.0f));
}
}
public void BitmapComparison_Positive()
{
using (var leftBitmap = TestUtilities.LoadBitmapFromResource("BitmapComparison", "FlatShadedObject.png"))
using (var rightBitmap = TestUtilities.LoadBitmapFromResource("BitmapComparison", "FlatShadedObject.png"))
{
Assert.IsTrue(
EngineMath.EqualsWithTolerance(BitmapComparison.CalculatePercentageDifference(leftBitmap, rightBitmap), 0f));
}
}
public void BitmapComparison_Positive()
{
using (GDI.Bitmap leftBitmap = Properties.Resources.FlatShadedObject)
using (GDI.Bitmap rightBitmap = Properties.Resources.FlatShadedObject)
{
Assert.True(
BitmapComparison.CalculatePercentageDifference(leftBitmap, rightBitmap) == 0f);
}
}
public void BitmapComparison_Negative_BlackWhite()
{
using (GDI.Bitmap leftBitmap = Properties.Resources.WhiteScreen)
using (GDI.Bitmap rightBitmap = Properties.Resources.BlackScreen)
{
float comparisonResult = BitmapComparison.CalculatePercentageDifference(leftBitmap, rightBitmap);
Assert.True(comparisonResult == 1.0f);
}
}
public void BitmapComparison_Negative_Smaller()
{
using (var leftBitmap = TestUtilities.LoadBitmapFromResource("BitmapComparison", "FlatShadedObject.png"))
using (var rightBitmap = TestUtilities.LoadBitmapFromResource("BitmapComparison", "FlatShadedObject_Smaller.png"))
{
var comparisonResult = BitmapComparison.CalculatePercentageDifference(leftBitmap, rightBitmap);
Assert.IsTrue(comparisonResult > 0.1);
Assert.IsTrue(comparisonResult < 0.4);
}
}
public void BitmapComparison_Negative_Enlighted()
{
using (GDI.Bitmap leftBitmap = Properties.Resources.FlatShadedObject)
using (GDI.Bitmap rightBitmap = Properties.Resources.FlatShadedObject_Enlighted)
{
float comparisonResult = BitmapComparison.CalculatePercentageDifference(leftBitmap, rightBitmap);
Assert.True(comparisonResult > 0.1);
Assert.True(comparisonResult < 0.4);
}
}
public void BitmapComparison_Negative_Without_Model()
{
using (var leftBitmap = TestUtilities.LoadBitmapFromResource("BitmapComparison", "ClearedScreen.png"))
using (var rightBitmap = TestUtilities.LoadBitmapFromResource("BitmapComparison", "FlatShadedObject.png"))
{
var comparisonResult = BitmapComparison.CalculatePercentageDifference(leftBitmap, rightBitmap);
Assert.IsTrue(comparisonResult > 0.25f);
Assert.IsTrue(comparisonResult < 0.6f);
}
}
public void BitmapComparison_Negative_Inversed_Image()
{
using (GDI.Bitmap leftBitmap = Properties.Resources.FlatShadedObject)
using (GDI.Bitmap rightBitmap = Properties.Resources.FlatShadedObject_Negative)
{
float comparisonResult = BitmapComparison.CalculatePercentageDifference(leftBitmap, rightBitmap);
Assert.True(comparisonResult > 0.9f);
Assert.True(comparisonResult <= 1.0f);
}
}
public void BitmapComparison_Negative_Without_Model()
{
using (GDI.Bitmap leftBitmap = Properties.Resources.ClearedScreen)
using (GDI.Bitmap rightBitmap = Properties.Resources.FlatShadedObject)
{
float comparisonResult = BitmapComparison.CalculatePercentageDifference(leftBitmap, rightBitmap);
Assert.True(comparisonResult > 0.25f);
Assert.True(comparisonResult < 0.6f);
}
}
public async Task Render_SimpleRoundedRect_Filled_LinearGradient()
{
await TestUtilities.InitializeWithGraphicsAsync();
using (var gradientBrush = new LinearGradientBrushResource(
new Vector2(0f, 0f),
new Vector2(512f, 0f),
new[]
{
new GradientStop {
Color = Color4.Gray, Position = 0f
},
new GradientStop {
Color = Color4.White, Position = 0.6f
},
new GradientStop {
Color = Color4.Black, Position = 1f
}
},
ExtendMode.Mirror))
using (var memRenderTarget = new MemoryRenderTarget(1024, 1024))
{
// Perform rendering
memRenderTarget.ClearColor = Color4.CornflowerBlue;
await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync(graphics =>
{
// 2D rendering is made here
graphics.FillRoundedRectangle(
new RectangleF(10, 10, 900, 900), 30, 30,
gradientBrush);
});
await memRenderTarget.AwaitRenderAsync();
// Take screenshot
var screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
// TestUtilities.DumpToDesktop(screenshot, "Blub.png");
// Calculate and check difference
var diff = BitmapComparison.CalculatePercentageDifference(
screenshot, TestUtilities.LoadBitmapFromResource("Drawing2D", "SimpleRoundedRectFilled_LinearGradient.png"));
Assert.IsTrue(diff < 0.2, "Difference to reference image is to big!");
}
}
public async Task Render_SimpleBitmap_Animated()
{
await TestUtilities.InitializeWithGraphicsAsync();
using (var bitmap = new StandardBitmapResource(
new AssemblyResourceLink(this.GetType(), "Resources.Bitmaps.Boom.png"),
8, 8))
using (var memRenderTarget = new MemoryRenderTarget(1024, 1024))
{
// Perform rendering
memRenderTarget.ClearColor = Color4.CornflowerBlue;
await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync(graphics =>
{
// 2D rendering is made here
for (var loop = 0; loop < 8; loop++)
{
graphics.DrawBitmap(bitmap, new Vector2(100f * loop, 10f), frameIndex: 7);
graphics.DrawBitmap(bitmap, new Vector2(100f * loop, 100f), frameIndex: 15);
graphics.DrawBitmap(bitmap, new Vector2(100f * loop, 200f), frameIndex: 23);
graphics.DrawBitmap(bitmap, new Vector2(100f * loop, 300f), frameIndex: 31);
graphics.DrawBitmap(bitmap, new Vector2(100f * loop, 400f), frameIndex: 39);
graphics.DrawBitmap(bitmap, new Vector2(100f * loop, 500f), frameIndex: 47);
graphics.DrawBitmap(bitmap, new Vector2(100f * loop, 600f), frameIndex: 55);
graphics.DrawBitmap(bitmap, new Vector2(100f * loop, 700f), frameIndex: 63);
}
});
//await AsyncResourceLoader.Current.WaitForAllFinishedAsync();
await memRenderTarget.AwaitRenderAsync();
// Take screenshot
var screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
// TestUtilities.DumpToDesktop(screenshot, "Blub.png");
// Calculate and check difference
var diff = BitmapComparison.CalculatePercentageDifference(
screenshot, TestUtilities.LoadBitmapFromResource("Drawing2D", "SimpleBitmap_Animated.png"));
Assert.IsTrue(diff < 0.02, "Difference to reference image is to big!");
}
}
public async Task Render_DebugLayer()
{
await TestUtilities.InitializeWithGraphicsAsync();
using (var debugLayer = new DebugDrawingLayer())
using (var memRenderTarget = new MemoryRenderTarget(1024, 1024))
{
// Perform rendering
memRenderTarget.ClearColor = Color4.CornflowerBlue;
await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync(debugLayer);
await memRenderTarget.AwaitRenderAsync();
// Take screenshot
var screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
// TestUtilities.DumpToDesktop(screenshot, "Blub.png");
// Calculate and check difference
var diff = BitmapComparison.CalculatePercentageDifference(
screenshot, TestUtilities.LoadBitmapFromResource("Drawing2D", "DebugDrawingLayer.png"));
Assert.IsTrue(diff < 0.2, "Difference to reference image is to big!");
}
}