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_Solid()
{
await UnitTestHelper.InitializeWithGrahicsAsync();
using (SolidBrushResource solidBrush = new SolidBrushResource(Color4.Gray))
using (MemoryRenderTarget 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
GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
//screenshot.DumpToDesktop("Blub.png");
// Calculate and check difference
float diff = BitmapComparison.CalculatePercentageDifference(
screenshot, Properties.Resources.ReferenceImage_SimpleRoundedRectFilled);
Assert.True(diff < 0.2, "Difference to reference image is to big!");
}
}
public async Task Render_SimpleBitmap_WithTransparency()
{
await UnitTestHelper.InitializeWithGrahicsAsync();
using (SolidBrushResource solidBrush = new SolidBrushResource(Color4.LightGray))
using (StandardBitmapResource bitmap = new StandardBitmapResource(new AssemblyResourceLink(this.GetType(), "Ressources.Bitmaps.Logo.png")))
using (MemoryRenderTarget 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 AsyncResourceLoader.Current.WaitForAllFinishedAsync();
await memRenderTarget.AwaitRenderAsync();
// Take screenshot
GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
//screenshot.DumpToDesktop("Blub.png");
// Calculate and check difference
float diff = BitmapComparison.CalculatePercentageDifference(
screenshot, Properties.Resources.ReferenceImage_SimpleBitmap_Transparency);
Assert.True(diff < 0.02, "Difference to reference image is to big!");
}
}
public async Task Render_SimpleGeometry_Ellipse()
{
await UnitTestHelper.InitializeWithGrahicsAsync();
using (SolidBrushResource solidBrush = new SolidBrushResource(Color4.LightGray))
using (SolidBrushResource solidBrushBorder = new SolidBrushResource(Color4.Gray))
using (EllipseGeometryResource ellipseGeometry = new EllipseGeometryResource(new Vector2(512, 512), 400f, 300f))
using (MemoryRenderTarget 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
GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
//screenshot.DumpToDesktop("Blub.png");
// Calculate and check difference
float diff = BitmapComparison.CalculatePercentageDifference(
screenshot, Properties.Resources.ReferenceImage_SimpleGeometry2D_Ellipse);
Assert.True(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_SimpleText_SimpleSingleColor()
{
await UnitTestHelper.InitializeWithGrahicsAsync();
using (SolidBrushResource solidBrush = new SolidBrushResource(Color4.RedColor))
using (TextFormatResource textFormat = new TextFormatResource("Arial", 70))
using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024))
{
// Perform rendering
memRenderTarget.ClearColor = Color4.CornflowerBlue;
await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync((graphics) =>
{
// 2D rendering is made here
graphics.DrawText(
string.Format("Just a dummy text ;){0}Just a dummy text ;)", Environment.NewLine),
textFormat,
new RectangleF(10, 10, 512, 512),
solidBrush);
});
await memRenderTarget.AwaitRenderAsync();
// Take screenshot
GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
//screenshot.DumpToDesktop("Blub.png");
// Calculate and check difference
float diff = BitmapComparison.CalculatePercentageDifference(
screenshot, Properties.Resources.ReferenceImage_SimpleText_SingleColor);
Assert.True(diff < 0.2, "Difference to reference image is to big!");
}
}
public async Task Render_SimpleObject_D2D_Texture()
{
await TestUtilities.InitializeWithGraphicsAsync();
using (var solidBrush = new SolidBrushResource(Color4.Gray))
using (var textFormat = new TextFormatResource("Arial", 36))
using (var textBrush = new SolidBrushResource(Color4.RedColor))
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, -7f);
camera.Target = new Vector3(0f, 0f, 0f);
camera.UpdateCamera();
// 2D rendering is made here
var d2dDrawingLayer = new Custom2DDrawingLayer(graphics =>
{
var d2dRectangle = new RectangleF(10, 10, 236, 236);
graphics.Clear(Color4.LightBlue);
graphics.FillRoundedRectangle(
d2dRectangle, 30, 30,
solidBrush);
d2dRectangle.Inflate(-10, -10);
graphics.DrawText("Hello Direct2D!", textFormat, d2dRectangle, textBrush);
});
// Define scene
await memRenderTarget.Scene.ManipulateSceneAsync(manipulator =>
{
var resD2DTexture = manipulator.AddResource(
_ => new Direct2DTextureResource(d2dDrawingLayer, 256, 256));
var resD2DMaterial = manipulator.AddStandardMaterialResource(resD2DTexture);
var geoResource = manipulator.AddResource(
_ => new GeometryResource(new CubeGeometryFactory()));
var newMesh = manipulator.AddMeshObject(geoResource, resD2DMaterial);
newMesh.RotationEuler = new Vector3(0f, EngineMath.RAD_90DEG / 2f, 0f);
newMesh.Scaling = new Vector3(2f, 2f, 2f);
});
await memRenderTarget.AwaitRenderAsync();
// Take screenshot
var screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
//TestUtilities.DumpToDesktop(screenshot, "Blub.png");
// Calculate and check difference
var isNearEqual = BitmapComparison.IsNearEqual(
screenshot, TestUtilities.LoadBitmapFromResource("Drawing2D", "SimpleObject_D2DTexture.png"));
Assert.IsTrue(isNearEqual, "Difference to reference image is to big!");
}
// Finishing checks
Assert.IsTrue(GraphicsCore.Current.MainLoop !.RegisteredRenderLoopCount == 0, "RenderLoops where not disposed correctly!");
}
public async Task Postprocessing_Focus()
{
await TestUtilities.InitializeWithGraphicsAsync();
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, -7f);
camera.Target = new Vector3(0f, 0f, 0f);
camera.UpdateCamera();
// Define scene
await memRenderTarget.Scene.ManipulateSceneAsync(manipulator =>
{
var keyPostprocess = manipulator.AddResource(
_ => new FocusPostprocessEffectResource(false, 0f));
var defaultLayer = manipulator.GetLayer(Scene.DEFAULT_LAYER_NAME);
var focusLayer = manipulator.AddLayer("Focus");
focusLayer.PostprocessEffectKey = keyPostprocess;
var resGeometry = manipulator.AddResource(
_ => new GeometryResource(new CubeGeometryFactory()));
var resMaterial = manipulator.AddStandardMaterialResource();
var frontMesh = manipulator.AddMeshObject(resGeometry, defaultLayer.Name, resMaterial);
frontMesh.Color = Color4.BlueColor;
frontMesh.Scaling = new Vector3(1f, 0.5f, 0.5f);
frontMesh.Position = new Vector3(0.5f, 2f, -3f);
var backMesh = manipulator.AddMeshObject(resGeometry, defaultLayer.Name, resMaterial);
backMesh.RotationEuler = new Vector3(0f, EngineMath.RAD_90DEG / 3f, 0f);
backMesh.Scaling = new Vector3(2f, 2f, 2f);
backMesh.Color = Color4.RedColor;
var focusMesh = manipulator.AddMeshObject(resGeometry, focusLayer.Name, resMaterial);
focusMesh.TransformSourceObject = backMesh;
focusMesh.TransformationType = SpacialTransformationType.TakeFromOtherObject;
focusMesh.Color = Color4.RedColor;
});
await memRenderTarget.AwaitRenderAsync();
// Take screenshot
var screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
// TestUtilities.DumpToDesktop(screenshot, "Blub.png");
// Calculate and check difference
var isNearEqual = BitmapComparison.IsNearEqual(
screenshot, TestUtilities.LoadBitmapFromResource("Postprocessing", "PostProcess_Focus.png"));
Assert.IsTrue(isNearEqual, "Difference to reference image is to big!");
}
// Finishing checks
Assert.IsTrue(GraphicsCore.Current.MainLoop !.RegisteredRenderLoopCount == 0, "RenderLoops where not disposed correctly!");
}
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 MemoryRenderTarget_GraphicsInitError()
{
await TestUtilities.InitializeWithGraphicsAsync();
// Ensure that any async disposal is done before we create a new GraphicsCore
await GraphicsCore.Current.MainLoop !.WaitForNextPassedLoopAsync();
await GraphicsCore.Current.MainLoop !.WaitForNextPassedLoopAsync();
var isRenderTargetOperational = true;
var isGraphicsCoreInitialized = true;
var isGraphicsLoaded = true;
var registeredRenderLoopCount = 1;
using (GraphicsCore.AutomatedTest_NewTestEnvironment())
using (GraphicsCore.AutomatedTest_ForceDeviceInitError())
{
await GraphicsCore.Loader
.LoadAsync();
using (var memRenderTarget = new MemoryRenderTarget(1024, 1024))
{
isRenderTargetOperational = memRenderTarget.IsOperational;
isGraphicsCoreInitialized = GraphicsCore.IsLoaded;
isGraphicsLoaded = GraphicsCore.IsGraphicsLoaded;
registeredRenderLoopCount = GraphicsCore.Current.RegisteredRenderLoopCount;
}
}
Assert.IsFalse(isRenderTargetOperational);
Assert.IsTrue(isGraphicsCoreInitialized);
Assert.IsFalse(isGraphicsLoaded);
Assert.IsTrue(registeredRenderLoopCount == 0);
}
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!");
}
}
private void StartRender(object sender, DoWorkEventArgs e)
{
var renderer = IoC.Resolve <IRenderer>();
var target = new MemoryRenderTarget(result.Width, result.Height);
var color = new Color(1, 0.84, 0);
var mesh = new MeshLoader().Load("bunny4.mesh");
var world = new NaiveScene();
world.AddGeometry(
new Renderable(
mesh,
new SolidMaterial(color)));
_renderMilliseconds = (int)new Stopwatch().Time(() =>
renderer.RenderScene(new RenderingContext {
Target = target,
World = world,
ImageMatrix = Matrix.Scaling(1d / target.Width * 100, 1d / target.Height * 100, 1),
ProjectionMatrix = Matrix.Scaling((double)target.Width / target.Height, 1, 1),
SamplesPerPixel = _samplesPerPixel
}));
_renderedImage = target.ToBitmap();
}
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 async Task Render_SimpleLine()
{
await TestUtilities.InitializeWithGraphicsAsync();
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, -7f);
camera.Target = new Vector3(0f, 0f, 0f);
camera.UpdateCamera();
// Define scene
await memRenderTarget.Scene.ManipulateSceneAsync(manipulator =>
{
var wireObject = new WireObject
{
LineData = new[]
{
new Line(
new Vector3(-0.5f, 0f, -0.5f),
new Vector3(0.5f, 0f, -0.5f)),
new Line(
new Vector3(0.5f, 0f, -0.5f),
new Vector3(0.5f, 0f, 0.5f)),
new Line(
new Vector3(0.5f, 0f, 0.5f),
new Vector3(-0.5f, 0f, 0.5f)),
new Line(
new Vector3(-0.5f, 0f, 0.5f),
new Vector3(-0.5f, 0f, -0.5f))
},
Color = Color4.RedColor
};
manipulator.AddObject(wireObject);
});
await memRenderTarget.AwaitRenderAsync();
// Take screenshot
var screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
// TestUtilities.DumpToDesktop(screenshot, "Blub.png");
// Calculate and check difference
var isNearEqual = BitmapComparison.IsNearEqual(
screenshot, TestUtilities.LoadBitmapFromResource("Drawing3D", "SimpleLine.png"));
Assert.IsTrue(isNearEqual, "Difference to reference image is to big!");
}
}
public async Task Render_SimpleRoundedRect_Filled_Over3D()
{
await UnitTestHelper.InitializeWithGrahicsAsync();
using (SolidBrushResource solidBrush = new SolidBrushResource(Color4.Gray.ChangeAlphaTo(0.5f)))
using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024))
{
memRenderTarget.ClearColor = Color4.CornflowerBlue;
// Get and configure the camera
PerspectiveCamera3D camera = memRenderTarget.Camera as PerspectiveCamera3D;
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
NamedOrGenericKey geoResource = manipulator.AddResource <GeometryResource>(
() => new GeometryResource(new PalletStackType(
NamedOrGenericKey.Empty, 10)));
var newObject = manipulator.AddGeneric(geoResource);
newObject.RotationEuler = new Vector3(0f, EngineMath.RAD_90DEG / 2f, 0f);
newObject.Scaling = new Vector3(2f, 2f, 2f);
newObject.Color = Color4.Goldenrod;
newObject.EnableShaderGeneratedBorder();
});
// Define 2D overlay
await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync((graphics) =>
{
// 2D rendering is made here
graphics.FillRoundedRectangle(
new RectangleF(10, 10, 512, 512), 30, 30,
solidBrush);
});
// Take screenshot
GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
//screenshot.DumpToDesktop("Blub.png");
// Calculate and check difference
float diff = BitmapComparison.CalculatePercentageDifference(
screenshot, Properties.Resources.ReferenceImage_RoundedRectOver3D);
Assert.True(diff < 0.2, "Difference to reference image is to big!");
}
// Finishing checks
Assert.True(GraphicsCore.Current.MainLoop.RegisteredRenderLoopCount == 0, "RenderLoops where not disposed correctly!");
}
public async Task Postprocessing_EdgeDetect()
{
await UnitTestHelper.InitializeWithGrahicsAsync();
using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024))
{
memRenderTarget.ClearColor = Color4.CornflowerBlue;
// Get and configure the camera
PerspectiveCamera3D camera = memRenderTarget.Camera as PerspectiveCamera3D;
camera.Position = new Vector3(0f, 5f, -7f);
camera.Target = new Vector3(0f, 0f, 0f);
camera.UpdateCamera();
// Define scene
await memRenderTarget.Scene.ManipulateSceneAsync((manipulator) =>
{
var keyPostprocess = manipulator.AddResource <EdgeDetectPostprocessEffectResource>(
() => new EdgeDetectPostprocessEffectResource()
{
Thickness = 10f
});
SceneLayer defaultLayer = manipulator.GetLayer(Scene.DEFAULT_LAYER_NAME);
defaultLayer.PostprocessEffectKey = keyPostprocess;
NamedOrGenericKey geoResource = manipulator.AddResource <GeometryResource>(
() => new GeometryResource(new PalletType()));
GenericObject newObject = manipulator.AddGeneric(geoResource);
newObject.RotationEuler = new Vector3(0f, EngineMath.RAD_90DEG / 2f, 0f);
newObject.Scaling = new Vector3(2f, 2f, 2f);
newObject.Color = Color4.RedColor;
});
// Take screenshot
GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
//screenshot.DumpToDesktop("Blub.png");
// Calculate and check difference
bool isNearEqual = BitmapComparison.IsNearEqual(
screenshot, Properties.Resources.ReferenceImage_PostProcess_EdgeDetect);
Assert.True(isNearEqual, "Difference to reference image is to big!");
}
// Finishing checks
Assert.True(GraphicsCore.Current.MainLoop.RegisteredRenderLoopCount == 0, "RenderLoops where not disposed correctly!");
}
public async Task Render3D_VideoTexture()
{
await UnitTestHelper.InitializeWithGrahicsAsync();
ResourceLink videoLink = new AssemblyResourceLink(
this.GetType().Assembly,
"SeeingSharp.Tests.Rendering.Ressources.Videos",
"DummyVideo.mp4");
using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024))
{
memRenderTarget.ClearColor = Color4.CornflowerBlue;
// Get and configure the camera
PerspectiveCamera3D camera = memRenderTarget.Camera as PerspectiveCamera3D;
camera.Position = new Vector3(0f, 5f, -7f);
camera.Target = new Vector3(0f, 0f, 0f);
camera.UpdateCamera();
// Define scene
await memRenderTarget.Scene.ManipulateSceneAsync((manipulator) =>
{
var resVideoTexture = manipulator.AddResource <VideoThumbnailTextureResource>(
() => new VideoThumbnailTextureResource(videoLink, TimeSpan.FromMilliseconds(300.0)));
var resVideoMaterial = manipulator.AddSimpleColoredMaterial(resVideoTexture, addToAlpha: 1f);
var geoResource = manipulator.AddResource <GeometryResource>(
() => new GeometryResource(new PalletType(
palletMaterial: NamedOrGenericKey.Empty,
contentMaterial: resVideoMaterial)));
GenericObject newObject = manipulator.AddGeneric(geoResource);
newObject.RotationEuler = new Vector3(0f, EngineMath.RAD_90DEG / 2f, 0f);
newObject.Scaling = new Vector3(2f, 2f, 2f);
});
// Take screenshot
GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
//screenshot.DumpToDesktop("Blub.png");
// Calculate and check difference
bool isNearEqual = BitmapComparison.IsNearEqual(
screenshot, Properties.Resources.ReferenceImage_SimpleObject_VideoTexture);
Assert.True(isNearEqual, "Difference to reference image is to big!");
}
// Finishing checks
Assert.True(GraphicsCore.Current.MainLoop.RegisteredRenderLoopCount == 0, "RenderLoops where not disposed correctly!");
}
/// <summary>
/// Base method used as common test scenario for all video renderers.
/// </summary>
/// <param name="videoWriter">The VideoWriter to be testet.</param>
/// <param name="countFrames">Total count of frames to be rendered.</param>
/// <param name="doAnimate">Execute animation during recording.</param>
private async Task RenderSimple_Generic(SeeingSharpVideoWriter videoWriter, int countFrames, bool doAnimate = true)
{
using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024))
{
memRenderTarget.ClearColor = Color4.CornflowerBlue;
// Get and configure the camera
PerspectiveCamera3D camera = memRenderTarget.Camera as PerspectiveCamera3D;
camera.Position = new Vector3(0f, 5f, -7f);
camera.Target = new Vector3(0f, 0f, 0f);
camera.UpdateCamera();
// Define scene
await memRenderTarget.Scene.ManipulateSceneAsync((manipulator) =>
{
NamedOrGenericKey geoResource = manipulator.AddResource <GeometryResource>(
() => new GeometryResource(new PalletType()));
var newObject = manipulator.AddGeneric(geoResource);
newObject.RotationEuler = new Vector3(0f, EngineMath.RAD_90DEG / 2f, 0f);
newObject.Scaling = new Vector3(2f, 2f, 2f);
if (doAnimate)
{
newObject.BuildAnimationSequence()
.RotateEulerAnglesTo(new Vector3(0f, EngineMath.RAD_180DEG, 0f), TimeSpan.FromMilliseconds(500.0))
.WaitFinished()
.RotateEulerAnglesTo(new Vector3(0f, 0, 0f), TimeSpan.FromMilliseconds(500.0))
.WaitFinished()
.ApplyAndRewind();
}
});
await memRenderTarget.RenderLoop.WaitForNextFinishedRenderAsync();
// Start video rendering
await memRenderTarget.RenderLoop.RegisterVideoWriterAsync(videoWriter);
// Write about 100 frames to the video
for (int loop = 0; loop < countFrames; loop++)
{
await memRenderTarget.RenderLoop.WaitForNextFinishedRenderAsync();
}
// finish video rendering
await memRenderTarget.RenderLoop.FinishVideoWriterAsync(videoWriter);
}
// Make shure that all the renderloop is correctly disposed
Assert.True(GraphicsCore.Current.MainLoop.RegisteredRenderLoopCount == 0, "RenderLoops where not disposed correctly!");
}
public async Task QueryInfo_FromSimpleMesh()
{
await TestUtilities.InitializeWithGraphicsAsync();
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, -7f);
camera.Target = new Vector3(0f, 0f, 0f);
camera.UpdateCamera();
// Define scene
Mesh?newMesh = null;
await memRenderTarget.Scene.ManipulateSceneAsync(manipulator =>
{
var resGeometry = manipulator.AddResource(
_ => new GeometryResource(new CubeGeometryFactory()));
var resMaterial = manipulator.AddStandardMaterialResource();
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.RedColor;
newMesh.TrySetInitialVisibility(memRenderTarget.RenderLoop.ViewInformation, true);
});
await memRenderTarget.AwaitRenderAsync();
// Query some information from the mesh
var renderingChunkCount = newMesh !.TryGetRenderingChunkCount(memRenderTarget.Device !);
var geoResource = newMesh.TryGetGeometryResource(memRenderTarget.Device !);
var materialResources = newMesh.TryGetMaterialResources(memRenderTarget.Device !);
// Take screenshot
var screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
// TestUtilities.DumpToDesktop(screenshot, "Blub.png");
// Calculate and check difference
var isNearEqual = BitmapComparison.IsNearEqual(
screenshot, TestUtilities.LoadBitmapFromResource("Drawing3D", "SimpleObject.png"));
Assert.IsTrue(isNearEqual, "Difference to reference image is to big!");
// Check info from mesh
Assert.IsTrue(renderingChunkCount == 1, "Invalid count of rendering chunks");
Assert.IsTrue(geoResource != null, "Can not query GeometryResource");
Assert.IsTrue(materialResources is { Length: 1 }, "Can not query MaterialResource");
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_SimpleObject()
{
await TestUtilities.InitializeWithGraphicsAsync();
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, -7f);
camera.Target = new Vector3(0f, 0f, 0f);
camera.UpdateCamera();
// Define scene
await memRenderTarget.Scene.ManipulateSceneAsync(manipulator =>
{
var resGeometry = manipulator.AddResource(
_ => new GeometryResource(new CubeGeometryFactory()));
var resMaterial = manipulator.AddStandardMaterialResource();
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.RedColor;
newMesh.TrySetInitialVisibility(memRenderTarget.RenderLoop.ViewInformation, true);
});
await memRenderTarget.AwaitRenderAsync();
// Take screenshot
var screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
// TestUtilities.DumpToDesktop(screenshot, "Blub.png");
// Calculate and check difference
var isNearEqual = BitmapComparison.IsNearEqual(
screenshot, TestUtilities.LoadBitmapFromResource("Drawing3D", "SimpleObject.png"));
Assert.IsTrue(isNearEqual, "Difference to reference image is to big!");
}
// Finishing checks
Assert.IsTrue(GraphicsCore.Current.MainLoop !.RegisteredRenderLoopCount == 0, "RenderLoops where not disposed correctly!");
}
public async Task LoadAndRender_ACTexturedObject()
{
await UnitTestHelper.InitializeWithGrahicsAsync();
using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024))
{
memRenderTarget.ClearColor = Color4.CornflowerBlue;
// Get and configure the camera
PerspectiveCamera3D camera = memRenderTarget.Camera as PerspectiveCamera3D;
camera.Position = new Vector3(-1f, 1f, -1f);
camera.Target = new Vector3(0f, 0f, 0f);
camera.UpdateCamera();
// Define scene
SceneObject newObject = null;
await memRenderTarget.Scene.ManipulateSceneAsync((manipulator) =>
{
NamedOrGenericKey geoResource = manipulator.AddResource <GeometryResource>(
() => new GeometryResource(ACFileLoader.ImportObjectType(new AssemblyResourceLink(
Assembly.GetExecutingAssembly(),
"SeeingSharp.Tests.Rendering.Ressources.Models",
"ModelTextured.ac"))));
newObject = manipulator.AddGeneric(geoResource);
});
await memRenderTarget.Scene.WaitUntilVisibleAsync(newObject, memRenderTarget.RenderLoop);
// Take screenshot
GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
//screenshot.DumpToDesktop(TEST_DUMMY_FILE_NAME);
// Calculate and check difference
bool isNearEqual = BitmapComparison.IsNearEqual(
screenshot, Properties.Resources.ReferenceImage_TexturedObject);
Assert.True(isNearEqual, "Difference to reference image is to big!");
}
// Finishing checks
Assert.True(GraphicsCore.Current.MainLoop.RegisteredRenderLoopCount == 0, "RenderLoops where not disposed correctly!");
}
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!");
}
}
