//private void GetFilterOffsets(int size)
//{
// //float fTexelSize = 3.0f / (2.0f * (float)size);
// float fTexelSize = 1.0f / (float)size;
// // Generate the tecture co-ordinates for the specified depth-map size
// // 4 3 5
// // 1 0 2
// // 7 6 8
// offsets[0] = new Vector2(0, 0);
// offsets[1] = new Vector2(-fTexelSize, 0.0f);
// offsets[2] = new Vector2(fTexelSize, 0.0f);
// offsets[3] = new Vector2(0.0f, -fTexelSize);
// offsets[6] = new Vector2(0.0f, fTexelSize);
// offsets[4] = new Vector2(-fTexelSize, -fTexelSize);
// offsets[5] = new Vector2(fTexelSize, -fTexelSize);
// offsets[7] = new Vector2(-fTexelSize, fTexelSize);
// offsets[8] = new Vector2(fTexelSize, fTexelSize);
//}
/// <summary>
/// Draw the scene`s dephts from the camera to the DephtTexture
/// </summary>
/// <param name="data">Scene , the current Scene</param>
public override void Apply()
{
if (EngineState.Shadow.Enable && (isDynamic || Rendered))
{
var device = GraphicDeviceFactory.Device;
Scene scene = Engine.Scene;
var oldvp = device.ViewPort;
device.ViewPort = _vp;
device.SaveRenderTarget();
ShadowMap.SetTarget(device);
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color4.White, 1, 0);
var oldCamera = scene.ActiveCamera;
device.Rasterizer = _rasterizer;
device.Blend = _blendState;
device.DepthTest = _detpthStencil;
scene.ActiveCamera = camera;
RenderManager.ApplyTechnique <DepthSceneRender>();
scene.ActiveCamera = oldCamera;
device.RestoreRenderTarget();
device.ViewPort = oldvp;
Rendered = true;
}
}
private void MensureLuminance(GraphicDevice device, IShaderStage stage)
{
effect.Technique = HdrEffect.SampleAvgLum;
RenderTexture2D dest = _rtToneMap[Tonemaptextures - 1];
RenderTexture2D source = _rtHdrScene;
dest.SetTarget(device);
source.SetTexture(0, device);
stage.SetSampler(0, _linearSampler);
device.Clear(ClearFlags.Target, Color4.Black, 1, 0);
_quadRender.DrawQuad(effect);
effect.Technique = HdrEffect.ResampleAvgLum;
stage.SetSampler(0, _pointSampler);
for (int i = Tonemaptextures - 2; i > 0; i--)
{
dest = _rtToneMap[i];
source = _rtToneMap[i + 1];
dest.SetTarget(device);
source.SetTexture(0, device);
device.Clear(ClearFlags.Target, Color4.Black, 1, 0);
_quadRender.DrawQuad(effect);
}
effect.Technique = HdrEffect.ResampleAvgLumExp;
source = _rtToneMap[1];
dest = _rtToneMap[0];
dest.SetTarget(device);
source.SetTexture(0, device);
device.Clear(ClearFlags.Target, Color4.Black, 1, 0);
_quadRender.DrawQuad(effect);
}
public override void Apply()
{
var graphic = GraphicDeviceFactory.Device;
graphic.SaveRenderTarget();
var oldvp = graphic.ViewPort;
graphic.ViewPort = _vp;
_shadowRt.SetTarget(graphic);
graphic.Clear(Graphics.ClearFlags.Target | Graphics.ClearFlags.ZBuffer, new Color4(0, 0, 0, 0), 1, 0);
base.Apply();
graphic.SetRenderTarget(null);
graphic.ViewPort = oldvp;
}
public bool IsTransparent(Texture2D texture)
{
var device = GraphicDeviceFactory.Device;
var oldvp = device.ViewPort;
device.ViewPort = new ViewPort(0, 0, 1, 1);
device.SaveRenderTarget();
_renderTexture.SetTarget();
device.PS.SetResource(0, texture);
device.PS.SetSampler(0, _samState);
_sprite.Begin();
var deviceBlend = device.Blend;
device.Blend = blend;
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, new Color4(0, 0, 0, 0), 1, 0);
_sprite.SetFullScreenTransform(_effect);
_sprite.DrawQuad(_effect);
_sprite.End();
device.RestoreRenderTarget();
device.ViewPort = oldvp;
device.Blend = deviceBlend;
byte alpha = 0;
var rec = _renderTexture.Texture.Map(0, MapType.Read);
unsafe
{
alpha = *(byte *)rec.DataPointer;
}
_renderTexture.Texture.UnMap(0);
return(alpha > 0);
}
private void DownSample(GraphicDevice graphic, RenderTexture2D src, RenderTexture2D dest)
{
dest.SetTarget(graphic);
src.SetTexture(0, graphic);
_sprite.DrawQuad(_effect);
}
public override unsafe void Apply()
{
#region Render
var graphics = GraphicDeviceFactory.Device;
var lighting = EngineState.Lighting;
var oldvp = graphics.ViewPort;
graphics.ViewPort = _vp;
graphics.RasterizerStack.Push(_rast);
graphics.BlendStack.Push(_blend);
graphics.DepthStencilStack.Push(_depth);
graphics.SaveRenderTarget();
_rtx.SetTarget(graphics);
var transp = lighting.TransparencyEnable;
lighting.TransparencyEnable = false;
graphics.Clear(ClearFlags.Target | ClearFlags.ZBuffer, new Color4(0, 0, 0, 0), 1, 0);
hitTestRender.RenderObjects();
graphics.RestoreRenderTarget();
graphics.RasterizerStack.Pop();
graphics.BlendStack.Pop();
graphics.DepthStencilStack.Pop();
graphics.ViewPort = oldvp;
lighting.TransparencyEnable = transp;
#endregion
#region Test Surface
try
{
var stream = _rtx.Texture.Map(0, MapType.Read);
if (Mode == HitTestMode.Single)
{
var point = HitTestLocation;
int x = (int)point.X;
int y = (int)point.Y;
int offset = y * stream.RowPitch + x * sizeof(int);
var abgr = *(int *)(stream.DataPointer + offset);
HitTestResult result;
hitTestRender.FindResult(abgr, out result); // AddSelection(id - 1);
//var pter = (byte*)stream.DataPointer;
// for (int i = 0; i < _rtx.Height; i++)
// {
// for (int j = 0; j < _rtx.Width; j++)
// {
// id = ((int*)pter)[j];
// if (id >0)
// AddSelection(id, visibleComponents, drawables);
// }
// pter += stream.RowPitch;
// }
}
else
{
var rec = this.HitTestRegion;
int offset = rec.Y * stream.RowPitch + rec.X * sizeof(int);
byte *pter = (byte *)stream.DataPointer + offset;
for (int i = 0; i < rec.Height && i < _rtx.Height; ++i)
{
for (int j = 0; j < rec.Width && j < _rtx.Width; ++j)
{
var abgr = ((int *)pter)[j];
HitTestResult result;
hitTestRender.FindResult(abgr, out result);
}
pter += stream.RowPitch;
}
}
}
finally
{
_rtx.Texture.UnMap(0);
}
#endregion
}
public override void Apply()
{
if (EngineState.Lighting.Reflection.Enable)
{
var graphic = GraphicDeviceFactory.Device;
graphic.SaveRenderTarget();
var tech = Service.Require <ClipPlaneSceneTechnique>();
#region RenderReflection
if (_useReflection)
{
if (_rasterizer == null)
{
_rasterizer = graphic.CreateRasterizerState(new RasterizerDesc(true)
{
Cull = CullMode.Front
});
}
graphic.RasterizerStack.Push(_rasterizer);
//var oldcamera = Engine.Scene.ActiveCamera;
//camera.Projection = oldcamera.Projection;
//var front = Vector3.TransformNormal(oldcamera.Front, _reflTransform);
//var right = Vector3.Normalize(Vector3.Cross(Vector3.UnitY, front));
//var up = Vector3.Normalize(Vector3.Cross(front, right));
//camera.Position = Vector3.TransformCoordinates(oldcamera.Position, _reflTransform);
//camera.Right = right;
//camera.Up = up;
//camera.Front = front;
//camera.CommitChanges();
//Engine.Scene.ActiveCamera = camera;
_rtReflection.SetTarget(graphic);
graphic.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color4.Black, 1, 0);
tech.ReflectionMatrix = _reflTransform;
tech.Plane = _plane;
RenderManager.ApplyTechnique(tech);
tech.ReflectionMatrix = Matrix.Identity;
tech.Plane = new Plane();
graphic.RasterizerStack.Pop();
//Engine.Scene.ActiveCamera = oldcamera;
}
#endregion
#region RenderRefraction
if (_useRefraction)
{
_rtRefraction.SetTarget(graphic);
GraphicDeviceFactory.Device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, 0, 1, 0);
tech.ReflectionMatrix = Matrix.Identity;
RenderManager.ApplyTechnique(tech);
}
#endregion
graphic.RestoreRenderTarget();
}
}
private unsafe void RenderStar(GraphicDevice device)
{
RenderTexture2D source;
RenderTexture2D dest;
var glare = _state.Glare;
//renderMgr.Fill(rtStarFinal, 0);
// Avoid rendering the star if it's not being used in the current glare
if (glare == null || glare.glareLuminance <= 0.0f || glare.starLuminance <= 0.0f)
{
_rtStarFinal.SetTarget(device);
device.Clear(ClearFlags.Target, Color4.Black, 1, 0);
return;
}
fixed(Vector4 *_ptSampleOffsets = _sampleOffsetsStar)
{
Vector2 *ptSampleOffsets = (Vector2 *)_ptSampleOffsets;
fixed(Vector4 *ptSampleWeights = _sampleWeightsStar)
{
//#region StarSourceToBloomSource (DownSampler2x2)
//effect.Technique = HDREffect.DownSampler2x2;
//dest = rtBrightPassFilter;
//source = rtStartSource;
//dest.SetTarget(device);
//source.SetTexture(0, device);
//device.Clear(ClearFlags.Target, Color4.Black, 1, 0);
//quadRender.DrawQuad(effect);
//#endregion
#region BrighPassToStarSource
effect.Technique = HdrEffect.GaussBlur5X5;
source = _rtBrightPassFilter;
dest = _rtStartSource;
dest.SetTarget(device);
source.SetTexture(0, device);
FillSampleOffsets_GaussBlur5x5(source.Width, source.Height, ptSampleOffsets, ptSampleWeights, 1);
_map.SampleOffsets = _sampleOffsetsStar;
_map.SampleWeights = _sampleWeightsStar;
_quadRender.DrawQuad(effect);
#endregion
//float fTanFoV = (float)Math.Atan(Numerics.PI / 8.0f);
const float fTanFoV = 0.37419668052268495F;
const int maxPasses = 3;
const int samples = 8;
int i; // Loop variables
StarDefinition starDef = glare.StarDef;
device.PS.SetSampler(0, _linearSampler);
float srcW = _rtStartSource.Width;
float srcH = _rtStartSource.Height;
for (int p = 0; p < maxPasses; p++)
{
float ratio = (float)(p + 1) / (float)maxPasses;
for (int s = 0; s < samples; s++)
{
Vector4 chromaticAberrColor = Numerics.Lerp(StarDefinition.ChromaticAberrationColor[s], _sColorWhite, ratio);
_sAaColor[p, s] = Numerics.Lerp(_sColorWhite, chromaticAberrColor, glare.chromaticAberration);
}
}
_time += starDef.rotation ? Engine.ElapsedTime : 0;
float radOffset = glare.starInclination + starDef.inclination + _time;
Vector2 stepUv;
int lines = starDef.StarLines.Length;
float attnPowScaleInicial = (fTanFoV + 0.1f) * 1.0f * (160.0f + 120.0f) / (srcW + srcH) * 1.2f;
for (int d = 0; d < lines; d++)
{
Starline starLine = starDef.StarLines[d];
float rad = radOffset + starLine.Inclination;
float sn = (float)Math.Sin(rad);
float cs = (float)Math.Cos(rad);
stepUv.X = sn / srcW * starLine.SampleLength;
stepUv.Y = cs / srcH * starLine.SampleLength;
float attnPowScale = attnPowScaleInicial;
#region PASSES
// 1 direction expansion loop
source = _rtStartSource;
dest = _rtStarPasses[0];
for (int p = 0; p < starLine.Passes; p++)
{
if (p == starLine.Passes - 1)
{
source = dest;
dest = _rtStarLines[d];
}
// Sampling configration for each stage
for (i = 0; i < samples; i++)
{
float lum = (float)Math.Pow(starLine.Attenuation, attnPowScale * i);
ptSampleWeights[i] = _sAaColor[starLine.Passes - 1 - p, i] * lum * (p + 1.0f) * 0.5f;
// Offset of sampling coordinate
ptSampleOffsets[i].X = stepUv.X * i;
ptSampleOffsets[i].Y = stepUv.Y * i;
if (Math.Abs(ptSampleOffsets[i].X) >= 0.9f || Math.Abs(ptSampleOffsets[i].Y) >= 0.9f)
{
ptSampleOffsets[i] = Vector2.Zero;
ptSampleWeights[i] = Vector4.Zero;
}
}
effect.Technique = HdrEffect.Star;
dest.SetTarget(device);
source.SetTexture(0, device);
_map.SampleOffsets = _sampleOffsetsStar;
_map.SampleWeights = _sampleWeightsStar;
_quadRender.DrawQuad(effect);
// Setup next expansion
stepUv *= samples;
attnPowScale *= samples;
// Set the work drawn just before to next texture source.
if (p == 0)
{
source = dest;
dest = _rtStarPasses[1];
}
else if (p != starLine.Passes - 1)
{
var rtTemp = source;
source = dest;
dest = source;
}
}
#endregion PASSES
}
dest = _rtStarFinal;
dest.SetTarget(device);
float invLines = 1.0f / (float)lines;
for (i = 0; i < lines; i++)
{
_rtStarLines[i].SetTexture(i, device);
device.PS.SetSampler(i, _linearSampler);
ptSampleWeights[i] = new Vector4(invLines, invLines, invLines, invLines);
}
effect.Technique = HdrEffect.MergeTexture;
_map.NbTextures = lines;
_map.SampleWeights = _sampleWeightsStar;
_quadRender.DrawQuad(effect);
//for (i = 0; i < lines; i++)
//{
// device.PSStage.SetSampler(i, pointSampler);
//}
}
}
}
public override void Apply()
{
if (_gaussianMean != _state.GaussainMean ||
_gaussianDev != _state.GaussianDeviation ||
_gaussainMultiplier != _state.GaussianMultiplier)
{
ComputeSamples();
}
var device = GraphicDeviceFactory.Device;
device.SaveRenderTarget();
RenderTexture2D dest;
RenderTexture2D source;
RenderTexture2D lumen;
var stage = device.PS;
var scene = Engine.Scene;
#region Render To HDRTexture
_rtHdrScene.SetTarget(device);
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Engine.BackColor, 1, 0);
RenderManager.PopTechnique();
RenderManager.ApplyTechnique();
RenderManager.PushTechnique(this);
#endregion
_quadRender.Begin();
_quadRender.SetFullScreenTransform(_input);
stage.SetSampler(0, _pointSampler);
stage.SetSampler(1, _pointSampler);
MensureLuminance(device, stage);
#region CalculateAdaptation
if (_state.CalculateEyeAdaptation)
{
effect.Technique = HdrEffect.CalculateAdaptedLum;
//swap last width current
var rtTemp = _rtLastAdaptedLuminance;
_rtLastAdaptedLuminance = _rtCurrentAdaptedLuminance;
_rtCurrentAdaptedLuminance = rtTemp;
_rtCurrentAdaptedLuminance.SetTarget(device);
_rtLastAdaptedLuminance.SetTexture(0, device);
_rtToneMap[0].SetTexture(1, device);
_map.ElapsedTime = Engine.ElapsedTime;
_quadRender.DrawQuad(effect);
lumen = _rtCurrentAdaptedLuminance;
}
else
{
lumen = _rtToneMap[0];
}
#endregion
#region BrightPassFilter
effect.Technique = HdrEffect.BrightPassFilter;
_rtBrightPassFilter.SetTarget(device);
_rtHdrScene.SetTexture(0, device);
lumen.SetTexture(1, device);
_map.MiddleGray = _state.MiddleGray;
_map.BrightPassThreshold = _state.BrightThreshold;
device.Clear(ClearFlags.Target, Color4.Black, 1, 0);
_quadRender.DrawQuad(effect);
#endregion
stage.SetSampler(0, _linearSampler);
#region BloomFilter
#region DownSample 4x4
effect.Technique = HdrEffect.DownSampler4X4;
dest = _rtBloom[2];
source = _rtBrightPassFilter;
dest.SetTarget(device);
source.SetTexture(0, device);
device.Clear(ClearFlags.Target, Color4.Black, 1, 0);
_quadRender.DrawQuad(effect);
#endregion
#region Horizontal Blur
effect.Technique = HdrEffect.Bloom;
//Horizontal Blur
source = _rtBloom[2];
dest = _rtBloom[1];
dest.SetTarget(device);
source.SetTexture(0, device);
device.Clear(ClearFlags.Target, Color4.Black, 1, 0);
_map.SampleOffsets = _sampleOffsetsH;
_map.SampleWeights = _sampleWeights;
device.Clear(ClearFlags.Target, Color4.Black, 1, 0);
_quadRender.DrawQuad(effect);
#endregion
#region Vertical Blur
source = _rtBloom[1];
dest = _rtBloom[0];
dest.SetTarget(device);
source.SetTexture(0, device);
_map.SampleOffsets = _sampleOffsetsV;
_map.SampleWeights = _sampleWeights;
device.Clear(ClearFlags.Target, Color4.Black, 1, 0);
_quadRender.DrawQuad(effect);
#endregion
#endregion
#region StarFilter
RenderStar(device);
#endregion
#region FinalPass
effect.Technique = HdrEffect.FinalScenePass;
device.RestoreRenderTarget();
stage.SetSampler(0, _pointSampler);
stage.SetSampler(1, _pointSampler);
stage.SetSampler(2, _linearSampler);
stage.SetSampler(3, _linearSampler);
_rtHdrScene.SetTexture(0, device);
lumen.SetTexture(1, device);
_rtBloom[0].SetTexture(2, device);
_rtStarFinal.SetTexture(3, device);
_map.MiddleGray = _state.MiddleGray;
var glare = _state.Glare;
if (glare == null || glare.glareLuminance <= 0.0f || glare.starLuminance <= 0.0f)
{
_map.GaussianScalar = _state.GaussianMultiplier;
}
else
{
_map.GaussianScalar = 2 * _state.GaussianMultiplier;
}
_map.EnableBlueShift = _state.EnableBlueShift;
_map.StarBlend = _state.StarBlendFactor;
_map.BloomBlend = _state.BloomBlendFactor;
device.Clear(ClearFlags.Target, Color4.Black, 1, 0);
_quadRender.DrawQuad(effect);
stage.SetResource(0, null);
stage.SetResource(1, null);
stage.SetResource(2, null);
stage.SetResource(3, null);
#endregion
_quadRender.End();
//device.PopGraphicState<BlendState>();
}
