public void BeginRenderPass(
IGameContext gameContext,
IRenderContext renderContext,
IRenderPass previousPass,
RenderTarget2D postProcessingSource)
{
_colorRenderTarget = _renderTargetBackBufferUtilities.UpdateCustomRenderTarget(_colorRenderTarget, gameContext, SurfaceFormat.Color, DepthFormat.Depth24, null);
_normalRenderTarget = _renderTargetBackBufferUtilities.UpdateCustomRenderTarget(_normalRenderTarget, gameContext, SurfaceFormat.Color, DepthFormat.None, null);
_depthRenderTarget = _renderTargetBackBufferUtilities.UpdateCustomRenderTarget(_depthRenderTarget, gameContext, SurfaceFormat.Single, DepthFormat.None, null);
_specularRenderTarget = _renderTargetBackBufferUtilities.UpdateCustomRenderTarget(_specularRenderTarget, gameContext, SurfaceFormat.Color, DepthFormat.None, null);
_diffuseLightRenderTarget = _renderTargetBackBufferUtilities.UpdateCustomRenderTarget(_diffuseLightRenderTarget, gameContext, null, DepthFormat.None, null);
_specularLightRenderTarget = _renderTargetBackBufferUtilities.UpdateCustomRenderTarget(_specularLightRenderTarget, gameContext, null, DepthFormat.None, null);
if (_rasterizerStateCullNone == null)
{
_rasterizerStateCullNone = new RasterizerState();
_rasterizerStateCullNone.CullMode = CullMode.None;
_rasterizerStateCullNone.FillMode = FillMode.Solid;
_rasterizerStateCullNone.DepthBias = 0;
_rasterizerStateCullNone.MultiSampleAntiAlias = true;
_rasterizerStateCullNone.ScissorTestEnable = false;
_rasterizerStateCullNone.SlopeScaleDepthBias = 0;
_rasterizerStateCullNone.DepthClipEnable = true;
}
if (_rasterizerStateCullClockwiseFace == null)
{
_rasterizerStateCullClockwiseFace = new RasterizerState();
_rasterizerStateCullClockwiseFace.CullMode = CullMode.CullClockwiseFace;
_rasterizerStateCullClockwiseFace.FillMode = FillMode.Solid;
_rasterizerStateCullClockwiseFace.DepthBias = 0;
_rasterizerStateCullClockwiseFace.MultiSampleAntiAlias = true;
_rasterizerStateCullClockwiseFace.ScissorTestEnable = false;
_rasterizerStateCullClockwiseFace.SlopeScaleDepthBias = 0;
_rasterizerStateCullClockwiseFace.DepthClipEnable = true;
}
if (_rasterizerStateCullCounterClockwiseFace == null)
{
_rasterizerStateCullCounterClockwiseFace = new RasterizerState();
_rasterizerStateCullCounterClockwiseFace.CullMode = CullMode.CullCounterClockwiseFace;
_rasterizerStateCullCounterClockwiseFace.FillMode = FillMode.Solid;
_rasterizerStateCullCounterClockwiseFace.DepthBias = 0;
_rasterizerStateCullCounterClockwiseFace.MultiSampleAntiAlias = true;
_rasterizerStateCullCounterClockwiseFace.ScissorTestEnable = false;
_rasterizerStateCullCounterClockwiseFace.SlopeScaleDepthBias = 0;
_rasterizerStateCullCounterClockwiseFace.DepthClipEnable = true;
}
if (_depthStencilState == null)
{
_depthStencilState = DepthStencilState.Default;
}
if (_lightDepthStencilState == null)
{
_lightDepthStencilState = DepthStencilState.None;
}
if (_blendState == null)
{
_blendState = BlendState.Opaque;
}
if (_lightBlendState == null)
{
_lightBlendState = BlendState.AlphaBlend;
}
renderContext.PushRenderTarget(
_colorRenderTarget,
_normalRenderTarget,
_depthRenderTarget,
_specularRenderTarget);
if (ClearDepthBuffer || ClearTarget)
{
var target = ClearDepthBuffer ? ClearOptions.DepthBuffer : ClearOptions.Target;
if (ClearDepthBuffer && ClearTarget)
{
target = ClearOptions.DepthBuffer | ClearOptions.Target;
}
renderContext.GraphicsDevice.Clear(
target,
Microsoft.Xna.Framework.Color.Transparent,
renderContext.GraphicsDevice.Viewport.MaxDepth,
0);
}
// Clear the geometry buffer before moving into main rendering.
_graphicsBlit.Blit(
renderContext,
null,
null,
_gbufferClearEffect.Effect);
_previousDepthStencilState = renderContext.GraphicsDevice.DepthStencilState;
_previousRasterizerState = renderContext.GraphicsDevice.RasterizerState;
_previousBlendState = renderContext.GraphicsDevice.BlendState;
renderContext.GraphicsDevice.DepthStencilState = _depthStencilState;
renderContext.GraphicsDevice.RasterizerState = _rasterizerStateCullCounterClockwiseFace;
renderContext.GraphicsDevice.BlendState = _blendState;
}
public RenderPipelineWorld(
IAssetManager assetManager,
I2DRenderUtilities renderUtilities,
IGraphicsFactory graphicsFactory,
IAssert assert,
ITestAttachment testAttachment,
IRenderTargetBackBufferUtilities renderTargetBackBufferUtilities,
IGraphicsBlit graphicsBlit)
{
_renderUtilities = renderUtilities;
_assert = assert;
_testAttachment = testAttachment;
_texture = assetManager.Get <TextureAsset>("texture.Player");
_invertPostProcess = graphicsFactory.CreateInvertPostProcessingRenderPass();
_blurPostProcess = graphicsFactory.CreateBlurPostProcessingRenderPass();
_customPostProcess = graphicsFactory.CreateCustomPostProcessingRenderPass("effect.MakeRed");
_captureInlinePostProcess = graphicsFactory.CreateCaptureInlinePostProcessingRenderPass();
_renderTargetBackBufferUtilities = renderTargetBackBufferUtilities;
_graphicsBlit = graphicsBlit;
_captureInlinePostProcess.RenderPipelineStateAvailable = (gameContext, renderContext, previousPass, d) =>
{
if (!_isValidRun)
{
return;
}
_renderTarget = _renderTargetBackBufferUtilities.UpdateCustomRenderTarget(_renderTarget, renderContext, SurfaceFormat.Color, DepthFormat.None, 1);
// Blit to the capture target.
_graphicsBlit.Blit(renderContext, d, _renderTarget);
#if MANUAL_TEST
#elif RECORDING
using (var writer = new StreamWriter("output" + _frame + ".png"))
{
_renderTarget.SaveAsPng(writer.BaseStream, Width, Height);
}
#else
var baseStream =
typeof(RenderPipelineWorld).Assembly.GetManifestResourceStream(
"Protogame.Tests.Expected.RenderPipeline.output" + _frame + ".png");
_assert.NotNull(baseStream);
var memoryStream = new MemoryStream();
_renderTarget.SaveAsPng(memoryStream, Width, Height);
// ReSharper disable once AssignNullToNotNullAttribute
var expected = new Bitmap(baseStream);
var actual = new Bitmap(memoryStream);
_assert.Equal(expected.Height, actual.Height);
_assert.Equal(expected.Width, actual.Width);
var totalPixelValues = 0L;
var incorrectPixelValues = 0L;
for (var x = 0; x < expected.Width; x++)
{
for (var y = 0; y < expected.Height; y++)
{
var expectedPixel = expected.GetPixel(x, y);
var actualPixel = actual.GetPixel(x, y);
totalPixelValues += 255 * 4;
if (expectedPixel != actualPixel)
{
var diffA = System.Math.Abs((int)actualPixel.A - (int)expectedPixel.A);
var diffR = System.Math.Abs((int)actualPixel.R - (int)expectedPixel.R);
var diffG = System.Math.Abs((int)actualPixel.G - (int)expectedPixel.G);
var diffB = System.Math.Abs((int)actualPixel.B - (int)expectedPixel.B);
incorrectPixelValues += (diffA + diffR + diffG + diffB);
}
}
}
var percentage = (100 - ((incorrectPixelValues / (double)totalPixelValues) * 100f));
var combination = _combinations[_frame % _combinations.Count];
_testAttachment.Attach("name-" + combination.Id, combination.Name);
_testAttachment.Attach("expected-" + combination.Id, baseStream);
_testAttachment.Attach("actual-" + combination.Id, memoryStream);
_testAttachment.Attach("threshold-" + combination.Id, 99.9);
_testAttachment.Attach("measured-" + combination.Id, percentage);
if (percentage <= 99.9f)
{
combination.FailureMessage = "The actual rendered image did not match the expected image close enough (99.9%).";
}
//memoryStream.Dispose();
//baseStream.Dispose();
#endif
#if MANUAL_TEST
_manualTest++;
if (_manualTest % 60 == 0)
{
_frame++;
}
#else
_frame++;
#endif
};
this.Entities = new List <IEntity>();
}
