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);
}
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);
}
/// <summary>
/// Application initialization
/// </summary>
public override void Initialize()
{
var graphicsDevice = new GraphicsDevice()
{
DeviceDirect3D = this.deviceResources.D3DDevice,
ContextDirect3D = this.deviceResources.D3DDeviceContext,
DxgiDeviceManager = this.deviceResources.DxgiDeviceManager
};
this.Adapter = new Adapter.Adapter(this, graphicsDevice);
this.adapter = this.Adapter as Adapter.Adapter;
this.renderTargetManager = this.Adapter.Graphics.RenderTargetManager as RenderTargetManager;
this.mixedRealityService = new MixedRealityService(this);
Framework.Services.WaveServices.RegisterService(this.mixedRealityService);
Framework.Services.WaveServices.RegisterService(new SpatialInputService());
this.eyesProperties = new VREye[3];
for (int i = 0; i < 3; i++)
{
this.eyesProperties[i] = new VREye();
}
this.backBufferHandles = new Dictionary <int, VREyeTexture[]>();
}
private void DownsampleDepth(Renderer renderer, RenderTarget2D depth)
{
var downsampled = RenderTargetManager.GetTarget(renderer.Device, depth.Width / 2, depth.Height / 2, SurfaceFormat.Single, name: "downsample depth");
scale.Scale(depth, downsampled);
Output("gbuffer_depth_downsample", downsampled);
}
public void Scale(RenderTarget2D source, RenderTarget2D destination)
{
effect.CurrentTechnique = source.Format.IsFloatingPoint() ? effect.Techniques["Software"] : effect.Techniques["Hardware"];
Vector2 resolution = new Vector2(source.Width, source.Height);
float ScaleFactor = (destination.Width > source.Width) ? 2 : 0.5f;
RenderTarget2D input = source;
RenderTarget2D output = null;
while (IntermediateNeeded(resolution, destination, ScaleFactor))
{
resolution *= ScaleFactor;
output = RenderTargetManager.GetTarget(device, (int)resolution.X, (int)resolution.Y, source.Format, name: "scaled");
Draw(input, output);
if (input != source)
{
RenderTargetManager.RecycleTarget(input);
}
input = output;
}
Draw(input, destination);
if (input != source)
{
RenderTargetManager.RecycleTarget(input);
}
}
internal override void LoadContent()
{
_sceneTarget = RenderTargetManager.CreateScreenTarget();
_batch = new SpriteBatch(Controller.GraphicsDevice);
_player = Controller.Content.LoadDirect <Texture2D>("Textures/Battle/player.png");
_pokeballOpening = Controller.Content.LoadDirect <Texture2D>("Textures/Battle/pokeballOpening.png");
_fontRenderer = new PokemonFontRenderer();
_fontRenderer.LoadContent();
_battleTextbox = new Textbox();
_battleTextbox.LoadContent();
_battleTextbox.OffsetY = StartY + (int)(12 * Border.UNIT * Border.SCALE);
_enemyPokemonStatus = new EnemyPokemonStatus();
_enemyPokemonStatus.LoadContent();
_playerPokemonStatus = new PlayerPokemonStatus();
_playerPokemonStatus.LoadContent();
_playerStatus = new PlayerStatus();
_playerStatus.LoadContent();
_pokemonStats = new PokemonStats();
_pokemonStats.LoadContent();
}
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);
}
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);
}
private void InitializeGFX(IGraphicsDeviceService graphics)
{
services = new GameServiceContainer();
services.AddService <IGraphicsDeviceService>(graphics);
this.graphics = graphics.GraphicsDevice;
Content = new ContentManager(services, "Content");
spriteBatch = new SpriteBatch(graphics.GraphicsDevice);
Pixel = new Texture2D(graphics.GraphicsDevice, 1, 1);
Pixel.SetData(new[] { Color.White });
Format = new System.Globalization.NumberFormatInfo();
Format.CurrencyDecimalSeparator = ".";
Cam = new Camera2D();
Cam.Position = new Vector2(
graphics.GraphicsDevice.Viewport.Width / 2, graphics.GraphicsDevice.Viewport.Height / 2);
#if DX
InternContent = new ResourceContentManager(services, DX.Properties.Resources.ResourceManager);
GetRenderTargetManager = new RenderTargetManager(this);
AntialisingRenderTarget = GetRenderTargetManager.CreateNewRenderTarget2D("MSAA", true);
RenderTargetTimer = new Timer();
RenderTargetTimer.Interval = 500;
RenderTargetTimer.Elapsed += (sender, e) => OnRenderTargetTimeOutEnd();
#elif GL
InternContent = new ResourceContentManager(services, GL.Properties.Resources.ResourceManager);
#endif
Font = InternContent.Load <SpriteFont>("Font");
FontHeight = Font.MeasureString("A").Y;
FrameworkDispatcher.Update();
}
public void LoadContent()
{
_fontRenderer = new PokemonFontRenderer();
_fontRenderer.LoadContent();
_continueArrow = Controller.Content.LoadDirect <Texture2D>("Textures/UI/Borders/continueArrow.png");
_textTarget = RenderTargetManager.CreateRenderTarget((int)(Border.SCREEN_WIDTH * Border.UNIT * Border.SCALE), (int)(HEIGHT * Border.UNIT * Border.SCALE) - 52);
_textBatch = new SpriteBatch(Controller.GraphicsDevice);
}
protected override void LoadContent()
{
base.LoadContent();
_batch = new SpriteBatch(GraphicsDevice);
RenderTargetManager.Initialize(RENDER_WIDTH, RENDER_HEIGHT);
GetComponent <ScreenManager>().ActiveScreen?.LoadContent();
}
public BasicFbo(RenderTargetManager textureManager, Vector2I size)
{
AttachTexture(FramebufferAttachment.DepthAttachment, textureManager.Get<RenderTargetDepthTexture>(size)); // Must be first due to error checking
AttachTexture(FramebufferAttachment.ColorAttachment0, textureManager.Get<RenderTargetColorTexture>(size));
FramebufferErrorCode err = GL.CheckFramebufferStatus(FramebufferTarget.Framebuffer);
Debug.Assert(err == FramebufferErrorCode.FramebufferComplete, "Framebuffer error: " + err);
}
public RenderTargetWrapper(int width, int height, Renderer.PixelInternalFormat pixelInternalFormat, RenderTargetManager manager, RenderTarget renderTarget)
{
Width = width;
Height = height;
PixelInternalFormat = pixelInternalFormat;
Manager = manager;
RenderTarget = renderTarget;
}
public void Draw(SpriteBatch batch, Color color)
{
if (Visible)
{
var height = (int)(HEIGHT * Border.UNIT * Border.SCALE);
var width = (int)(Border.SCREEN_WIDTH * Border.UNIT * Border.SCALE);
var unit = (int)(Border.UNIT * Border.SCALE);
var startX = Controller.ClientRectangle.Width / 2 - width / 2;
var startY = OffsetY;
Border.Draw(batch, startX, startY, Border.SCREEN_WIDTH, HEIGHT, Border.SCALE, color);
var previousTargets = Controller.GraphicsDevice.GetRenderTargets();
RenderTargetManager.BeginRenderToTarget(_textTarget);
Controller.GraphicsDevice.Clear(Color.Transparent);
_textBatch.Begin(samplerState: SamplerState.PointClamp);
var lines = _text[_textIndex];
var line1 = lines[_lineIndex];
var line1Length = line1.Length;
line1 = line1.Substring(0, Math.Min(_charIndex, line1Length));
_fontRenderer.DrawText(_textBatch, line1,
new Vector2(unit, unit * 2 - 32 - _scrollValue),
Color.Black, Border.SCALE);
if (line1Length == line1.Length && lines.Length > _lineIndex + 1)
{
var line2 = lines[_lineIndex + 1];
line2 = line2.Substring(0, _charIndex - line1Length);
_fontRenderer.DrawText(_textBatch, line2,
new Vector2(unit, unit * 4 - 32 - _scrollValue),
Color.Black, Border.SCALE);
}
_textBatch.End();
Controller.GraphicsDevice.SetRenderTargets(previousTargets);
batch.Draw(_textTarget, new Vector2(0, 32) + new Vector2(startX, startY), Color.White);
// draw advance arrow
// do this when there is another text block/line
if (_arrowVisible && !_scrolling && CanAdvance() &&
(AlwaysDisplayContinueArrow || (lines.Length > _lineIndex + 2 || _text.Length > _textIndex + 1)))
{
batch.Draw(_continueArrow,
new Rectangle(startX + width - unit * 2, startY + height - unit, unit, unit),
color);
}
}
}
public BasicFboMultisample(RenderTargetManager renderTargetManager, Vector2I size, int multisampleCount)
{
MultisampleCount = multisampleCount;
AttachTexture(FramebufferAttachment.DepthAttachment, renderTargetManager.Get<RenderTargetDepthTextureMultisample>(size, multisampleCount)); // Must be first due to error checking
AttachTexture(FramebufferAttachment.ColorAttachment0, renderTargetManager.Get<RenderTargetColorTextureMultisample>(size, multisampleCount));
FramebufferErrorCode err = GL.CheckFramebufferStatus(FramebufferTarget.Framebuffer);
Debug.Assert(err == FramebufferErrorCode.FramebufferComplete, "Framebuffer error: " + err);
}
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()
{
Width = (int)resolution.X, Height = (int)resolution.Y, SurfaceFormat = SurfaceFormat.Rgba64
};
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 PostEffectManager(Common.IO.FileSystem fileSystem, Common.ResourceManager resourceManager, Backend backend, int width, int height)
{
if (fileSystem == null)
throw new ArgumentNullException("fileSystem");
if (resourceManager == null)
throw new ArgumentNullException("resourceManager");
if (backend == null)
throw new ArgumentNullException("backend");
ResourceManager = resourceManager;
Backend = backend;
RenderTargetManager = new Post.RenderTargetManager(Backend);
TemporaryRenderTargets[0] = Backend.CreateRenderTarget("post_0", new Definition(width, height, false, new List<Definition.Attachment>()
{
new Definition.Attachment(Definition.AttachmentPoint.Color, Renderer.PixelFormat.Rgba, Renderer.PixelInternalFormat.Rgba16f, Renderer.PixelType.Float, 0)
}));
TemporaryRenderTargets[1] = Backend.CreateRenderTarget("post_1", new Definition(width, height, false, new List<Definition.Attachment>()
{
new Definition.Attachment(Definition.AttachmentPoint.Color, Renderer.PixelFormat.Rgba, Renderer.PixelInternalFormat.Rgba16f, Renderer.PixelType.Float, 0)
}));
QuadMesh = Backend.CreateBatchBuffer();
QuadMesh.Begin();
QuadMesh.AddQuad(new Vector2(-1, -1), new Vector2(2, 2), Vector2.Zero, new Vector2(1, 1));
QuadMesh.End();
Sprite = Backend.CreateSpriteBatch();
// Setup effects
ScreenSpaceReflections = new Effects.ScreenSpaceReflections(Backend, ResourceManager, QuadMesh);
AdaptLuminance = new Effects.AdaptLuminance(Backend, ResourceManager, QuadMesh);
Bloom = new Effects.Bloom(Backend, ResourceManager, QuadMesh);
LensFlares = new Effects.LensFlares(Backend, ResourceManager, QuadMesh);
Tonemap = new Effects.Tonemap(Backend, ResourceManager, QuadMesh);
Gamma = new Effects.Gamma(Backend, ResourceManager, QuadMesh);
FXAA = new Effects.FXAA(Backend, ResourceManager, QuadMesh);
SMAA = new Effects.SMAA(Backend, fileSystem, ResourceManager, QuadMesh);
// Default settings
HDRSettings.KeyValue = 0.115f;
HDRSettings.AdaptationRate = 0.5f;
HDRSettings.BlurSigma = 3.0f;
HDRSettings.BloomThreshold = 9.0f;
HDRSettings.EnableBloom = true;
HDRSettings.EnableLensFlares = true;
ScreenSpaceReflectionsSettings.Enable = false;
}
public override void Draw(Renderer renderer)
{
var target = RenderTargetManager.GetTarget(renderer.Device, new RenderTargetInfo()
{
Height = 50, Width = 50
});
renderer.Device.SetRenderTarget(target);
spriteBatch.Begin();
spriteBatch.DrawString(font, "B", Vector2.Zero, Color.White);
spriteBatch.End();
Output("b", 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);
}
private void ToneMap(Renderer renderer, Box <Vector2> resolution, GraphicsDevice device, Texture2D lightBuffer)
{
var toneMapped = RenderTargetManager.GetTarget(device, (int)resolution.Value.X, (int)resolution.Value.Y, SurfaceFormat.Color, depthFormat: DepthFormat.Depth24Stencil8, name: "tone mapped");
device.SetRenderTarget(toneMapped);
device.Clear(Color.Transparent);
device.DepthStencilState = DepthStencilState.None;
device.BlendState = BlendState.Opaque;
toneMap.Parameters["Texture"].SetValue(lightBuffer);
toneMap.Parameters["Luminance"].SetValue(adaptedLuminance[current]);
toneMap.Parameters["MinExposure"].SetValue(renderer.Data.Get <float>("hdr_minexposure").Value);
toneMap.Parameters["MaxExposure"].SetValue(renderer.Data.Get <float>("hdr_maxexposure").Value);
quad.Draw(toneMap, renderer.Data);
Output("tonemapped", toneMapped);
}
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);
}
private void DrawShadowMap(Renderer renderer, LightData data)
{
var light = data.Light;
var target = RenderTargetManager.GetTarget(renderer.Device, light.ShadowResolution, light.ShadowResolution, SurfaceFormat.Single, DepthFormat.Depth24Stencil8, name: "spot light shadow map");
renderer.Device.SetRenderTarget(target);
renderer.Device.Clear(Color.Black);
var resolution = renderer.Data.Get <Vector2>("resolution");
var previousResolution = resolution.Value;
resolution.Value = new Vector2(light.ShadowResolution);
renderer.Device.DepthStencilState = DepthStencilState.Default;
renderer.Device.BlendState = BlendState.Opaque;
renderer.Device.RasterizerState = RasterizerState.CullCounterClockwise;
var view = renderer.Data.Get <View>("activeview");
var previousView = view.Value;
view.Value = shadowView;
data.View = Matrix.CreateLookAt(
light.Position,
light.Position + light.Direction,
light.Direction == Vector3.Up || light.Direction == Vector3.Down ? Vector3.Right : Vector3.Up);
data.Projection = Matrix.CreatePerspectiveFieldOfView(light.Angle, 1, 1, light.Range);
shadowView.Camera.View = data.View;
shadowView.Camera.Projection = data.Projection;
shadowView.Camera.NearClip = 1;
shadowView.Camera.FarClip = light.Range;
shadowView.Viewport = new Viewport(0, 0, light.ShadowResolution, light.ShadowResolution);
shadowView.SetMetadata(renderer.Data);
foreach (var item in renderer.Scene.FindManagers <IGeometryProvider>())
{
item.Draw("shadows_viewlength", renderer.Data);
}
data.ShadowMap = target;
resolution.Value = previousResolution;
previousView.SetMetadata(renderer.Data);
view.Value = previousView;
}
private void Bloom(Renderer renderer, Box <Vector2> resolution, GraphicsDevice device, Texture2D lightBuffer)
{
var screenResolution = resolution.Value;
var halfResolution = screenResolution / 2;
var quarterResolution = halfResolution / 2;
// downsample the light buffer to half resolution, and threshold at the same time
var thresholded = RenderTargetManager.GetTarget(device, (int)halfResolution.X, (int)halfResolution.Y, SurfaceFormat.Rgba64, name: "bloom thresholded");
device.SetRenderTarget(thresholded);
bloom.Parameters["Resolution"].SetValue(halfResolution);
bloom.Parameters["Threshold"].SetValue(renderer.Data.Get <float>("hdr_bloomthreshold").Value);
bloom.Parameters["MinExposure"].SetValue(renderer.Data.Get <float>("hdr_minexposure").Value);
bloom.Parameters["MaxExposure"].SetValue(renderer.Data.Get <float>("hdr_maxexposure").Value);
bloom.Parameters["Texture"].SetValue(lightBuffer);
bloom.Parameters["Luminance"].SetValue(adaptedLuminance[current]);
bloom.CurrentTechnique = bloom.Techniques["ThresholdDownsample2X"];
quad.Draw(bloom);
// downsample again to quarter resolution
var downsample = RenderTargetManager.GetTarget(device, (int)quarterResolution.X, (int)quarterResolution.Y, SurfaceFormat.Rgba64, name: "bloom downsampled");
device.SetRenderTarget(downsample);
bloom.Parameters["Resolution"].SetValue(quarterResolution);
bloom.Parameters["Texture"].SetValue(thresholded);
bloom.CurrentTechnique = bloom.Techniques["Scale"];
quad.Draw(bloom);
// blur the target
var blurred = RenderTargetManager.GetTarget(device, (int)quarterResolution.X, (int)quarterResolution.Y, SurfaceFormat.Rgba64, name: "bloom blurred");
gaussian.Blur(downsample, blurred, renderer.Data.Get <float>("hdr_bloomblurammount").Value);
// upscale back to half resolution
device.SetRenderTarget(thresholded);
bloom.Parameters["Resolution"].SetValue(halfResolution);
bloom.Parameters["Texture"].SetValue(blurred);
quad.Draw(bloom);
// output result
Output("bloom", thresholded);
// cleanup temp render targets
RenderTargetManager.RecycleTarget(downsample);
RenderTargetManager.RecycleTarget(blurred);
}
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 override void Draw(Renderer renderer)
{
var metadata = renderer.Data;
var resolution = renderer.Data.Get <Vector2>("resolution").Value;
var targetInfo = new RenderTargetInfo()
{
Width = (int)resolution.X, Height = (int)resolution.Y, SurfaceFormat = SurfaceFormat.Rgba64, DepthFormat = DepthFormat.Depth24Stencil8
};
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()
{
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 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);
}
public void Prepare(Renderer renderer)
{
renderer.Data.Get <BoundingFrustum>("viewfrustum").Value.GetCorners(frustumCornersWS);
for (int i = 0; i < lights.Count; i++)
{
var data = lights[i];
var light = data.Light;
light.Direction = Vector3.Normalize(light.Direction);
if (data.ShadowMap != null)
{
RenderTargetManager.RecycleTarget(data.ShadowMap);
data.ShadowMap = null;
}
if (light.ShadowResolution != 0)
{
CalculateShadowMatrices(renderer, data);
DrawShadowMap(renderer, data);
}
}
}
public override void Draw(Renderer renderer)
{
var metadata = renderer.Data;
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);
var depth = metadata.Get <Texture2D>("gbuffer_depth").Value;
var normals = metadata.Get <Texture2D>("gbuffer_normals").Value;
var diffuse = metadata.Get <Texture2D>("gbuffer_diffuse").Value;
//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 void Prepare(Renderer renderer)
{
touchesNearPlane.Clear();
touchesFarPlane.Clear();
touchesBothPlanes.Clear();
touchesNeitherPlane.Clear();
var frustum = renderer.Data.Get <BoundingFrustum>("viewfrustum").Value;
float falloffFactor = renderer.Data.Get("lighting_attenuationscale", 100).Value;
geometryLightingMaterial.Parameters["LightFalloffFactor"].SetValue(falloffFactor);
quadLightingMaterial.Parameters["LightFalloffFactor"].SetValue(falloffFactor);
//float threshold = renderer.Data.Get("lighting_threshold", 1f / 100f).Value;
//float adaptedLuminance = renderer.Data.Get<float>("adaptedluminance", 1).Value;
//threshold = adaptedLuminance * threshold;
foreach (var light in lights)
{
light.Light.Direction = Vector3.Normalize(light.Light.Direction);
//var luminance = Math.Max(light.Colour.X, Math.Max(light.Colour.Y, light.Colour.Z));
//light.range = (float)Math.Sqrt(luminance * falloffFactor / threshold);
var bounds = new BoundingSphere(light.Light.Position, light.Light.Range);
if (!bounds.Intersects(frustum))
{
continue;
}
var near = bounds.Intersects(frustum.Near) == PlaneIntersectionType.Intersecting;
var far = bounds.Intersects(frustum.Far) == PlaneIntersectionType.Intersecting;
if (near && far)
{
touchesBothPlanes.Add(light);
}
else if (near)
{
touchesNearPlane.Add(light);
}
else if (far)
{
touchesFarPlane.Add(light);
}
else
{
touchesNeitherPlane.Add(light);
}
if (light.ShadowMap != null)
{
RenderTargetManager.RecycleTarget(light.ShadowMap);
light.ShadowMap = null;
}
if (light.Light.ShadowResolution > 0)
{
DrawShadowMap(renderer, light);
}
}
}
public DX11TempRTRendererNode(IPluginHost FHost, IIOFactory iofactory)
{
this.depthmanager = new DepthBufferManager(FHost, iofactory);
this.rtm = new RenderTargetManager(FHost, iofactory);
}
internal override void Draw(GameTime gameTime)
{
// clear backbuffer
Controller.GraphicsDevice.Clear(BACKGROUND_COLOR);
var previousTargets = Controller.GraphicsDevice.GetRenderTargets();
RenderTargetManager.BeginRenderToTarget(_sceneTarget);
Controller.GraphicsDevice.Clear(BACKGROUND_COLOR);
_batch.Begin(samplerState: SamplerState.PointClamp);
var(unit, startX, width, height) = Border.GetDefaultScreenValues();
// draw empty box at bottom of the screen
Border.Draw(_batch, startX, StartY + unit * 12, Border.SCREEN_WIDTH, 6, Border.SCALE);
DrawScreen(gameTime);
// status
_enemyPokemonStatus.Draw(_batch);
_playerPokemonStatus.Draw(_batch);
_playerStatus.Draw(_batch);
_pokemonStats.Draw(_batch);
// battle messages
_battleTextbox.Draw(_batch, Border.DefaultWhite);
// main menu
if (_menuState == BattleMenuState.Main)
{
Border.Draw(_batch, startX + unit * 8, StartY + unit * 12, 12, 6, Border.SCALE);
var menuStr = "";
for (var i = 0; i < MENU_OPTIONS.Length; i++)
{
if (i == _mainMenuIndex)
{
menuStr += ">";
}
else
{
menuStr += " ";
}
menuStr += MENU_OPTIONS[i].PadRight(5);
if (i == 1)
{
menuStr += "\n";
}
}
_fontRenderer.LineGap = 1;
_fontRenderer.DrawText(_batch, menuStr,
new Vector2(startX + unit * 9, StartY + unit * 14), Color.Black, Border.SCALE);
}
else if (_menuState == BattleMenuState.Fight)
{
Border.Draw(_batch, startX + unit * 4, StartY + unit * 12, 16, 6, Border.SCALE);
// move list
var pokemon = Battle.ActiveBattle.PlayerPokemon.Pokemon;
var moveListStr = "";
for (var i = 0; i < Pokemon.MAX_MOVES; i++)
{
if (i == _moveMenuIndex)
{
moveListStr += ">";
}
else
{
moveListStr += " ";
}
if (pokemon.Moves.Length > i)
{
moveListStr += pokemon.Moves[i].name;
}
else
{
moveListStr += "-";
}
moveListStr += "\n";
}
_fontRenderer.LineGap = 0;
_fontRenderer.DrawText(_batch, moveListStr,
new Vector2(startX + unit * 5, StartY + unit * 13), Color.Black, Border.SCALE);
// move info
Border.Draw(_batch, startX, StartY + unit * 8, 11, 5, Border.SCALE);
var selectedMove = pokemon.Moves[_moveMenuIndex];
// disabled?
if (Battle.ActiveBattle.PlayerPokemon.DisabledMove == selectedMove &&
Battle.ActiveBattle.PlayerPokemon.DisabledTurns > 0)
{
_fontRenderer.DrawText(_batch, "Disabled!",
new Vector2(startX + unit, StartY + unit * 10), Color.Black, Border.SCALE);
}
else
{
_fontRenderer.DrawText(_batch,
"TYPE/\n" +
" " + selectedMove.GetMove().Type.ToString().ToUpper() + "\n" +
new string(' ', 4) + selectedMove.pp.ToString().PadLeft(2) + "/" +
selectedMove.maxPP.ToString().PadLeft(2),
new Vector2(startX + unit, StartY + unit * 9), Color.Black, Border.SCALE);
}
}
// animations
lock (_animations)
{
foreach (var animation in _animations)
{
if (!animation.IsFinished)
{
animation.Draw(_batch);
}
}
}
_batch.End();
Controller.GraphicsDevice.SetRenderTargets(previousTargets);
if (_invertColors)
{
_batch.Begin(samplerState: SamplerState.PointClamp, blendState: INVERT_COLORS_BLENDSTATE, effect: _screenEffect);
}
else
{
_batch.Begin(samplerState: SamplerState.PointClamp, effect: _screenEffect);
}
var color = Color.White;
if (_fadeOut)
{
color = new Color(255, 255, 255, (int)(255 * (1f - _fadeOutProgress)));
}
_batch.Draw(_sceneTarget, _screenOffset, color);
_batch.End();
}
internal override void LoadContent()
{
_target = RenderTargetManager.CreateScreenTarget();
_batch = new SpriteBatch(Controller.GraphicsDevice);
}
/// <summary>
/// Create Render targets
/// </summary>
/// <param name="cameraResources">camera Resources</param>
/// <param name="newWidth">render width</param>
/// <param name="newHeight">render height</param>
/// <param name="backBufferPointer">target handle</param>
/// <param name="adapter">adapter instance</param>
/// <param name="renderTargetManager">render Target Manager</param>
private void CreateRenderTargets(CameraResources cameraResources, int newWidth, int newHeight, int backBufferPointer, Adapter.Adapter adapter, RenderTargetManager renderTargetManager)
{
adapter.SetSize(newWidth, newHeight);
DepthTexture depthTexture = renderTargetManager.CreateDepthTexture(newWidth, newHeight);
var lenght = cameraResources.IsRenderingStereoscopic ? 2 : 1;
for (int i = 0; i < lenght; i++)
{
RenderTargetViewDescription rtViewDescription = new RenderTargetViewDescription()
{
Format = cameraResources.BackBufferTexture2D.Description.Format,
Dimension = RenderTargetViewDimension.Texture2DArray,
Texture2DArray = new RenderTargetViewDescription.Texture2DArrayResource()
{
FirstArraySlice = i,
ArraySize = 1,
MipSlice = 0
}
};
var renderTarget = renderTargetManager.CreateRenderTarget(cameraResources.BackBufferTexture2D, rtViewDescription);
renderTarget.DepthTexture = depthTexture;
var eyeTexture = new VREyeTexture()
{
Viewport = new Viewport(0, 0, 1, 1),
NearPlane = 0.01f,
FarPlane = 1000,
RenderTarget = renderTarget
};
this.eyesProperties[i].Texture = eyeTexture;
}
var eyeRT = this.eyesProperties[0].Texture.RenderTarget;
var dxRT = renderTargetManager.TargetFromHandle <DXRenderTarget>(eyeRT.TextureHandle);
adapter.GraphicsDevice.BackBuffer = dxRT.TargetView;
}
