protected override void BeginTransitionOn() { _scene = new TestScene(_kernel, _kernel.Get<Game>(), _kernel.Get<ContentManager>(), _kernel.Get<GraphicsDevice>(), new TestScene.SceneConfiguration() { View = false }); _renderer = _scene.Scene.GetService<Renderer>(); _renderer.StartPlan() .Then<GeometryBufferComponent>() .Then<EdgeDetectComponent>() .Then<Ssao>() .Then<LightingComponent>() .Then<RestoreDepthPhase>() .Then<TranslucentComponent>() .Then<ToneMapComponent>() .Then<AntiAliasComponent>() .Apply(); var w = _renderer.Device.Viewport.Width / 2; var h = _renderer.Device.Viewport.Height / 2; AddCamera("gbuffer_depth", new Viewport { X = 0, Y = 0, Width = w, Height = h }); AddCamera("gbuffer_normals", new Viewport { X = w, Y = 0, Width = w, Height = h }); AddCamera("gbuffer_diffuse", new Viewport { X = 0, Y = h, Width = w, Height = h }); AddCamera("lightbuffer", new Viewport { X = w, Y = h, Width = w, Height = h }); base.OnShown(); }
public override void Initialise(Renderer renderer, ResourceContext context) { // define outputs context.DefineOutput(_name, true, null, _targetInfo); base.Initialise(renderer, context); }
protected override void BeginTransitionOn() { _scene = _kernel.Get<TestScene>(); _renderer = _scene.Scene.GetService<Renderer>(); _fullPlan = _renderer.StartPlan() .Then<GeometryBufferComponent>() .Then<EdgeDetectComponent>() .Then<Ssao>() .Then<LightingComponent>() .Then<RestoreDepthPhase>() .Then<TranslucentComponent>() .Then<ToneMapComponent>() .Then<AntiAliasComponent>() .Show("antialiased"); _noAaPlan = _renderer.StartPlan() .Then<GeometryBufferComponent>() .Then<EdgeDetectComponent>() .Then<Ssao>() .Then<LightingComponent>() .Then<RestoreDepthPhase>() .Then<TranslucentComponent>() .Then<ToneMapComponent>() .Show("tonemapped"); base.OnShown(); }
public override void End(Renderer renderer) { base.End(renderer); //Restore previous plan if (_previousPlan != null) _previousPlan.Apply(); _previousPlan = null; }
public override void Initialise(Renderer renderer, ResourceContext context) { // define input context.DefineInput("scene"); // define output context.DefineOutput("scene"); base.Initialise(renderer, context); }
public override void Draw(Renderer renderer) { var resolution = renderer.Data.Get<Vector2>("resolution").Value; var targetInfo = new RenderTargetInfo((int) resolution.X, (int) resolution.Y, SurfaceFormat.Color, DepthFormat.None, 4, default(bool), default(RenderTargetUsage)); var target = RenderTargetManager.GetTarget(renderer.Device, targetInfo); renderer.Device.SetRenderTarget(target); renderer.Device.Clear(Colour); Output("scene", target); }
public override void Initialise(Renderer renderer, ResourceContext context) { foreach (var resource in context.SetRenderTargets) { context.DefineInput(resource.Name); context.DefineOutput(resource); } renderables = renderer.Scene.FindManagers<IRenderable>(); base.Initialise(renderer, context); }
public override void Draw(Renderer renderer) { var resolution = renderer.Data.Get<Vector2>("resolution").Value; var targetInfo = new RenderTargetInfo() { Width = (int)resolution.X, Height = (int)resolution.Y, SurfaceFormat = SurfaceFormat.Color, DepthFormat = DepthFormat.None, MultiSampleCount = 4 }; var target = RenderTargetManager.GetTarget(renderer.Device, targetInfo); renderer.Device.SetRenderTarget(target); renderer.Device.Clear(Colour); Output("scene", target); }
public override void Begin(Renderer renderer) { base.Begin(renderer); //Get or create a plan for this renderer RenderPlan plan; if (!_plans.TryGetValue(renderer, out plan)) { plan = CreatePlan(renderer); _plans[renderer] = plan; } //Cache plan which is already applied _previousPlan = renderer.Plan; //If a null plan is returned use the default renderer plan if (plan == null) return; //Apply new plan plan.Apply(); }
public override void Draw(Renderer renderer) { var info = _targetInfo; if (info.Width == 0 || info.Height == 0) { var resolution = renderer.Data.GetValue(new TypedName<Vector2>("resolution")); info = new RenderTargetInfo( (int) resolution.X, (int) resolution.Y, info.SurfaceFormat, info.DepthFormat, info.MultiSampleCount, info.MipMap, info.Usage ); } var target = RenderTargetManager.GetTarget(renderer.Device, info); renderer.Device.SetRenderTarget(target); renderer.Device.Clear(ClearOptions.Target | ClearOptions.DepthBuffer | ClearOptions.Stencil, Color.Black, 1, 0); Output(_name, target); }
protected override RenderPlan CreatePlan(Renderer renderer) { return renderer.Plan.Clone() .Show(_output); }
public override void Draw(Renderer renderer) { foreach (var item in renderables) item.Draw(renderer); }
//protected override void SpecifyResources(IList<Input> inputs, IList<RendererComponent.Resource> outputs, out RenderTargetInfo? outputTarget) //{ // inputs.Add(new Input() { Name = "gbuffer_depth" }); // inputs.Add(new Input() { Name = "gbuffer_depth_downsample" }); // inputs.Add(new Input() { Name = "gbuffer_normals" }); // inputs.Add(new Input() { Name = "gbuffer_diffuse" }); // outputs.Add(new Resource() { Name = "scene", IsLeftSet = true }); // outputTarget = new RenderTargetInfo(); //} //protected override bool ValidateInput(RenderTargetInfo? previousRenderTarget) //{ // return true; //} public override void Initialise(Renderer renderer, ResourceContext context) { // define inputs context.DefineInput("gbuffer_depth"); context.DefineInput("gbuffer_depth_downsample"); context.DefineInput("gbuffer_normals"); context.DefineInput("gbuffer_diffuse"); // define outputs context.DefineOutput("scene"); base.Initialise(renderer, context); }
public override void Draw(Renderer renderer) { var metadata = renderer.Data; var resolution = metadata.GetOrCreate<Vector2>(Names.View.Resolution).Value; var targetInfo = new RenderTargetInfo((int) resolution.X, (int) resolution.Y, default(SurfaceFormat), default(DepthFormat), default(int), default(bool), default(RenderTargetUsage)); var target = RenderTargetManager.GetTarget(renderer.Device, targetInfo); renderer.Device.SetRenderTarget(target); var depth = metadata.GetValue<Texture2D>(Names.Deferred.Textures.Depth); var normals = metadata.GetValue<Texture2D>(Names.Deferred.Textures.Normals); var diffuse = metadata.GetValue<Texture2D>(Names.Deferred.Textures.Diffuse); //Save(depth, "depth.jpg"); //Save(normals, "normal.jpg"); //Save(diffuse, "diffuse.jpg"); var halfWidth = (int)(resolution.X / 2); var halfHeight = (int)(resolution.Y / 2); _batch.GraphicsDevice.Clear(Color.Black); _batch.Begin(SpriteSortMode.Immediate, BlendState.Opaque); _batch.GraphicsDevice.SamplerStates[0] = SamplerState.PointClamp; _batch.Draw(depth, new Rectangle(0, 0, halfWidth, halfHeight), Color.White); _batch.GraphicsDevice.SamplerStates[0] = SamplerState.LinearClamp; _batch.Draw(normals, new Rectangle(halfWidth, 0, halfWidth, halfHeight), Color.White); _batch.Draw(diffuse, new Rectangle(0, halfHeight, halfWidth, halfHeight), Color.White); _batch.End(); Output("scene", target); }
public override void Draw(Renderer renderer) { var target = RenderTargetManager.GetTarget(renderer.Device, 1280, 720); renderer.Device.SetRenderTarget(target); var metadata = renderer.Data; var c = metadata.Get<Texture2D>("c").Value; spriteBatch.Begin(); spriteBatch.Draw(c, new Rectangle(590, 335, 100, 50), Color.White); spriteBatch.End(); Output("d", target); }
public override void Draw(Renderer renderer) { var target = RenderTargetManager.GetTarget(renderer.Device, new RenderTargetInfo(50, 50, default(SurfaceFormat), default(DepthFormat), default(int), default(bool), default(RenderTargetUsage))); renderer.Device.SetRenderTarget(target); renderer.Device.Clear(Color.White); spriteBatch.Begin(); spriteBatch.DrawString(font, "A", Vector2.Zero, Color.Black); spriteBatch.End(); Output("a", target); }
//protected override void SpecifyResources(IList<Input> inputs, IList<RendererComponent.Resource> outputs, out RenderTargetInfo? outputTarget) //{ // inputs.Add(new Input() { Name = "tonemapped" }); // inputs.Add(new Input() { Name = "luminancemap" }); // outputs.Add(new Resource() { Name = "scene", IsLeftSet = true }); // outputTarget = new RenderTargetInfo() { SurfaceFormat = SurfaceFormat.Rgba64, DepthFormat = DepthFormat.Depth24Stencil8 }; //} //protected override bool ValidateInput(RenderTargetInfo? previousRenderTarget) //{ // return true; //} public override void Initialise(Renderer renderer, ResourceContext context) { // define inputs context.DefineInput("tonemapped"); //context.DefineInput("luminancemap"); // define outputs context.DefineOutput("scene", surfaceFormat: SurfaceFormat.Rgba64, depthFormat: DepthFormat.Depth24Stencil8); base.Initialise(renderer, context); }
/// <summary> /// Draws this component. /// </summary> /// <param name="renderer">The renderer</param> public abstract void Draw(Renderer renderer);
protected abstract RenderPlan CreatePlan(Renderer renderer);
public override void Draw(Renderer renderer) { var metadata = renderer.Data; var resolution = renderer.Data.Get<Vector2>("resolution").Value; var targetInfo = new RenderTargetInfo((int)resolution.X, (int)resolution.Y, SurfaceFormat.Rgba64, DepthFormat.Depth24Stencil8, default(int), default(bool), default(RenderTargetUsage)); var target = RenderTargetManager.GetTarget(renderer.Device, targetInfo); renderer.Device.SetRenderTarget(target); var light = metadata.Get<Texture2D>("tonemapped").Value; var luminance = metadata.Get<Texture2D>("luminancemap").Value; //using (var stream = File.Create("luminance.jpg")) // light.SaveAsJpeg(stream, light.Width, light.Height); var width = (int)resolution.X; var height = (int)resolution.Y; batch.GraphicsDevice.Clear(Color.Black); batch.Begin(SpriteSortMode.Immediate, BlendState.Opaque); if (drawScene) { batch.GraphicsDevice.SamplerStates[0] = SamplerState.PointClamp; batch.Draw(light, new Rectangle(0, 0, width, height), Color.White); //batch.Draw(luminance, new Rectangle(50, height - (height / 5) - 50, height / 5, height / 5), Color.White); //batch.Draw(toneMap.AdaptedLuminance, new Rectangle(50 + 20 + (height / 5), height - (height / 5) - 50, height / 5, height / 5), Color.White); batch.GraphicsDevice.SamplerStates[0] = SamplerState.LinearClamp; } else { batch.GraphicsDevice.SamplerStates[0] = SamplerState.PointClamp; batch.Draw(luminance, new Rectangle(0, 0, width, height), Color.White); batch.GraphicsDevice.SamplerStates[0] = SamplerState.LinearClamp; } batch.End(); Output("scene", target); }
public override void Draw(Renderer renderer) { var resolution = renderer.Data.Get<Vector2>("resolution").Value; var targetInfo = new RenderTargetInfo((int) resolution.X, (int) resolution.Y, default(SurfaceFormat), default(DepthFormat), default(int), default(bool), default(RenderTargetUsage)); var target = RenderTargetManager.GetTarget(renderer.Device, targetInfo); renderer.Device.SetRenderTarget(target); _batch.Begin(); _batch.DrawString(Font, "This is being drawn by a RenderPhase!", new Vector2(640, 360).ToXNA(), Color.White); _batch.End(); Output("scene", target); }
public override void Draw(Renderer renderer) { var target = RenderTargetManager.GetTarget(renderer.Device, new RenderTargetInfo() { Height = 50, Width = 50 }); renderer.Device.SetRenderTarget(target); renderer.Device.Clear(Color.White); spriteBatch.Begin(); spriteBatch.DrawString(font, "A", Vector2.Zero, Color.Black); spriteBatch.End(); Output("a", target); }
/// <summary> /// Initialised this renderer component. /// </summary> /// <remarks> /// Here, components may validate that required inputs are available, and /// define their output. /// </remarks> /// <param name="renderer">The renderer.</param> /// <param name="context">The resource context containing environment information and providing means to define inputs and outputs.</param> public virtual void Initialise(Renderer renderer, ResourceContext context) { Initialised = true; }
public override void Draw(Renderer renderer) { KeyboardState keyboard = Keyboard.GetState(); if (keyboard.IsKeyDown(Keys.Space) && previousKeyboard.IsKeyUp(Keys.Space)) drawGBuffer = !drawGBuffer; previousKeyboard = keyboard; var metadata = renderer.Data; var resolution = renderer.Data.Get<Vector2>("resolution").Value; var targetInfo = new RenderTargetInfo((int)resolution.X, (int)resolution.Y, SurfaceFormat.Rgba64, default(DepthFormat), default(int), default(bool), default(RenderTargetUsage)); var target = RenderTargetManager.GetTarget(renderer.Device, targetInfo); renderer.Device.SetRenderTarget(target); var depth = metadata.Get<Texture2D>("gbuffer_depth").Value; var normals = metadata.Get<Texture2D>("gbuffer_normals").Value; var diffuse = metadata.Get<Texture2D>("gbuffer_diffuse").Value; var light = metadata.Get<Texture2D>("lightbuffer").Value; //using (var stream = File.Create("lightbuffer.jpg")) // light.SaveAsJpeg(stream, light.Width, light.Height); var halfWidth = (int)(resolution.X / 2); var halfHeight = (int)(resolution.Y / 2); batch.GraphicsDevice.Clear(Color.Black); batch.Begin(SpriteSortMode.Immediate, BlendState.Opaque); if (drawGBuffer) { batch.GraphicsDevice.SamplerStates[0] = SamplerState.PointClamp; batch.Draw(depth, new Rectangle(0, 0, halfWidth, halfHeight), Color.White); batch.Draw(light, new Rectangle(halfWidth, halfHeight, halfWidth, halfHeight), Color.White); batch.GraphicsDevice.SamplerStates[0] = SamplerState.LinearClamp; batch.Draw(normals, new Rectangle(halfWidth, 0, halfWidth, halfHeight), Color.White); batch.Draw(diffuse, new Rectangle(0, halfHeight, halfWidth, halfHeight), Color.White); } else { batch.GraphicsDevice.SamplerStates[0] = SamplerState.PointClamp; batch.Draw(light, new Rectangle(0, 0, (int)resolution.X, (int)resolution.Y), Color.White); batch.GraphicsDevice.SamplerStates[0] = SamplerState.LinearClamp; } batch.End(); Output("scene", target); }
public override void Draw(Renderer renderer) { var target = RenderTargetManager.GetTarget(renderer.Device, 50, 100); renderer.Device.SetRenderTarget(target); var metadata = renderer.Data; var a = metadata.Get<Texture2D>("a").Value; var b = metadata.Get<Texture2D>("b").Value; spriteBatch.Begin(); spriteBatch.Draw(a, new Rectangle(0, 0, 50, 50), Color.White); spriteBatch.Draw(b, new Rectangle(50, 0, 50, 50), Color.White); spriteBatch.End(); Output("c", target); }
public override void Draw(Renderer renderer) { var resolution = renderer.Data.Get<Vector2>("resolution").Value; var targetInfo = new RenderTargetInfo() { Width = (int)resolution.X, Height = (int)resolution.Y }; var target = RenderTargetManager.GetTarget(renderer.Device, targetInfo); renderer.Device.SetRenderTarget(target); batch.Begin(); batch.DrawString(Font, "This is being drawn by a RenderPhase!", new Vector2(640, 360), Color.White); batch.End(); Output("scene", target); }
public void Finalise(Renderer renderer, RenderTarget2D target) { Finaliser(renderer, target); }