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