//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;
}
}
public override void Apply()
{
if (!isDynamic && this._rendered)
{
return;
}
var device = GraphicDeviceFactory.Device;
device.SaveRenderTarget();
var oldvp = device.ViewPort;
device.ViewPort = _vp;
var scene = Engine.Scene;
var oldCamera = scene.ActiveCamera;
//foreach (var item in nodes)
// item.Component.Visibl = false;
bool restore = false;
var useDefaulTechnique = EngineState.Lighting.Reflection.UseDefaultTechnique;
if (useDefaulTechnique && !RenderManager.IsTechniqueActive <DefaultTechnique>())
{
RenderManager.PushTechnique <DefaultTechnique>();
restore = true;
}
for (int i = 0; i < 6; i++)
{
RenderTarget.SetTarget(i, device);
scene.ActiveCamera = cameras[i];
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Engine.BackColor, 1, 0);
RenderManager.ApplyTechnique();
}
//foreach (var item in nodes)
// item.Visible = true;
device.ViewPort = oldvp;
device.RestoreRenderTarget();
scene.ActiveCamera = oldCamera;
if (restore)
{
RenderManager.PopTechnique();
}
this._rendered = true;
}
public List <HitTestResult> HitTest(Vector2 point)
{
if (Engine.Scene == null)
{
return(null);
}
Engine.Scene.UpdateVisibleComponents();
_tecnique.Mode = HitTestTechnique.HitTestMode.Single;
_tecnique.HitTestLocation = point;
RenderManager.ApplyTechnique(_tecnique);
return(_tecnique.HitTestResults);
}
public override void Apply()
{
var graphic = GraphicDeviceFactory.Device;
var ps = graphic.PS;
ps.SetResource(8, null);
//render to shadow factor texture
RenderManager.ApplyTechnique(_silluteRender);
#region render to edgeTexture
var edgeTexture = _silluteRender.ShadowFatorTex;
_downSampledRts[0].SetTarget(graphic);
edgeTexture.SetTexture(0, graphic);
_effect.Technique = 1;
ps.SetSampler(0, SamplerState.Point);
_sprite.Begin();
_sprite.SetFullScreenTransform(_input);
_sprite.DrawQuad(_effect);
_sprite.End();
#endregion
#region DownSampling
ps.SetSampler(0, SamplerState.Point);
_effect.Technique = 2;
_sprite.Begin();
for (int i = 0; i < _downSampledRts.Length - 1; i++)
{
DownSample(graphic, _downSampledRts[i], _downSampledRts[i + 1]);
ps.SetResource(0, null);
}
_sprite.End();
_effect.Technique = 0;
graphic.RestoreRenderTarget();
#endregion
base.Apply();
}
//[Serializable]
//class Activator : IResourceActivator
//{
// AssetReference _package;
// string _name;
// private AssetReference _physics;
// public void Initialize(IAssetProvider provider)
// {
// Scene scene = (Scene)provider;
// AssetContext.SetGlobal<Scene>(scene);
// _name = scene.Name;
// //descrip = new SceneDescription
// //{
// // Name = scene.name,
// // CreateRootNode = false,
// // QuadTreeMaxSize = scene.quadTree.BoundRect.Width,
// // QuadTreeMinSize = scene.quadTree.BoundRect.Width / (float)Math.Pow(2, scene.quadTree.MaxLevel)
// //};
// ContentPackage pk = AssetContext.GetGlobal<ContentPackage>();
// bool removePk = false;
// if (pk == null)
// {
// pk = new ContentPackage(scene._name);
// AssetContext.SetGlobal<ContentPackage>(pk);
// removePk = true;
// }
// scene.AddToPackage(pk);
// if (scene._physics != null)
// {
// _physics = AssetManager.Instance.GetAssetReference(scene._physics);
// AssetContext.SetGlobal<Physic>(scene._physics);
// //scene.physScene.AddToPackage(pk);
// }
// _package = AssetManager.Instance.GetAssetReference(pk);
// if (removePk)
// {
// AssetContext.SetGlobal<ContentPackage>(null);
// }
// }
// public IAssetProvider OnCreateResource()
// {
// Scene scene = new Scene();
// AssetContext.SetGlobal<Scene>(scene);
// if (_physics != null)
// {
// scene.Physics = (Physic)AssetManager.Instance.GetAssetProvider(_physics);
// AssetContext.SetGlobal<Physic>(scene._physics);
// }
// ContentPackage pk = (ContentPackage)AssetManager.Instance.GetAssetProvider(_package);
// AssetContext.SetGlobal<Scene>(null);
// AssetContext.SetGlobal<Physic>(null);
// scene.Nodes.AddRange(pk.Providers.FindAll(x => (x is SceneNode) && ((SceneNode)x).Parent == null).Cast<SceneNode>());
// return scene;
// }
//}
public virtual void Draw()
{
RenderManager.ApplyTechnique();
if (_physics != null && _physics.Visible)
{
var tech = Service.Require <PhysicDisplayTechnique>();
tech.Apply();
}
foreach (var item in Drawables)
{
item.Draw();
}
foreach (var entry in GetDecalGraphics())
{
entry.Draw(PixelClipping.None);
}
}
protected override void Render()
{
var graphics = GraphicDeviceFactory.Device;
var scene = Engine.Scene;
//swapChain.MakeCurrent();
graphics.SetRenderTarget(_swapChain.BackBuffer, _depthBuffer);
graphics.ViewPort = _viewport;
graphics.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Engine.BackColor, 1, 0);
OnRenderBegin();
if (scene != null)
{
RenderManager.ApplyTechnique();
}
OnRender();
_swapChain.Present();
}
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();
}
}
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>();
}
