public void UpdateRenderTargetSize(CanvasDevice device, GameGeometry geometry)
{
RenderTargetAspectRatio = geometry.AspectRatio;
if (RenderTargetAspectRatio < 0.1f)
{
RenderTargetAspectRatio = (float)(geometry.BaseWidth) / geometry.BaseHeight;
}
if (RenderTarget != null)
{
var currentSize = RenderTarget.Size;
if (currentSize.Width >= geometry.MaxWidth && currentSize.Height >= geometry.MaxHeight)
{
return;
}
}
lock (RenderTargetLock)
{
var size = Math.Max(Math.Max(geometry.MaxWidth, geometry.MaxHeight), RenderTargetMinSize);
size = ClosestGreaterPowerTwo(size);
RenderTarget?.Dispose();
RenderTargetSurface?.Dispose();
RenderTargetSurface = D3DSurfaceMap.CreateMappableD3DSurface(device, size, size);
RenderTarget = CanvasBitmap.CreateFromDirect3D11Surface(device, RenderTargetSurface);
}
}
public void LinearizeDepth(RenderTargetSurface dst, ShaderResource src)
{
throw new NotImplementedException();
#if false
Debug.Assert(Game.IsServiceExist <Camera>());
var camera = Game.GetService <Camera>();
bufLinearizeDepth.Data.linearizeDepthA = 1.0f / camera.FrustumZFar - 1.0f / camera.FrustumZNear;
bufLinearizeDepth.Data.linearizeDepthB = 1.0f / camera.FrustumZNear;
bufLinearizeDepth.UpdateCBuffer();
var isDepthMSAA = (src.SampleCount > 1);
var depthShader = (int)(isDepthMSAA ? ShaderFlags.RESOLVE_AND_LINEARIZE_DEPTH_MSAA : ShaderFlags.LINEARIZE_DEPTH);
string signature;
SetDefaultRenderStates();
using (new PixEvent()) {
bufLinearizeDepth.SetCBufferPS(0);
shaders.SetPixelShader(depthShader);
shaders.SetVertexShader(depthShader);
dst.SetViewport();
device.SetRenderTargets(dst);
src.SetPS(0);
device.Draw(Primitive.TriangleList, 3, 0);
}
device.ResetStates();
#endif
}
/*-----------------------------------------------------------------------------------------------
*
* Base filters
*
* -----------------------------------------------------------------------------------------------*/
/// <summary>
/// Performs good-old StretchRect to destination buffer with blending.
/// </summary>
/// <param name="dst"></param>
/// <param name="src"></param>
/// <param name="filter"></param>
/// <param name="rect"></param>
public void StretchRect(RenderTargetSurface dst, ShaderResource src, SamplerState filter = null, bool flipToCubeFace = false)
{
SetDefaultRenderStates();
using (new PixEvent("StretchRect")) {
SetViewport(dst);
device.SetTargets(null, dst);
if (flipToCubeFace)
{
device.PipelineState = factory[(int)(ShaderFlags.STRETCH_RECT | ShaderFlags.TO_CUBE_FACE)];
}
else
{
device.PipelineState = factory[(int)ShaderFlags.STRETCH_RECT];
}
device.VertexShaderResources[0] = src;
device.PixelShaderResources[0] = src;
device.PixelShaderSamplers[0] = filter ?? SamplerState.LinearPointClamp;
device.VertexShaderConstants[0] = sourceRectCB;
device.Draw(3, 0);
}
device.ResetStates();
}
public void Dispose()
{
RenderTarget?.Dispose();
RenderTarget = null;
RenderTargetSurface?.Dispose();
RenderTargetSurface = null;
}
/// <summary>
/// Draws sprite laters and all sublayers.
/// </summary>
/// <param name="gameTime"></param>
/// <param name="stereoEye"></param>
public void DrawSprites(GameTime gameTime, StereoEye stereoEye, RenderTargetSurface surface, IEnumerable <SpriteLayer> layers)
{
device.ResetStates();
//device.RestoreBackbuffer();
device.SetTargets(null, surface);
DrawSpritesRecursive(gameTime, stereoEye, surface, layers, Matrix.Identity, new Color4(1f, 1f, 1f, 1f));
}
/*-----------------------------------------------------------------------------------------------
*
* Base filters
*
* -----------------------------------------------------------------------------------------------*/
/// <summary>
/// Performs good-old StretchRect to destination buffer with blending.
/// </summary>
/// <param name="dst"></param>
/// <param name="src"></param>
/// <param name="blendState"></param>
public void StretchRect(RenderTargetSurface dst, ShaderResource src, SamplerState filter = null)
{
SetDefaultRenderStates();
using (new PixEvent()) {
SetViewport(dst);
rs.SetTargets(null, dst);
rs.PipelineState = factory[(int)ShaderFlags.DOWNSAMPLE_2_2x2];
rs.VertexShaderResources[0] = src;
rs.PixelShaderResources[0] = src;
rs.PixelShaderSamplers[0] = filter ?? SamplerState.LinearPointClamp;
rs.Draw(3, 0);
}
rs.ResetStates();
}
/// <summary>
///
/// </summary>
/// <param name="dst">target to copy to</param>
/// <param name="src">target to copy from</param>
public void FillAlphaOne(RenderTargetSurface dst)
{
SetDefaultRenderStates();
using (new PixEvent("FillAlphaOne")) {
if (dst == null)
{
device.RestoreBackbuffer();
}
else
{
SetViewport(dst);
device.SetTargets(null, dst);
}
device.PipelineState = factory[(int)ShaderFlags.FILL_ALPHA_ONE];
device.Draw(3, 0);
}
device.ResetStates();
}
/// <summary>
///
/// </summary>
/// <param name="dst">target to copy to</param>
/// <param name="src">target to copy from</param>
public void OverlayAdditive(RenderTargetSurface dst, ShaderResource src)
{
SetDefaultRenderStates();
using (new PixEvent("OverlayAdditive")) {
if (dst == null)
{
device.RestoreBackbuffer();
}
else
{
device.SetTargets(null, dst);
}
device.PipelineState = factory[(int)ShaderFlags.OVERLAY_ADDITIVE];
device.PixelShaderResources[0] = src;
device.Draw(3, 0);
}
device.ResetStates();
}
/// <summary>
///
/// </summary>
/// <param name="dst">target to copy to</param>
/// <param name="src">target to copy from</param>
public void CopyAlpha(RenderTargetSurface dst, ShaderResource src)
{
SetDefaultRenderStates();
using (new PixEvent("Copy")) {
if (dst == null)
{
device.RestoreBackbuffer();
}
else
{
SetViewport(dst);
device.SetTargets(null, dst);
}
device.PipelineState = factory[(int)ShaderFlags.COPY_ALPHA];
device.PixelShaderResources[0] = src;
device.Draw(3, 0);
}
device.ResetStates();
}
/// <summary>
///
/// </summary>
/// <param name="dst">target to copy to</param>
/// <param name="src">target to copy from</param>
public void Copy(RenderTargetSurface dst, ShaderResource src)
{
SetDefaultRenderStates();
using (new PixEvent()) {
if (dst == null)
{
rs.RestoreBackbuffer();
}
else
{
SetViewport(dst);
rs.SetTargets(null, dst);
}
rs.PipelineState = factory[(int)ShaderFlags.COPY];
rs.PixelShaderResources[0] = src;
rs.Draw(3, 0);
}
rs.ResetStates();
}
public void RadialBlur(RenderTargetSurface dst, RenderTarget2D src, Vector2 blurPoint, float offset, float size)
{
SetDefaultRenderStates();
var data = new Vector4(blurPoint.X, blurPoint.Y, offset, size);
radialDataCB.SetData(data);
using (new PixEvent()) {
rs.SetTargets(null, dst);
SetViewport(dst);
rs.PipelineState = factory[(int)ShaderFlags.RADIAL_BLUR];
rs.VertexShaderResources[0] = src;
rs.PixelShaderResources[0] = src;
rs.PixelShaderSamplers[0] = SamplerState.LinearPointClamp;
rs.PixelShaderConstants[0] = radialDataCB;
rs.VertexShaderConstants[0] = radialDataCB;
rs.Draw(3, 0);
}
rs.ResetStates();
}
/// <summary>
/// Renders view
/// </summary>
internal void Render(GameTime gameTime, StereoEye stereoEye, RenderTargetSurface targetSurface)
{
if (captureRadiance)
{
RenderRadiance();
captureRadiance = false;
}
// clear target buffer if necassary :
if (Clear)
{
rs.Device.Clear(targetSurface, ClearColor);
}
var viewport = new Viewport(0, 0, targetSurface.Width, targetSurface.Height);
// Render HDR stuff: mesh instances,
// special effects, sky, water, light etc.
RenderHdrScene(gameTime, stereoEye, viewport, targetSurface);
// fill alpha with one value :
rs.Filter.FillAlphaOne(targetSurface);
}
/// <summary>
/// Performs FXAA antialiasing.
/// </summary>
/// <param name="dst">Target buffer to render FXAA to</param>
/// <param name="src">Source image with luminance in alpha</param>
public void Fxaa(RenderTargetSurface dst, ShaderResource src)
{
SetDefaultRenderStates();
using (new PixEvent("Fxaa")) {
if (dst == null)
{
device.RestoreBackbuffer();
}
else
{
SetViewport(dst);
device.SetTargets(null, dst);
}
device.PipelineState = factory[(int)ShaderFlags.FXAA];
device.VertexShaderResources[0] = src;
device.PixelShaderResources[0] = src;
device.PixelShaderSamplers[0] = SamplerState.LinearPointClamp;
device.Draw(3, 0);
}
device.ResetStates();
}
public void StretchRect4x4(RenderTargetSurface dst, RenderTarget2D src, SamplerState filter = null, bool flipToCubeFace = false)
{
SetDefaultRenderStates();
using (new PixEvent("StretchRect4x4")) {
device.SetTargets(null, dst);
SetViewport(dst);
if (flipToCubeFace)
{
device.PipelineState = factory[(int)(ShaderFlags.DOWNSAMPLE_2_4x4 | ShaderFlags.TO_CUBE_FACE)];
}
else
{
device.PipelineState = factory[(int)ShaderFlags.DOWNSAMPLE_2_4x4];
}
device.VertexShaderResources[0] = src;
device.PixelShaderResources[0] = src;
device.PixelShaderSamplers[0] = filter ?? SamplerState.LinearPointClamp;
device.Draw(3, 0);
}
device.ResetStates();
}
/// <summary>
///
/// </summary>
/// <param name="gameTime"></param>
internal void RenderShadow(GameTime gameTime, Viewport viewport, Matrix view, Matrix projection, RenderTargetSurface particleShadow, DepthStencilSurface depthBuffer)
{
if (rs.SkipParticleShadows)
{
return;
}
var colorTarget = particleShadow;
var depthTarget = depthBuffer;
RenderGeneric("Particles Shadow", gameTime, null, viewport, view, projection, colorTarget, depthTarget, null, Flags.DRAW_SHADOW);
}
/// <summary>
///
/// </summary>
void RenderGeneric(string passName, GameTime gameTime, Camera camera, Viewport viewport, Matrix view, Matrix projection, RenderTargetSurface colorTarget, DepthStencilSurface depthTarget, ShaderResource depthValues, Flags flags)
{
var device = Game.GraphicsDevice;
using (new PixEvent(passName)) {
device.ResetStates();
//
// Setup images :
//
if (Images != null && !Images.IsDisposed)
{
imagesCB.SetData(Images.GetNormalizedRectangles(MaxImages));
}
SetupGPUParameters(0, renderWorld, view, projection, flags);
device.ComputeShaderConstants[0] = paramsCB;
//
// Render
//
using (new PixEvent("Drawing")) {
// target and viewport :
device.SetTargets(depthTarget, colorTarget);
device.SetViewport(viewport);
// params CB :
device.ComputeShaderConstants[0] = paramsCB;
device.VertexShaderConstants[0] = paramsCB;
device.GeometryShaderConstants[0] = paramsCB;
device.PixelShaderConstants[0] = paramsCB;
// atlas CB :
device.VertexShaderConstants[1] = imagesCB;
device.GeometryShaderConstants[1] = imagesCB;
device.PixelShaderConstants[1] = imagesCB;
// sampler & textures :
device.PixelShaderSamplers[0] = SamplerState.LinearClamp4Mips;
device.PixelShaderResources[0] = Images == null? rs.WhiteTexture.Srv : Images.Texture.Srv;
device.PixelShaderResources[5] = depthValues;
device.GeometryShaderResources[1] = simulationBuffer;
device.GeometryShaderResources[2] = simulationBuffer;
device.GeometryShaderResources[3] = sortParticlesBuffer;
device.GeometryShaderResources[4] = particleLighting;
// setup PS :
device.PipelineState = factory[(int)flags];
// GPU time : 0.81 ms -> 0.91 ms
device.Draw(MaxSimulatedParticles, 0);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="view"></param>
/// <param name="projection"></param>
public void RenderLighting(Matrix view, Matrix projection, RenderTargetSurface hdrTarget, ShaderResource occlusionMap)
{
var device = Game.GraphicsDevice;
device.ResetStates();
LightingFlags flags = LightingFlags.NONE;
if (!Config.SkipDirectLight)
{
flags |= LightingFlags.DIRECT;
if (Config.ShowCSMSplits)
{
flags |= LightingFlags.SHOW_SPLITS;
}
}
if (!Config.SkipOmniLights)
{
flags |= LightingFlags.OMNI;
if (Config.ShowOmniLightTileLoad)
{
flags |= LightingFlags.SHOW_OMNI_LOAD;
}
}
if (!Config.SkipSpotLights)
{
flags |= LightingFlags.SPOT;
if (Config.ShowSpotLightTileLoad)
{
flags |= LightingFlags.SHOW_SPOT_LOAD;
}
}
if (Config.UseUE4LightingModel)
{
flags |= LightingFlags.USE_UE4;
}
//
// Setup compute shader parameters and states :
//
try {
device.PipelineState = factory[(int)flags];
//lightingShader.SetComputeShader((int)flags);
var cbData = new LightingParams();
var invView = Matrix.Invert(view);
var invVP = Matrix.Invert(view * projection);
var viewPos = invView.TranslationVector;
cbData.DirectLightDirection = new Vector4(DirectLightDirection, 0);
cbData.DirectLightIntensity = DirectLightIntensity.ToVector4();
cbData.Projection = projection;
cbData.CSMViewProjection0 = csmViewProjections[0];
cbData.CSMViewProjection1 = csmViewProjections[1];
cbData.CSMViewProjection2 = csmViewProjections[2];
cbData.CSMViewProjection3 = csmViewProjections[3];
cbData.View = view;
cbData.ViewPosition = new Vector4(viewPos, 1);
cbData.InverseViewProjection = invVP;
cbData.CSMFilterRadius = new Vector4(Config.CSMFilterSize);
cbData.AmbientColor = AmbientLevel;
PrepareOmniLights(view, projection);
PrepareSpotLights(view, projection);
//
// set states :
//
device.SetTargets(null, hdrTarget);
lightingCB.SetData(cbData);
device.ComputeShaderSamplers[0] = SamplerState.PointClamp;
device.ComputeShaderSamplers[1] = SamplerState.LinearClamp;
device.ComputeShaderSamplers[2] = SamplerState.ShadowSampler;
device.ComputeShaderResources[0] = diffuseBuffer;
device.ComputeShaderResources[1] = specularBuffer;
device.ComputeShaderResources[2] = normalMapBuffer;
device.ComputeShaderResources[3] = depthBuffer;
device.ComputeShaderResources[4] = csmColor;
device.ComputeShaderResources[5] = spotColor;
device.ComputeShaderResources[6] = MaskAtlas.Texture;
device.ComputeShaderResources[7] = omniLightBuffer;
device.ComputeShaderResources[8] = spotLightBuffer;
device.ComputeShaderResources[9] = occlusionMap;
device.ComputeShaderConstants[0] = lightingCB;
device.SetCSRWTexture(0, lightAccumBuffer.Surface);
//
// Dispatch :
//
device.Dispatch(MathUtil.IntDivUp(hdrTarget.Width, BlockSizeX), MathUtil.IntDivUp(hdrTarget.Height, BlockSizeY), 1);
} catch (UbershaderException e) {
e.Report();
}
//device.DisplayBounds
//
// Add accumulated light :
//
device.ResetStates();
device.SetTargets(null, hdrTarget);
var sb = Game.GetService <SpriteBatch>();
sb.Begin(SpriteBlend.Additive);
sb.Draw(lightAccumBuffer, 0, 0, lightAccumBuffer.Width, lightAccumBuffer.Height, Color.White);
sb.End();
device.ResetStates();
/*if ( Config.ShowSpotLightExtents ) {
* device.ResetStates();
* device.SetTargets( null, hdrTarget );
*
* var sb = Game.GetService<SpriteBatch>();
* sb.Begin( BlendState.Additive );
* foreach ( var spot in spotLightData ) {
*
* sb.Draw( sb.TextureWhite,
* spot.ExtentMin.X,
* spot.ExtentMin.Y,
* spot.ExtentMax.X-spot.ExtentMin.X,
* spot.ExtentMax.Y-spot.ExtentMin.Y,
* new Color(32,0,32,255) );
*
* }
* sb.End();
* } */
}
public void CopyColor(RenderTargetSurface dst, ShaderResource src)
{
Copy(dst, src);
}
void SetViewport(RenderTargetSurface dst)
{
device.SetViewport(0, 0, dst.Width, dst.Height);
}
/// <summary>
///
/// </summary>
/// <param name="gameTime"></param>
/// <param name="stereoEye"></param>
void RenderHdrScene(GameTime gameTime, StereoEye stereoEye, Viewport viewport, RenderTargetSurface targetSurface)
{
// clear g-buffer and hdr-buffers:
ClearBuffers(viewHdrFrame);
// single pass for stereo rendering :
if (stereoEye != StereoEye.Right)
{
// simulate particles BEFORE lighting
// to make particle lit (position is required) and
// get simulated particles for shadows.
ParticleSystem.Simulate(gameTime, Camera);
// render shadows :
rs.LightRenderer.RenderShadows(this, this.LightSet);
}
// render g-buffer :
rs.SceneRenderer.RenderGBuffer(gameTime, stereoEye, Camera, viewHdrFrame, this, false);
// render ssao :
rs.SsaoFilter.Render(stereoEye, Camera, viewHdrFrame.DepthBuffer, viewHdrFrame.GBuffer1);
switch (rs.ShowGBuffer)
{
case 1: rs.Filter.CopyColor(targetSurface, viewHdrFrame.GBuffer0); return;
case 2: rs.Filter.CopyAlpha(targetSurface, viewHdrFrame.GBuffer0); return;
case 3: rs.Filter.CopyColor(targetSurface, viewHdrFrame.GBuffer1); return;
case 4: rs.Filter.CopyAlpha(targetSurface, viewHdrFrame.GBuffer1); return;
case 5: rs.Filter.CopyColor(targetSurface, viewHdrFrame.HdrBuffer); return;
case 6: rs.Filter.Copy(targetSurface, rs.SsaoFilter.OcclusionMap); return;
case 7: rs.Filter.StretchRect(targetSurface, rs.LightRenderer.CascadedShadowMap.ParticleShadow); return;
case 8: rs.Filter.StretchRect(targetSurface, rs.LightRenderer.CascadedShadowMap.ColorBuffer); return;
case 9: rs.Filter.StretchRect(targetSurface, viewHdrFrame.FeedbackBufferRB, SamplerState.PointClamp); return;
}
if (rs.VTSystem.ShowPhysicalTextures)
{
rs.Filter.StretchRect(targetSurface, rs.VTSystem.PhysicalPages0);
return;
}
if (rs.VTSystem.ShowPageTexture)
{
rs.Filter.Copy(targetSurface, rs.VTSystem.PageTable);
return;
}
// render sky :
rs.Sky.Render(Camera, stereoEye, viewHdrFrame, SkySettings);
rs.Sky.RenderFogTable(SkySettings);
// render lights :
rs.LightRenderer.RenderLighting(stereoEye, Camera, viewHdrFrame, this, Radiance);
// render "solid" DOF :
rs.DofFilter.Render(gameTime, viewHdrFrame.LightAccumulator, viewHdrFrame.HdrBuffer, viewHdrFrame.DepthBuffer, this);
// render and simulate particles :
ParticleSystem.Render(gameTime, Camera, stereoEye, viewHdrFrame);
// apply tonemapping and bloom :
rs.HdrFilter.Render(gameTime, TempFXBuffer.Surface, viewHdrFrame.HdrBuffer, this);
// apply FXAA
if (rs.UseFXAA)
{
rs.Filter.Fxaa(targetSurface, TempFXBuffer);
}
else
{
rs.Filter.Copy(targetSurface, TempFXBuffer);
}
// draw debug lines :
Debug.Render(targetSurface, viewHdrFrame.DepthBuffer.Surface, Camera);
}
/// <summary>
/// Performs luminance measurement, tonemapping, applies bloom.
/// </summary>
/// <param name="target">LDR target.</param>
/// <param name="hdrImage">HDR source image.</param>
public void Render(GameTime gameTime, RenderTargetSurface target, ShaderResource hdrImage, RenderWorld viewLayer)
{
var device = Game.GraphicsDevice;
var filter = Game.RenderSystem.Filter;
var settings = viewLayer.HdrSettings;
using (new PixEvent("HDR Postprocessing")) {
//
// Rough downsampling of source HDR-image :
//
filter.StretchRect(averageLum.Surface, hdrImage, SamplerState.PointClamp);
averageLum.BuildMipmaps();
//
// Make bloom :
//
filter.StretchRect(viewLayer.Bloom0.Surface, hdrImage, SamplerState.LinearClamp);
viewLayer.Bloom0.BuildMipmaps();
filter.GaussBlur(viewLayer.Bloom0, viewLayer.Bloom1, settings.GaussBlurSigma, 0);
filter.GaussBlur(viewLayer.Bloom0, viewLayer.Bloom1, settings.GaussBlurSigma, 1);
filter.GaussBlur(viewLayer.Bloom0, viewLayer.Bloom1, settings.GaussBlurSigma, 2);
filter.GaussBlur(viewLayer.Bloom0, viewLayer.Bloom1, settings.GaussBlurSigma, 3);
//
// Setup parameters :
//
var paramsData = new Params();
paramsData.AdaptationRate = 1 - (float)Math.Pow(0.5f, gameTime.ElapsedSec / settings.AdaptationHalfLife);
paramsData.LuminanceLowBound = settings.LuminanceLowBound;
paramsData.LuminanceHighBound = settings.LuminanceHighBound;
paramsData.KeyValue = settings.KeyValue;
paramsData.BloomAmount = settings.BloomAmount;
paramsData.DirtMaskLerpFactor = settings.DirtMaskLerpFactor;
paramsData.DirtAmount = settings.DirtAmount;
paramsData.Saturation = settings.Saturation;
paramsData.MaximumOutputValue = settings.MaximumOutputValue;
paramsData.MinimumOutputValue = settings.MinimumOutputValue;
paramsData.DitherAmount = settings.DitherAmount;
paramsCB.SetData(paramsData);
device.PixelShaderConstants[0] = paramsCB;
//
// Measure and adapt :
//
device.SetTargets(null, viewLayer.MeasuredNew);
device.PixelShaderResources[0] = averageLum;
device.PixelShaderResources[1] = viewLayer.MeasuredOld;
device.PipelineState = factory[(int)(Flags.MEASURE_ADAPT)];
device.Draw(3, 0);
//
// Tonemap and compose :
//
device.SetTargets(null, target);
device.PixelShaderResources[0] = hdrImage; // averageLum;
device.PixelShaderResources[1] = viewLayer.MeasuredNew; // averageLum;
device.PixelShaderResources[2] = viewLayer.Bloom0; // averageLum;
device.PixelShaderResources[3] = settings.DirtMask1 == null ? whiteTex.Srv : settings.DirtMask1.Srv;
device.PixelShaderResources[4] = settings.DirtMask2 == null ? whiteTex.Srv : settings.DirtMask2.Srv;
device.PixelShaderResources[5] = noiseTex.Srv;
device.PixelShaderSamplers[0] = SamplerState.LinearClamp;
Flags op = Flags.LINEAR;
if (settings.TonemappingOperator == TonemappingOperator.Filmic)
{
op = Flags.FILMIC;
}
if (settings.TonemappingOperator == TonemappingOperator.Linear)
{
op = Flags.LINEAR;
}
if (settings.TonemappingOperator == TonemappingOperator.Reinhard)
{
op = Flags.REINHARD;
}
device.PipelineState = factory[(int)(Flags.TONEMAPPING | op)];
device.Draw(3, 0);
device.ResetStates();
// swap luminanice buffers :
Misc.Swap(ref viewLayer.MeasuredNew, ref viewLayer.MeasuredOld);
}
}
/// <summary>
/// Draw sprite layers
/// </summary>
/// <param name="gameTime"></param>
/// <param name="stereoEye"></param>
/// <param name="layers"></param>
void DrawSpritesRecursive(GameTime gameTime, StereoEye stereoEye, RenderTargetSurface surface, IEnumerable <SpriteLayer> layers, Matrix parentTransform, Color4 parentColor)
{
int w = surface.Width;
int h = surface.Height;
var ofs = 0f;
var projection = Matrix.OrthoOffCenterRH(ofs, w + ofs, h + ofs, ofs, -9999, 9999);
var orderedLayers = layers.Where(layer0 => layer0 != null).OrderBy(layer1 => layer1.Order);
foreach (var layer in orderedLayers)
{
if (!layer.Visible)
{
continue;
}
using (new PixEvent("SpriteLayer")) {
Matrix absTransform = parentTransform * layer.Transform;
Color4 absColor = parentColor * layer.Color.ToColor4();
constData.Transform = absTransform * projection;
constData.ClipRectangle = new Vector4(0, 0, 0, 0);
constData.MasterColor = absColor;
constBuffer.SetData(constData);
device.VertexShaderConstants[0] = constBuffer;
device.PixelShaderConstants[0] = constBuffer;
PipelineState ps = null;
SamplerState ss = null;
switch (layer.FilterMode)
{
case SpriteFilterMode.PointClamp: ss = SamplerState.PointClamp; break;
case SpriteFilterMode.PointWrap: ss = SamplerState.PointWrap; break;
case SpriteFilterMode.LinearClamp: ss = SamplerState.LinearClamp; break;
case SpriteFilterMode.LinearWrap: ss = SamplerState.LinearWrap; break;
case SpriteFilterMode.AnisotropicClamp: ss = SamplerState.AnisotropicClamp; break;
case SpriteFilterMode.AnisotropicWrap: ss = SamplerState.AnisotropicWrap; break;
}
switch (layer.BlendMode)
{
case SpriteBlendMode.Opaque: ps = factory[(int)Flags.OPAQUE]; break;
case SpriteBlendMode.AlphaBlend: ps = factory[(int)Flags.ALPHA_BLEND]; break;
case SpriteBlendMode.AlphaBlendPremul: ps = factory[(int)Flags.ALPHA_BLEND_PREMUL]; break;
case SpriteBlendMode.Additive: ps = factory[(int)Flags.ADDITIVE]; break;
case SpriteBlendMode.Screen: ps = factory[(int)Flags.SCREEN]; break;
case SpriteBlendMode.Multiply: ps = factory[(int)Flags.MULTIPLY]; break;
case SpriteBlendMode.NegMultiply: ps = factory[(int)Flags.NEG_MULTIPLY]; break;
case SpriteBlendMode.AlphaOnly: ps = factory[(int)Flags.ALPHA_ONLY]; break;
}
device.PipelineState = ps;
device.PixelShaderSamplers[0] = ss;
layer.Draw(gameTime, stereoEye);
DrawSpritesRecursive(gameTime, stereoEye, surface, layer.Layers, absTransform, absColor);
}
}
}
/// <summary>
/// Renders sky with specified technique
/// </summary>
/// <param name="rendCtxt"></param>
/// <param name="techName"></param>
public void Render(GameTime gameTime, DepthStencilSurface depthBuffer, RenderTargetSurface hdrTarget, Matrix view, Matrix projection, RenderTarget2D cloudTarget, RenderTarget2D smallerCloudTarget)
{
var camera = Game.GetService <Camera>();
var scale = Matrix.Scaling(Params.SkySphereSize);
var rotation = Matrix.Identity;
var sunPos = GetSunDirection();
var sunColor = GetSunGlowColor();
rs.ResetStates();
//rs.DepthStencilState = depthBuffer==null? DepthStencilState.None : DepthStencilState.Default ;
rs.SetViewport(0, 0, hdrTarget.Width, hdrTarget.Height);
rs.SetTargets(depthBuffer, hdrTarget);
var viewMatrix = view;
var projMatrix = projection;
skyConstsData.MatrixWVP = scale * rotation * MathUtil.Transformation(viewMatrix.Right, viewMatrix.Up, viewMatrix.Backward) * projMatrix;
skyConstsData.SunPosition = sunPos;
skyConstsData.SunColor = sunColor;
skyConstsData.Turbidity = Params.SkyTurbidity;
skyConstsData.Temperature = Temperature.Get(Params.SunTemperature);
skyConstsData.SkyIntensity = Params.SkyIntensity;
skyConstsCB.SetData(skyConstsData);
rs.VertexShaderConstants[0] = skyConstsCB;
rs.PixelShaderConstants[0] = skyConstsCB;
//
// Sky :
//
SkyFlags flags = SkyFlags.PROCEDURAL_SKY;
ApplyColorSpace(ref flags);
rs.PipelineState = factory[(int)flags];
for (int j = 0; j < skySphere.Meshes.Count; j++)
{
var mesh = skySphere.Meshes[j];
rs.SetupVertexInput(vertexBuffers[j], indexBuffers[j]);
rs.DrawIndexed(mesh.IndexCount, 0, 0);
}
//
// Clouds :
//
scale = Matrix.Scaling(Params.SkySphereSize, Params.SkySphereSize, Params.SkySphereSize);
//scale = Matrix.Scaling( Params.SkySphereSize, Params.SkySphereSize * 0.1f, Params.SkySphereSize );
skyConstsData.MatrixWVP = scale * rotation * MathUtil.Transformation(viewMatrix.Right, viewMatrix.Up, viewMatrix.Backward) * projMatrix;
skyConstsData.SunPosition = sunPos;
skyConstsData.SunColor = GetSunLightColor();
skyConstsData.Turbidity = Params.SkyTurbidity;
skyConstsData.Temperature = Temperature.Get(Params.SunTemperature);
skyConstsData.SkyIntensity = Params.SkyIntensity;
skyConstsData.Ambient = GetAmbientLevel().ToVector3();
skyConstsData.Time = (float)gameTime.Total.TotalSeconds;
skyConstsCB.SetData(skyConstsData);
rs.SetTargets(depthBuffer, hdrTarget);
// rs.SetTargets( null, cloudTarget.Surface );
flags = SkyFlags.CLOUDS;
//int i = 0;
for (int i = 0; i < 3; i++)
{
if (i == 0)
{
flags = SkyFlags.CLOUDS | SkyFlags.A | SkyFlags.RED;
}
if (i == 1)
{
flags = SkyFlags.CLOUDS | SkyFlags.B | SkyFlags.GREEN;
}
if (i == 2)
{
flags = SkyFlags.CLOUDS | SkyFlags.C | SkyFlags.BLUE;
}
ApplyColorSpace(ref flags);
rs.PipelineState = factory[(int)flags];
rs.PixelShaderResources[0] = clouds;
rs.PixelShaderResources[1] = cirrus;
rs.PixelShaderResources[2] = noise;
rs.PixelShaderResources[3] = arrows;
rs.PixelShaderSamplers[0] = SamplerState.AnisotropicWrap;
for (int j = 0; j < cloudSphere.Meshes.Count; j++)
{
var mesh = cloudSphere.Meshes[j];
rs.SetupVertexInput(cloudVertexBuffers[j], cloudIndexBuffers[j]);
rs.DrawIndexed(mesh.IndexCount, 0, 0);
}
}
#if false
//Blur
var filter = Game.GetService <Filter>();
//filter.RadialBlur(smallerCloudTarget.Surface, cloudTarget, new Vector2(0.5f, 0.5f), 1.0f, -0.2f);
//if(Game.InputDevice.IsKeyDown(Keys.LeftButton))
//{
Vector4 sunProj = Vector4.Transform(new Vector4(sunPos, 0), viewMatrix);
sunProj = Vector4.Transform(sunProj, projMatrix);
sunProj = new Vector4(sunProj.X / sunProj.W, sunProj.Y / sunProj.W, sunProj.Z / sunProj.W, 1);
Vector2 relSunPosition = new Vector2(0.5f, 0.5f);
//if ( Math.Abs(sunProj.X ) < 1 && Math.Abs (sunProj.Y) < 1){
relSunPosition = new Vector2((sunProj.X + 1) / 2, -(sunProj.Y - 1) / 2);
//}
//Log.Message(relSunPosition + "");
filter.RadialBlur(smallerCloudTarget.Surface, cloudTarget, relSunPosition, 1.0f, -0.2f);
//}
flags = SkyFlags.BLUR_CLOUD;
skyConstsData.MatrixWVP = Matrix.Identity;
skyConstsCB.SetData(skyConstsData);
rs.SetTargets(null, hdrTarget);
ApplyColorSpace(ref flags);
rs.VertexShaderConstants[0] = skyConstsCB;
rs.PixelShaderConstants[0] = skyConstsCB;
rs.PipelineState = factory[(int)flags];
rs.PixelShaderResources[4] = cloudTarget;
rs.PixelShaderSamplers[1] = SamplerState.LinearWrap;
var v0 = new VertexColorTextureTBN {
Position = new Vector3(-1.0f, -1.0f, 0), TexCoord = new Vector2(0, 1),
};
var v1 = new VertexColorTextureTBN {
Position = new Vector3(1.0f, 1.0f, 0), TexCoord = new Vector2(1, 0),
};
var v2 = new VertexColorTextureTBN {
Position = new Vector3(-1.0f, 1.0f, 0), TexCoord = new Vector2(0, 0),
};
var v3 = new VertexColorTextureTBN {
Position = new Vector3(-1.0f, -1.0f, 0), TexCoord = new Vector2(0, 1),
};
var v4 = new VertexColorTextureTBN {
Position = new Vector3(1.0f, -1.0f, 0), TexCoord = new Vector2(1, 1),
};
var v5 = new VertexColorTextureTBN {
Position = new Vector3(1.0f, 1.0f, 0), TexCoord = new Vector2(1, 0),
}; //*/
var data = new VertexColorTextureTBN[] { v0, v1, v2, v3, v4, v5 };
//Log.Message(""+v0.TexCoord);
vertexBufferBlur.SetData(data, 0, 6);
//for ( int j=0; j<cloudSphere.Meshes.Count; j++) {
// var mesh = cloudSphere.Meshes[j];
// rs.SetupVertexInput( cloudVertexBuffers[j], cloudIndexBuffers[j] );
// rs.DrawIndexed( mesh.IndexCount, 0, 0 );
// }
rs.SetupVertexInput(vertexBufferBlur, null);
rs.Draw(6, 0);
#endif
rs.ResetStates();
}
/// <summary>
/// Performs luminance measurement, tonemapping, applies bloom.
/// </summary>
/// <param name="target">LDR target.</param>
/// <param name="hdrImage">HDR source image.</param>
public void Render(GameTime gameTime, RenderTargetSurface target, ShaderResource hdrImage)
{
var device = Game.GraphicsDevice;
var filter = Game.GetService <Filter>();
var ds = Game.GetService <DebugStrings>();
//
// Rough downsampling of source HDR-image :
//
filter.StretchRect(averageLum.Surface, hdrImage);
averageLum.BuildMipmaps();
//
// Make bloom :
//
filter.StretchRect(bloom0.Surface, hdrImage);
bloom0.BuildMipmaps();
filter.GaussBlur(bloom0, bloom1, Config.GaussBlurSigma, 0);
filter.GaussBlur(bloom0, bloom1, Config.GaussBlurSigma, 1);
filter.GaussBlur(bloom0, bloom1, Config.GaussBlurSigma, 2);
filter.GaussBlur(bloom0, bloom1, Config.GaussBlurSigma, 3);
//
// Setup parameters :
//
var paramsData = new Params();
paramsData.AdaptationRate = 1 - (float)Math.Pow(0.5f, gameTime.ElapsedSec / Config.AdaptationHalfLife);
paramsData.LuminanceLowBound = Config.LuminanceLowBound;
paramsData.LuminanceHighBound = Config.LuminanceHighBound;
paramsData.KeyValue = Config.KeyValue;
paramsData.BloomAmount = Config.BloomAmount;
paramsCB.SetData(paramsData);
device.PixelShaderConstants[0] = paramsCB;
//
// Measure and adapt :
//
device.SetTargets(null, measuredNew);
device.PixelShaderResources[0] = averageLum;
device.PixelShaderResources[1] = measuredOld;
device.PipelineState = factory[(int)(Flags.MEASURE_ADAPT)];
device.Draw(3, 0);
//
// Tonemap and compose :
//
device.SetTargets(null, target);
device.PixelShaderResources[0] = hdrImage; // averageLum;
device.PixelShaderResources[1] = measuredNew; // averageLum;
device.PixelShaderResources[2] = bloom0; // averageLum;
device.PixelShaderResources[3] = Game.GetService <SpriteBatch>().TextureWhite;
device.PixelShaderSamplers[0] = SamplerState.LinearClamp;
Flags op = Flags.LINEAR;
if (Config.TonemappingOperator == TonemappingOperator.Filmic)
{
op = Flags.FILMIC;
}
if (Config.TonemappingOperator == TonemappingOperator.Linear)
{
op = Flags.LINEAR;
}
if (Config.TonemappingOperator == TonemappingOperator.Reinhard)
{
op = Flags.REINHARD;
}
device.PipelineState = factory[(int)(Flags.TONEMAPPING | op)];
device.Draw(3, 0);
device.ResetStates();
// swap luminanice buffers :
Misc.Swap(ref measuredNew, ref measuredOld);
}
/// <summary>
///
/// </summary>
internal void Render(RenderTargetSurface colorBuffer, DepthStencilSurface depthBuffer, Camera camera)
{
DrawTracers();
if (!vertexDataAccum.Any())
{
return;
}
if (Game.RenderSystem.SkipDebugRendering)
{
vertexDataAccum.Clear();
return;
}
var dev = Game.GraphicsDevice;
dev.ResetStates();
dev.SetTargets(depthBuffer, colorBuffer);
var a = camera.GetProjectionMatrix(StereoEye.Mono).M11;
var b = camera.GetProjectionMatrix(StereoEye.Mono).M22;
var w = (float)colorBuffer.Width;
var h = (float)colorBuffer.Height;
constData.View = camera.GetViewMatrix(StereoEye.Mono);
constData.Projection = camera.GetProjectionMatrix(StereoEye.Mono);
constData.ViewPosition = camera.GetCameraPosition4(StereoEye.Mono);
constData.PixelSize = new Vector4(1 / w / a, 1 / b / h, 1 / w, 1 / h);
constBuffer.SetData(constData);
dev.SetupVertexInput(vertexBuffer, null);
dev.VertexShaderConstants[0] = constBuffer;
dev.PixelShaderConstants[0] = constBuffer;
dev.GeometryShaderConstants[0] = constBuffer;
var flags = new[] { RenderFlags.SOLID, RenderFlags.GHOST };
foreach (var flag in flags)
{
dev.PipelineState = factory[(int)flag];
int numDPs = MathUtil.IntDivUp(vertexDataAccum.Count, vertexBufferSize);
for (int i = 0; i < numDPs; i++)
{
int numVerts = i < numDPs - 1 ? vertexBufferSize : vertexDataAccum.Count % vertexBufferSize;
if (numVerts == 0)
{
break;
}
vertexDataAccum.CopyTo(i * vertexBufferSize, vertexArray, 0, numVerts);
vertexBuffer.SetData(vertexArray, 0, numVerts);
dev.Draw(numVerts, 0);
}
}
vertexDataAccum.Clear();
}
