/// <summary>
/// Initializes a new instance of the <see cref="MainPlugin"/> class.
/// </summary>
/// <param name="name">The name.</param>
public MainPlugin(string name)
: base(name)
{
ViewParameters = new RenderViewport("ViewParameters");
ViewParameters.RegisterParameter(GlobalKeys.Time);
ViewParameters.RegisterParameter(GlobalKeys.TimeStep);
Parameters.AddSources(ViewParameters);
//Parameters.RegisterParameter(TransformationKeys.ViewProjection);
}
public override void Load()
{
base.Load();
RenderPass.AddPass(boundingBoxPass, heatShimmerPass, heatShimmerComposePass);
// Use MinMax Plugin
var bbRenderTargetPlugin = new RenderTargetsPlugin("BoundingBoxRenderTargetPlugin")
{
EnableSetTargets = true,
EnableClearTarget = true,
RenderTarget = null,
RenderPass = boundingBoxPass,
Services = Services
};
bbRenderTargetPlugin.Apply();
Parameters.AddSources(ViewParameters);
Parameters.SetDefault(RenderTargetKeys.DepthStencilSource);
Parameters.SetDefault(TexturingKeys.Sampler);
bbRenderTargetPlugin.Parameters.AddSources(Parameters);
EffectOld minMaxEffect = this.EffectSystemOld.BuildEffect("MinMax")
.Using(new MinMaxShaderPlugin("MinMaxShaderPlugin")
{
RenderPassPlugin = bbRenderTargetPlugin
})
.Using(new BasicShaderPlugin("TransformationWVP")
{
RenderPassPlugin = bbRenderTargetPlugin
})
.KeepAliveBy(ActiveObjects)
.InstantiatePermutation()
.KeepAliveBy(ActiveObjects);
heatShimmerPass.Parameters = new ParameterCollection();
heatShimmerPass.Parameters.AddSources(Parameters);
heatShimmerPass.Parameters.AddSources(NoisePlugin.Parameters);
EffectOld heatShimmerEffect = this.EffectSystemOld.BuildEffect("HeatShimmer")
.Using(new PostEffectSeparateShaderPlugin()
{
RenderPass = heatShimmerPass
})
.Using(
new BasicShaderPlugin(
new ShaderMixinSource()
{
Mixins = new List <ShaderClassSource>()
{
// TODO add support for IsZReverse
//new ShaderClassSource("PostEffectHeatShimmer", Debug ? 1 : 0, effectSystemOld.IsZReverse ? 1 : 0, 3),
new ShaderClassSource("PostEffectHeatShimmer", Debug ? 1 : 0, false ? 1 : 0, 3)
},
Compositions = new Dictionary <string, ShaderSource>()
{
{ "NoiseSource", new ShaderClassSource("SimplexNoise") }
},
}
)
{
RenderPass = heatShimmerPass
})
.KeepAliveBy(ActiveObjects)
.InstantiatePermutation()
.KeepAliveBy(ActiveObjects);
EffectOld heatShimmerDisplayEffect = this.EffectSystemOld.BuildEffect("HeatShimmer")
.Using(new PostEffectSeparateShaderPlugin()
{
RenderPass = heatShimmerComposePass
})
.Using(new BasicShaderPlugin(new ShaderClassSource("PostEffectHeatShimmerDisplay", Debug ? 1 : 0))
{
RenderPass = heatShimmerComposePass
})
.KeepAliveBy(ActiveObjects)
.InstantiatePermutation()
.KeepAliveBy(ActiveObjects);
if (OfflineCompilation)
{
return;
}
Parameters.Set(RenderTargetKeys.DepthStencilSource, DepthStencil.Texture);
Parameters.Set(TexturingKeys.Sampler, GraphicsDevice.SamplerStates.PointClamp);
// ------------------------------------------
// BoundingBox prepass
// ------------------------------------------
var renderTargetDesc = RenderSource.Description;
var bbRenderTarget = Texture.New2D(GraphicsDevice, renderTargetDesc.Width, renderTargetDesc.Height, PixelFormat.R32G32_Float, TextureFlags.ShaderResource | TextureFlags.RenderTarget).KeepAliveBy(ActiveObjects);
bbRenderTargetPlugin.RenderTarget = bbRenderTarget.ToRenderTarget();
// Add meshes
foreach (var bbMeshData in BoundingBoxes)
{
// Mesh for MinPass
var bbMesh = new EffectMesh(minMaxEffect, bbMeshData).KeepAliveBy(ActiveObjects);
// Add mesh
// boundingBoxPass.AddPass(bbMesh.EffectMeshPasses[0].EffectPass);
effectMeshes.Add(bbMesh);
RenderSystem.GlobalMeshes.AddMesh(bbMesh);
}
// ------------------------------------------
// Heat Compute
// ------------------------------------------
var shimmerTexture = Texture.New2D(GraphicsDevice, renderTargetDesc.Width, renderTargetDesc.Height, PixelFormat.R8_UNorm, TextureFlags.ShaderResource | TextureFlags.RenderTarget);
var shimmerRenderTarget = shimmerTexture.ToRenderTarget();
heatShimmerPass.StartPass += context => context.GraphicsDevice.Clear(shimmerRenderTarget, Color.Black);
var quadMesh = new EffectMesh(heatShimmerEffect).KeepAliveBy(ActiveObjects);
quadMesh.Parameters.Set(TexturingKeys.Texture1, bbRenderTarget);
quadMesh.Parameters.Set(RenderTargetKeys.RenderTarget, shimmerRenderTarget);
effectMeshes.Add(quadMesh);
RenderSystem.GlobalMeshes.AddMesh(quadMesh);
// ------------------------------------------
// Heat display
// ------------------------------------------
quadMesh = new EffectMesh(heatShimmerDisplayEffect).KeepAliveBy(ActiveObjects);
quadMesh.Parameters.Set(TexturingKeys.Texture0, RenderSource);
quadMesh.Parameters.Set(TexturingKeys.Texture1, shimmerTexture);
quadMesh.Parameters.Set(RenderTargetKeys.RenderTarget, RenderTarget);
effectMeshes.Add(quadMesh);
RenderSystem.GlobalMeshes.AddMesh(quadMesh);
}
public override void Initialize()
{
base.Initialize();
boundingBoxPass = new RenderPass("BoundingBoxPass");
minMaxPass = new RenderPass("MinmaxPass");
lightShaftPass = new RenderPass("LightShaftPass");
filterUpscalePass = new RenderPass("UpscalePass");
RenderPass.AddPass(boundingBoxPass, minMaxPass, lightShaftPass, filterUpscalePass);
var useUpScaling = false;
var bbRenderTargetPlugin = new RenderTargetsPlugin("BoundingBoxRenderTargetPlugin")
{
EnableSetTargets = true,
EnableClearTarget = true,
RenderPass = boundingBoxPass,
Services = Services,
};
var minMaxEffectBuilder = this.EffectSystemOld.BuildEffect("MinMax")
.Using(new MinMaxShaderPlugin("MinMaxShaderPlugin")
{
RenderPassPlugin = bbRenderTargetPlugin
})
.Using(new BasicShaderPlugin("TransformationWVP")
{
RenderPassPlugin = bbRenderTargetPlugin
});
var minmaxEffectBuilder = this.EffectSystemOld.BuildEffect("LightShaftsMinMax")
.Using(new PostEffectSeparateShaderPlugin()
{
RenderPass = minMaxPass
})
.Using(new BasicShaderPlugin("ForwardShadowMapBase")
{
RenderPass = minMaxPass
})
.Using(new BasicShaderPlugin(new ShaderClassSource("PostEffectMinMax", "ShadowMapUtils.shadowMapTexture", "PointSampler", 4, 4, 0.0, 1.0))
{
RenderPass = minMaxPass
});
var lightShaftsEffectBuilder = this.EffectSystemOld.BuildEffect("LightShafts")
.Using(new PostEffectSeparateShaderPlugin()
{
RenderPass = lightShaftPass
})
.Using(new StateShaderPlugin()
{
UseBlendState = !useUpScaling, RenderPass = lightShaftPass
})
//.Using(new BasicShaderPlugin(new ShaderClassSource("PostEffectLightShafts", Debug ? 1 : 0, RenderContext.IsZReverse ? 1 : 0, StepCount)) { RenderPass = lightShaftPass });
.Using(new BasicShaderPlugin(new ShaderClassSource("PostEffectLightShafts", Debug ? 1 : 0, false ? 1 : 0, StepCount))
{
RenderPass = lightShaftPass
});
if (OfflineCompilation)
{
minMaxEffectBuilder.InstantiatePermutation();
minmaxEffectBuilder.InstantiatePermutation();
lightShaftsEffectBuilder.InstantiatePermutation();
return;
}
Parameters.AddSources(ViewParameters);
Parameters.Set(RenderTargetKeys.DepthStencilSource, DepthStencil.Texture);
Parameters.Set(TexturingKeys.Sampler, GraphicsDevice.SamplerStates.PointClamp);
// BoundingBox prepass
var gbufferDesc = RenderTarget.Description;
var bbRenderTarget = Texture2D.New(GraphicsDevice, gbufferDesc.Width / 8, gbufferDesc.Height / 8, PixelFormat.R32G32_Float, TextureFlags.ShaderResource | TextureFlags.RenderTarget);
// Use MinMax Plugin
bbRenderTargetPlugin.RenderTarget = bbRenderTarget.ToRenderTarget();
bbRenderTargetPlugin.Parameters.AddSources(Parameters);
bbRenderTargetPlugin.Apply();
EffectOld minMaxEffect = minMaxEffectBuilder.InstantiatePermutation();
// Add meshes
foreach (var bbMeshData in BoundingBoxes)
{
// Mesh for MinPass
var bbMesh = new EffectMesh(minMaxEffect, bbMeshData).KeepAliveBy(this);
// Add mesh
// boundingBoxPass.AddPass(bbMesh.EffectMeshPasses[0].EffectPass);
RenderSystem.GlobalMeshes.AddMesh(bbMesh);
}
// MinMax render target
var minMaxRenderTarget = Texture2D.New(GraphicsDevice, 256, 256, PixelFormat.R32G32_Float, TextureFlags.ShaderResource | TextureFlags.RenderTarget);
minMaxPass.Parameters = new ParameterCollection(null);
minMaxPass.Parameters.AddSources(ShadowMap.Parameters);
minMaxPass.Parameters.AddSources(Parameters);
minMaxPass.Parameters.AddDynamic(PostEffectMinMaxKeys.MinMaxCoords, ParameterDynamicValue.New(LightingPlugin.CascadeTextureCoords, (ref Vector4[] cascadeTextureCoords, ref Vector4 output) =>
{
output = cascadeTextureCoords[0];
}, autoCheckDependencies: false));
EffectOld minmaxEffect = minmaxEffectBuilder.InstantiatePermutation();
var minMaxMesh = new EffectMesh(minmaxEffect).KeepAliveBy(this);
minMaxMesh.Parameters.Set(RenderTargetKeys.RenderTarget, minMaxRenderTarget.ToRenderTarget());
RenderSystem.GlobalMeshes.AddMesh(minMaxMesh);
// Light Shafts effect
var blendStateDesc = new BlendStateDescription();
blendStateDesc.SetDefaults();
blendStateDesc.AlphaToCoverageEnable = false;
blendStateDesc.IndependentBlendEnable = false;
blendStateDesc.RenderTargets[0].BlendEnable = true;
blendStateDesc.RenderTargets[0].AlphaBlendFunction = BlendFunction.Add;
blendStateDesc.RenderTargets[0].AlphaSourceBlend = Blend.One;
blendStateDesc.RenderTargets[0].AlphaDestinationBlend = Blend.One;
blendStateDesc.RenderTargets[0].ColorBlendFunction = BlendFunction.Add;
blendStateDesc.RenderTargets[0].ColorSourceBlend = Blend.One;
blendStateDesc.RenderTargets[0].ColorDestinationBlend = Blend.One;
blendStateDesc.RenderTargets[0].ColorWriteChannels = ColorWriteChannels.All;
var additiveBlending = BlendState.New(GraphicsDevice, blendStateDesc);
additiveBlending.Name = "LightShaftAdditiveBlend";
var shaftRenderTarget = useUpScaling ? Texture2D.New(GraphicsDevice, gbufferDesc.Width / 2, gbufferDesc.Height / 2, PixelFormat.R16G16B16A16_Float, TextureFlags.ShaderResource | TextureFlags.RenderTarget).ToRenderTarget() : RenderTarget;
lightShaftPass.Parameters = new ParameterCollection();
lightShaftPass.Parameters.AddSources(ShadowMap.Parameters);
lightShaftPass.Parameters.AddSources(Parameters);
this.lightShaftsEffect = lightShaftsEffectBuilder.InstantiatePermutation();
var mesh = new EffectMesh(lightShaftsEffect).KeepAliveBy(this);
mesh.Parameters.Set(TexturingKeys.Texture0, minMaxRenderTarget);
mesh.Parameters.Set(TexturingKeys.Texture1, bbRenderTarget);
mesh.Parameters.Set(RenderTargetKeys.RenderTarget, shaftRenderTarget);
if (!useUpScaling)
{
mesh.Parameters.Set(EffectPlugin.BlendStateKey, additiveBlending);
}
RenderSystem.GlobalMeshes.AddMesh(mesh);
// Bilateral Gaussian filtering for up-sampling
if (useUpScaling)
{
var bbRenderTargetUpScaleH = Texture2D.New(GraphicsDevice, gbufferDesc.Width, gbufferDesc.Height / 2, PixelFormat.R16G16B16A16_Float, TextureFlags.ShaderResource | TextureFlags.RenderTarget);
var bbRenderTargetUpScaleV = RenderTarget;
//var bbRenderTargetUpScaleV = GraphicsDevice.RenderTarget2D.New(gbufferDesc.Width, gbufferDesc.Height, PixelFormat.HalfVector4);
var blurEffects = new EffectOld[] {
this.EffectSystemOld.BuildEffect("BilateralGaussianFiltering")
.Using(new PostEffectSeparateShaderPlugin())
.Using(new BasicShaderPlugin(new ShaderClassSource("PostEffectBilateralGaussian", 0))),
this.EffectSystemOld.BuildEffect("BilateralGaussianFiltering")
.Using(new StateShaderPlugin()
{
UseBlendState = true
})
.Using(new PostEffectSeparateShaderPlugin())
.Using(new BasicShaderPlugin(new ShaderClassSource("PostEffectBilateralGaussian", 1))),
};
Texture2D textureSourceH = (Texture2D)shaftRenderTarget.Texture;
Texture2D textureSourceV = bbRenderTargetUpScaleH;
RenderTarget renderTargetH = bbRenderTargetUpScaleH.ToRenderTarget();
RenderTarget renderTargetV = bbRenderTargetUpScaleV;
var blurQuadMesh = new EffectMesh[2];
for (int i = 0; i < 2; ++i)
{
blurQuadMesh[i] = new EffectMesh(blurEffects[i]).KeepAliveBy(this);
filterUpscalePass.AddPass(blurQuadMesh[i].EffectPass);
RenderSystem.GlobalMeshes.AddMesh(blurQuadMesh[i]);
}
blurQuadMesh[0].Parameters.Set(TexturingKeys.Texture0, textureSourceH);
blurQuadMesh[1].Parameters.Set(TexturingKeys.Texture0, textureSourceV);
blurQuadMesh[0].Parameters.Set(RenderTargetKeys.RenderTarget, renderTargetH);
blurQuadMesh[1].Parameters.Set(RenderTargetKeys.RenderTarget, renderTargetV);
// Additive blending for 2nd render target
blurQuadMesh[1].Parameters.Set(EffectPlugin.BlendStateKey, additiveBlending);
}
}
public override void Load()
{
base.Load();
if (OfflineCompilation)
{
return;
}
var renderTargets = new RenderTarget[2];
DepthStencilBuffer depthStencilBuffer = null;
Texture2D depthStencilTexture = null;
Parameters.AddSources(MainPlugin.ViewParameters);
Parameters.RegisterParameter(EffectPlugin.BlendStateKey);
var filteredPasses = new FastList <RenderPass>();
RenderPass.UpdatePasses += updatePassesAction = (RenderPass currentRenderPass, ref FastList <RenderPass> currentPasses) =>
{
var originalPasses = currentPasses;
filteredPasses.Clear();
currentPasses = filteredPasses;
Parameters.Set(PickingFrameIndex, ++currentPickingFrameIndex);
Request[] requests;
lock (pendingRequests)
{
// No picking request or no mesh to pick?
if (pendingRequests.Count == 0)
{
return;
}
requests = pendingRequests.ToArray();
pendingRequests.Clear();
}
foreach (var request in requests)
{
requestResults.Add(request);
}
if (originalPasses == null)
{
return;
}
// Count mesh passes
int meshIndex = 0;
foreach (var pass in originalPasses)
{
meshIndex += pass.Passes.Count;
}
// No mesh to pick?
if (meshIndex == 0)
{
return;
}
// Copy mesh passes and assign indices
var meshPasses = new EffectMesh[meshIndex];
meshIndex = 0;
foreach (var pass in RenderPass.Passes)
{
throw new NotImplementedException();
//foreach (var effectMeshPass in pass.Meshes)
//{
// meshPasses[meshIndex] = (EffectMesh)effectMeshPass;
// // Prefix increment so that 0 means no rendering.
// effectMeshPass.Parameters.Set(PickingMeshIndex, ++meshIndex);
//}
}
// For now, it generates one rendering per picking.
// It would be quite easy to optimize it by make Picking shader works on multiple picking points at a time.
foreach (var request in requests)
{
var pickingRenderPass = new RenderPass("Picking");
pickingRenderPass.StartPass.AddFirst = (threadContext) =>
{
threadContext.GraphicsDevice.Clear(renderTargets[0], Color.Black);
threadContext.GraphicsDevice.Clear(renderTargets[1], Color.Black);
threadContext.Parameters.Set(PickingScreenPosition, request.Location);
threadContext.GraphicsDevice.SetViewport(new Viewport(0, 0, renderTargets[0].Description.Width, renderTargets[0].Description.Height));
threadContext.GraphicsDevice.Clear(depthStencilBuffer, DepthStencilClearOptions.DepthBuffer);
threadContext.GraphicsDevice.SetRenderTargets(depthStencilBuffer, renderTargets);
};
pickingRenderPass.EndPass.AddLast = (threadContext) =>
{
threadContext.Parameters.Reset(PickingScreenPosition);
threadContext.GraphicsDevice.Copy(renderTargets[0].Texture, request.ResultTextures[0]);
threadContext.GraphicsDevice.Copy(renderTargets[1].Texture, request.ResultTextures[1]);
};
//pickingRenderPass.PassesInternal = originalPasses;
throw new NotImplementedException();
request.MeshPasses = meshPasses;
currentPasses.Add(pickingRenderPass);
request.HasResults = true;
// Wait 2 frames before pulling the results.
request.FrameCounter = 2;
}
};
RenderSystem.GlobalPass.EndPass.AddLast = CheckPickingResults;
var backBuffer = GraphicsDevice.BackBuffer;
int pickingArea = 1 + PickingDistance * 2;
renderTargets[0] = Texture.New2D(GraphicsDevice, pickingArea, pickingArea, PixelFormat.R32_UInt, TextureFlags.ShaderResource | TextureFlags.RenderTarget).ToRenderTarget().KeepAliveBy(ActiveObjects);
renderTargets[1] = Texture.New2D(GraphicsDevice, pickingArea, pickingArea, PixelFormat.R32G32B32A32_Float, TextureFlags.ShaderResource | TextureFlags.RenderTarget).ToRenderTarget().KeepAliveBy(ActiveObjects);
depthStencilTexture = Texture.New2D(GraphicsDevice, pickingArea, pickingArea, PixelFormat.D32_Float, TextureFlags.ShaderResource | TextureFlags.DepthStencil).KeepAliveBy(ActiveObjects);
depthStencilBuffer = depthStencilTexture.ToDepthStencilBuffer(false);
Parameters.AddDynamic(PickingMatrix, ParameterDynamicValue.New(PickingScreenPosition, (ref Vector2 pickingPosition, ref Matrix picking) =>
{
// Move center to picked position, and zoom (it is supposed to stay per-pixel according to render target size)
picking = Matrix.Translation(1.0f - (pickingPosition.X) / backBuffer.Width * 2.0f, -1.0f + (pickingPosition.Y) / backBuffer.Height * 2.0f, 0.0f)
* Matrix.Scaling((float)backBuffer.Width / (float)pickingArea, (float)backBuffer.Height / (float)pickingArea, 1.0f);
}));
}
/// <inheritdoc/>
public override void Initialize()
{
base.Initialize();
graphicsDeviceService = Services.GetServiceAs <IGraphicsDeviceService>();
var graphicsDevice = graphicsDeviceService.GraphicsDevice;
Parameters.AddSources(MainPlugin.ViewParameters);
if (OfflineCompilation)
{
return;
}
// Create texture used for normal packing
var texture2D = Texture2D.New(GraphicsDevice, 1024, 1024, 1, PixelFormat.A8_UNorm);
texture2D.Name = "Renorm";
// Load normal packing data
var texDataStream = VirtualFileSystem.OpenStream("/assets/effects/gbuffer/renorm.bin", VirtualFileMode.Open, VirtualFileAccess.Read);
var texFileLength = texDataStream.Length;
var texData = new byte[texFileLength];
texDataStream.Read(texData, 0, (int)texFileLength);
texture2D.SetData(graphicsDevice, texData);
texDataStream.Dispose();
// Force custom depth stencil state on main pass
var mainDepthStencilState = MainTargetPlugin.Parameters.TryGet(EffectPlugin.DepthStencilStateKey) ?? graphicsDevice.DepthStencilStates.Default;
MainTargetPlugin.Parameters.Set(EffectPlugin.DepthStencilStateKey, mainDepthStencilState);
// Use depth stencil value from MainPlugin
var defaultDescription = mainDepthStencilState.Description;
ClearDepth = MainTargetPlugin.ClearDepth;
// Use Default ZTest for GBuffer
var depthStencilStateZStandard = DepthStencilState.New(GraphicsDevice, defaultDescription);
depthStencilStateZStandard.Name = "ZStandard";
Parameters.Set(EffectPlugin.DepthStencilStateKey, depthStencilStateZStandard);
Parameters.Set(GBufferKeys.NormalPack, texture2D);
Parameters.Set(TexturingKeys.PointSampler, graphicsDevice.SamplerStates.PointWrap);
// MainPlugin is going to use the readonly depth stencil buffer
if (DepthStencilBuffer.IsReadOnlySupported(GraphicsDevice))
{
MainTargetPlugin.UseDepthStencilReadOnly = true;
MainTargetPlugin.Parameters.Set(RenderTargetKeys.DepthStencilSource, DepthStencil.Texture);
MainTargetPlugin.DepthStencilReadOnly = DepthStencil.Texture.ToDepthStencilBuffer(true);
}
else
{
RenderPass.EndPass += (context) =>
{
//context.GraphicsDevice.Copy(DepthStencil
//DepthStencil.SynchronizeReadonly(context.GraphicsDevice)
};
}
defaultDescription = mainDepthStencilState.Description;
defaultDescription.DepthBufferWriteEnable = false;
DepthStencilStateZReadOnly = DepthStencilState.New(GraphicsDevice, defaultDescription);
DepthStencilStateZReadOnly.Name = "ZReadOnly";
// Create normal texture (that LightPlugin will use)
var gbufferTexture = Texture2D.New(GraphicsDevice, graphicsDevice.BackBuffer.Width, graphicsDevice.BackBuffer.Height, PixelFormat.R8G8B8A8_UNorm, TextureFlags.ShaderResource | TextureFlags.RenderTarget);
gbufferTexture.Name = "GBufferTexture";
Parameters.Set(GBufferBaseKeys.GBufferTexture, gbufferTexture);
RenderTarget = gbufferTexture.ToRenderTarget();
// Set parameters for MainPlugin
MainTargetPlugin.Parameters.Set(GBufferBaseKeys.GBufferTexture, gbufferTexture);
}
public override void Load()
{
base.Load();
skyboxEffect = this.EffectSystemOld.BuildEffect("Skybox")
.Using(new StateShaderPlugin()
{
RenderPassPlugin = this, UseDepthStencilState = true
})
.Using(new BasicShaderPlugin(
new ShaderMixinSource()
{
Mixins = new List <ShaderClassSource>()
{
new ShaderClassSource("SkyBox")
},
Compositions = new Dictionary <string, ShaderSource>()
{
{ "color", SkyBoxColor }
}
})
{
RenderPassPlugin = this
})
.InstantiatePermutation();
if (OfflineCompilation)
{
return;
}
Parameters.AddSources(MainPlugin.ViewParameters);
var zBackgroundValue = MainTargetPlugin.ClearDepth;
// Generates a quad for post effect rendering (should be utility function)
var vertices = new[]
{
-1.0f, 1.0f, zBackgroundValue, 1.0f,
1.0f, 1.0f, zBackgroundValue, 1.0f,
-1.0f, -1.0f, zBackgroundValue, 1.0f,
1.0f, -1.0f, zBackgroundValue, 1.0f,
};
Parameters.RegisterParameter(EffectPlugin.DepthStencilStateKey);
Parameters.Set(TexturingKeys.Sampler, GraphicsDevice.SamplerStates.LinearWrap);
// Use the quad for this effectMesh
var quadData = new Mesh();
quadData.Draw = new MeshDraw
{
DrawCount = 4,
PrimitiveType = PrimitiveType.TriangleStrip,
VertexBuffers = new[]
{
new VertexBufferBinding(Buffer.Vertex.New(GraphicsDevice, vertices), new VertexDeclaration(VertexElement.Position <Vector4>()), 4)
}
};
RenderPass.StartPass += (context) =>
{
// Setup the Viewport
context.GraphicsDevice.SetViewport(MainTargetPlugin.Viewport);
// Setup the depth stencil and main render target.
context.GraphicsDevice.SetRenderTarget(MainTargetPlugin.DepthStencil, MainTargetPlugin.RenderTarget);
};
RenderPass.EndPass += (context) => context.GraphicsDevice.UnsetRenderTargets();
var skyboxMesh = new EffectMesh(skyboxEffect, quadData).KeepAliveBy(this);
// If the main target plugin is not clearing anything, we assume that this is the job of the skybox plugin
if (!MainTargetPlugin.EnableClearTarget && !MainTargetPlugin.EnableClearDepth)
{
var description = new DepthStencilStateDescription().Default();
description.DepthBufferFunction = CompareFunction.Always;
var alwaysWrite = DepthStencilState.New(GraphicsDevice, description);
skyboxMesh.Parameters.Set(EffectPlugin.DepthStencilStateKey, alwaysWrite);
}
else
{
skyboxMesh.Parameters.Set(EffectPlugin.DepthStencilStateKey, MainTargetPlugin.DepthStencilState);
}
skyboxMesh.Parameters.AddSources(this.Parameters);
RenderSystem.GlobalMeshes.AddMesh(skyboxMesh);
}
public override void Load()
{
base.Load();
Parameters.AddSources(GBufferPlugin.MainPlugin.ViewParameters);
Lights = this.EffectSystemOld.BuildEffect("Lights").Using(new LightPlugin()).InstantiatePermutation();
// TODO: Check if released properly.
for (int i = 0; i < 2; ++i)
{
if (i == 1)
{
if (!Debug)
{
continue;
}
// Add the debug as an overlay on the main pass
debugRenderPass = new RenderPass("LightPrePassDebug").KeepAliveBy(ActiveObjects);
GBufferPlugin.MainPlugin.RenderPass.AddPass(debugRenderPass);
}
var debug = i == 1;
var renderPass = i == 1 ? debugRenderPass : RenderPass;
var lightDeferredEffectBuilder = this.EffectSystemOld.BuildEffect("LightPrePass" + (debug ? "Debug" : string.Empty)).KeepAliveBy(ActiveObjects);
foreach (var effectPlugin in BasePlugins)
{
lightDeferredEffectBuilder.Using(new BasicShaderPlugin(effectPlugin)
{
Services = Services, RenderPassPlugin = this, RenderPass = renderPass
});
}
lightDeferredEffectBuilder.Using(new LightingPrepassShaderPlugin("LightPreShaderPass" + (debug ? "Debug" : string.Empty))
{
Services = Services, RenderPassPlugin = this, RenderPass = renderPass, Debug = debug
});
lightDeferredEffects[i] = lightDeferredEffectBuilder.InstantiatePermutation().KeepAliveBy(ActiveObjects);
}
if (OfflineCompilation)
{
return;
}
// Create lighting accumulation texture (that LightPlugin will use)
var mainBackBuffer = graphicsDeviceService.GraphicsDevice.BackBuffer;
var lightTexture = Texture.New2D(GraphicsDevice, mainBackBuffer.Width, mainBackBuffer.Height, PixelFormat.R16G16B16A16_Float, TextureFlags.ShaderResource | TextureFlags.RenderTarget);
lightTexture.Name = "LightTexture";
LightTexture = lightTexture.ToRenderTarget();
// Set Parameters for this plugin
Parameters.Set(LightDeferredShadingKeys.LightTexture, lightTexture);
// Set GBuffer Texture0
Parameters.Set(GBufferBaseKeys.GBufferTexture, (Texture2D)GBufferPlugin.RenderTarget.Texture);
// Set parameters for MainPlugin
GBufferPlugin.MainTargetPlugin.Parameters.Set(LightDeferredShadingKeys.LightTexture, lightTexture);
CreatePrePassMesh(RenderPass, false);
if (Debug)
{
CreatePrePassMesh(debugRenderPass, true);
}
}
