private static ShadowMapRenderer AddShadowMap(IServiceRegistry serviceRegistry, RenderPipeline pipeline, string effectName) { var shadowMapPipeline = new RenderPipeline("ShadowMap"); shadowMapPipeline.Renderers.Add(new ModelRenderer(serviceRegistry, effectName + ".ShadowMapCaster").AddContextActiveLayerFilter().AddShadowCasterFilter()); var shadowMapRenderer = new ShadowMapRenderer(serviceRegistry, shadowMapPipeline); pipeline.Renderers.Add(shadowMapRenderer); return(shadowMapRenderer); }
public RenderModel(RenderPipeline pipeline, Model model) { if (pipeline == null) { throw new ArgumentNullException("pipeline"); } Pipeline = pipeline; Model = model; var slotCount = Pipeline.GetOrCreateModelRendererState().ModelSlotCount; RenderMeshes = new List <RenderMesh> [slotCount]; }
public RenderSystem(IServiceRegistry registry) : base(registry) { pipelines.CollectionChanged += Pipelines_CollectionChanged; // Register both implem and interface Services.AddService(typeof(RenderSystem), this); // Create default pipeline Pipeline = new RenderPipeline("Main"); // Register default pipeline pipelines.Add(Pipeline); Visible = true; }
/// <summary> /// Initializes a new instance of the <see cref="RenderModel" /> class. /// </summary> /// <param name="pipeline">The pipeline.</param> /// <param name="modelInstance">The model instance.</param> /// <exception cref="System.ArgumentNullException">pipeline</exception> public RenderModel(RenderPipeline pipeline, IModelInstance modelInstance) { if (pipeline == null) { throw new ArgumentNullException("pipeline"); } Pipeline = pipeline; ModelInstance = modelInstance; Model = modelInstance.Model; Parameters = modelInstance.Parameters; var modelRendererState = Pipeline.GetOrCreateModelRendererState(); var slotCount = modelRendererState.ModelSlotCount; RenderMeshes = new List <RenderMesh> [slotCount]; if (Model != null) { modelRendererState.PrepareRenderModel(this); } }
public GBufferRenderProcessor(IServiceRegistry services, RenderPipeline recursivePipeline, Texture depthStencilBuffer, bool normalPack) : base(services, recursivePipeline) { this.depthStencilBuffer = depthStencilBuffer; useNormalPack = normalPack; }
/// <summary> /// Creates a basic deferred rendering pipeline. /// </summary> /// <param name="serviceRegistry">The IServiceRegistry.</param> /// <param name="effectName">The name of the main effect.</param> /// <param name="prepassEffectName">The name of the light prepass effect.</param> /// <param name="clearColor">The clear color of the final frame buffer.</param> /// <param name="useShadows">A flag stating if shadows are available in this pipeline.</param> /// <param name="ui">A flag stating if a UI renderer should be added to the pipeline.</param> /// <param name="backgroundName">The name of the background texture.</param> public static void CreateDefaultDeferred(IServiceRegistry serviceRegistry, string effectName, string prepassEffectName, Color clearColor, bool useShadows, bool ui, string backgroundName) { if (serviceRegistry == null) { throw new ArgumentNullException("serviceRegistry"); } if (effectName == null) { throw new ArgumentNullException("effectName"); } var renderSystem = serviceRegistry.GetSafeServiceAs <RenderSystem>(); var graphicsService = serviceRegistry.GetSafeServiceAs <IGraphicsDeviceService>(); #if SILICONSTUDIO_PARADOX_GRAPHICS_API_OPENGL var width = graphicsService.GraphicsDevice.DepthStencilBuffer.Width; var height = graphicsService.GraphicsDevice.DepthStencilBuffer.Height; // On OpenGL, intermediate texture are flipped and we cannot create a framebuffer with a user-generated attachment and a default one. // So we will render everything into a intermediate texture and draw it on screen at the end. var finalRenderTexture = Texture.New2D(graphicsService.GraphicsDevice, width, height, PixelFormat.R8G8B8A8_UNorm, TextureFlags.RenderTarget | TextureFlags.ShaderResource); var finalDepthBuffer = Texture.New2D(graphicsService.GraphicsDevice, width, height, PixelFormat.D32_Float, TextureFlags.DepthStencil | TextureFlags.ShaderResource); #else var finalRenderTexture = graphicsService.GraphicsDevice.BackBuffer; var finalDepthBuffer = graphicsService.GraphicsDevice.DepthStencilBuffer; #endif var readOnlyDepthBuffer = finalDepthBuffer.ToDepthStencilReadOnlyTexture(); // Adds a light processor that will track all the entities that have a light component. // This will also handle the shadows (allocation, activation etc.). AddLightProcessor(serviceRegistry, graphicsService.GraphicsDevice, useShadows); // Create Main pass var mainPipeline = renderSystem.Pipeline; // Adds a camera setter that will automatically fill the parameters from the camera (matrices, fov etc.). mainPipeline.Renderers.Add(new CameraSetter(serviceRegistry)); // Adds a recursive pass to render the shadow maps // This will render all the meshes with a different effect for shadow casting. if (useShadows) { AddShadowMap(serviceRegistry, mainPipeline, effectName); } // Create G-buffer pass var gbufferPipeline = new RenderPipeline("GBuffer"); // Renders the G-buffer for opaque geometry. gbufferPipeline.Renderers.Add(new ModelRenderer(serviceRegistry, effectName + ".ParadoxGBufferShaderPass").AddOpaqueFilter()); var gbufferProcessor = new GBufferRenderProcessor(serviceRegistry, gbufferPipeline, finalDepthBuffer, false); // Add sthe G-buffer pass to the pipeline. mainPipeline.Renderers.Add(gbufferProcessor); // Performs the light prepass on opaque geometry. // Adds this pass to the pipeline. var lightDeferredProcessor = new LightingPrepassRenderer(serviceRegistry, prepassEffectName, finalDepthBuffer, gbufferProcessor.GBufferTexture); mainPipeline.Renderers.Add(lightDeferredProcessor); // Sets the render targets and clear them. Also sets the viewport. mainPipeline.Renderers.Add(new RenderTargetSetter(serviceRegistry) { ClearColor = clearColor, EnableClearDepth = false, RenderTarget = finalRenderTexture, DepthStencil = finalDepthBuffer, Viewport = new Viewport(0, 0, finalRenderTexture.ViewWidth, finalRenderTexture.ViewHeight) }); // Draws a background from a texture. if (backgroundName != null) { mainPipeline.Renderers.Add(new BackgroundRenderer(serviceRegistry, backgroundName)); } // Prevents depth write since depth was already computed in G-buffer pas. mainPipeline.Renderers.Add(new RenderStateSetter(serviceRegistry) { DepthStencilState = graphicsService.GraphicsDevice.DepthStencilStates.DepthRead }); mainPipeline.Renderers.Add(new ModelRenderer(serviceRegistry, effectName).AddOpaqueFilter()); mainPipeline.Renderers.Add(new RenderTargetSetter(serviceRegistry) { EnableClearDepth = false, EnableClearTarget = false, RenderTarget = finalRenderTexture, DepthStencil = finalDepthBuffer, Viewport = new Viewport(0, 0, finalRenderTexture.ViewWidth, finalRenderTexture.ViewHeight) }); // Renders transparent geometry. Depth stencil state is determined by the object to draw. mainPipeline.Renderers.Add(new RenderStateSetter(serviceRegistry) { DepthStencilState = graphicsService.GraphicsDevice.DepthStencilStates.DepthRead }); mainPipeline.Renderers.Add(new ModelRenderer(serviceRegistry, effectName).AddTransparentFilter()); #if SILICONSTUDIO_PARADOX_GRAPHICS_API_OPENGL // on OpenGL, draw the final texture to the framebuffer mainPipeline.Renderers.Add(new RenderStateSetter(serviceRegistry) { DepthStencilState = graphicsService.GraphicsDevice.DepthStencilStates.None, BlendState = graphicsService.GraphicsDevice.BlendStates.Opaque }); mainPipeline.Renderers.Add(new RenderTargetSetter(serviceRegistry) { ClearColor = clearColor, EnableClearDepth = false, EnableClearStencil = false, EnableClearTarget = false, RenderTarget = graphicsService.GraphicsDevice.BackBuffer, DepthStencil = null, Viewport = new Viewport(0, 0, graphicsService.GraphicsDevice.BackBuffer.ViewWidth, graphicsService.GraphicsDevice.BackBuffer.ViewHeight) }); mainPipeline.Renderers.Add(new DelegateRenderer(serviceRegistry) { Render = (context => graphicsService.GraphicsDevice.DrawTexture(finalRenderTexture, true)) }); #endif // Renders the UI. if (ui) { mainPipeline.Renderers.Add(new UIRenderer(serviceRegistry)); } graphicsService.GraphicsDevice.Parameters.Set(RenderingParameters.UseDeferred, true); }
public RecursiveRenderer(IServiceRegistry services, RenderPipeline recursivePipeline) : base(services) { RecursivePipeline = recursivePipeline; }