/// <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); } }