public SceneRenderer(GameSettingsAsset gameSettings) { if (gameSettings == null) throw new ArgumentNullException(nameof(gameSettings)); // Initialize services Services = new ServiceRegistry(); ContentManager = new ContentManager(Services); var renderingSettings = gameSettings.Get<RenderingSettings>(); GraphicsDevice = GraphicsDevice.New(DeviceCreationFlags.None, new[] { renderingSettings.DefaultGraphicsProfile }); var graphicsDeviceService = new GraphicsDeviceServiceLocal(Services, GraphicsDevice); EffectSystem = new EffectSystem(Services); GraphicsContext = new GraphicsContext(GraphicsDevice); Services.AddService(typeof(GraphicsContext), GraphicsContext); SceneSystem = new SceneSystem(Services); // Create game systems GameSystems = new GameSystemCollection(Services); GameSystems.Add(new GameFontSystem(Services)); GameSystems.Add(new UISystem(Services)); GameSystems.Add(EffectSystem); GameSystems.Add(SceneSystem); GameSystems.Initialize(); // Fake presenter // TODO GRAPHICS REFACTOR: This is needed be for render stage setup GraphicsDevice.Presenter = new RenderTargetGraphicsPresenter(GraphicsDevice, Texture.New2D(GraphicsDevice, renderingSettings.DefaultBackBufferWidth, renderingSettings.DefaultBackBufferHeight, renderingSettings.ColorSpace == ColorSpace.Linear ? PixelFormat.R8G8B8A8_UNorm_SRgb : PixelFormat.R8G8B8A8_UNorm, TextureFlags.ShaderResource | TextureFlags.RenderTarget), PixelFormat.D24_UNorm_S8_UInt); SceneSystem.MainRenderFrame = RenderFrame.FromTexture(GraphicsDevice.Presenter.BackBuffer, GraphicsDevice.Presenter.DepthStencilBuffer); }
/// <summary> /// Draws a quad. The effect must have been applied before calling this method with pixel shader having the signature float2:TEXCOORD. /// </summary> /// <param name="texture"></param> public void Draw(GraphicsContext graphicsContext, EffectInstance effectInstance) { effectInstance.UpdateEffect(GraphicsDevice); pipelineState.State.RootSignature = effectInstance.RootSignature; pipelineState.State.EffectBytecode = effectInstance.Effect.Bytecode; pipelineState.State.BlendState = BlendStates.Default; pipelineState.State.Output.CaptureState(graphicsContext.CommandList); pipelineState.Update(); graphicsContext.CommandList.SetPipelineState(pipelineState.CurrentState); // Apply the effect effectInstance.Apply(graphicsContext); Draw(graphicsContext.CommandList); }
public void Apply(GraphicsContext graphicsContext) { var commandList = graphicsContext.CommandList; parameterUpdater.Update(commandList.GraphicsDevice, graphicsContext.ResourceGroupAllocator, Parameters); // Flush resource groups and cbuffer graphicsContext.ResourceGroupAllocator.Flush(); var resourceGroups = parameterUpdater.ResourceGroups; // Update cbuffer bufferUploader.Apply(commandList, resourceGroups, 0); // Bind descriptor sets for (int i = 0; i < descriptorSets.Length; ++i) descriptorSets[i] = resourceGroups[i].DescriptorSet; commandList.SetDescriptorSets(0, descriptorSets); }
public SkyboxGeneratorContext(SkyboxAsset skybox) { if (skybox == null) throw new ArgumentNullException(nameof(skybox)); Skybox = skybox; Services = new ServiceRegistry(); Content = new ContentManager(Services); GraphicsDevice = GraphicsDevice.New(); GraphicsDeviceService = new GraphicsDeviceServiceLocal(Services, GraphicsDevice); var graphicsContext = new GraphicsContext(GraphicsDevice); Services.AddService(typeof(GraphicsContext), graphicsContext); EffectSystem = new EffectSystem(Services); EffectSystem.Initialize(); ((IContentable)EffectSystem).LoadContent(); ((EffectCompilerCache)EffectSystem.Compiler).CompileEffectAsynchronously = false; RenderContext = RenderContext.GetShared(Services); RenderDrawContext = new RenderDrawContext(Services, RenderContext, graphicsContext); }
/// <summary> /// Starts the drawing of a frame. This method is followed by calls to Draw and EndDraw. /// </summary> /// <returns><c>true</c> to continue drawing, false to not call <see cref="Draw"/> and <see cref="EndDraw"/></returns> protected virtual bool BeginDraw() { beginDrawOk = false; if ((graphicsDeviceManager != null) && !graphicsDeviceManager.BeginDraw()) { return false; } // Setup default command list if (GraphicsContext == null) { GraphicsContext = new GraphicsContext(GraphicsDevice); Services.AddService(typeof(GraphicsContext), GraphicsContext); } else { // Reset allocator GraphicsContext.ResourceGroupAllocator.Reset(GraphicsContext.CommandList); GraphicsContext.CommandList.Reset(); } beginDrawOk = true; // Clear states GraphicsContext.CommandList.ClearState(); // Perform begin of frame presenter operations if (GraphicsDevice.Presenter != null) { GraphicsContext.CommandList.ResourceBarrierTransition(GraphicsDevice.Presenter.DepthStencilBuffer, GraphicsResourceState.DepthWrite); GraphicsContext.CommandList.ResourceBarrierTransition(GraphicsDevice.Presenter.BackBuffer, GraphicsResourceState.RenderTarget); GraphicsDevice.Presenter.BeginDraw(GraphicsContext.CommandList); } return true; }
/// <summary> /// Draws a quad with a texture. This Draw method is using the current effect bound to this instance. /// </summary> /// <param name="texture">The texture.</param> /// <param name="applyEffectStates">The flag to apply effect states.</param> public void Draw(GraphicsContext graphicsContext, Texture texture, BlendStateDescription? blendState = null) { Draw(graphicsContext, texture, null, Color.White, blendState); }
/// <summary> /// Draws a quad with a texture. This Draw method is using a simple pixel shader that is sampling the texture. /// </summary> /// <param name="texture">The texture to draw.</param> /// <param name="samplerState">State of the sampler. If null, default sampler is <see cref="SamplerStateFactory.LinearClamp" />.</param> /// <param name="color">The color.</param> /// <param name="applyEffectStates">The flag to apply effect states.</param> /// <exception cref="System.ArgumentException">Expecting a Texture;texture</exception> public void Draw(GraphicsContext graphicsContext, Texture texture, SamplerState samplerState, Color4 color, BlendStateDescription? blendState = null) { pipelineState.State.RootSignature = simpleEffect.RootSignature; pipelineState.State.EffectBytecode = simpleEffect.Effect.Bytecode; pipelineState.State.BlendState = blendState ?? BlendStates.Default; pipelineState.State.Output.CaptureState(graphicsContext.CommandList); pipelineState.Update(); graphicsContext.CommandList.SetPipelineState(pipelineState.CurrentState); // Make sure that we are using our vertex shader simpleEffect.Parameters.Set(SpriteEffectKeys.Color, color); simpleEffect.Parameters.Set(TexturingKeys.Texture0, texture); simpleEffect.Parameters.Set(TexturingKeys.Sampler, samplerState ?? GraphicsDevice.SamplerStates.LinearClamp); simpleEffect.Apply(graphicsContext); Draw(graphicsContext.CommandList); // TODO ADD QUICK UNBIND FOR SRV //GraphicsDevice.Context.PixelShader.SetShaderResource(0, null); }
/// <summary> /// Begins a image batch rendering using the specified blend state, sampler, depth stencil, rasterizer state objects, and the view-projection transformation matrix. /// Passing null for any of the state objects selects the default default state objects (BlendState.AlphaBlend, DepthStencilState.None, RasterizerState.CullCounterClockwise, SamplerState.LinearClamp). /// </summary> /// <param name="graphicsContext">The graphics context to use.</param> /// <param name="blendState">Blending options.</param> /// <param name="samplerState">Texture sampling options.</param> /// <param name="depthStencilState">Depth and stencil options.</param> /// <param name="rasterizerState">Rasterization options.</param> /// <param name="viewProjection">The view projection matrix used for this series of draw calls</param> /// <param name="stencilValue">The value of the stencil buffer to take as reference</param> public void Begin(GraphicsContext graphicsContext, ref Matrix viewProjection, BlendStateDescription?blendState, SamplerState samplerState, RasterizerStateDescription?rasterizerState, DepthStencilStateDescription?depthStencilState, int stencilValue) { viewProjectionMatrix = viewProjection; Begin(graphicsContext, null, SpriteSortMode.BackToFront, blendState, samplerState, depthStencilState, rasterizerState, stencilValue); }
/// <summary> /// Begins a image batch rendering using the specified blend state, depth stencil and a view-projection transformation matrix. /// Passing null for any of the state objects selects the default default state objects (BlendState.AlphaBlend, DepthStencilState.None). /// </summary> /// <param name="graphicsContext">The graphics context to use.</param> /// <param name="blendState">Blending options.</param> /// <param name="depthStencilState">Depth and stencil options.</param> /// <param name="viewProjection">The view projection matrix used for this series of draw calls</param> /// <param name="stencilValue">The value of the stencil buffer to take as reference</param> public void Begin(GraphicsContext graphicsContext, ref Matrix viewProjection, BlendStateDescription?blendState, DepthStencilStateDescription?depthStencilState, int stencilValue) { Begin(graphicsContext, ref viewProjection, blendState, null, null, depthStencilState, stencilValue); }
/// <summary> /// Begins a sprite batch rendering using the specified sorting mode and blend state, sampler, depth stencil, rasterizer state objects, plus a custom effect and a 2D transformation matrix. Passing null for any of the state objects selects the default default state objects (BlendState.AlphaBlend, DepthStencilState.Default, RasterizerState.CullCounterClockwise, SamplerState.LinearClamp). Passing a null effect selects the default SpriteBatch Class shader. /// </summary> /// <param name="graphicsContext">The graphics context to use.</param> /// <param name="viewMatrix">The view matrix to use for the batch session</param> /// <param name="sortMode">The sprite drawing order to use for the batch session</param> /// <param name="blendState">The blending state to use for the batch session</param> /// <param name="samplerState">The sampling state to use for the batch session</param> /// <param name="depthStencilState">The depth stencil state to use for the batch session</param> /// <param name="rasterizerState">The rasterizer state to use for the batch session</param> /// <param name="effect">The effect to use for the batch session</param> /// <param name="stencilValue">The value of the stencil buffer to take as reference for the batch session</param> public void Begin(GraphicsContext graphicsContext, Matrix viewMatrix, SpriteSortMode sortMode = SpriteSortMode.Deferred, BlendStateDescription?blendState = null, SamplerState samplerState = null, DepthStencilStateDescription?depthStencilState = null, RasterizerStateDescription?rasterizerState = null, EffectInstance effect = null, int stencilValue = 0) { UpdateDefaultProjectionMatrix(graphicsContext.CommandList); Begin(graphicsContext, viewMatrix, defaultProjectionMatrix, sortMode, blendState, samplerState, depthStencilState, rasterizerState, effect, stencilValue); }
/// <summary> /// Begins a sprite batch operation using deferred sort and default state objects (BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.Default, RasterizerState.CullCounterClockwise). /// </summary> /// <param name="graphicsContext">The graphics context to use.</param> /// <param name="sortMode">The sprite drawing order to use for the batch session</param> /// <param name="effect">The effect to use for the batch session</param> public void Begin(GraphicsContext graphicsContext, SpriteSortMode sortMode, EffectInstance effect) { UpdateDefaultProjectionMatrix(graphicsContext.CommandList); Begin(graphicsContext, defaultViewMatrix, defaultProjectionMatrix, sortMode, null, null, null, null, effect); }