public void Render(SpriteBatch spriteBatch, GraphicsDevice Device)
{
Device.SetRenderTarget(this.rt2d);
Device.Clear(Color.Transparent);
spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.Default, null, null);
foreach (Enemy x in this.lxEnemies)
{
x.xRenderComponent.Render(spriteBatch);
}
foreach (RenderComponent x2 in this.lxRenderComponents)
{
x2.Render(spriteBatch);
}
spriteBatch.End();
Device.SetRenderTarget(null);
if (this.iFramesToRender > 0 && this.iFramesRendered < this.iFramesToRender && this.iCounter % this.iRenderStep == 0)
{
if (!Directory.Exists("../Slashas"))
{
Directory.CreateDirectory("../Slashas");
}
FileStream mos = new FileStream("../Slashas/0" + this.iFramesRendered + ".png", FileMode.Create, FileAccess.Write);
this.rt2d.SaveAsPng(mos, this.rt2d.Width, this.rt2d.Height);
mos.Close();
this.iFramesRendered++;
if (this.iFramesRendered == this.iFramesToRender)
{
this.iFramesToRender = 0;
}
}
}
protected override void Initialize()
{
graphics.IsFullScreen = false;
graphics.PreferredBackBufferWidth = width;
graphics.PreferredBackBufferHeight = height;
graphics.ApplyChanges();
Window.Title = "Exercise I.7";
this.IsMouseVisible = true;
spriteBatch = new SpriteBatch(GraphicsDevice);
device = graphics.GraphicsDevice;
rt = new RenderTarget2D(GraphicsDevice,
width,
height,
false,
device.PresentationParameters.BackBufferFormat,
DepthFormat.Depth24,
0,
RenderTargetUsage.PreserveContents);
device.SetRenderTarget(rt);
device.Clear(Color.Black);
device.SetRenderTarget(null);
Drawing.init(device, spriteBatch);
Stats.init();
w = new Walker(width, height);
base.Initialize();
}
public void addarea(int left, int top, int width, int height,GraphicsDevice device,SpriteBatch batch)
{
for (int I = left; I < left + width; I++)
{
for (int J = top; J < top + height; J++)
{
tilearray[I, J] = new tile();
}
}
RenderTarget2D target = new RenderTarget2D(device, 4096, 4096);
device.SetRenderTarget(target);
device.Clear(Color.Transparent);
batch.Begin();
for (int X = 0; X < 256; X++)
{
for (int Y = 0; Y < 256; Y++)
{
if (tilearray[X, Y] != null)
{
batch.Draw(tiletexture, new Vector2(X*8, Y*8), Color.White);
}
}
}
batch.End();
tileoverlay = (Texture2D)target;
device.SetRenderTarget(null);
device.Clear(Color.CornflowerBlue);
}
public static Texture2D FromText(string text, SpriteFont font, Color color, Size size, bool multiLine, int lineStart, GraphicsDevice device)
{
string[] drawAbleText = multiLine ? text.Split(new string[1] { "\n" }, StringSplitOptions.None) : new string[1] { text };
RenderTarget2D target = new RenderTarget2D(device, size.Width, size.Height);
SpriteBatch sb = new SpriteBatch(device);
device.SetRenderTarget(target);
device.Clear(Color.Transparent);
sb.Begin();
for (int i = lineStart; i < drawAbleText.Length; i++)
{
float y = 1 + (i - lineStart) * font.GetHeight();
sb.DrawString(font, drawAbleText[i], new Vector2(1, y), color, 0f, Vector2.Zero, Vector2.One, SpriteEffects.None, 0f);
}
sb.End();
device.SetRenderTarget(null);
Texture2D texture = new Texture2D(device, size.Width, size.Height);
Color[] colorData = target.GetColorData();
texture.SetData(colorData);
target.Dispose();
sb.Dispose();
return texture;
}
public TextureAtlasAsset CreateTextureAtlasAsset(
string name,
GraphicsDevice graphicsDevice,
IEnumerable<TextureAsset> textures)
{
if (name == null) throw new ArgumentNullException("name");
if (graphicsDevice == null) throw new ArgumentNullException("graphicsDevice");
if (textures == null) throw new ArgumentNullException("textures");
var textureArray = textures.ToArray();
var size = this.CalculateSizeForTextures(textureArray);
var mappings = new Dictionary<string, Rectangle>();
var renderTarget = new RenderTarget2D(graphicsDevice, (int)size.X, (int)size.Y);
try
{
var x = 0;
var y = 0;
graphicsDevice.SetRenderTarget(renderTarget);
graphicsDevice.Clear(Color.Transparent);
using (var spriteBatch = new SpriteBatch(graphicsDevice))
{
spriteBatch.Begin();
foreach (var texture in textureArray)
{
if (texture.Texture.Width == 16 ||
texture.Texture.Height == 16)
{
spriteBatch.Draw(texture.Texture, new Vector2(x, y));
mappings.Add(texture.Name, new Rectangle(x, y, 16, 16));
x += 16;
if (x >= size.X)
{
x = 0;
y += 16;
}
}
}
spriteBatch.End();
}
}
catch (InvalidOperationException)
{
}
graphicsDevice.SetRenderTarget(null);
graphicsDevice.BlendState = BlendState.Opaque;
graphicsDevice.DepthStencilState = DepthStencilState.Default;
graphicsDevice.SamplerStates[0] = SamplerState.LinearWrap;
graphicsDevice.RasterizerState = RasterizerState.CullCounterClockwise;
return new TextureAtlasAsset(
name,
renderTarget,
mappings);
}
private Texture2D CreateBackground(GraphicsDevice gd, SpriteBatch sb, ContentManager cm)
{
RenderTarget2D target = new RenderTarget2D(gd, 2048, 2048);
//tell the GraphicsDevice we want to render to the gamesMenu rendertarget (an in-memory buffer)
gd.SetRenderTarget(target);
//clear the background
gd.Clear(Color.Transparent);
//begin drawing
sb.Begin();
for (int x = 0; x < 8; x++)
{
for (int y = 0; y < 8; y++)
{
sb.Draw(cm.Load<Texture2D>("Backgrounds/" + _level.ToString()), new Vector2(x * 400, y * 256), Color.White);
}
}
sb.End();
//reset the GraphicsDevice to draw on the backbuffer (directly to the backbuffer)
gd.SetRenderTarget(null);
return (Texture2D)target;
}
private void AccumulateLights(IEnumerable<ILightProvider> lights, SpriteBatch sb, GraphicsDevice graphicsDevice)
{
graphicsDevice.SetRenderTarget(_accumulatorRT);
graphicsDevice.Clear(Color.Black);
foreach (var light in lights)
{
sb.Begin(SpriteSortMode.Immediate, BlendState.Additive, SamplerState.LinearClamp, DepthStencilState.None, RasterizerState.CullCounterClockwise, _lightAccumulatorFX, GameVariables.CameraZoomMatrix);
var normalizedPosition = new Vector2(light.Position.X / _accumulatorRT.Width,
light.Position.Y / _accumulatorRT.Height);
_lightAccumulatorFX.Parameters["lightPosition"].SetValue(normalizedPosition);
_lightAccumulatorFX.Parameters["lightRadius"].SetValue(light.LightRadius);
_lightAccumulatorFX.Parameters["lightIntensity"].SetValue(light.LightIntensity);
sb.Draw(_screenTex, new Rectangle(0, 0, _accumulatorRT.Width, _accumulatorRT.Height), Color.White);
sb.End();
}
graphicsDevice.SetRenderTarget(null);
//if (lights.Any())
//{
// using (var stream = new FileStream("output.png", FileMode.OpenOrCreate))
// {
// _accumulatorRT.SaveAsPng(stream, _accumulatorRT.Width, _accumulatorRT.Height);
// }
//}
}
private Texture2D CreateBackground(GraphicsDevice graphics, SpriteBatch spriteBatch, ContentManager Content)
{
RenderTarget2D target = new RenderTarget2D(graphics, 2048, 2048);
//tell the GraphicsDevice we want to render to the gamesMenu rendertarget (an in-memory buffer)
graphics.SetRenderTarget(target);
//clear the background
graphics.Clear(Color.Transparent);
//begin drawing
spriteBatch.Begin();
for (int x = 0; x < 8; x++)
{
for (int y = 0; y < 8; y++)
{
spriteBatch.Draw(Content.Load<Texture2D>("starBackground"), new Vector2(x * 256, y * 256), Color.White);
}
}
spriteBatch.End();
//reset the GraphicsDevice to draw on the backbuffer (directly to the backbuffer)
graphics.SetRenderTarget(null);
return target;
}
public LineRenderer(GraphicsDevice p_gd, ContentManager p_content)
{
m_lineTexture = new RenderTarget2D(p_gd, 1, 1);
p_gd.SetRenderTarget(m_lineTexture);
p_gd.Clear(Color.White);
p_gd.SetRenderTarget(null);
m_aalineTexture = p_content.Load<Texture2D>("aaline");
}
public LineRenderer(GraphicsDevice graphicsDevice)
{
lineTexture = new RenderTarget2D(graphicsDevice, 2, 3);
graphicsDevice.SetRenderTarget(lineTexture);
graphicsDevice.Clear(Color.White);
graphicsDevice.SetRenderTarget(null);
}
//Sam was here
//Do not use unless you plan on doing pixel perfect collision (I don't think we will but just in case)
public Texture2D GetTexture(GraphicsDevice graphicsDevice, SpriteBatch spriteBatch)
{
RenderTarget2D renderTarget = new RenderTarget2D(graphicsDevice, frameWidth, frameHeight);
graphicsDevice.SetRenderTarget(renderTarget);
graphicsDevice.Clear(new Color(0, 0, 0, 0));
spriteBatch.Begin();
Draw(spriteBatch, new Rectangle(0, 0, frameWidth, frameHeight));
spriteBatch.End();
graphicsDevice.SetRenderTarget(null);
return renderTarget;
}
public Bar(Texture2D texture, Vector2 position,GraphicsDevice graphicsDevice)
: base(texture, new Vector2(-100,-100), Microsoft.Xna.Framework.Color.White, 0.0f, Vector2.Zero, Vector2.One, SpriteEffects.None, 0.0f)
{
rt2d = new RenderTarget2D(graphicsDevice, texture.Width - 1, texture.Height - 1);
graphicsDevice.SetRenderTarget(rt2d);
graphicsDevice.Clear(Microsoft.Xna.Framework.Color.Red);
graphicsDevice.SetRenderTarget(null);
metervalue = 1;
barmeter = new Microsoft.Xna.Framework.Rectangle((int)position.X, (int)position.Y, 0, (int)texture.Height - 2);
width = texture.Width - 2;
}
public void GenerateShadow(Texture2D shadowmap, SpriteBatch spriteBatch,GraphicsDevice graphicsDevice,List<Effect>EffectList)
{
#region Snatch texture
graphicsDevice.SetRenderTarget(area);
spriteBatch.Begin(SpriteSortMode.Immediate,BlendState.Opaque);
graphicsDevice.Clear(Color.White);
spriteBatch.Draw(shadowmap,
new Rectangle(0, 0, range * 2, range * 2),
RenderArea,
Color.White);
#endregion
#region Calculate Fade
graphicsDevice.SetRenderTarget(output[1]);
EffectList[1].CurrentTechnique.Passes[0].Apply();
spriteBatch.Draw(area, new Rectangle(0, 0, range * 2, range * 2), Color.White);
#endregion
#region Calculate Distorted
graphicsDevice.SetRenderTarget(output[0]);
EffectList[0].CurrentTechnique.Passes[0].Apply();
spriteBatch.Draw(output[1], new Rectangle(0, 0, range * 2, range * 2), Color.White);
#endregion
#region Horizontal Reduction
int order = 0;
//represents the order of the power of 2 used in the reduction
//first pass of the lap makes the pixel the min of itself and the pixel near it (2^0)
//second pass makes the pixel the min of itself and the one two pixels to the right
// and so on until 2^order>range
EffectList[2].Parameters["range"].SetValue(range);
EffectList[2].CurrentTechnique.Passes[0].Apply();
while (Math.Pow(2, order) <= range)
{
graphicsDevice.SetRenderTarget(output[(order + 1) ]);
EffectList[2].Parameters["order"].SetValue((float)(Math.Pow(2, order)) / (range * 2));
spriteBatch.Draw(output[order ], new Rectangle(0, 0, range * 2, range * 2), Color.White);
EffectList[2].CurrentTechnique.Passes[0].Apply();
order++;
}
#endregion
#region Shadow Resolve
graphicsDevice.SetRenderTarget(area);
EffectList[3].CurrentTechnique.Passes[0].Apply();
spriteBatch.Draw(output[order ], new Rectangle(0, 0, range * 2, range * 2), Color.White);
#endregion region Shadow Resolve
spriteBatch.End();
graphicsDevice.SetRenderTarget(null);
}
public static Texture2D FromLabels(KeyValuePair<string, Color>[] labels, SpriteFont font, Size size, GraphicsDevice device)
{
RenderTarget2D target = new RenderTarget2D(device, size.Width, size.Height);
SpriteBatch sb = new SpriteBatch(device);
device.SetRenderTarget(target);
device.Clear(Color.Transparent);
sb.Begin();
for (int i = 0; i < labels.Length; i++)
{
string prevString = string.Join(" ", labels.Select(l => l.Key).ToArray(), 0, i);
if (i > 0) prevString += " ";
float x = 1 + font.MeasureString(prevString).X;
sb.DrawString(font, labels[i].Key, new Vector2(x, 1), labels[i].Value, 0f, Vector2.Zero, Vector2.One, SpriteEffects.None, 0f);
}
sb.End();
device.SetRenderTarget(null);
Texture2D texture = new Texture2D(device, size.Width, size.Height);
Color[] colorData = target.GetColorData();
texture.SetData(colorData);
target.Dispose();
return texture;
}
public void DrawReflectionMap(GraphicsDevice device, GameTime gameTime)
{
UpdateReflectionViewMatrix(DisplayController.Camera);
Vector4 reflectionPlane = CreatePlane(terrainWater.WaterHeight, new Vector3(0, -1, 0), true);
device.SetRenderTarget(terrainWater.ReflectionRenderTarget);
device.Clear(ClearOptions.Target, Color.Black, 1.0f, 0);
terrainWater.Board.GetDrawer().Draw(device, gameTime, reflectionPlane);
Matrix cameraMatrix = DisplayController.Camera.CameraMatrix;
DisplayController.Camera.CameraMatrix = terrainWater.ReflectionViewMatrix;
foreach (GameObject o in terrainWater.MissionController.GetMissionObjects())
{
o.GetDrawer().Draw(device, gameTime, reflectionPlane);
}
DisplayController.Camera.CameraMatrix = cameraMatrix;
terrainWater.ReflectionMap = terrainWater.ReflectionRenderTarget;
/*using (FileStream fileStream = File.OpenWrite("reflectionmap.jpg"))
{
terrainWater.ReflectionMap.SaveAsJpeg(fileStream, terrainWater.ReflectionMap.Width, terrainWater.ReflectionMap.Height);
fileStream.Close();
}*/
}
public static void ResolveRenderTarger(GraphicsDevice device)
{
device.SetRenderTarget(null);
miniMap = minimap;
Camera.upDownRot = MathHelper.ToRadians(-45);
Camera.cameraPosition = new Vector3(30, 80, 100);
}
public static RenderTarget2D GenerateShadows(RenderTarget2D shadowCaster,SpriteBatch spriteBatch,GraphicsDevice graphicsDevice)
{
foreach (LightSource CurrentLight in LightList)
{
if (CurrentLight.distance < 1000)
{
CurrentLight.GenerateShadow(shadowCaster, spriteBatch, graphicsDevice, ShadowEffectList);
}
}
graphicsDevice.SetRenderTarget(shadowMap);
graphicsDevice.Clear(Color.Transparent);
spriteBatch.Begin(SpriteSortMode.Immediate,BlendState.NonPremultiplied);
//draw every small shadow map to the bigger one
TestClass.DebugFrame.debugText += "Number of lights:" + LightList.Count().ToString()+"\n";
foreach (LightSource CurrentLight in LightList)
{
spriteBatch.Draw(CurrentLight.area,
CurrentLight.RenderArea,
Color.White);
}
spriteBatch.End();
return shadowMap;
}
public void PreRender(SpriteBatch spriteBatch, GraphicsDevice graphics)
{
graphics.SetRenderTarget(this.rt2dOverlay);
graphics.Clear(Color.Transparent);
Vector2 v2PlayerRenderedAt = Utility.Vector2_ToInts(this.xTransform.v2Pos + this.v2OffsetRenderPos) - Utility.Vector2_ToInts(this.xCamera.v2TopLeft * this.v2ParallaxFactor);
v2PlayerRenderedAt.Y -= 8f;
float fScale = this.xWatcher.fRadius / 200f;
int iRadiusInInts = (int)(100f * fScale);
spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.Default, null, null);
spriteBatch.Draw(this.txBlindWindow, v2PlayerRenderedAt, null, this.cColor, this.fRotation, new Vector2(100f, 100f), fScale, this.enSpriteEffect, 0f);
if (v2PlayerRenderedAt.Y - (float)iRadiusInInts >= 0f)
{
spriteBatch.Draw(RenderMaster.txNoTex, new Rectangle(0, 0, 640, (int)v2PlayerRenderedAt.Y - iRadiusInInts), Color.Black);
}
if (360 - ((int)v2PlayerRenderedAt.Y - iRadiusInInts) > 0)
{
spriteBatch.Draw(RenderMaster.txNoTex, new Rectangle(0, (int)v2PlayerRenderedAt.Y + iRadiusInInts, 640, 360 - ((int)v2PlayerRenderedAt.Y - iRadiusInInts)), Color.Black);
}
if ((int)v2PlayerRenderedAt.X - iRadiusInInts > 0)
{
spriteBatch.Draw(RenderMaster.txNoTex, new Rectangle(0, (int)v2PlayerRenderedAt.Y - iRadiusInInts, (int)v2PlayerRenderedAt.X - iRadiusInInts, iRadiusInInts * 2), Color.Black);
}
if ((int)v2PlayerRenderedAt.X + iRadiusInInts < 640)
{
spriteBatch.Draw(RenderMaster.txNoTex, new Rectangle((int)v2PlayerRenderedAt.X + iRadiusInInts, (int)v2PlayerRenderedAt.Y - iRadiusInInts, 640 - ((int)v2PlayerRenderedAt.X + iRadiusInInts), iRadiusInInts * 2), Color.Black);
}
spriteBatch.End();
}
public UIRenderPlane(UISpriteBatch batch, Promise<Texture2D> texture)
{
this.GD = batch.GraphicsDevice;
this.Target = batch.GetBuffer();
this.Texture = texture;
this.Batch = batch;
//GD.PresentationParameters.RenderTargetUsage = RenderTargetUsage.PreserveContents;
/** Switch the render target **/
Batch.Pause();
GD.SetRenderTarget(0, Target);
GD.Clear(Color.TransparentBlack);
Batch.Resume();
/**
batch.Pause();
var buffer = batch.GetBuffer();
var gd = GameFacade.GraphicsDevice;
var renderTarget = gd.GetRenderTarget(0);
gd.SetRenderTarget(0, buffer);
batch.Resume();
gd.render
//gd.Clear(Color.TransparentBlack);**/
}
public void DrawLightDarkness(GraphicsDevice graphicsDevice, SpriteBatch sb, RenderTarget2D sceneRt)
{
graphicsDevice.SetRenderTarget(null);
sb.Begin(SpriteSortMode.Immediate, null, null, null, null, _lightCombinerFX);
sb.Draw(_accumulatorRT, new Rectangle(0, 0, _accumulatorRT.Width, _accumulatorRT.Height), Color.White);
sb.End();
}
internal Pipeline(VGDevice device, VGSurface surface, VGState state)
{
Device = device;
Surface = surface;
State = state;
_device = device.GraphicsDevice;
_device.SetRenderTarget(surface.Target);
_device.RasterizerState = State.RasterizerState;
}
public RenderTargetOperation(RenderTarget2D renderTarget, GraphicsDevice graphicsDevice, Color backgroundColor)
{
_graphicsDevice = graphicsDevice;
_viewport = _graphicsDevice.Viewport;
_previousRenderTargetUsage = _graphicsDevice.PresentationParameters.RenderTargetUsage;
_graphicsDevice.PresentationParameters.RenderTargetUsage = RenderTargetUsage.PreserveContents;
_graphicsDevice.SetRenderTarget(renderTarget);
_graphicsDevice.Clear(backgroundColor);
}
public override void Draw(GraphicsDevice device)
{
var oldTargets = device.GetRenderTargets();
device.SetRenderTarget(Target);
device.Clear(Color.Transparent);
device.DepthStencilState = DepthStencilState.Default;
Camera.ProjectionDirty();
base.Draw(device);
device.SetRenderTargets(oldTargets);
}
public void PrintLightsOverTexture(RenderTarget2D renderTarget, SpriteBatch spriteBatch, GraphicsDevice graphics, Texture2D light, Texture2D underlyingTexture, float mixFactor0to1)
{
this.LightBlender.Parameters["MixFactor"].SetValue(mixFactor0to1);
graphics.SetRenderTarget(renderTarget);
spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.LinearClamp, null, RasterizerState.CullNone, this.LightBlender);
graphics.Textures[1] = light;
graphics.Textures[1].GraphicsDevice.SamplerStates[1] = SamplerState.LinearClamp;
spriteBatch.Draw(underlyingTexture, Vector2.Zero, Color.White);
spriteBatch.End();
}
static public Texture2D LoadTexture (GraphicsDevice device, Stream input) {
Texture2D file = Texture2D.FromStream(device, input);
// Setup a render target to hold our final texture which will have premulitplied alpha values
RenderTarget2D result = new RenderTarget2D(device, file.Width, file.Height);
device.SetRenderTarget(result);
device.Clear(Color.Black);
// Multiply each color by the source alpha, and write in just the color values into the final texture
BlendState blendColor = new BlendState();
blendColor.ColorWriteChannels = ColorWriteChannels.Red | ColorWriteChannels.Green | ColorWriteChannels.Blue;
blendColor.AlphaDestinationBlend = Blend.Zero;
blendColor.ColorDestinationBlend = Blend.Zero;
blendColor.AlphaSourceBlend = Blend.SourceAlpha;
blendColor.ColorSourceBlend = Blend.SourceAlpha;
SpriteBatch spriteBatch = new SpriteBatch(device);
spriteBatch.Begin(SpriteSortMode.Immediate, blendColor);
spriteBatch.Draw(file, file.Bounds, Color.White);
spriteBatch.End();
// Now copy over the alpha values from the PNG source texture to the final one, without multiplying them
BlendState blendAlpha = new BlendState();
blendAlpha.ColorWriteChannels = ColorWriteChannels.Alpha;
blendAlpha.AlphaDestinationBlend = Blend.Zero;
blendAlpha.ColorDestinationBlend = Blend.Zero;
blendAlpha.AlphaSourceBlend = Blend.One;
blendAlpha.ColorSourceBlend = Blend.One;
spriteBatch.Begin(SpriteSortMode.Immediate, blendAlpha);
spriteBatch.Draw(file, file.Bounds, Color.White);
spriteBatch.End();
// Release the GPU back to drawing to the screen
device.SetRenderTarget(null);
#if IOS
return result as Texture2D;
#else
// RenderTarget2D are volatile and will be lost on screen resolution changes.
// So instead of using this directly, we create a non-voliate Texture2D.
// This is computationally slower, but should be safe as long as it is done
// on load.
Texture2D resultTexture = new Texture2D(device, file.Width, file.Height);
Color[] resultContent = new Color[Convert.ToInt32(file.Width * file.Height)];
result.GetData(resultContent);
resultTexture.SetData(resultContent);
// Dispose of the RenderTarget2D immediately.
result.Dispose();
return resultTexture;
#endif
}
public void RenderEffect(Renderer renderer, GraphicsDevice device)
{
RenderTarget2D half0 = renderer.HalfDepth;
//render to a half-res buffer
device.SetRenderTarget(half0);
Apply();
device.BlendState = BlendState.Opaque;
device.DepthStencilState = DepthStencilState.None;
_quadRenderer.RenderQuad(device, -Vector2.One, Vector2.One);
}
public ToneMapComponent(GraphicsDevice device)
{
quad = new Quad(device);
var effect = Content.Load<Effect>("CalculateLuminance");
calculateLuminance = new Material(effect.Clone(), "ExtractLuminance");
adaptLuminance = new Material(effect.Clone(), "AdaptLuminance");
readLuminance = new Material(effect.Clone(), "ReadLuminance");
copyLuminance = new Material(effect.Clone(), "Copy");
toneMap = new Material(Content.Load<Effect>("ToneMap"), null);
bloom = Content.Load<Effect>("Bloom");
gaussian = new Gaussian(device);
scale = new Resample(device);
adaptedLuminance = new RenderTarget2D[2];
adaptedLuminance[0] = new RenderTarget2D(device, 1, 1, false, SurfaceFormat.Single, DepthFormat.None);
adaptedLuminance[1] = new RenderTarget2D(device, 1, 1, false, SurfaceFormat.Single, DepthFormat.None);
device.SetRenderTarget(adaptedLuminance[previous]);
device.Clear(Color.Transparent);
device.SetRenderTarget(null);
}
public void DrawLightBloomEnd(GraphicsDevice device)
{
int width = renderTarget1.Width;
int height = renderTarget1.Height;
spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Additive);
spriteBatch.Draw(previous, new Rectangle(0, 0, width, height), new Color(200, 200, 200));
spriteBatch.End();
// Pass 2: draw from rendertarget 1 into rendertarget 2,
// using a shader to apply a horizontal gaussian blur filter.
SetBlurEffectParameters(1.0f / (float)renderTarget1.Width, 0);
device.SetRenderTarget(renderTarget2);
DrawFullscreenQuad(renderTarget1, width, height, gaussianBlurEffect);
// Pass 3: draw from rendertarget 2 back into rendertarget 1,
// using a shader to apply a vertical gaussian blur filter.
SetBlurEffectParameters(0, 1.0f / (float)renderTarget1.Height);
device.SetRenderTarget(renderTarget1);
DrawFullscreenQuad(renderTarget2, width, height, gaussianBlurEffect);
// Pass 4: draw both rendertarget 1 and the original scene
// image back into the main backbuffer, using a shader that
// combines them to produce the final bloomed result.
device.SetRenderTarget(null);
previous = renderTarget2;
EffectParameterCollection parameters = bloomCombineEffect.Parameters;
parameters["BloomIntensity"].SetValue(bloomValue);
parameters["BaseIntensity"].SetValue(baseValue);
parameters["BloomSaturation"].SetValue(bloomSat);
parameters["BaseSaturation"].SetValue(baseSat);
device.Textures[1] = sceneRenderTarget;
Viewport viewport = device.Viewport;
DrawFullscreenQuad(renderTarget1, viewport.Width, viewport.Height, bloomCombineEffect);
}
// We get the destinations of our particles by drawing our font to a render target and
// reading back which pixels were set.
List<Vector2> GetParticlePositions(GraphicsDevice device, SpriteFont font, string text)
{
Vector2 size = font.MeasureString(text) + new Vector2(0.5f);
int width = (int)size.X;
int height = (int)size.Y;
// Create a temporary render target and draw the font on it.
RenderTarget2D target = new RenderTarget2D(device, width, height);
device.SetRenderTarget(target);
device.Clear(Color.Black);
SpriteBatch spriteBatch = new SpriteBatch(device);
spriteBatch.Begin();
spriteBatch.DrawString(font, text, Vector2.Zero, Color.White);
spriteBatch.End();
device.SetRenderTarget(null); // unset the render target
// read back the pixels from the render target
Color[] data = new Color[width * height];
target.GetData<Color>(data);
target.Dispose();
// Return a list of points corresponding to pixels drawn by the font. The font size will affect the number of
// points and the quality of the text.
List<Vector2> points = new List<Vector2>();
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
// Add all points that are lighter than 50% grey. The text is white, but due to anti-aliasing pixels
// on the border may be shades of grey.
if (data[width * y + x].R > 128)
points.Add(new Vector2(x, y));
}
}
return points;
}
public static Texture2D LoadTexture(GraphicsDevice device, Stream input)
{
Texture2D file = Texture2D.FromStream(device, input);
// Setup a render target to hold our final texture which will have premulitplied alpha values
RenderTarget2D result = new RenderTarget2D(device, file.Width, file.Height);
device.SetRenderTarget(result);
device.Clear(Color.Black);
// Multiply each color by the source alpha, and write in just the color values into the final texture
BlendState blendColor = new BlendState();
blendColor.ColorWriteChannels = ColorWriteChannels.Red | ColorWriteChannels.Green | ColorWriteChannels.Blue;
blendColor.AlphaDestinationBlend = Blend.Zero;
blendColor.ColorDestinationBlend = Blend.Zero;
blendColor.AlphaSourceBlend = Blend.SourceAlpha;
blendColor.ColorSourceBlend = Blend.SourceAlpha;
SpriteBatch spriteBatch = new SpriteBatch(device);
spriteBatch.Begin(SpriteSortMode.Immediate, blendColor);
spriteBatch.Draw(file, file.Bounds, Color.White);
spriteBatch.End();
// Now copy over the alpha values from the PNG source texture to the final one, without multiplying them
BlendState blendAlpha = new BlendState();
blendAlpha.ColorWriteChannels = ColorWriteChannels.Alpha;
blendAlpha.AlphaDestinationBlend = Blend.Zero;
blendAlpha.ColorDestinationBlend = Blend.Zero;
blendAlpha.AlphaSourceBlend = Blend.One;
blendAlpha.ColorSourceBlend = Blend.One;
spriteBatch.Begin(SpriteSortMode.Immediate, blendAlpha);
spriteBatch.Draw(file, file.Bounds, Color.White);
spriteBatch.End();
// Release the GPU back to drawing to the screen
device.SetRenderTarget(null);
return result as Texture2D;
}
public override void draw(
Microsoft.Xna.Framework.Graphics.SpriteBatch spriteBatch,
Microsoft.Xna.Framework.Graphics.GraphicsDevice device,
Microsoft.Xna.Framework.Graphics.RenderTarget2D[] render_targets)
{
base.draw(spriteBatch, device, render_targets);
device.SetRenderTarget(render_targets[0]);
device.Clear(Color.Transparent);
spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend);
Splash.draw(spriteBatch);
if (DisclaimerIndex < DISCLAIMERS.Length)
PreviewString.draw(spriteBatch);
BlackScreen.draw(spriteBatch);
spriteBatch.End();
}
