protected override void OnDraw(FrameArgs e)
{
base.OnDraw(e);
// the first stage draws the sprite to the frame buffer with
// a horizontal blur
using (_fbcam.Begin()) { // using the camera...
using (_fb.Begin()) { // ...and drawing to buffer...
using (_matHblur.Begin()) { // ...and blur mat...
// since a material was put in scope, it overrides
// the sprite's built-in material
_sprites["star"].Draw(Matrix4.Identity);
}
}
}
// the second stage draws the sprite with a vertical blur
// to the screen. normal sprites are drawn last to create
// a glow effect on the rightmost sprite.
using (_cam.Begin()) {
using (_matVblur.Begin()) {
// draw blurred sprite in middle
_quad.Draw(Matrix4.Identity);
// draw blurred sprighte on right
_quad.Draw(Matrix4.CreateTranslation(128, 0, 0));
}
// draw sprite on left
_sprites["star"].Draw(Matrix4.CreateTranslation(-128, 0, 1));
// draw sprite on right on top of blurred sprite
_sprites["star"].Draw(Matrix4.CreateTranslation(128, 0, 1));
}
}
public void Blur(RenderTarget2D source, RenderTarget2D destination, float sigma)
{
if (width != source.Width || height != source.Height || this.sigma != sigma)
{
CalculateWeights(source.Width, source.Height, sigma);
}
effect.Parameters["Resolution"].SetValue(new Vector2(width, height));
var intermediate = RenderTargetManager.GetTarget(device, width, height, destination.Format, name: "gaussian intermediate");
device.SetRenderTarget(intermediate);
effect.Parameters["Texture"].SetValue(source);
effect.CurrentTechnique = effect.Techniques["BlurHorizontal"];
quad.Draw(effect);
device.SetRenderTarget(destination);
effect.Parameters["Texture"].SetValue(intermediate);
effect.CurrentTechnique = effect.Techniques["BlurVertical"];
quad.Draw(effect);
RenderTargetManager.RecycleTarget(intermediate);
}
public override void Draw(Renderer renderer)
{
var resolution = renderer.Data.Get <Vector2>("resolution").Value;
//if (renderer.Data.Get<float>("ssao_radiosityintensity").Value > 0)
// ssaoMaterial.CurrentTechnique = ssaoMaterial.Techniques["SSGI"];
//else
//{
if (renderer.Data.Get <bool>("ssao_highquality").Value)
{
ssaoMaterial.CurrentTechnique = ssaoMaterial.Techniques["HQ_SSAO"];
}
else
{
ssaoMaterial.CurrentTechnique = ssaoMaterial.Techniques["LQ_SSAO"];
}
//}
var unblured = RenderTargetManager.GetTarget(renderer.Device, (int)resolution.X, (int)resolution.Y, surfaceFormat: SurfaceFormat.HalfVector4, name: "ssao unblurred");//, SurfaceFormat.HalfVector4);
renderer.Device.SetRenderTarget(unblured);
renderer.Device.Clear(Color.Transparent);
renderer.Device.BlendState = BlendState.Opaque;
quad.Draw(ssaoMaterial, renderer.Data);
ssao = RenderTargetManager.GetTarget(renderer.Device, (int)resolution.X, (int)resolution.Y, SurfaceFormat.HalfVector4, name: "ssao");
renderer.Device.SetRenderTarget(ssao);
renderer.Device.Clear(Color.Transparent);
ssaoBlurMaterial.Parameters["SSAO"].SetValue(unblured);
quad.Draw(ssaoBlurMaterial, renderer.Data);
RenderTargetManager.RecycleTarget(unblured);
Output("ssao", ssao);
}
protected void DrawAvatarTool(RendererBase <ToyWorld> renderer, IAvatar avatar, Vector2 size, Vector2 position, ToolBackgroundType type = ToolBackgroundType.BrownBorder)
{
GameObjectPainter goPainter = Owner.GameObjectPainter;
GL.Enable(EnableCap.Blend);
Owner.SetDefaultBlending();
// Bind stuff to GL (used in overrides)
renderer.TextureManager.Bind(goPainter.TilesetTexture);
renderer.EffectManager.Use(goPainter.Effect);
goPainter.Effect.TextureUniform(0);
if (Owner.FlipYAxis)
{
size.Y = -size.Y;
position.Y = -position.Y;
}
Matrix transform = Matrix.CreateScale(size);
transform *= Matrix.CreateTranslation(position.X, position.Y, 0.01f);
// Draw the inventory background
renderer.TextureManager.Bind(m_overlayTexture, Owner.GetTextureUnit(RenderRequestBase.TextureBindPosition.Ui));
renderer.EffectManager.Use(m_overlayEffect);
m_overlayEffect.TextureUniform((int)RenderRequestBase.TextureBindPosition.Ui);
m_overlayEffect.TileTypesTextureUniform((int)RenderRequestBase.TextureBindPosition.TileTypes);
m_overlayEffect.TileTypesIdxOffsetUniform(0);
m_overlayEffect.ModelViewProjectionUniform(ref transform);
goPainter.LocalTileTypesBuffer[0] = (ushort)type;
if (avatar.Tool != null)
{
goPainter.LocalTileTypesBuffer[1] = (ushort)avatar.Tool.TilesetId;
}
GL.BindBuffer(BufferTarget.PixelUnpackBuffer, 0);
goPainter.TileTypesTexure.Update1D(2, dataType: PixelType.UnsignedShort, data: goPainter.LocalTileTypesBuffer);
QuadOffset.Draw();
// Draw the inventory Tool
if (avatar.Tool != null)
{
renderer.TextureManager.Bind(goPainter.TilesetTexture);
renderer.EffectManager.Use(goPainter.Effect);
goPainter.Effect.DiffuseUniform(new Vector4(1, 1, 1, 1));
goPainter.Effect.TileTypesIdxOffsetUniform(1);
Matrix toolTransform = Matrix.CreateScale(0.7f) * transform;
goPainter.Effect.ModelViewProjectionUniform(ref toolTransform);
QuadOffset.Draw();
}
}
protected override void OnDraw(FrameArgs e)
{
base.OnDraw(e);
using (_cam1.Begin()) { // using the orthographic cam...
_quad.Draw(Matrix4.Scale(100f));
}
using (_cam2.Begin()) { // using the perspective cam...
_quad.Draw(Matrix4.CreateTranslation(0, -2.25f, 0)
* Matrix4.CreateRotationX(-Mathf.PiOver2 * 0.9f));
}
}
public override void Draw(Renderer renderer)
{
var metadata = renderer.Data;
var device = renderer.Device;
var resolution = metadata.Get <Vector2>("resolution").Value;
var width = (int)resolution.X;
var height = (int)resolution.Y;
var depth = RenderTargetManager.GetTarget(device, width, height, SurfaceFormat.Single, DepthFormat.Depth24Stencil8, name: "depth");
var normals = RenderTargetManager.GetTarget(device, width, height, SurfaceFormat.Rgba1010102, name: "normals");
var diffuse = RenderTargetManager.GetTarget(device, width, height, SurfaceFormat.Color, name: "diffuse");
device.SetRenderTargets(depth, normals, diffuse);
device.BlendState = BlendState.Opaque;
device.Clear(Color.Black);
device.DepthStencilState = DepthStencilState.None;
quad.Draw(clear, metadata);
device.DepthStencilState = DepthStencilState.Default;
device.BlendState = BlendState.Opaque;
foreach (var geometryProvider in renderer.Scene.FindManagers <IGeometryProvider>())
{
geometryProvider.Draw("gbuffer", metadata);
}
Output("gbuffer_depth", depth);
Output("gbuffer_normals", normals);
Output("gbuffer_diffuse", diffuse);
DownsampleDepth(renderer, depth);
}
public void Draw(Renderer renderer)
{
var metadata = renderer.Data;
var device = renderer.Device;
// set deice for drawing sphere mesh
var part = geometry.Meshes[0].MeshParts[0];
device.SetVertexBuffer(part.VertexBuffer);
device.Indices = part.IndexBuffer;
// draw lights which touch near plane
// back faces, cull those in front of geometry
device.DepthStencilState = depthGreater;
device.RasterizerState = RasterizerState.CullClockwise;
DrawGeometryLights(touchesNearPlane, metadata, device);
// draw lights which touch both planes
// full screen quad
device.DepthStencilState = DepthStencilState.None;
device.RasterizerState = RasterizerState.CullCounterClockwise;
foreach (var light in touchesBothPlanes)
{
SetupLight(metadata, quadLightingMaterial, light);
quad.Draw(quadLightingMaterial, metadata);
}
// draw all other lights
// front faces, cull those behind geometry
device.DepthStencilState = depthLess;
DrawGeometryLights(doesntTouchNear, metadata, device);
}
public override void Draw()
{
Sketch.CreateBackgroundLayer(Color.White);
Sketch.Begin();
{
quad.Draw(Camera);
}
Sketch.End();
Sketch.AttachEffect(new Outline(Engine.RenderTarget, 1, new Color(Color.Black, 0.25f)));
Sketch.AttachEffect(new ChromaticAberration(Engine.RenderTarget, 4, new Vector2(1, 0), new Vector2(0, 1), new Vector2(1, 1)));
Sketch.Begin();
{
Polygon[] polygons = new Polygon[Player.Farts.Count];
for (int i = 0; i < polygons.Length; i++)
{
polygons[i] = Player.Farts[i].Circle;
}
Batcher.DrawPolygons(polygons, Camera);
}
Sketch.End();
Sketch.AttachEffect(new DropShadow(Engine.RenderTarget, new Vector2(1, 1), 4, new Color(Color.Black, 100)));
Sketch.Begin();
{
foreach (Entity e in entities)
{
e.Draw(Camera);
}
}
Sketch.End();
}
public void Draw(Renderer renderer)
{
foreach (var light in lights)
{
SetupLight(renderer.Data, light);
quad.Draw(material, renderer.Data);
}
}
private void CalculateLuminance(Renderer renderer, Box <Vector2> resolution, GraphicsDevice device, Texture2D lightBuffer)
{
var tmp = previous;
previous = current;
current = tmp;
// calculate luminance map
var luminanceMap = RenderTargetManager.GetTarget(device, 1024, 1024, SurfaceFormat.Single, mipMap: true, name: "luminance map");
device.SetRenderTarget(luminanceMap);
device.BlendState = BlendState.Opaque;
device.Clear(Color.Transparent);
calculateLuminance.Parameters["Texture"].SetValue(lightBuffer);
quad.Draw(calculateLuminance, renderer.Data);
Output("luminance", luminanceMap);
// read bottom mipmap to find average luminance
averageLuminance = RenderTargetManager.GetTarget(device, 1, 1, SurfaceFormat.Single, name: "average luminance");
device.SetRenderTarget(averageLuminance);
readLuminance.Parameters["Texture"].SetValue(luminanceMap);
quad.Draw(readLuminance, renderer.Data);
// adapt towards the current luminance
device.SetRenderTarget(adaptedLuminance[current]);
adaptLuminance.Parameters["Texture"].SetValue(averageLuminance);
adaptLuminance.Parameters["PreviousAdaption"].SetValue(adaptedLuminance[previous]);
quad.Draw(adaptLuminance, renderer.Data);
}
protected override void OnDraw(FrameArgs e)
{
base.OnDraw(e);
using (_cam.Begin()) {
_quad.Draw(Matrix4.Scale(100f)
* Matrix4.CreateTranslation(100, 0, 0));
}
}
protected override void OnDraw(FrameArgs e)
{
base.OnDraw(e);
using (_cam.Begin()) { // using the camera...
// ... draw the quad
_quad.Draw(ref _world);
}
}
public override void Draw(Camera cam)
{
sprite.Draw(cam);
if (DebugManager.Debugging)
{
debugBounds.Draw(cam);
}
}
protected override void OnDraw(FrameArgs e)
{
base.OnDraw(e);
using (_cam.Begin()) { // using the camera...
// ... draw the quads
_quad1.Draw(Matrix4.CreateTranslation(-125, 0, 0));
_quad2.Draw(Matrix4.CreateTranslation(125, 0, 0));
}
}
private void Draw(RenderTarget2D input, RenderTarget2D output)
{
device.SetRenderTarget(output);
effect.Parameters["Resolution"].SetValue(new Vector2(output.Width, output.Height));
effect.Parameters["SourceResolution"].SetValue(new Vector2(input.Width, input.Height));
effect.Parameters["Texture"].SetValue(input);
quad.Draw(effect);
}
/// <inheritdoc />
public override void Draw(GameTime gameTime)
{
Game.Background = Color.Black;
GraphicsDevice.DepthStencilState = DepthStencilState.None;
GraphicsDevice.BlendState = BlendState.Opaque;
Effect.Parameters["Time"]?.SetValue((float)gameTime.TotalGameTime.TotalSeconds);
Quad.Draw(Effect);
base.Draw(gameTime);
}
/// <inheritdoc />
public override void Draw(GameTime gameTime)
{
// Calculate the ViewProjection matrix
var viewProjection = Camera.View * Camera.Projection;
// Draw the Robot
Robot.Draw(RobotWorld, Camera.View, Camera.Projection);
// Set the WorldViewProjection and Texture for the Floor and draw it
TilingEffect.Parameters["WorldViewProjection"].SetValue(FloorWorld * viewProjection);
TilingEffect.Parameters["Texture"].SetValue(FloorTexture);
Quad.Draw(TilingEffect);
// Draw each Wall
// First, set the Wall Texture
TilingEffect.Parameters["Texture"].SetValue(WallTexture);
for (int index = 0; index < WallWorldMatrices.Length - 1; index++)
{
// Set the WorldViewProjection matrix for each Wall
TilingEffect.Parameters["WorldViewProjection"].SetValue(WallWorldMatrices[index] * viewProjection);
// Draw the Wall
Quad.Draw(TilingEffect);
}
// Draw the traversing Wall
// For this, disable Back-Face Culling as we want to draw both sides of the Quad
// Save the past RasterizerState
var rasterizerState = GraphicsDevice.RasterizerState;
// Use a RasterizerState which has Back-Face Culling disabled
GraphicsDevice.RasterizerState = RasterizerState.CullNone;
// Set the WorldViewProjection matrix and draw the Wall
TilingEffect.Parameters["WorldViewProjection"].SetValue(WallWorldMatrices[WallWorldMatrices.Length - 1] * viewProjection);
Quad.Draw(TilingEffect);
// Restore the old RasterizerState
GraphicsDevice.RasterizerState = rasterizerState;
// Draw Gizmos for Bounding Boxes and Robot Cylinder
for (int index = 0; index < WallBoxes.Length; index++)
{
var box = WallBoxes[index];
var center = BoundingVolumesExtensions.GetCenter(box);
var extents = BoundingVolumesExtensions.GetExtents(box);
Game.Gizmos.DrawCube(center, extents * 2f, Color.Red);
}
Game.Gizmos.DrawCylinder(RobotCylinder.Transform, Color.Yellow);
base.Draw(gameTime);
}
/// <inheritdoc />
public override void Draw(GameTime gameTime)
{
Game.Background = Color.CornflowerBlue;
GraphicsDevice.DepthStencilState = DepthStencilState.Default;
AxisLines.Draw(Camera.View, Camera.Projection);
Box.Draw(Matrix.CreateRotationY(BoxRotation) * BoxWorld, Camera.View, Camera.Projection);
Quad.Draw(QuadWorld, Camera.View, Camera.Projection);
base.Draw(gameTime);
}
protected override void OnDraw(FrameArgs e)
{
base.OnDraw(e);
using (_cam.Begin()) { // using the camera...
// ... draw the quad
// it will use the material we passed the constructor, but we
// also could have put it in scope manually with _mat.Begin()
// alternatively, put a different material in scope to override
_quad.Draw(ref _world);
}
}
protected override void OnDraw(FrameArgs e)
{
base.OnDraw(e);
using (_cam.Begin()) { // using the camera...
// ... draw the quads
foreach (var pos in _markers)
{
_quad.Draw(Matrix4.CreateTranslation(pos));
}
}
}
public static void RestoreDepth(Renderer renderer, Quad quad, Material restoreDepth, bool clearDepth = true)
{
// work arround for a bug in xna 4.0
renderer.Device.SamplerStates[0] = SamplerState.LinearClamp;
renderer.Device.SamplerStates[0] = SamplerState.PointClamp;
if (clearDepth)
renderer.Device.Clear(ClearOptions.DepthBuffer, Color.Transparent, 1, 0);
renderer.Device.DepthStencilState = DepthStencilState.Default;
renderer.Device.BlendState = BlendState.Additive;
quad.Draw(restoreDepth, renderer.Data);
}
protected virtual void OnComposeScenes(FrameArgs e, Texture prevTexture, Texture nextTexture, float t)
{
using (_cam.Begin()) {
var origColor = ClearColor;
ClearColor = System.Drawing.Color.Black;
base.OnDraw(e);
ClearColor = origColor;
_mat.Texture = prevTexture;
_mat.Color = Vector4.One;
using (_mat.Begin()) {
_quad.Draw(0, 0, 0);
}
if (_t > 0)
{
_mat.Texture = nextTexture;
_mat.Color = new Vector4(t, t, t, t);
using (_mat.Begin()) {
_quad.Draw(0, 0, 1);
}
}
}
}
public override void Draw(Renderer renderer)
{
// work arround for a bug in xna 4.0
renderer.Device.SamplerStates[0] = SamplerState.LinearClamp;
renderer.Device.SamplerStates[0] = SamplerState.PointClamp;
if (ClearDepth)
{
renderer.Device.Clear(ClearOptions.DepthBuffer, Color.Transparent, 1, 0);
}
renderer.Device.DepthStencilState = DepthStencilState.Default;
renderer.Device.BlendState = BlendState.Additive;
quad.Draw(restoreDepth, renderer.Data);
}
private void RenderWithoutDof(float dt)
{
RenderColorRenderTarget(dt);
Platform.Instance.Device.BlendState = BlendState.Opaque;
Platform.Instance.Device.RasterizerState = RasterizerState.CullCounterClockwise;
Quad scquad = GetScreenQuad();
Material dof = Renderer.Instance.GetBlurMaterial();
dof.SetParameter("ColorMap", _color);
scquad.Draw(dof);
Renderer.Instance.CurrentFrame = _color;
Renderer.Instance.LastFrame = Renderer.Instance.CurrentFrame;
}
public void Draw(Renderer renderer)
{
var metadata = renderer.Data;
var device = renderer.Device;
var part = geometry.Meshes[0].MeshParts[0];
device.SetVertexBuffer(part.VertexBuffer);
device.Indices = part.IndexBuffer;
DrawGeometryLights(touchesFarPlane, metadata, device);
device.DepthStencilState = depthGreater;
device.RasterizerState = RasterizerState.CullClockwise;
DrawGeometryLights(touchesNearPlane, metadata, device);
DrawGeometryLights(touchesNeitherPlane, metadata, device);
//foreach (var light in touchesNeitherPlane)
//{
// device.DepthStencilState = stencilWritePass;
// device.RasterizerState = RasterizerState.CullNone;
// device.BlendState = colourWriteDisable;
// device.Clear(ClearOptions.Stencil, Color.Transparent, 0, 0);
// SetupLight(metadata, null, light);
// DrawGeomery(nothingMaterial, metadata, device);
// device.DepthStencilState = stencilCheckPass;
// device.RasterizerState = RasterizerState.CullCounterClockwise;
// device.BlendState = BlendState.Additive;
// DrawGeomery(geometryLightingMaterial, metadata, device);
//}
device.DepthStencilState = DepthStencilState.None;
device.RasterizerState = RasterizerState.CullCounterClockwise;
foreach (var light in touchesBothPlanes)
{
SetupLight(metadata, quadLightingMaterial, light);
quad.Draw(quadLightingMaterial, metadata);
}
}
public override void Draw(Renderer renderer)
{
var metadata = renderer.Data;
var device = renderer.Device;
var resolution = metadata.Get <Vector2>("resolution").Value;
var width = (int)resolution.X;
var height = (int)resolution.Y;
var target = RenderTargetManager.GetTarget(device, width, height, SurfaceFormat.Color, DepthFormat.None, name: "edges");
device.SetRenderTarget(target);
device.BlendState = BlendState.Opaque;
device.Clear(Color.Black);
edgeDetect.Parameters["TexelSize"].SetValue(new Vector2(1f / width, 1f / height));
quad.Draw(edgeDetect, metadata);
Output("edges", target);
}
private void RenderDepth(float dt)
{
Platform.Instance.Device.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.DarkSlateBlue, 1.0f, 0);
RenderDepthRenderTarget(dt);
RenderColorRenderTarget(dt);
Platform.Instance.Device.BlendState = new BlendState();
Platform.Instance.Device.RasterizerState = RasterizerState.CullCounterClockwise;
Quad scquad = GetScreenQuad();
Material dof = Renderer.Instance.GetDepthOfFieldMaterial();
dof.SetParameter("matWorldViewProj", Matrix.Identity);
dof.SetParameter("ColorMap", _color);
dof.SetParameter("DepthMap", _depth);
scquad.Draw(dof);
Renderer.Instance.LastFrame = Renderer.Instance.CurrentFrame;
}
public void Draw(Renderer renderer)
{
var metadata = renderer.Data;
var view = metadata.Get <Matrix>("view").Value;
var ssao = metadata.Get <Texture2D>("ssao").Value;
if (ssao != null)
{
lightingMaterial.CurrentTechnique = lightingMaterial.Techniques["AmbientSSAO"];
}
else
{
lightingMaterial.CurrentTechnique = lightingMaterial.Techniques["Ambient"];
}
foreach (var light in Behaviours)
{
lightingMaterial.Parameters["Up"].SetValue(Vector3.TransformNormal(light.Up, view));
lightingMaterial.Parameters["SkyColour"].SetValue(light.SkyColour);
lightingMaterial.Parameters["GroundColour"].SetValue(light.GroundColour);
quad.Draw(lightingMaterial, metadata);
}
}
public override void Draw(Microsoft.Xna.Framework.GameTime gameTime)
{
quad.Draw(material, metadata);
base.Draw(gameTime);
}
public void draw()
{
quad.Draw(Global.gameTime, scale * rotation * translation, Global.CurrentCamera.view, Global.CurrentCamera.projection);
}
void DrawPong(float dt, float betweenFrameAlpha)
{
GameManager.GraphicsDevice.SetRenderTarget(_pongRenderTarget);
Matrix center = Matrix.CreateTranslation(_pongRenderTarget.Bounds.Width / 2,
_pongRenderTarget.Bounds.Height / 2,
0);
_renderSystem.DrawEntities(center,
Constants.Pong.RENDER_GROUP,
dt,
betweenFrameAlpha);
_renderSystem.SpriteBatch.Begin(SpriteSortMode.Deferred,
null,
null,
null,
null,
null,
center);
VelocityParticleManager.Draw(_renderSystem.SpriteBatch);
_renderSystem.SpriteBatch.Draw(Content.Load <Texture2D>(Constants.Resources.TEXTURE_PONG_EDGE),
new Vector2(0, Constants.Pong.PLAYFIELD_HEIGHT / 2
+ Constants.Pong.EDGE_HEIGHT
+ 100 / 2),
null,
null,
new Vector2(0.5f, 0.5f),
0,
new Vector2(Constants.Pong.PLAYFIELD_WIDTH,
100),
Color.Black,
SpriteEffects.None,
0);
_renderSystem.SpriteBatch.Draw(Content.Load <Texture2D>(Constants.Resources.TEXTURE_PONG_EDGE),
new Vector2(0, -(Constants.Pong.PLAYFIELD_HEIGHT / 2
+ Constants.Pong.EDGE_HEIGHT
+ 100 / 2)),
null,
null,
new Vector2(0.5f, 0.5f),
0,
new Vector2(Constants.Pong.PLAYFIELD_WIDTH,
100),
Color.Black,
SpriteEffects.None,
0);
_renderSystem.SpriteBatch.End();
GameManager.GraphicsDevice.SetRenderTarget(null);
_quadEffect.View = _pongCamera.TransformMatrix;
_quadEffect.Projection = _pongCamera.PerspectiveMatrix;
_quadEffect.Texture = _pongRenderTarget;
PongPostProcessor.Begin();
foreach (EffectPass pass in _quadEffect.CurrentTechnique.Passes)
{
pass.Apply();
_quad.Draw(GameManager.GraphicsDevice);
}
RenderTarget2D processedPongRender = PongPostProcessor.End(false);
_renderSystem.SpriteBatch.Begin(SpriteSortMode.Deferred,
null,
null,
null,
null,
null,
_mainCamera.TransformMatrix);
_renderSystem.SpriteBatch.Draw(processedPongRender, new Rectangle((int)(processedPongRender.Bounds.X - processedPongRender.Bounds.Width / 2 + Constants.Pong.BUFFER_RENDER_POSITION.X),
(int)(processedPongRender.Bounds.Y - processedPongRender.Bounds.Height / 2 + Constants.Pong.BUFFER_RENDER_POSITION.Y),
processedPongRender.Bounds.Width,
processedPongRender.Bounds.Height), Color.White);
_renderSystem.SpriteBatch.End();
}
internal static void PerformLightingPass(Renderer renderer, bool ssao, Quad quad, Material restoreDepth, Material copyTexture, IReadOnlyList<IDirectLight> directLights, IReadOnlyList<IIndirectLight> indirectLights, out RenderTarget2D directLightBuffer, out RenderTarget2D indirectLightBuffer)
{
//Get some handy objects
var device = renderer.Device;
var resolution = renderer.Data.GetValue(new TypedName<Vector2>("resolution"));
var width = (int)resolution.X;
var height = (int)resolution.Y;
//Enable or disable SSAO
renderer.Data.Set("ssao", ssao);
// prepare direct lights
for (int i = 0; i < directLights.Count; i++)
directLights[i].Prepare(renderer);
// set and clear direct light buffer
directLightBuffer = RenderTargetManager.GetTarget(device, width, height, SurfaceFormat.HdrBlendable, DepthFormat.Depth24Stencil8);
device.SetRenderTarget(directLightBuffer);
device.Clear(Color.Transparent);
// work around for a bug in xna 4.0
renderer.Device.SamplerStates[0] = SamplerState.LinearClamp;
renderer.Device.SamplerStates[0] = SamplerState.PointClamp;
// set render states to draw opaque geometry
device.BlendState = BlendState.Opaque;
device.DepthStencilState = DepthStencilState.Default;
// restore depth
quad.Draw(restoreDepth, renderer.Data);
// set render states to additive blend
device.BlendState = BlendState.Additive;
// draw direct lights
foreach (IDirectLight light in directLights)
light.Draw(renderer);
// prepare indirect lights
for (int i = 0; i < indirectLights.Count; i++)
indirectLights[i].Prepare(renderer);
// set and clear indirect light buffer
indirectLightBuffer = RenderTargetManager.GetTarget(device, width, height, SurfaceFormat.HdrBlendable, DepthFormat.Depth24Stencil8);
device.SetRenderTarget(indirectLightBuffer);
device.Clear(Color.Transparent);
//draw indirect lights
foreach (IIndirectLight light in indirectLights)
light.Draw(renderer);
// blend direct lighting into the indirect light buffer
copyTexture.Parameters["Texture"].SetValue(directLightBuffer);
quad.Draw(copyTexture, renderer.Data);
}
