public override void Draw(Texture2D ImageToProcess,RenderHelper rHelper, GameTime gt, Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatingBuffer)
{
rHelper.PushRenderTarget(renderTarget1);
Saturate.Parameters["current"].SetValue(ImageToProcess);
Saturate.Parameters["halfPixel"].SetValue(GraphicInfo.HalfPixel);
if(useFloatingBuffer)
rHelper.RenderFullScreenQuadVertexPixel(Saturate,SamplerState.PointClamp);
else
rHelper.RenderFullScreenQuadVertexPixel(Saturate, SamplerState.LinearClamp);
Texture2D t = rHelper.PopRenderTargetAsSingleRenderTarget2D();
rHelper.PushRenderTarget(renderTarget0);
gaussian.Draw(t, rHelper, gt, GraphicInfo, world,useFloatingBuffer);
Texture2D x = rHelper.PopRenderTargetAsSingleRenderTarget2D();
rHelper.Clear(Color.Black);
Combine.Parameters["halfPixel"].SetValue(GraphicInfo.HalfPixel);
Combine.Parameters["base"].SetValue(ImageToProcess);
Combine.Parameters["last"].SetValue(x);
if (useFloatingBuffer)
rHelper.RenderFullScreenQuadVertexPixel(Combine , SamplerState.PointClamp);
else
rHelper.RenderFullScreenQuadVertexPixel(Combine, GraphicInfo.SamplerState);
}
public override void Draw(Microsoft.Xna.Framework.Graphics.Texture2D ImageToProcess, RenderHelper rHelper, Microsoft.Xna.Framework.GameTime gt, PloobsEngine.Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatBuffer)
{
//mix with last frame downsampled
if (tex != null)
{
rHelper.PushRenderTarget(rtend);
rHelper.RenderTextureComplete(tex, Color.FromNonPremultiplied(255, 255, 255, 255), GraphicInfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.LinearClamp);
rHelper.RenderTextureComplete(ImageToProcess, Color.FromNonPremultiplied(255, 255, 255, Amount), GraphicInfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.LinearClamp, BlendState.AlphaBlend);
end = rHelper.PopRenderTargetAsSingleRenderTarget2D();
}
//DownSample
rHelper.PushRenderTarget(rt);
rHelper.Clear(Color.Black);
if (end == null)
{
rHelper.RenderTextureComplete(ImageToProcess, Color.White, rt.Bounds, Matrix.Identity, ImageToProcess.Bounds, true, SpriteSortMode.Deferred, SamplerState.AnisotropicClamp);
}
else
{
rHelper.RenderTextureComplete(end, Color.White, rt.Bounds, Matrix.Identity, ImageToProcess.Bounds, true, SpriteSortMode.Deferred, SamplerState.AnisotropicClamp);
}
tex = rHelper.PopRenderTargetAsSingleRenderTarget2D();
if(end!=null)
rHelper.RenderTextureComplete(end, Color.White, GraphicInfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.LinearClamp);
else
rHelper.RenderTextureComplete(ImageToProcess, Color.White, GraphicInfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.LinearClamp);
}
public override void Draw(Texture2D ImageToProcess, RenderHelper rHelper, GameTime gt, GraphicInfo GraphicInfo, IWorld world, bool useFloatingBuffer)
{
//if (Keyboard.GetState().IsKeyDown(Keys.Space))
//{
// rHelper.RenderTextureComplete(ImageToProcess);
// return;
//}
rHelper.PushRenderTarget(rt0);
rHelper.Clear(Color.Transparent);
if (mLAntiAliasingEdgeDetectionMode == MLAntiAliasingEdgeDetectionMode.Color)
effect.CurrentTechnique = effect.Techniques["ColorEdgeDetection"];
else
{
effect.CurrentTechnique = effect.Techniques["DepthEdgeDetection"];
effect.Parameters["depthTex"].SetValue(rHelper[PrincipalConstants.DephRT]);
}
effect.Parameters["PIXEL_SIZE"].SetValue(GraphicInfo.HalfPixel * 2);
effect.Parameters["colorTex"].SetValue(rHelper[PrincipalConstants.CombinedImage]);
effect.Parameters["threshold"].SetValue(0.0008f);
rHelper.RenderFullScreenQuadVertexPixel(effect);
Texture edges = rHelper.PopRenderTargetAsSingleRenderTarget2D();
rHelper.PushRenderTarget(rt1);
rHelper.Clear(Color.Transparent);
effect.CurrentTechnique = effect.Techniques["BlendWeightCalculation"];
effect.Parameters["areaTex"].SetValue(tex);
effect.Parameters["edgesTex"].SetValue(edges);
effect.Parameters["MAX_SEARCH_STEPS"].SetValue(16);
effect.Parameters["MAX_DISTANCE"].SetValue(65);
rHelper.RenderFullScreenQuadVertexPixel(effect);
Texture2D tt = rHelper.PopRenderTargetAsSingleRenderTarget2D();
rHelper.Clear(Color.Transparent);
pass.Parameters["cena"].SetValue(ImageToProcess);
//if (Keyboard.GetState().IsKeyDown(Keys.RightAlt))
//{
// rHelper.RenderTextureComplete(tt);
// return;
//}
//else
//{
//pass.Parameters["cena"].SetValue(ImageToProcess);
rHelper.RenderFullScreenQuadVertexPixel(pass);
//}
effect.CurrentTechnique = effect.Techniques["NeighborhoodBlending"];
effect.Parameters["colorTex"].SetValue(ImageToProcess);
effect.Parameters["blendTex"].SetValue(tt);
rHelper.RenderFullScreenQuadVertexPixel(effect);
}
public override void Draw(Texture2D ImageToProcess, RenderHelper rHelper, Microsoft.Xna.Framework.GameTime gt, PloobsEngine.Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatBuffer)
{
rHelper.PushRenderTarget(target);
rHelper.Clear(Color.Black);
effectdistorcion.Parameters["halfPixel"].SetValue(GraphicInfo.HalfPixel);
effectdistorcion.Parameters["DEPTH"].SetValue(rHelper[PrincipalConstants.DephRT]);
effectdistorcion.Parameters["DistortionScale"].SetValue(Distortion);
rHelper.PushDepthStencilState(DepthStencilState.None);
foreach (var obj in objs)
{
IModelo modelo = obj.Modelo;
for (int i = 0; i < modelo.MeshNumber; i++)
{
BatchInformation[] bi = modelo.GetBatchInformation(i);
for (int j = 0; j < bi.Count(); j++)
{
Matrix w = bi[j].ModelLocalTransformation * obj.WorldMatrix;
effectdistorcion.Parameters["WorldViewProjection"].SetValue(w * world.CameraManager.ActiveCamera.View * world.CameraManager.ActiveCamera.Projection);
effectdistorcion.Parameters["WorldView"].SetValue(w * world.CameraManager.ActiveCamera.View);
rHelper.RenderBatch(bi[j], effectdistorcion);
}
}
}
rHelper.PopDepthStencilState();
x = rHelper.PopRenderTargetAsSingleRenderTarget2D();
rHelper.Clear(Color.Black);
effect.Parameters["SceneTexture"].SetValue(ImageToProcess);
effect.Parameters["DistortionMap"].SetValue(x);
//effect.Parameters["halfPixel"].SetValue(GraphicInfo.HalfPixel);
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess,effect,GraphicInfo.FullScreenRectangle);
}
public override void Draw(Texture2D ImageToProcess, RenderHelper rHelper, GameTime gt, Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatingBuffer)
{
rHelper.PushRenderTarget(target);
be.Draw(ImageToProcess, rHelper, gt, GraphicInfo, world,useFloatingBuffer);
depht.Parameters["BlurScene"].SetValue(rHelper.PopRenderTargetAsSingleRenderTarget2D());
depht.Parameters["FarPlane"].SetValue(world.CameraManager.ActiveCamera.FarPlane);
depht.Parameters["D1M"].SetValue(rHelper[PrincipalConstants.DephRT]);
rHelper.Clear(Color.Black,ClearOptions.Target);
SetShaderParameters(distance, range, world.CameraManager.ActiveCamera.NearPlane, world.CameraManager.ActiveCamera.FarPlane);
if (useFloatingBuffer)
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, depht, GraphicInfo.FullScreenRectangle, SamplerState.PointClamp);
else
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, depht, GraphicInfo.FullScreenRectangle, GraphicInfo.SamplerState);
}
protected override void Draw(Microsoft.Xna.Framework.GameTime gameTime, RenderHelper render)
{
render.Clear(Color.Black);
int w = render.GetViewPort().Width;
int h = render.GetViewPort().Height;
render.RenderTextComplete(texts[state], new Vector2(w / 2, h / 2), Color.DarkRed, Matrix.Identity, arenScript);
if (interval < maxInterval)
{
interval++;
}
else
{
ChangeState();
interval = 0;
}
}
public override void Draw(Texture2D ImageToProcess, RenderHelper rHelper, GameTime gt, GraphicInfo GraphicInfo, IWorld world, bool useFloatingBuffer)
{
effect.Parameters["e_barrier"].SetValue(barrier);
effect.Parameters["e_kernel"].SetValue(kernel);
effect.Parameters["e_weights"].SetValue(weights);
effect.Parameters["pixel_size"].SetValue(GraphicInfo.HalfPixel);
effect.Parameters["depthTex"].SetValue(rHelper[PrincipalConstants.DephRT]);
effect.Parameters["normalTex"].SetValue(rHelper[PrincipalConstants.normalRt]);
effect.Parameters["image"].SetValue(ImageToProcess);
rHelper.Clear(Color.Transparent);
//if (Keyboard.GetState().IsKeyDown(Keys.Space))
//{
// rHelper.RenderTextureComplete(ImageToProcess);
// return;
//}
if (useFloatingBuffer)
rHelper.RenderFullScreenQuadVertexPixel(effect, SamplerState.PointClamp);
else
rHelper.RenderFullScreenQuadVertexPixel(effect, GraphicInfo.SamplerState);
}
public override void Draw(Microsoft.Xna.Framework.Graphics.Texture2D ImageToProcess, RenderHelper rHelper, Microsoft.Xna.Framework.GameTime gt, PloobsEngine.Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatBuffer)
{
Matrix v = world.CameraManager.ActiveCamera.View;
Matrix p = world.CameraManager.ActiveCamera.Projection;
if (firstTime)
{
oldViewProjection = world.CameraManager.ActiveCamera.ViewProjection;
firstTime = false;
}
rHelper.PushRenderTarget(rt);
rHelper.Clear(Color.Black);
rHelper.RenderSceneWithCustomMaterial(effectvelocity,
(effect, obj, bi,ti,s,er,wvp) =>
{
Matrix w1 = Matrix.Multiply(obj.WorldMatrix, bi.ModelLocalTransformation);
effect.Parameters["wvp"].SetValue(w1 * wvp);
effect.Parameters["oldwvp"].SetValue(w1 * oldViewProjection);
}, world, gt, null, ref v, ref p, false, true);
Texture2D tex = rHelper.PopRenderTargetAsSingleRenderTarget2D();
eff.Parameters["halfPixel"].SetValue(GraphicInfo.HalfPixel);
eff.Parameters["numSamples"].SetValue(NumSamples);
eff.Parameters["velocity"].SetValue(tex);
eff.Parameters["cena"].SetValue(ImageToProcess);
eff.Parameters["Attenuation"].SetValue(Attenuation);
oldViewProjection = world.CameraManager.ActiveCamera.ViewProjection;
if (useFloatBuffer)
rHelper.RenderFullScreenQuadVertexPixel(eff, SamplerState.PointClamp);
else
rHelper.RenderFullScreenQuadVertexPixel(eff, GraphicInfo.SamplerState);
}
public override void Draw(Texture2D ImageToProcess, RenderHelper rHelper, GameTime gt, Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatingBuffer)
{
if (firstTime)
{
rHelper.PushRenderTarget(lastFrameAdaptedLuminance);
rHelper.Clear(Color.White, ClearOptions.Target);
rHelper.PopRenderTargetAsSingleRenderTarget2D();
firstTime = false;
}
long time = stopwatch.ElapsedMilliseconds;
dt = (time - lastTime) / 1000.0f;
lastTime = time;
Texture2D d4 = DownScale(rHelper, ImageToProcess, 4, SurfaceFormat.HalfVector4, "Downscale4", useFloatingBuffer);
Texture2D d16 = DownScale(rHelper, d4, 4, SurfaceFormat.HalfVector4, "Downscale4", useFloatingBuffer);
Texture2D tex = Luminance(rHelper, d16, luminanceChain[0], "Luminance");
for (int i = 1; i < luminanceChain.Length; i++)
{
tex = DownScale(rHelper, tex, luminanceChain[i], "Downscale4", useFloatingBuffer); //possivelmente mudar para o efeito Downscale4Luminance
}
// Final downscale
tex = DownScale(rHelper, tex, currentFrameLuminance, "Downscale4Luminance", useFloatingBuffer);
// Adapt the luminance, to simulate slowly adjust exposure
luminance.Parameters["g_fDT"].SetValue(dt);
luminance.Parameters["fTau"].SetValue(fTau);
luminance.Parameters["SourceTexture1"].SetValue(lastFrameAdaptedLuminance);
tex = Luminance(rHelper, tex, currentFrameAdaptedLuminance, "CalcAdaptedLuminance");
//Bloom
IntermediateRenderTarget thresholdTex = factory.GetRenderTargetFromPool(d16.Width, d16.Height, SurfaceFormat.HalfVector4);
threshold.CurrentTechnique = threshold.Techniques["Threshold"];
threshold.Parameters["g_fThreshold"].SetValue(bloomThreshold);
threshold.Parameters["g_fMiddleGrey"].SetValue(toneMapKey);
threshold.Parameters["g_fMaxLuminance"].SetValue(maxLuminance);
threshold.Parameters["SourceTexture0"].SetValue(d16);
threshold.Parameters["SourceTexture1"].SetValue(tex);
threshold.Parameters["g_vSourceDimensions"].SetValue(new Vector2(d16.Width, d16.Height));
threshold.Parameters["g_vDestinationDimensions"].SetValue(new Vector2(thresholdTex.RenderTarget.Width, thresholdTex.RenderTarget.Height));
rHelper.PushRenderTarget(thresholdTex.RenderTarget);
rHelper.RenderFullScreenQuadVertexPixel(threshold);
Texture2D blom = rHelper.PopRenderTargetAsSingleRenderTarget2D();
IntermediateRenderTarget postBlur = factory.GetRenderTargetFromPool(d16.Width, d16.Height, SurfaceFormat.Color);
Texture2D blur = BlurHV(rHelper, blom, postBlur.RenderTarget);
thresholdTex.InUse = false;
IntermediateRenderTarget upscale1 = factory.GetRenderTargetFromPool(GraphicInfo.BackBufferWidth / 8, GraphicInfo.BackBufferHeight / 8, SurfaceFormat.Color);
DownScale(rHelper, postBlur.RenderTarget, upscale1.RenderTarget, "ScaleHW", useFloatingBuffer);
postBlur.InUse = false;
IntermediateRenderTarget upscale2 = factory.GetRenderTargetFromPool(GraphicInfo.BackBufferWidth / 4, GraphicInfo.BackBufferHeight / 4, SurfaceFormat.Color);
DownScale(rHelper, upscale1.RenderTarget, upscale2.RenderTarget, "ScaleHW", useFloatingBuffer);
upscale1.InUse = false;
IntermediateRenderTarget bloom = factory.GetRenderTargetFromPool(GraphicInfo.BackBufferWidth / 2, GraphicInfo.BackBufferHeight / 2, SurfaceFormat.Color);
Texture2D resp = DownScale(rHelper, upscale2.RenderTarget, bloom.RenderTarget, "ScaleHW", useFloatingBuffer);
upscale2.InUse = false;
//toScreen.Parameters["SourceTexture0"].SetValue(resp);
//toScreen.Parameters["g_vSourceDimensions"].SetValue(new Vector2(resp.Width, resp.Height));
//toScreen.Parameters["g_vDestinationDimensions"].SetValue(new Vector2(GraphicInfo.BackBufferWidth, GraphicInfo.BackBufferHeight));
//rHelper.RenderFullScreenQuadVertexPixel(toScreen);
// Now do tone mapping on the main source image, and add in the bloom
tone.CurrentTechnique = tone.Techniques["Tone"];
tone.Parameters["g_fMiddleGrey"].SetValue(toneMapKey);
tone.Parameters["g_fMaxLuminance"].SetValue(maxLuminance);
tone.Parameters["g_fBloomMultiplier"].SetValue(bloomMultiplier);
tone.Parameters["g_vDestinationDimensions"].SetValue(new Vector2(GraphicInfo.BackBufferWidth, GraphicInfo.BackBufferHeight));
tone.Parameters["SourceTexture0"].SetValue(ImageToProcess);
tone.Parameters["SourceTexture1"].SetValue(currentFrameAdaptedLuminance);
tone.Parameters["SourceTexture2"].SetValue(resp);
rHelper.RenderFullScreenQuadVertexPixel(tone);
//// Flip the luminance textures
Swap(ref currentFrameAdaptedLuminance, ref lastFrameAdaptedLuminance);
bloom.InUse = false;
}
protected override void Draw(GameTime gameTime, RenderHelper render)
{
render.Clear(Color.Black);
render.RenderTextComplete("Welcome to the Ploobs Game Engine Advanced Demos", new Vector2(40, 30), Color.White,Matrix.Identity);
render.RenderTextComplete("The Focus here were in the funcionalities, not in the visual", new Vector2(40, 50), Color.Red, Matrix.Identity);
render.RenderTextComplete("As you will see, we need Modelers =P Join us =P", new Vector2(40, 70), Color.Red, Matrix.Identity);
render.RenderTextComplete("(Press F1 to cycle through demos)", new Vector2(40, 95), Color.White, Matrix.Identity);
render.RenderTextComplete("(Press Escape to exit)", new Vector2(40, 115), Color.White, Matrix.Identity);
}
public override void Draw(Texture2D ImageToProcess, RenderHelper rHelper, GameTime gt, Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatingBuffer)
{
if (firstTime)
{
rHelper.PushRenderTarget(lastFrameAdaptedLuminance);
rHelper.Clear(Color.White,ClearOptions.Target);
rHelper.PopRenderTargetAsSingleRenderTarget2D();
firstTime = false;
}
long time = stopwatch.ElapsedMilliseconds;
dt = (time - lastTime) / 1000.0f;
lastTime = time;
Texture2D d4 = DownScale(rHelper, ImageToProcess, 4, SurfaceFormat.HalfVector4, "Downscale4", useFloatingBuffer);
Texture2D d16 = DownScale(rHelper, d4, 4, SurfaceFormat.HalfVector4, "Downscale4", useFloatingBuffer);
Texture2D tex = Luminance(rHelper, d16, luminanceChain[0], "Luminance");
for (int i = 1; i < luminanceChain.Length; i++)
tex = DownScale(rHelper, tex, luminanceChain[i], "Downscale4", useFloatingBuffer); //possivelmente mudar para o efeito Downscale4Luminance
// Final downscale
tex = DownScale(rHelper, tex, currentFrameLuminance, "Downscale4Luminance", useFloatingBuffer);
// Adapt the luminance, to simulate slowly adjust exposure
luminance.Parameters["g_fDT"].SetValue(dt);
luminance.Parameters["fTau"].SetValue(fTau);
luminance.Parameters["SourceTexture1"].SetValue(lastFrameAdaptedLuminance);
tex = Luminance(rHelper, tex, currentFrameAdaptedLuminance, "CalcAdaptedLuminance");
//Bloom
IntermediateRenderTarget thresholdTex = factory.GetRenderTargetFromPool(d16.Width, d16.Height, SurfaceFormat.HalfVector4);
threshold.CurrentTechnique = threshold.Techniques["Threshold"];
threshold.Parameters["g_fThreshold"].SetValue(bloomThreshold);
threshold.Parameters["g_fMiddleGrey"].SetValue(toneMapKey);
threshold.Parameters["g_fMaxLuminance"].SetValue(maxLuminance);
threshold.Parameters["SourceTexture0"].SetValue(d16);
threshold.Parameters["SourceTexture1"].SetValue(tex);
threshold.Parameters["g_vSourceDimensions"].SetValue(new Vector2(d16.Width, d16.Height));
threshold.Parameters["g_vDestinationDimensions"].SetValue(new Vector2(thresholdTex.RenderTarget.Width, thresholdTex.RenderTarget.Height));
rHelper.PushRenderTarget(thresholdTex.RenderTarget);
rHelper.RenderFullScreenQuadVertexPixel(threshold);
Texture2D blom = rHelper.PopRenderTargetAsSingleRenderTarget2D();
IntermediateRenderTarget postBlur = factory.GetRenderTargetFromPool(d16.Width, d16.Height, SurfaceFormat.Color);
Texture2D blur = BlurHV(rHelper, blom, postBlur.RenderTarget);
thresholdTex.InUse = false;
IntermediateRenderTarget upscale1 = factory.GetRenderTargetFromPool(GraphicInfo.BackBufferWidth / 8, GraphicInfo.BackBufferHeight / 8, SurfaceFormat.Color);
DownScale(rHelper, postBlur.RenderTarget, upscale1.RenderTarget, "ScaleHW", useFloatingBuffer);
postBlur.InUse = false;
IntermediateRenderTarget upscale2 = factory.GetRenderTargetFromPool(GraphicInfo.BackBufferWidth / 4, GraphicInfo.BackBufferHeight / 4, SurfaceFormat.Color);
DownScale(rHelper, upscale1.RenderTarget, upscale2.RenderTarget, "ScaleHW", useFloatingBuffer);
upscale1.InUse = false;
IntermediateRenderTarget bloom = factory.GetRenderTargetFromPool(GraphicInfo.BackBufferWidth / 2, GraphicInfo.BackBufferHeight / 2, SurfaceFormat.Color);
Texture2D resp = DownScale(rHelper, upscale2.RenderTarget, bloom.RenderTarget, "ScaleHW",useFloatingBuffer);
upscale2.InUse = false;
//toScreen.Parameters["SourceTexture0"].SetValue(resp);
//toScreen.Parameters["g_vSourceDimensions"].SetValue(new Vector2(resp.Width, resp.Height));
//toScreen.Parameters["g_vDestinationDimensions"].SetValue(new Vector2(GraphicInfo.BackBufferWidth, GraphicInfo.BackBufferHeight));
//rHelper.RenderFullScreenQuadVertexPixel(toScreen);
// Now do tone mapping on the main source image, and add in the bloom
tone.CurrentTechnique = tone.Techniques["Tone"];
tone.Parameters["g_fMiddleGrey"].SetValue(toneMapKey);
tone.Parameters["g_fMaxLuminance"].SetValue(maxLuminance);
tone.Parameters["g_fBloomMultiplier"].SetValue(bloomMultiplier);
tone.Parameters["g_vDestinationDimensions"].SetValue(new Vector2(GraphicInfo.BackBufferWidth, GraphicInfo.BackBufferHeight));
tone.Parameters["SourceTexture0"].SetValue(ImageToProcess);
tone.Parameters["SourceTexture1"].SetValue(currentFrameAdaptedLuminance);
tone.Parameters["SourceTexture2"].SetValue(resp);
rHelper.RenderFullScreenQuadVertexPixel(tone);
//// Flip the luminance textures
Swap(ref currentFrameAdaptedLuminance, ref lastFrameAdaptedLuminance);
bloom.InUse = false;
}
protected override void Draw(GameTime gameTime, RenderHelper render)
{
render.Clear(Color.Black);
render.RenderTextComplete("Welcome to the Ploobs Game Engine Funcionality Introduction Demos", new Vector2(40, 30), Color.White, Matrix.Identity);
render.RenderTextComplete("The focus here is not in the visual, it is in the funcionalities (Check the Source Code =P)", new Vector2(40, 50), Color.Red, Matrix.Identity);
render.RenderTextComplete("(Press F1 to cycle through demos)", new Vector2(40, 75), Color.White, Matrix.Identity);
render.RenderTextComplete("(Press Escape to exit)", new Vector2(40, 95), Color.White, Matrix.Identity);
render.RenderTextComplete("All Demos uses Bepu Physic Engine, For Nvidia Physx See Advanced Demos", new Vector2(40, 115), Color.White, Matrix.Identity);
}
public override void Draw(Texture2D ImageToProcess, RenderHelper rHelper, GameTime gt, PloobsEngine.Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatBuffer)
{
Matrix v = world.CameraManager.ActiveCamera.View;
Matrix p = world.CameraManager.ActiveCamera.Projection;
rHelper.PushRenderTarget(depthrender);
rHelper.Clear(Color.Black);
rHelper.RenderSceneWithCustomMaterial(renderdepth,
(effect, obj, bi, ti, s, er, wvp) =>
{
Matrix w1 = Matrix.Multiply(obj.WorldMatrix, bi.ModelLocalTransformation);
effect.Parameters["wvp"].SetValue(w1 * wvp);
effect.Parameters["WorldView"].SetValue(w1 * v);
effect.Parameters["farPlane"].SetValue(world.CameraManager.ActiveCamera.FarPlane);
}, world, gt, null, ref v, ref p, false, true);
Texture2D depth = rHelper.PopRenderTargetAsSingleRenderTarget2D();
// Set shader atributes
//SetNormalTexture(rHelper[PrincipalConstants.normalRt]);
//shader.Parameters["depthTexture"].SetValue(rHelper[PrincipalConstants.DephRT]);
shader.Parameters["depthTexture"].SetValue(depth);
//shader.Parameters["InvertViewProjection"].SetValue(Matrix.Invert(world.CameraManager.ActiveCamera.Projection));
NumberSteps = 8;
NumberDirections = 12;
Radius = 10f;
LineAttenuation = 0.75f;
Contrast = 1.0f;
AngleBias = 0.00218166653f;
LineAttenuation = 0.75f;
// It works a the depth texture resolution. Use a downsampled version of the G-Buffer.
SetResolution(new Vector2(GraphicInfo.BackBufferWidth, GraphicInfo.BackBufferHeight));
SetInverseResolution(new Vector2(1f / (float)GraphicInfo.BackBufferWidth, 1f / (float)GraphicInfo.BackBufferHeight));
SetNumberSteps(8);
SetNumberDirections(12);
SetContrast(Contrast / (1.0f - (float)Math.Sin(AngleBias)));
SetLineAttenuation(LineAttenuation);
SetRadius(Radius );
SetAngleBias(AngleBias);
SetHalfPixel(GraphicInfo.HalfPixel);
float _tanFovy = (float)Math.Tan(world.CameraManager.ActiveCamera.FieldOfView / 2);
Vector2 focalLen = new Vector2
{
X = world.CameraManager.ActiveCamera.AspectRatio / _tanFovy,
Y = 1.0f / _tanFovy
};
//pointLightEffect.Parameters["farPlane"].SetValue(camera.FarPlane);
SetFocalLength(focalLen);
SetInverseFocalLength(new Vector2(_tanFovy * world.CameraManager.ActiveCamera.AspectRatio, -_tanFovy));
SetSquareRadius(AngleBias * AngleBias);
SetInverseRadius(1f / AngleBias);
SetTanAngleBias((float)Math.Tan(AngleBias));
//rHelper.PushRenderTarget(RenderTarget2D);
rHelper.SetSamplerStates(SamplerState.PointWrap);
rHelper.Clear(Color.White);
rHelper.RenderFullScreenQuadVertexPixel(shader, SamplerState.PointWrap);
return;
Texture2D t = rHelper.PopRenderTargetAsSingleRenderTarget2D();
//rHelper.PushRenderTarget(RenderTarget2D2);
//rHelper.Clear(Color.Black);
//g.Draw(t, rHelper, gt, GraphicInfo, world, useFloatBuffer);
//t = rHelper.PopRenderTargetAsSingleRenderTarget2D();
ssaofinal.Parameters["SSAOTex"].SetValue(t);
ssaofinal.Parameters["SceneTexture"].SetValue(ImageToProcess);
ssaofinal.Parameters["halfPixel"].SetValue(GraphicInfo.HalfPixel);
ssaofinal.Parameters["weight"].SetValue(1);
rHelper.SetSamplerStates(SamplerState.PointClamp);
if (useFloatBuffer)
rHelper.RenderFullScreenQuadVertexPixel(ssaofinal, SamplerState.PointClamp);
else
rHelper.RenderFullScreenQuadVertexPixel(ssaofinal, GraphicInfo.SamplerState);
}
public void DrawScene(GameTime gameTime, IWorld world, RenderHelper render, GraphicInfo ginfo, List<IObject> objs)
{
Matrix v = world.CameraManager.ActiveCamera.View;
Matrix p = world.CameraManager.ActiveCamera.Projection;
render.PushRenderTarget(colorRT, normalRT, depthRT, lightOclusionRT);
render.RenderPreComponents(gameTime, ref v, ref p);
System.Diagnostics.Debug.Assert(render.PeekBlendState() == BlendState.Opaque);
System.Diagnostics.Debug.Assert(render.PeekDepthState() == DepthStencilState.Default);
System.Diagnostics.Debug.Assert(render.PeekRasterizerState() == RasterizerState.CullCounterClockwise);
render.SetSamplerState(ginfo.SamplerState, 0);
foreach (IObject item in objs)
{
item.Material.Drawn(gameTime,item, world.CameraManager.ActiveCamera, world.Lights, render);
}
render.PopRenderTarget();
colorRTFINAL = colorRT2;
render.PushRenderTarget(colorRTFINAL);
render.Clear(Color.CornflowerBlue);
effect.Parameters["View"].SetValue(world.CameraManager.ActiveCamera.View);
effect.Parameters["Projection"].SetValue(world.CameraManager.ActiveCamera.Projection);
{
foreach (IObject item in world.Culler.GetNotCulledObjectsList(MaterialType.DEFERRED))
{
for (int i = 0; i < item.Modelo.MeshNumber; i++)
{
BatchInformation[] bi = item.Modelo.GetBatchInformation(i);
for (int j = 0; j < bi.Count(); j++)
{
effect.Parameters["Texture"].SetValue(item.Modelo.getTexture(TextureType.DIFFUSE,i,j));
effect.Parameters["World"].SetValue(bi[j].ModelLocalTransformation * item.WorldMatrix);
render.RenderBatch(bi[j], effect);
}
}
}
}
render.PopRenderTarget();
}
public override void PreDrawPhase(GameTime gt, IWorld world, IObject obj, RenderHelper render, ICamera cam)
{
render.ValidateSamplerStates();
Matrix view = cam.View;
Matrix projection = cam.Projection;
//REFRACAO
Plane refractionClipPlane;
if (cam.Position.Y > -plane.D)
{
refractionClipPlane = CreateReflectionPlane(plane.D, ref plane.Normal, ref view, ref projection, true);
}
else
{
refractionClipPlane = CreateReflectionPlane(plane.D, ref plane.Normal, ref view, ref projection, false);
}
render.PushRenderTarget(refractionRT);
render.Clear(Color.Black);
render.RenderSceneReflectionRefration(world, gt, new List<IObject>() { obj }, ref view, ref projection, true, true,refractionClipPlane);
refractionMap = render.PopRenderTarget()[0].RenderTarget as Texture2D;
//REFLEXAO
Matrix m = Matrix.CreateReflection(plane);
Vector3 pos;
Vector3 target;
Vector3 up;
pos = Vector3.Transform(cam.Position, m);
target = Vector3.Transform(cam.Target, m);
up = Vector3.Transform(cam.Up, m);
reflectiveViewMatrix = Matrix.CreateLookAt(pos, target, up);
Plane reflectionClipPlane = CreateReflectionPlane(plane.D, ref plane.Normal, ref reflectiveViewMatrix, ref projection, false);
render.PushRenderTarget(reflectionRT);
render.Clear(Color.Black);
render.PushRasterizerState(RasterizerState.CullClockwise);
render.RenderSceneReflectionRefration(world, gt, new List<IObject>() { obj }, ref reflectiveViewMatrix, ref projection, true, true,reflectionClipPlane);
render.PopRasterizerState();
reflectionMap = render.PopRenderTarget()[0].RenderTarget as Texture2D;
}
protected override void Draw(Microsoft.Xna.Framework.GameTime gameTime, RenderHelper render)
{
render.Clear(Color.Black);
render.RenderTextureComplete(tex, Color.White, GraphicInfo.FullScreenRectangle, Matrix.Identity);
}
public override void Draw(Texture2D ImageToProcess, RenderHelper rHelper, GameTime gt, Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatingBuffer)
{
rHelper.PushRenderTarget(target);
rHelper.Clear(Color.Black,ClearOptions.Target);
SetParameters(GaussianBlurDirection.Horizontal);
if (useFloatingBuffer)
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, gblur, GraphicInfo.FullScreenRectangle, SamplerState.PointClamp, BlendState.Opaque);
else
rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, gblur, GraphicInfo.FullScreenRectangle, GraphicInfo.SamplerState, BlendState.Opaque);
intermediateTex = rHelper.PopRenderTargetAsSingleRenderTarget2D();
rHelper.Clear(Color.Black, ClearOptions.Target);
SetParameters(GaussianBlurDirection.Vertical); // Set vertical parameters
if (useFloatingBuffer)
rHelper.RenderTextureToFullScreenSpriteBatch(intermediateTex, gblur, GraphicInfo.FullScreenRectangle, SamplerState.PointClamp, BlendState.Opaque);
else
rHelper.RenderTextureToFullScreenSpriteBatch(intermediateTex, gblur, GraphicInfo.FullScreenRectangle, GraphicInfo.SamplerState, BlendState.Opaque);
}
/// <summary>
/// Renders a list of models to the shadow map, and returns a surface
/// containing the shadow occlusion factor
/// </summary>
/// <param name="gameTime">The game time.</param>
/// <param name="render">The render.</param>
/// <param name="ginfo">The ginfo.</param>
/// <param name="light">The light for which the shadow is being calculated</param>
/// <param name="mainCamera">The camera viewing the scene containing the light</param>
/// <param name="world">The world.</param>
/// <param name="deferredGBuffer">The deferred G buffer.</param>
/// <returns>
/// The shadow occlusion texture
/// </returns>
internal RenderTarget2D Render(GameTime gameTime, RenderHelper render,GraphicInfo ginfo, DirectionalLightPE light,
ICamera mainCamera, IWorld world, IDeferredGBuffer deferredGBuffer)
{
vp = render.GetViewPort();
// Set our targets
render.PushRenderTarget(shadowMap);
render.Clear(Color.White,ClearOptions.Target, 1.0f, 0);
render.Clear(Color.Black, ClearOptions.DepthBuffer, 1.0f, 0);
// Get corners of the main camera's bounding frustum
Matrix cameraTransform, viewMatrix;
viewMatrix = mainCamera.View;
cameraTransform = Matrix.Invert(viewMatrix);
mainCamera.BoundingFrustum.GetCorners(frustumCornersWS);
Vector3.Transform(frustumCornersWS, ref viewMatrix, frustumCornersVS);
for (int i = 0; i < 4; i++)
farFrustumCornersVS[i] = frustumCornersVS[i + 4];
// Calculate the cascade splits. We calculate these so that each successive
// split is larger than the previous, giving the closest split the most amount
// of shadow detail.
float N = NumSplits;
float near = mainCamera.NearPlane, far = mainCamera.FarPlane;
splitDepths[0] = near;
splitDepths[NumSplits] = far;
for (int i = 1; i < splitDepths.Length - 1; i++)
splitDepths[i] = splitConstant * near * (float)Math.Pow(far / near, i / N) + (1.0f - splitConstant) * ((near + (i / N)) * (far - near));
// Render our scene geometry to each split of the cascade
for (int i = 0; i < NumSplits; i++)
{
float minZ = splitDepths[i];
float maxZ = splitDepths[i + 1];
CalculateFrustum(light, mainCamera, minZ, maxZ, out lightProjectionMatrices[i], out lightViewMatrices[i],out lightViewProjectionMatrices[i]);
RenderShadowMap(gameTime,render, i,world);
}
render.PopRenderTargetAsSingleRenderTarget2D();
render.SetViewPort(ginfo.Viewport);
RenderShadowOcclusion(render,mainCamera,light,deferredGBuffer);
return shadowOcclusion;
}
protected override void Draw(Microsoft.Xna.Framework.GameTime gameTime, RenderHelper render)
{
render.Clear(Color.Black);
render.RenderTextComplete("LOADING SCREEN", new Vector2(50, 50), Color.White, Matrix.Identity);
}
/// <summary>
/// Draws the specified game time.
/// </summary>
/// <param name="gameTime">The game time.</param>
/// <param name="world">The world.</param>
/// <param name="render">The render.</param>
protected void Draw(GameTime gameTime, IWorld world, RenderHelper render)
{
Matrix view = world.CameraManager.ActiveCamera.View;
Matrix projection = world.CameraManager.ActiveCamera.Projection;
world.Culler.StartFrame(ref view, ref projection, world.CameraManager.ActiveCamera.BoundingFrustum);
List<IObject> AllnotCulledObjectsList = world.Culler.GetNotCulledObjectsList(null);
List<IObject> DeferrednotCulledObjectsList = world.Culler.GetNotCulledObjectsList(MaterialType.DEFERRED);
List<IObject> ForwardnotCulledObjectsList = world.Culler.GetNotCulledObjectsList(MaterialType.FORWARD);
if (desc.OrderAllObjectsBeforeDraw != null)
AllnotCulledObjectsList = desc.OrderAllObjectsBeforeDraw(AllnotCulledObjectsList);
if (desc.OrderDeferredObjectsBeforeDraw != null)
DeferrednotCulledObjectsList = desc.OrderDeferredObjectsBeforeDraw(DeferrednotCulledObjectsList);
if (desc.OrderForwardObjectsBeforeDraw != null)
ForwardnotCulledObjectsList = desc.OrderForwardObjectsBeforeDraw(ForwardnotCulledObjectsList);
render.SetSamplerStates(ginfo.SamplerState);
render.DettachBindedTextures();
deferredGBuffer.PreDrawScene(gameTime, world, render, ginfo, AllnotCulledObjectsList);
render.SetSamplerStates(ginfo.SamplerState);
render.DettachBindedTextures();
deferredGBuffer.SetGBuffer(render);
deferredGBuffer.ClearGBuffer(render);
deferredGBuffer.DrawScene(gameTime, world, render, ginfo, DeferrednotCulledObjectsList);
deferredGBuffer.ResolveGBuffer(render);
render[PrincipalConstants.DephRT] = deferredGBuffer[GBufferTypes.DEPH];
render[PrincipalConstants.normalRt] = deferredGBuffer[GBufferTypes.NORMAL];
render.DettachBindedTextures();
render.ValidateSamplerStates();
deferredLightMap.SetLightMap(render);
deferredLightMap.DrawLights(gameTime, world, deferredGBuffer, render);
deferredLightMap.ResolveLightMap(render);
render[PrincipalConstants.lightRt] = deferredLightMap[DeferredLightMapType.LIGHTMAP];
render.DettachBindedTextures(5);
render.ValidateSamplerStates();
render.PushRenderTarget(scenerender);
render.Clear(desc.BackGroundColor);
foreach (IObject item in AllnotCulledObjectsList)
{
if (item.Material.IsVisible)
item.Material.PosDrawnPhase(gameTime, item, world.CameraManager.ActiveCamera, world.Lights, render);
}
render.DettachBindedTextures(3);
render.ValidateSamplerStates();
if (world.PhysicWorld.isDebugDraw)
{
world.PhysicWorld.iDebugDrawn(render, gameTime, world.CameraManager.ActiveCamera);
}
if (world.ParticleManager != null)
{
world.ParticleManager.iDraw(gameTime, world.CameraManager.ActiveCamera.View, world.CameraManager.ActiveCamera.Projection, render);
render.ResyncStates();
render.SetSamplerStates(ginfo.SamplerState);
}
render.DettachBindedTextures(6);
render.ValidateSamplerStates();
render.RenderPosWithDepthComponents(gameTime, ref view, ref projection);
render.DettachBindedTextures(6);
render.ValidateSamplerStates();
render[PrincipalConstants.colorRT] = scenerender;
render[PrincipalConstants.normalRt] = deferredGBuffer[GBufferTypes.NORMAL];
render[PrincipalConstants.lightRt] = deferredLightMap[DeferredLightMapType.LIGHTMAP];
render[PrincipalConstants.DephRT] = deferredGBuffer[GBufferTypes.DEPH];
render[PrincipalConstants.extra1RT] = deferredGBuffer[GBufferTypes.Extra1];
render[PrincipalConstants.CurrentImage] = render[PrincipalConstants.CombinedImage] = render.PopRenderTargetAsSingleRenderTarget2D();
for (int i = 0; i < PostEffects.Count; i++)
{
if (PostEffects[i].Enabled)
{
render.PushRenderTarget(PostEffectTarget);
render.Clear(Color.Black);
PostEffects[i].Draw(render[PrincipalConstants.CurrentImage], render, gameTime, ginfo, world, true);
Texture2D tex = render.PopRenderTarget()[0].RenderTarget as Texture2D;
render[PrincipalConstants.CurrentImage] = tex;
SwapTargetBuffers();
}
}
render.SetSamplerStates(ginfo.SamplerState);
render.DettachBindedTextures(6);
render.Clear(Color.Black);
render.RenderTextureComplete(render[PrincipalConstants.CurrentImage], Color.White, ginfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.PointClamp);
}
protected override void Draw(Microsoft.Xna.Framework.GameTime gameTime, RenderHelper render)
{
render.Clear(Color.Black);
render.RenderTextComplete("LOADING SCREEN", new Vector2(50, 50), Color.White, Matrix.Identity);
}
/// <summary>
/// Draws the specified game time.
/// </summary>
/// <param name="gameTime">The game time.</param>
/// <param name="world">The world.</param>
/// <param name="render">The render.</param>
protected void Draw(GameTime gameTime, IWorld world, RenderHelper render)
{
Matrix view = world.CameraManager.ActiveCamera.View;
Matrix projection = world.CameraManager.ActiveCamera.Projection;
world.Culler.StartFrame(ref view, ref projection, world.CameraManager.ActiveCamera.BoundingFrustum);
List <IObject> AllnotCulledObjectsList = world.Culler.GetNotCulledObjectsList(null);
List <IObject> DeferrednotCulledObjectsList = world.Culler.GetNotCulledObjectsList(MaterialType.DEFERRED);
List <IObject> ForwardnotCulledObjectsList = world.Culler.GetNotCulledObjectsList(MaterialType.FORWARD);
if (desc.OrderAllObjectsBeforeDraw != null)
{
AllnotCulledObjectsList = desc.OrderAllObjectsBeforeDraw(AllnotCulledObjectsList);
}
if (desc.OrderDeferredObjectsBeforeDraw != null)
{
DeferrednotCulledObjectsList = desc.OrderDeferredObjectsBeforeDraw(DeferrednotCulledObjectsList);
}
if (desc.OrderForwardObjectsBeforeDraw != null)
{
ForwardnotCulledObjectsList = desc.OrderForwardObjectsBeforeDraw(ForwardnotCulledObjectsList);
}
render.SetSamplerStates(ginfo.SamplerState);
render.DettachBindedTextures();
deferredGBuffer.PreDrawScene(gameTime, world, render, ginfo, AllnotCulledObjectsList);
render.SetSamplerStates(ginfo.SamplerState);
render.DettachBindedTextures();
deferredGBuffer.SetGBuffer(render);
deferredGBuffer.ClearGBuffer(render);
deferredGBuffer.DrawScene(gameTime, world, render, ginfo, DeferrednotCulledObjectsList);
deferredGBuffer.ResolveGBuffer(render);
render[PrincipalConstants.DephRT] = deferredGBuffer[GBufferTypes.DEPH];
render[PrincipalConstants.normalRt] = deferredGBuffer[GBufferTypes.NORMAL];
render.DettachBindedTextures();
render.ValidateSamplerStates();
deferredLightMap.SetLightMap(render);
deferredLightMap.DrawLights(gameTime, world, deferredGBuffer, render);
deferredLightMap.ResolveLightMap(render);
render[PrincipalConstants.lightRt] = deferredLightMap[DeferredLightMapType.LIGHTMAP];
render.DettachBindedTextures(5);
render.ValidateSamplerStates();
render.PushRenderTarget(scenerender);
render.Clear(desc.BackGroundColor);
foreach (IObject item in AllnotCulledObjectsList)
{
if (item.Material.IsVisible)
{
item.Material.PosDrawnPhase(gameTime, item, world.CameraManager.ActiveCamera, world.Lights, render);
}
}
render.DettachBindedTextures(3);
render.ValidateSamplerStates();
if (world.PhysicWorld.isDebugDraw)
{
world.PhysicWorld.iDebugDrawn(render, gameTime, world.CameraManager.ActiveCamera);
}
if (world.ParticleManager != null)
{
world.ParticleManager.iDraw(gameTime, world.CameraManager.ActiveCamera.View, world.CameraManager.ActiveCamera.Projection, render);
render.ResyncStates();
render.SetSamplerStates(ginfo.SamplerState);
}
render.DettachBindedTextures(6);
render.ValidateSamplerStates();
render.RenderPosWithDepthComponents(gameTime, ref view, ref projection);
render.DettachBindedTextures(6);
render.ValidateSamplerStates();
render[PrincipalConstants.colorRT] = scenerender;
render[PrincipalConstants.normalRt] = deferredGBuffer[GBufferTypes.NORMAL];
render[PrincipalConstants.lightRt] = deferredLightMap[DeferredLightMapType.LIGHTMAP];
render[PrincipalConstants.DephRT] = deferredGBuffer[GBufferTypes.DEPH];
render[PrincipalConstants.extra1RT] = deferredGBuffer[GBufferTypes.Extra1];
render[PrincipalConstants.CurrentImage] = render[PrincipalConstants.CombinedImage] = render.PopRenderTargetAsSingleRenderTarget2D();
for (int i = 0; i < PostEffects.Count; i++)
{
if (PostEffects[i].Enabled)
{
render.PushRenderTarget(PostEffectTarget);
render.Clear(Color.Black);
PostEffects[i].Draw(render[PrincipalConstants.CurrentImage], render, gameTime, ginfo, world, true);
Texture2D tex = render.PopRenderTarget()[0].RenderTarget as Texture2D;
render[PrincipalConstants.CurrentImage] = tex;
SwapTargetBuffers();
}
}
render.SetSamplerStates(ginfo.SamplerState);
render.DettachBindedTextures(6);
render.Clear(Color.Black);
render.RenderTextureComplete(render[PrincipalConstants.CurrentImage], Color.White, ginfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.PointClamp);
}
protected override void ExecuteTechnic(Microsoft.Xna.Framework.GameTime gameTime, RenderHelper render, I2DWorld world)
{
Matrix simview = world.Camera2D.SimView;
Matrix simprojection = world.Camera2D.SimProjection;
Matrix view = world.Camera2D.View;
Matrix projection = world.Camera2D.Projection;
world.Culler.StartFrame(ref simview, ref simprojection, world.Camera2D.BoundingFrustrum);
Dictionary <Type, List <I2DObject> > objs = world.Culler.GetNotCulledObjectsList();
if (UsePreDrawPhase)
{
foreach (var item in objs.Keys)
{
IMaterialProcessor MaterialProcessor = MaterialProcessors[item];
if (MaterialProcessor != null)
{
MaterialProcessor.ProcessPreDraw(UseLayerInPreDraw, gameTime, render, world.Camera2D, world, objs[item]);
}
else
{
foreach (var iobj in objs[item])
{
if (iobj.PhysicObject.Enabled == true)
{
iobj.Material.PreDrawnPhase(gameTime, world, iobj, render);
}
}
}
}
}
#if !WINDOWS_PHONE && !REACH
if (UseShadow)
{
render.PushRenderTarget(screenShadowsTESTE);
render.Clear(Color.Black);
foreach (var item in objs.Keys)
{
IMaterialProcessor MaterialProcessor = MaterialProcessors[item];
if (MaterialProcessor != null)
{
MaterialProcessor.ProcessDraw(UseLayerInDraw, gameTime, render, world.Camera2D, objs[item]);
}
else
{
foreach (var iobj in objs[item])
{
if (iobj.PhysicObject.Enabled == true)
{
iobj.Material.Draw(gameTime, iobj, render);
}
}
}
}
render.PopRenderTarget();
}
render.PushRenderTarget(renderTarget);
render.Clear(Color.Black);
if (RenderBackGround != null)
{
RenderBackGround(ginfo, render);
}
if (UseDrawComponents)
{
render.RenderPreComponents(gameTime, ref view, ref projection);
}
if (BeforeDraw != null)
{
BeforeDraw(ginfo, render);
}
foreach (var item in objs.Keys)
{
IMaterialProcessor MaterialProcessor = MaterialProcessors[item];
if (MaterialProcessor != null)
{
MaterialProcessor.ProcessDraw(UseLayerInDraw, gameTime, render, world.Camera2D, objs[item]);
}
else
{
foreach (var iobj in objs[item])
{
if (iobj.PhysicObject.Enabled == true)
{
iobj.Material.Draw(gameTime, iobj, render);
}
}
}
}
if (UseDrawComponents)
{
render.RenderPosWithDepthComponents(gameTime, ref view, ref projection);
}
if (world.ParticleManager != null)
{
world.ParticleManager.iDraw(gameTime, world.Camera2D.View, world.Camera2D.SimProjection, render);
}
if (AfterDrawBeforePostEffects != null)
{
AfterDrawBeforePostEffects(ginfo, render);
}
render.PopRenderTarget();
if (UseLights)
{
BoundingFrustum bf = world.Camera2D.BoundingFrustrum;
foreach (var item in world.Lights2D)
{
if (UseShadow)
{
item.BeginDrawingShadowCasters(render);
item.UpdateLight(world.Camera2D.View);
if (item.CasShadow)
{
foreach (var item2 in objs.Keys)
{
IMaterialProcessor MaterialProcessor = MaterialProcessors[item2];
if (MaterialProcessor != null)
{
MaterialProcessor.ProcessLightDraw(gameTime, render, world.Camera2D, objs[item2], Color.Black, item);
}
else
{
foreach (var iobj in objs[item2])
{
if (iobj.PhysicObject.Enabled == true)
{
iobj.Material.LightDraw(gameTime, iobj, render, Color.Black, item);
}
}
}
}
}
else
{
render.Clear(Color.Black);
}
item.EndDrawingShadowCasters(render);
shadowmapResolver.ResolveShadows(item);
shadowmapResolver.ResolveNoShadow(item);
}
else
{
item.UpdateLight(world.Camera2D.View);
shadowmapResolver.ResolveNoShadow(item);
}
}
render.PushRenderTarget(screenShadows);
render.Clear(ambientColor);
render.RenderBegin(Matrix.Identity, null, SpriteSortMode.Deferred, SamplerState.LinearClamp, BlendState.Additive);
if (UseShadow)
{
foreach (var item in world.Lights2D)
{
render.RenderTexture(item.RenderTarget, item.LightPosition - item.LightAreaSize * 0.5f, item.Color, 0, Vector2.Zero, 1);
}
}
else
{
foreach (var item in world.Lights2D)
{
render.RenderTexture(item.RenderTargetNS, item.LightPosition - item.LightAreaSize * 0.5f, item.Color, 0, Vector2.Zero, 1);
}
}
render.RenderEnd();
render.PopRenderTarget();
if (UseShadow)
{
render.PushRenderTarget(screenShadowsNS);
render.Clear(AmbientColor);
render.RenderBegin(Matrix.Identity, null, SpriteSortMode.Deferred, SamplerState.LinearClamp, BlendState.Additive);
foreach (var item in world.Lights2D)
{
render.RenderTexture(item.RenderTargetNS, item.LightPosition - item.LightAreaSize * 0.5f, item.Color, 0, Vector2.Zero, 1);
}
render.RenderEnd();
render.PopRenderTarget();
render.PushRenderTarget(lalalala);
render.Clear(Color.Black);
render.RenderBegin(Matrix.Identity, null, SpriteSortMode.Immediate, SamplerState.LinearClamp, BlendState.Opaque);
render.RenderTexture(screenShadowsNS, Vector2.Zero, LightMaskAttenuation, 0, Vector2.Zero, 1);
render.RenderEnd();
render.RenderBegin(Matrix.Identity, null, SpriteSortMode.Immediate, SamplerState.LinearClamp, blend);
render.RenderTexture(screenShadowsTESTE, Vector2.Zero, Color.White, 0, Vector2.Zero, 1);
render.RenderEnd();
render.PopRenderTarget();
if (UsePostProcessing)
{
render.PushRenderTarget(postEffectTargetScene);
}
render.RenderBegin(Matrix.Identity, null, SpriteSortMode.Immediate, SamplerState.LinearClamp, BlendState.Opaque);
render.RenderTexture(screenShadows, Vector2.Zero, Color.White, 0, Vector2.Zero, 1);
render.RenderEnd();
render.RenderBegin(Matrix.Identity, null, SpriteSortMode.Immediate, SamplerState.LinearClamp, blend);
render.RenderTexture(renderTarget, Vector2.Zero, Color.White, 0, Vector2.Zero, 1);
render.RenderEnd();
render.RenderBegin(Matrix.Identity, null, SpriteSortMode.Immediate, SamplerState.LinearClamp, BlendState.Additive);
render.RenderTexture(lalalala, Vector2.Zero, Color.White, 0, Vector2.Zero, 1);
render.RenderEnd();
}
else
{
if (UsePostProcessing)
{
render.PushRenderTarget(postEffectTargetScene);
}
render.RenderBegin(Matrix.Identity, null, SpriteSortMode.Immediate, SamplerState.LinearClamp, BlendState.Opaque);
render.RenderTexture(screenShadows, Vector2.Zero, Color.White, 0, Vector2.Zero, 1);
render.RenderEnd();
render.RenderBegin(Matrix.Identity, null, SpriteSortMode.Immediate, SamplerState.LinearClamp, blend);
render.RenderTexture(renderTarget, Vector2.Zero, Color.White, 0, Vector2.Zero, 1);
render.RenderEnd();
}
}
else
{
#endif
if (UsePostProcessing)
{
render.PushRenderTarget(postEffectTargetScene);
}
render.Clear(AmbientColor);
if (RenderBackGround != null)
{
RenderBackGround(ginfo, render);
}
if (UseDrawComponents)
{
render.RenderPreComponents(gameTime, ref view, ref projection);
}
if (BeforeDraw != null)
{
BeforeDraw(ginfo, render);
}
foreach (var item in objs.Keys)
{
IMaterialProcessor MaterialProcessor = MaterialProcessors[item];
if (MaterialProcessor != null)
{
MaterialProcessor.ProcessDraw(UseLayerInDraw, gameTime, render, world.Camera2D, objs[item]);
}
else
{
foreach (var iobj in objs[item])
{
if (iobj.PhysicObject.Enabled == true)
{
iobj.Material.Draw(gameTime, iobj, render);
}
}
}
}
if (UseDrawComponents)
{
render.RenderPosWithDepthComponents(gameTime, ref view, ref projection);
}
if (world.ParticleManager != null)
{
world.ParticleManager.iDraw(gameTime, world.Camera2D.View, world.Camera2D.SimProjection, render);
}
if (AfterDrawBeforePostEffects != null)
{
AfterDrawBeforePostEffects(ginfo, render);
}
#if !WINDOWS_PHONE && !REACH
}
#endif
if (UsePostProcessing)
{
render[PrincipalConstants.CurrentImage] = render.PopRenderTarget()[0].RenderTarget as Texture2D;
render[PrincipalConstants.CombinedImage] = render[PrincipalConstants.CurrentImage];
for (int i = 0; i < PostEffects.Count; i++)
{
if (PostEffects[i].Enabled)
{
render.PushRenderTarget(postEffectTarget);
PostEffects[i].Draw(render[PrincipalConstants.CurrentImage], render, gameTime, ginfo, null, false);
Texture2D tex = render.PopRenderTarget()[0].RenderTarget as Texture2D;
render[PrincipalConstants.CurrentImage] = tex;
}
}
render.Clear(Color.Black);
render.RenderTextureComplete(render[PrincipalConstants.CurrentImage], Color.White, ginfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.AnisotropicClamp, BlendState.AlphaBlend);
}
if (UseDrawComponents)
{
render.RenderPosComponents(gameTime, ref view, ref projection);
}
}
protected override void Draw(GameTime gameTime, RenderHelper render)
{
render.Clear(Color.Black);
render.RenderTextComplete("Welcome to the Ploobs Game Engine 2D/3D Reach Funcionality Demos", new Vector2(40, 30), Color.White, Matrix.Identity);
render.RenderTextComplete("The focus here is not in the visual, it is in the funcionalities (Check the Source Code =P)", new Vector2(40, 50), Color.Red, Matrix.Identity);
render.RenderTextComplete("(Press F1 to cycle through demos)", new Vector2(40, 75), Color.White, Matrix.Identity);
render.RenderTextComplete("(Press Escape to exit)", new Vector2(40, 95), Color.White, Matrix.Identity);
}
/// <summary>
/// This is called when the screen should draw itself.
/// </summary>
/// <param name="gameTime"></param>
/// <param name="render"></param>
protected override void Draw(GameTime gameTime, RenderHelper render)
{
render.Clear(backGoundColor);
Texture2D videoTexture = null;
if (videoPlayer.State != MediaState.Stopped)
videoTexture = videoPlayer.GetTexture();
// Draw the video, if we have a texture to draw.
if (videoTexture != null)
{
render.RenderTextureComplete(videoTexture,Color.White,GraphicInfo.FullScreenRectangle,Matrix.Identity);
}
}
protected override void ExecuteTechnic(Microsoft.Xna.Framework.GameTime gameTime, RenderHelper render, IWorld world)
{
ICamera camera = world.CameraManager.ActiveCamera;
Matrix view = world.CameraManager.ActiveCamera.View;
Matrix projection = world.CameraManager.ActiveCamera.Projection;
ComputeFrustumCorners(camera);
world.Culler.StartFrame(ref view, ref projection, world.CameraManager.ActiveCamera.BoundingFrustum);
List<IObject> AllnotCulledObjectsList = world.Culler.GetNotCulledObjectsList(null);
List<IObject> DeferrednotCulledObjectsList = world.Culler.GetNotCulledObjectsList(MaterialType.DEFERRED);
List<IObject> ForwardnotCulledObjectsList = world.Culler.GetNotCulledObjectsList(MaterialType.FORWARD);
foreach (IObject item in AllnotCulledObjectsList)
{
if (item.Material.IsVisible)
item.Material.PreDrawnPhase(gameTime, world, item, world.CameraManager.ActiveCamera, world.Lights, render);
}
render.PushRenderTargetBinding(_gBufferBinding);
render.Clear(Color.Black,ClearOptions.DepthBuffer | ClearOptions.Stencil, 1.0f, 0);
render.PushDepthStencilState(DepthStencilState.None);
render.PushRasterizerState(RasterizerState.CullNone);
render.RenderFullScreenQuadVertexPixel(_clearGBuffer);
render.PopDepthStencilState();
render.PopRasterizerState();
foreach (IObject item in DeferrednotCulledObjectsList)
{
if (item.Material.IsVisible)
item.Material.Drawn(gameTime, item, world.CameraManager.ActiveCamera, world.Lights, render);
}
render.PopRenderTarget();
render[PrincipalConstants.DephRT] = _depthBuffer;
render[PrincipalConstants.normalRt] = _normalBuffer;
//render.PushRenderTargetBinding(_lightAccumBinding);
render.Clear(new Color(0, 0, 0, 0));
render.PushDepthStencilState(DepthStencilState.None);
//draw using additive blending.
//At first I was using BlendState.additive, but it seems to use alpha channel for modulation,
//and as we use alpha channel as the specular intensity, we have to create our own blend state here
render.PushBlendState(_lightAddBlendState);
RenderLights(camera,world,render,ginfo);
//render[PrincipalConstants.lightRt] = render.PopRenderTarget()[0].RenderTarget as Texture2D;
render.PopDepthStencilState();
render.PopBlendState();
return;
render.PushRenderTarget(_outputTexture);
render.Clear(Color.Black);
foreach (IObject item in AllnotCulledObjectsList)
{
if (item.Material.IsVisible)
item.Material.PosDrawnPhase(gameTime, item, world.CameraManager.ActiveCamera, world.Lights, render);
}
if (world.PhysicWorld.isDebugDraw)
{
//world.PhysicWorld.iDebugDrawn(render, gameTime, world.CameraManager.ActiveCamera);
}
if (world.ParticleManager != null)
{
//world.ParticleManager.iDraw(gameTime, world.CameraManager.ActiveCamera.View, world.CameraManager.ActiveCamera.Projection, render);
//render.ResyncStates();
}
ForwardPass.Draw(gameTime, world, render, DeferrednotCulledObjectsList, ForwardnotCulledObjectsList);
render.RenderPosWithDepthComponents(gameTime, ref view, ref projection);
render[PrincipalConstants.CurrentImage] = render.PopRenderTargetAsSingleRenderTarget2D();
for (int i = 0; i < PostEffects.Count; i++)
{
if (PostEffects[i].Enabled)
{
render.PushRenderTarget(PostEffectTarget);
render.Clear(Color.Black);
PostEffects[i].Draw(render[PrincipalConstants.CurrentImage], render, gameTime, ginfo, world, true);
Texture2D tex = render.PopRenderTarget()[0].RenderTarget as Texture2D;
System.Diagnostics.Debug.Assert(tex != null);
render[PrincipalConstants.CurrentImage] = tex;
SwapTargetBuffers();
}
}
render.Clear(Color.Black);
render.RenderTextureComplete(render[PrincipalConstants.CurrentImage], Color.White, ginfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.PointClamp);
render.RenderPosComponents(gameTime, ref view, ref projection);
}
public void DrawLights(GameTime gameTime, IWorld world, IDeferredGBuffer deferredGBuffer, RenderHelper render)
{
render.Clear(Color.Black,ClearOptions.Target);
render.PushBlendState(_lightAddBlendState);
render.PushDepthStencilState(DepthStencilState.None);
DrawDirectionalLight(world.CameraManager.ActiveCamera, world.Lights, deferredGBuffer,render);
DrawPointLight(world.CameraManager.ActiveCamera, world.Lights, deferredGBuffer,render);
DrawnSpotLight(world.CameraManager.ActiveCamera, world.Lights, deferredGBuffer,render);
render.PopBlendState();
render.PopDepthStencilState();
}
internal void BeginDrawingShadowCasters(RenderHelper render)
{
render.PushRenderTarget(RenderTarget);
render.Clear(Color.Transparent,ClearOptions.Target);
}
private void RenderShadowMap(GameTime gt, RenderHelper render, ref Matrix view, ref Matrix proj, IWorld world, IDeferredGBuffer deferredGBuffer)
{
render.PushRenderTarget(shadowRT);
render.Clear(Color.Transparent,ClearOptions.Target | ClearOptions.DepthBuffer,1,0);
render.RenderSceneDepth(world, gt, ref view, ref proj, true);
shadowMap = render.PopRenderTargetAsSingleRenderTarget2D();
}
protected override void Draw(Microsoft.Xna.Framework.GameTime gameTime, RenderHelper render)
{
render.Clear(Color.Black);
render.RenderTextureComplete(tex,Color.White,GraphicInfo.FullScreenRectangle,Matrix.Identity);
}
/// <summary>
/// Draws the specified game time.
/// </summary>
/// <param name="gameTime">The game time.</param>
/// <param name="world">The world.</param>
/// <param name="render">The render.</param>
protected void Draw(GameTime gameTime, IWorld world, RenderHelper render)
{
Matrix view = world.CameraManager.ActiveCamera.View;
Matrix projection = world.CameraManager.ActiveCamera.Projection;
world.Culler.StartFrame(ref view, ref projection, world.CameraManager.ActiveCamera.BoundingFrustum);
List <IObject> AllnotCulledObjectsList = world.Culler.GetNotCulledObjectsList(null);
List <IObject> DeferrednotCulledObjectsList = world.Culler.GetNotCulledObjectsList(MaterialType.DEFERRED, CullerComparer.ComparerFrontToBack, world.CameraManager.ActiveCamera.Position);
List <IObject> ForwardnotCulledObjectsList = world.Culler.GetNotCulledObjectsList(MaterialType.FORWARD, CullerComparer.ComparerBackToFront, world.CameraManager.ActiveCamera.Position);
if (desc.OrderAllObjectsBeforeDraw != null)
{
AllnotCulledObjectsList = desc.OrderAllObjectsBeforeDraw(AllnotCulledObjectsList, world);
}
if (desc.OrderDeferredObjectsBeforeDraw != null)
{
DeferrednotCulledObjectsList = desc.OrderDeferredObjectsBeforeDraw(DeferrednotCulledObjectsList, world);
}
if (desc.OrderForwardObjectsBeforeDraw != null)
{
ForwardnotCulledObjectsList = desc.OrderForwardObjectsBeforeDraw(ForwardnotCulledObjectsList, world);
}
render.SetSamplerStates(ginfo.SamplerState);
render.DettachBindedTextures();
deferredGBuffer.PreDrawScene(gameTime, world, render, ginfo, AllnotCulledObjectsList);
render.SetSamplerStates(ginfo.SamplerState);
render.DettachBindedTextures();
deferredGBuffer.SetGBuffer(render);
deferredGBuffer.ClearGBuffer(render);
deferredGBuffer.DrawScene(gameTime, world, render, ginfo, DeferrednotCulledObjectsList);
deferredGBuffer.ResolveGBuffer(render);
render.DettachBindedTextures();
render.ValidateSamplerStates();
deferredLightMap.SetLightMap(render);
deferredLightMap.DrawLights(gameTime, world, deferredGBuffer, render);
deferredLightMap.ResolveLightMap(render);
render.DettachBindedTextures(5);
render.ValidateSamplerStates();
deferredFinalCombination.SetFinalCombination(render);
deferredFinalCombination.DrawScene(gameTime, world, deferredGBuffer, deferredLightMap, render);
render.DettachBindedTextures(3);
render.ValidateSamplerStates();
if (desc.ExtraForwardPass)
{
render[PrincipalConstants.colorRT] = deferredGBuffer[GBufferTypes.COLOR];
render[PrincipalConstants.normalRt] = deferredGBuffer[GBufferTypes.NORMAL];
render[PrincipalConstants.lightRt] = deferredLightMap[DeferredLightMapType.LIGHTMAP];
render[PrincipalConstants.DephRT] = deferredGBuffer[GBufferTypes.DEPH];
render[PrincipalConstants.extra1RT] = deferredGBuffer[GBufferTypes.Extra1];
render[PrincipalConstants.CombinedImage] = deferredFinalCombination[GBufferTypes.FINALIMAGE];
render[PrincipalConstants.CurrentImage] = deferredFinalCombination[GBufferTypes.FINALIMAGE];
if (desc.RestoreDepthOption == RestoreDepthOption.BEFORE_POSTEFFECT)
{
restoreDepth.PerformForwardPass(render[PrincipalConstants.CombinedImage], render[PrincipalConstants.DephRT], render, ginfo);
render.DettachBindedTextures(2);
render.ValidateSamplerStates();
if (world.PhysicWorld.isDebugDraw)
{
world.PhysicWorld.iDebugDrawn(render, gameTime, world.CameraManager.ActiveCamera);
}
if (world.ParticleManager != null)
{
world.ParticleManager.iDraw(gameTime, world.CameraManager.ActiveCamera.View, world.CameraManager.ActiveCamera.Projection, render);
render.ResyncStates();
render.SetSamplerStates(ginfo.SamplerState);
}
render.DettachBindedTextures(6);
render.ValidateSamplerStates();
forwardPass.Draw(gameTime, world, render, DeferrednotCulledObjectsList, ForwardnotCulledObjectsList);
render.DettachBindedTextures(6);
render.ValidateSamplerStates();
render.RenderPosWithDepthComponents(gameTime, ref view, ref projection);
render.DettachBindedTextures(6);
render.ValidateSamplerStates();
render[PrincipalConstants.CurrentImage] = restoreDepth.EndForwardPass(render);
render[PrincipalConstants.CombinedImage] = render[PrincipalConstants.CurrentImage];
for (int i = 0; i < PostEffects.Count; i++)
{
if (PostEffects[i].Enabled)
{
render.PushRenderTarget(PostEffectTarget);
render.Clear(Color.Black);
PostEffects[i].Draw(render[PrincipalConstants.CurrentImage], render, gameTime, ginfo, world, desc.UseFloatingBufferForLightMap);
Texture2D tex = render.PopRenderTarget()[0].RenderTarget as Texture2D;
render[PrincipalConstants.CurrentImage] = tex;
SwapTargetBuffers();
}
}
render.SetSamplerStates(ginfo.SamplerState);
render.DettachBindedTextures(6);
if (desc.UseFloatingBufferForLightMap)
{
render.Clear(Color.Black);
render.RenderTextureComplete(render[PrincipalConstants.CurrentImage], Color.White, ginfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.PointClamp);
}
else
{
render.Clear(Color.Black);
render.RenderTextureComplete(render[PrincipalConstants.CurrentImage], Color.White, ginfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, ginfo.SamplerState);
}
}
else if (desc.RestoreDepthOption == RestoreDepthOption.AFTER_POSTEFFECT)
{
for (int i = 0; i < PostEffects.Count; i++)
{
if (PostEffects[i].Enabled)
{
render.PushRenderTarget(PostEffectTarget);
render.Clear(Color.Black);
PostEffects[i].Draw(render[PrincipalConstants.CurrentImage], render, gameTime, ginfo, world, desc.UseFloatingBufferForLightMap);
Texture2D tex = render.PopRenderTarget()[0].RenderTarget as Texture2D;
render[PrincipalConstants.CurrentImage] = tex;
SwapTargetBuffers();
}
}
render.SetSamplerStates(ginfo.SamplerState);
render.DettachBindedTextures(16);
restoreDepth.PerformForwardPass(render[PrincipalConstants.CurrentImage], render[PrincipalConstants.DephRT], render, ginfo);
render.DettachBindedTextures(2);
if (world.PhysicWorld.isDebugDraw)
{
world.PhysicWorld.iDebugDrawn(render, gameTime, world.CameraManager.ActiveCamera);
}
if (world.ParticleManager != null)
{
world.ParticleManager.iDraw(gameTime, world.CameraManager.ActiveCamera.View, world.CameraManager.ActiveCamera.Projection, render);
render.ResyncStates();
render.SetSamplerStates(ginfo.SamplerState);
}
render.DettachBindedTextures(16);
forwardPass.Draw(gameTime, world, render, DeferrednotCulledObjectsList, ForwardnotCulledObjectsList);
render.DettachBindedTextures(16);
render.RenderPosWithDepthComponents(gameTime, ref view, ref projection);
render.DettachBindedTextures(16);
render[PrincipalConstants.CurrentImage] = restoreDepth.EndForwardPass(render);
if (desc.UseFloatingBufferForLightMap)
{
System.Diagnostics.Debug.Assert(render.PeekBlendState() == BlendState.Opaque);
render.Clear(Color.Black);
render.RenderTextureComplete(render[PrincipalConstants.CurrentImage], Color.White, ginfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.PointClamp);
System.Diagnostics.Debug.Assert(render.PeekBlendState() == BlendState.Opaque);
}
else
{
render.Clear(Color.Black);
render.RenderTextureComplete(render[PrincipalConstants.CurrentImage], Color.White, ginfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, ginfo.SamplerState);
}
}
else if (desc.RestoreDepthOption == RestoreDepthOption.NONE)
{
for (int i = 0; i < PostEffects.Count; i++)
{
if (PostEffects[i].Enabled)
{
render.PushRenderTarget(PostEffectTarget);
render.Clear(Color.Black);
PostEffects[i].Draw(render[PrincipalConstants.CurrentImage], render, gameTime, ginfo, world, desc.UseFloatingBufferForLightMap);
Texture2D tex = render.PopRenderTarget()[0].RenderTarget as Texture2D;
System.Diagnostics.Debug.Assert(tex != null);
render[PrincipalConstants.CurrentImage] = tex;
SwapTargetBuffers();
}
}
if (desc.UseFloatingBufferForLightMap)
{
render.Clear(Color.Black);
render.RenderTextureComplete(render[PrincipalConstants.CurrentImage], Color.White, ginfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.PointClamp);
}
else
{
render.Clear(Color.Black);
render.RenderTextureComplete(render[PrincipalConstants.CurrentImage], Color.White, ginfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, ginfo.SamplerState);
}
}
render.RenderPosComponents(gameTime, ref view, ref projection);
if (desc.DefferedDebug)
{
render.Clear(Color.Black);
if (desc.UseFloatingBufferForLightMap)
{
render.RenderBegin(Matrix.Identity, null, SpriteSortMode.Immediate, SamplerState.PointClamp);
}
else
{
render.RenderBegin(Matrix.Identity, null, SpriteSortMode.Immediate, ginfo.SamplerState);
}
render.RenderTexture(render[desc.RenderTargetsNameToDefferedDebug[0]], Color.White, new Rectangle(0, 0, halfWidth, halfHeight));
render.RenderTexture(render[desc.RenderTargetsNameToDefferedDebug[1]], Color.White, new Rectangle(0, halfHeight, halfWidth, halfHeight));
render.RenderTexture(render[desc.RenderTargetsNameToDefferedDebug[2]], Color.White, new Rectangle(halfWidth, 0, halfWidth, halfHeight));
render.RenderTexture(render[desc.RenderTargetsNameToDefferedDebug[3]], Color.White, new Rectangle(halfWidth, halfHeight, halfWidth, halfHeight));
render.RenderEnd();
}
}
else
{
render.RenderPosComponents(gameTime, ref view, ref projection);
}
render.ValidateSamplerStates();
}
public override void Draw(Microsoft.Xna.Framework.Graphics.Texture2D ImageToProcess, RenderHelper rHelper, Microsoft.Xna.Framework.GameTime gt, PloobsEngine.Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatBuffer)
{
//mix with last frame downsampled
if (tex != null)
{
rHelper.PushRenderTarget(rtend);
rHelper.Clear(Color.Black);
if (useFloatBuffer)
{
rHelper.RenderTextureComplete(ImageToProcess, Color.FromNonPremultiplied(255, 255, 255, 255), GraphicInfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.PointClamp);
rHelper.RenderTextureComplete(tex, Color.FromNonPremultiplied(255, 255, 255, Amount), GraphicInfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.PointClamp, BlendState.AlphaBlend);
}
else
{
rHelper.RenderTextureComplete(ImageToProcess, Color.FromNonPremultiplied(255, 255, 255, 255), GraphicInfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, GraphicInfo.SamplerState);
rHelper.RenderTextureComplete(tex, Color.FromNonPremultiplied(255, 255, 255, Amount), GraphicInfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, GraphicInfo.SamplerState, BlendState.AlphaBlend);
}
end = rHelper.PopRenderTargetAsSingleRenderTarget2D();
}
//DownSample
rHelper.PushRenderTarget(rt);
rHelper.Clear(Color.Black);
if (end == null)
{
if (useFloatBuffer)
{
rHelper.RenderTextureComplete(ImageToProcess, Color.White, rt.Bounds, Matrix.Identity, ImageToProcess.Bounds, true, SpriteSortMode.Deferred, SamplerState.PointClamp);
}
else
{
rHelper.RenderTextureComplete(ImageToProcess, Color.White, rt.Bounds, Matrix.Identity, ImageToProcess.Bounds, true, SpriteSortMode.Deferred, GraphicInfo.SamplerState);
}
}
else
{
if (useFloatBuffer)
{
rHelper.RenderTextureComplete(end, Color.White, rt.Bounds, Matrix.Identity, ImageToProcess.Bounds, true, SpriteSortMode.Deferred, SamplerState.PointClamp);
}
else
{
rHelper.RenderTextureComplete(end, Color.White, rt.Bounds, Matrix.Identity, ImageToProcess.Bounds, true, SpriteSortMode.Deferred, GraphicInfo.SamplerState);
}
}
tex = rHelper.PopRenderTargetAsSingleRenderTarget2D();
rHelper.Clear(Color.Black);
if (end != null)
{
if (useFloatBuffer)
{
rHelper.RenderTextureComplete(end, Color.White, GraphicInfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.PointClamp);
}
else
{
rHelper.RenderTextureComplete(end, Color.White, GraphicInfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, GraphicInfo.SamplerState);
}
}
else
{
if (useFloatBuffer)
{
rHelper.RenderTextureComplete(ImageToProcess, Color.White, GraphicInfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.PointClamp);
}
else
{
rHelper.RenderTextureComplete(ImageToProcess, Color.White, GraphicInfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, GraphicInfo.SamplerState);
}
}
}
public void DrawLights(GameTime gameTime, IWorld world, IDeferredGBuffer deferredGBuffer, RenderHelper render)
{
render.Clear(Color.Transparent, ClearOptions.Target);
foreach (ILight light in world.Lights.Where((a) => a.CastShadown == true && a.Enabled == true))
{
switch (light.LightType)
{
case LightType.Deferred_Directional:
DirectionalLightPE dl = light as DirectionalLightPE;
shadowMap = shadow.Render(gameTime, render, ginfo, dl, world.CameraManager.ActiveCamera, world, deferredGBuffer);
render.PushBlendState(_lightAddBlendState);
DrawDirectionalLight(render, ginfo, world.CameraManager.ActiveCamera, dl, deferredGBuffer);
render.PopBlendState();
break;
case LightType.Deferred_Point:
#if WINDOWS
System.Diagnostics.Debug.Fail("Point Light Shadow not supported, in production no error will be created, the light just wont cast any shadow");
#endif
render.PushBlendState(_lightAddBlendState);
DrawPointLight(render, ginfo, world.CameraManager.ActiveCamera, light as PointLightPE, deferredGBuffer, true);
render.PopBlendState();
break;
case LightType.Deferred_Spot:
SpotLightPE sl = light as SpotLightPE;
Matrix v = sl.ViewMatrix;
Matrix p = sl.ProjMatrix;
RenderShadowMap(gameTime, render, ref v, ref p, world, deferredGBuffer);
render.PushBlendState(_lightAddBlendState);
DrawnSpotLight(render, ginfo, world.CameraManager.ActiveCamera, sl, deferredGBuffer);
render.PopBlendState();
break;
default:
throw new Exception("Light type Unexpected");
}
}
render.DettachBindedTextures();
render.SetSamplerStates(ginfo.SamplerState);
render.PushBlendState(_lightAddBlendState);
foreach (ILight light in world.Lights.Where((a) => a.CastShadown != true && a.Enabled == true))
{
switch (light.LightType)
{
case LightType.Deferred_Directional:
DirectionalLightPE dl = light as DirectionalLightPE;
DrawDirectionalLight(render, ginfo, world.CameraManager.ActiveCamera, dl, deferredGBuffer);
break;
case LightType.Deferred_Point:
DrawPointLight(render, ginfo, world.CameraManager.ActiveCamera, light as PointLightPE, deferredGBuffer, true);
break;
case LightType.Deferred_Spot:
SpotLightPE sl = light as SpotLightPE;
DrawnSpotLight(render, ginfo, world.CameraManager.ActiveCamera, sl, deferredGBuffer);
break;
default:
throw new Exception("Light type Unexpected");
}
}
render.PopBlendState();
}
/// <summary>
/// Draws
/// </summary>
/// <param name="ImageToProcess">The image to process.</param>
/// <param name="render">The render.</param>
/// <param name="gt">The gt.</param>
/// <param name="GraphicInfo">The graphic info.</param>
/// <param name="world">The world.</param>
/// <param name="useFloatingBuffer">if set to <c>true</c> [use floating buffer].</param>
public override void Draw(Texture2D ImageToProcess, RenderHelper render, GameTime gt, Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatingBuffer)
{
//NOSSO threshold FILTER KKKKK =P
render.PushRenderTarget(rt);
render.Clear(Color.FromNonPremultiplied(bloomThreshold, bloomThreshold, bloomThreshold, 255));
render.RenderTextureComplete(ImageToProcess, Color.White, GraphicInfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.LinearClamp, subBlend);
render.PopRenderTarget();
render.Clear(Color.Black);
render.RenderTextureComplete(ImageToProcess, Color.White, GraphicInfo.FullScreenRectangle, Matrix.Identity);
//NOSSO BLUR KKKKK (mais KKKK)
render.RenderTextureComplete(rt, Color.FromNonPremultiplied(255, 255, 255, brightNess), GraphicInfo.FullScreenRectangle, Matrix.CreateTranslation(2, 2, 0), null, true, SpriteSortMode.Deferred, SamplerState.AnisotropicClamp, additiveBlend);
render.RenderTextureComplete(rt, Color.FromNonPremultiplied(255, 255, 255, brightNess), GraphicInfo.FullScreenRectangle, Matrix.CreateTranslation(-2, -2, 0), null, true, SpriteSortMode.Deferred, SamplerState.AnisotropicClamp, additiveBlend);
render.RenderTextureComplete(rt, Color.FromNonPremultiplied(255, 255, 255, brightNess), GraphicInfo.FullScreenRectangle, Matrix.CreateTranslation(2, -2, 0), null, true, SpriteSortMode.Deferred, SamplerState.AnisotropicClamp, additiveBlend);
render.RenderTextureComplete(rt, Color.FromNonPremultiplied(255, 255, 255, brightNess), GraphicInfo.FullScreenRectangle, Matrix.CreateTranslation(-2, 2, 0), null, true, SpriteSortMode.Deferred, SamplerState.AnisotropicClamp, additiveBlend);
}
public override void Draw(Texture2D ImageToProcess, RenderHelper rHelper, GameTime gt, PloobsEngine.Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatBuffer)
{
Matrix v = world.CameraManager.ActiveCamera.View;
Matrix p = world.CameraManager.ActiveCamera.Projection;
rHelper.PushRenderTarget(depthrender);
rHelper.Clear(Color.Black);
rHelper.RenderSceneWithCustomMaterial(renderdepth,
(effect, obj, bi, ti, s, er, wvp) =>
{
Matrix w1 = Matrix.Multiply(obj.WorldMatrix, bi.ModelLocalTransformation);
effect.Parameters["wvp"].SetValue(w1 * wvp);
effect.Parameters["WorldView"].SetValue(w1 * v);
effect.Parameters["farPlane"].SetValue(world.CameraManager.ActiveCamera.FarPlane);
}, world, gt, null, ref v, ref p, false, true);
Texture2D depth = rHelper.PopRenderTargetAsSingleRenderTarget2D();
// Set shader atributes
//SetNormalTexture(rHelper[PrincipalConstants.normalRt]);
//shader.Parameters["depthTexture"].SetValue(rHelper[PrincipalConstants.DephRT]);
shader.Parameters["depthTexture"].SetValue(depth);
//shader.Parameters["InvertViewProjection"].SetValue(Matrix.Invert(world.CameraManager.ActiveCamera.Projection));
NumberSteps = 8;
NumberDirections = 12;
Radius = 10f;
LineAttenuation = 0.75f;
Contrast = 1.0f;
AngleBias = 0.00218166653f;
LineAttenuation = 0.75f;
// It works a the depth texture resolution. Use a downsampled version of the G-Buffer.
SetResolution(new Vector2(GraphicInfo.BackBufferWidth, GraphicInfo.BackBufferHeight));
SetInverseResolution(new Vector2(1f / (float)GraphicInfo.BackBufferWidth, 1f / (float)GraphicInfo.BackBufferHeight));
SetNumberSteps(8);
SetNumberDirections(12);
SetContrast(Contrast / (1.0f - (float)Math.Sin(AngleBias)));
SetLineAttenuation(LineAttenuation);
SetRadius(Radius);
SetAngleBias(AngleBias);
SetHalfPixel(GraphicInfo.HalfPixel);
float _tanFovy = (float)Math.Tan(world.CameraManager.ActiveCamera.FieldOfView / 2);
Vector2 focalLen = new Vector2
{
X = world.CameraManager.ActiveCamera.AspectRatio / _tanFovy,
Y = 1.0f / _tanFovy
};
//pointLightEffect.Parameters["farPlane"].SetValue(camera.FarPlane);
SetFocalLength(focalLen);
SetInverseFocalLength(new Vector2(_tanFovy * world.CameraManager.ActiveCamera.AspectRatio, -_tanFovy));
SetSquareRadius(AngleBias * AngleBias);
SetInverseRadius(1f / AngleBias);
SetTanAngleBias((float)Math.Tan(AngleBias));
//rHelper.PushRenderTarget(RenderTarget2D);
rHelper.SetSamplerStates(SamplerState.PointWrap);
rHelper.Clear(Color.White);
rHelper.RenderFullScreenQuadVertexPixel(shader, SamplerState.PointWrap);
return;
Texture2D t = rHelper.PopRenderTargetAsSingleRenderTarget2D();
//rHelper.PushRenderTarget(RenderTarget2D2);
//rHelper.Clear(Color.Black);
//g.Draw(t, rHelper, gt, GraphicInfo, world, useFloatBuffer);
//t = rHelper.PopRenderTargetAsSingleRenderTarget2D();
ssaofinal.Parameters["SSAOTex"].SetValue(t);
ssaofinal.Parameters["SceneTexture"].SetValue(ImageToProcess);
ssaofinal.Parameters["halfPixel"].SetValue(GraphicInfo.HalfPixel);
ssaofinal.Parameters["weight"].SetValue(1);
rHelper.SetSamplerStates(SamplerState.PointClamp);
if (useFloatBuffer)
{
rHelper.RenderFullScreenQuadVertexPixel(ssaofinal, SamplerState.PointClamp);
}
else
{
rHelper.RenderFullScreenQuadVertexPixel(ssaofinal, GraphicInfo.SamplerState);
}
}
public override void Draw(Texture2D ImageToProcess, RenderHelper rHelper, GameTime gt, Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatingBuffer)
{
effect.Parameters["Params"].SetValue(new Vector4(GraphicInfo.BackBufferWidth, GraphicInfo.BackBufferHeight, world.CameraManager.ActiveCamera.FarPlane, intensity));
effect.Parameters["DepthBuffer"].SetValue(rHelper[PrincipalConstants.DephRT]);
effect.Parameters["NormalBuffer"].SetValue(rHelper[PrincipalConstants.normalRt]);
effect.Parameters["RandomTexture"].SetValue(RandomTexture);
effect.Parameters["InvProj"].SetValue(Matrix.Transpose(Matrix.Invert(world.CameraManager.ActiveCamera.Projection)));
effect.Parameters["View"].SetValue(world.CameraManager.ActiveCamera.View);
effect.Parameters["jitter"].SetValue(jitter);
effect.Parameters["halfPixel"].SetValue(GraphicInfo.HalfPixel);
effect.Parameters["diffScale"].SetValue(diffscale);
effect.Parameters["whiteCorrection"].SetValue(whiteCorrection);
if (outputONLYSSAOMAP)
{
rHelper.RenderFullScreenQuadVertexPixel(effect);
return;
}
rHelper.PushRenderTarget(target);
rHelper.Clear(Color.Black, ClearOptions.Target);
rHelper.RenderFullScreenQuadVertexPixel(effect);
Texture2D r = rHelper.PopRenderTargetAsSingleRenderTarget2D();
if (blurMode == BlurMode.SINGLE || blurMode == BlurMode.DOUBLE)
{
rHelper.PushRenderTarget(target2);
rHelper.Clear(Color.Black, ClearOptions.Target);
gbp.Draw(r, rHelper, gt, GraphicInfo, world, useFloatingBuffer);
Texture2D x = rHelper.PopRenderTargetAsSingleRenderTarget2D();
if (blurMode == BlurMode.DOUBLE)
{
rHelper.PushRenderTarget(target3);
rHelper.Clear(Color.Black, ClearOptions.Target);
gbp.Draw(x, rHelper, gt, GraphicInfo, world, useFloatingBuffer);
x = rHelper.PopRenderTargetAsSingleRenderTarget2D();
}
ssaofinal.Parameters["SSAOTex"].SetValue(x);
}
else if (blurMode == BlurMode.NONE)
{
ssaofinal.Parameters["SSAOTex"].SetValue(r);
}
rHelper.Clear(Color.Black, ClearOptions.Target);
ssaofinal.Parameters["SceneTexture"].SetValue(ImageToProcess);
ssaofinal.Parameters["halfPixel"].SetValue(GraphicInfo.HalfPixel);
ssaofinal.Parameters["weight"].SetValue(Weight);
if (useFloatingBuffer)
rHelper.RenderFullScreenQuadVertexPixel(ssaofinal, SamplerState.PointClamp);
else
rHelper.RenderFullScreenQuadVertexPixel(ssaofinal, GraphicInfo.SamplerState);
}
protected override void ExecuteTechnic(Microsoft.Xna.Framework.GameTime gameTime, RenderHelper render, IWorld world)
{
ICamera camera = world.CameraManager.ActiveCamera;
Matrix view = world.CameraManager.ActiveCamera.View;
Matrix projection = world.CameraManager.ActiveCamera.Projection;
ComputeFrustumCorners(camera);
world.Culler.StartFrame(ref view, ref projection, world.CameraManager.ActiveCamera.BoundingFrustum);
List <IObject> AllnotCulledObjectsList = world.Culler.GetNotCulledObjectsList(null);
List <IObject> DeferrednotCulledObjectsList = world.Culler.GetNotCulledObjectsList(MaterialType.DEFERRED);
List <IObject> ForwardnotCulledObjectsList = world.Culler.GetNotCulledObjectsList(MaterialType.FORWARD);
foreach (IObject item in AllnotCulledObjectsList)
{
if (item.Material.IsVisible)
{
item.Material.PreDrawnPhase(gameTime, world, item, world.CameraManager.ActiveCamera, world.Lights, render);
}
}
render.PushRenderTargetBinding(_gBufferBinding);
render.Clear(Color.Black, ClearOptions.DepthBuffer | ClearOptions.Stencil, 1.0f, 0);
render.PushDepthStencilState(DepthStencilState.None);
render.PushRasterizerState(RasterizerState.CullNone);
render.RenderFullScreenQuadVertexPixel(_clearGBuffer);
render.PopDepthStencilState();
render.PopRasterizerState();
foreach (IObject item in DeferrednotCulledObjectsList)
{
if (item.Material.IsVisible)
{
item.Material.Drawn(gameTime, item, world.CameraManager.ActiveCamera, world.Lights, render);
}
}
render.PopRenderTarget();
render[PrincipalConstants.DephRT] = _depthBuffer;
render[PrincipalConstants.normalRt] = _normalBuffer;
//render.PushRenderTargetBinding(_lightAccumBinding);
render.Clear(new Color(0, 0, 0, 0));
render.PushDepthStencilState(DepthStencilState.None);
//draw using additive blending.
//At first I was using BlendState.additive, but it seems to use alpha channel for modulation,
//and as we use alpha channel as the specular intensity, we have to create our own blend state here
render.PushBlendState(_lightAddBlendState);
RenderLights(camera, world, render, ginfo);
//render[PrincipalConstants.lightRt] = render.PopRenderTarget()[0].RenderTarget as Texture2D;
render.PopDepthStencilState();
render.PopBlendState();
return;
render.PushRenderTarget(_outputTexture);
render.Clear(Color.Black);
foreach (IObject item in AllnotCulledObjectsList)
{
if (item.Material.IsVisible)
{
item.Material.PosDrawnPhase(gameTime, item, world.CameraManager.ActiveCamera, world.Lights, render);
}
}
if (world.PhysicWorld.isDebugDraw)
{
//world.PhysicWorld.iDebugDrawn(render, gameTime, world.CameraManager.ActiveCamera);
}
if (world.ParticleManager != null)
{
//world.ParticleManager.iDraw(gameTime, world.CameraManager.ActiveCamera.View, world.CameraManager.ActiveCamera.Projection, render);
//render.ResyncStates();
}
ForwardPass.Draw(gameTime, world, render, DeferrednotCulledObjectsList, ForwardnotCulledObjectsList);
render.RenderPosWithDepthComponents(gameTime, ref view, ref projection);
render[PrincipalConstants.CurrentImage] = render.PopRenderTargetAsSingleRenderTarget2D();
for (int i = 0; i < PostEffects.Count; i++)
{
if (PostEffects[i].Enabled)
{
render.PushRenderTarget(PostEffectTarget);
render.Clear(Color.Black);
PostEffects[i].Draw(render[PrincipalConstants.CurrentImage], render, gameTime, ginfo, world, true);
Texture2D tex = render.PopRenderTarget()[0].RenderTarget as Texture2D;
System.Diagnostics.Debug.Assert(tex != null);
render[PrincipalConstants.CurrentImage] = tex;
SwapTargetBuffers();
}
}
render.Clear(Color.Black);
render.RenderTextureComplete(render[PrincipalConstants.CurrentImage], Color.White, ginfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.PointClamp);
render.RenderPosComponents(gameTime, ref view, ref projection);
}
public void DrawLights(GameTime gameTime, IWorld world, IDeferredGBuffer deferredGBuffer, RenderHelper render)
{
render.Clear(Color.Transparent, ClearOptions.Target);
foreach (ILight light in world.Lights.Where((a) => a.CastShadown == true && a.Enabled == true))
{
switch (light.LightType)
{
case LightType.Deferred_Directional:
DirectionalLightPE dl = light as DirectionalLightPE;
shadowMap = shadow.Render(gameTime, render, ginfo, dl, world.CameraManager.ActiveCamera, world, deferredGBuffer);
render.PushBlendState(_lightAddBlendState);
DrawDirectionalLight(render, ginfo, world.CameraManager.ActiveCamera, dl, deferredGBuffer);
render.PopBlendState();
break;
case LightType.Deferred_Point:
#if WINDOWS
System.Diagnostics.Debug.Fail("Point Light Shadow not supported, in production no error will be created, the light just wont cast any shadow");
#endif
render.PushBlendState(_lightAddBlendState);
DrawPointLight(render, ginfo, world.CameraManager.ActiveCamera, light as PointLightPE, deferredGBuffer, true);
render.PopBlendState();
break;
case LightType.Deferred_Spot:
SpotLightPE sl = light as SpotLightPE;
Matrix v = sl.ViewMatrix;
Matrix p =sl.ProjMatrix;
RenderShadowMap(gameTime, render, ref v, ref p, world, deferredGBuffer);
render.PushBlendState(_lightAddBlendState);
DrawnSpotLight(render, ginfo, world.CameraManager.ActiveCamera, sl, deferredGBuffer);
render.PopBlendState();
break;
default:
throw new Exception("Light type Unexpected");
}
}
render.DettachBindedTextures();
render.SetSamplerStates(ginfo.SamplerState);
render.PushBlendState(_lightAddBlendState);
foreach (ILight light in world.Lights.Where((a) => a.CastShadown != true && a.Enabled == true))
{
switch (light.LightType)
{
case LightType.Deferred_Directional:
DirectionalLightPE dl = light as DirectionalLightPE;
DrawDirectionalLight(render,ginfo, world.CameraManager.ActiveCamera, dl, deferredGBuffer);
break;
case LightType.Deferred_Point:
DrawPointLight(render,ginfo, world.CameraManager.ActiveCamera, light as PointLightPE, deferredGBuffer,true);
break;
case LightType.Deferred_Spot:
SpotLightPE sl = light as SpotLightPE;
DrawnSpotLight(render,ginfo, world.CameraManager.ActiveCamera, sl, deferredGBuffer);
break;
default:
throw new Exception("Light type Unexpected");
}
}
render.PopBlendState();
}
/// <summary>
/// Draws the specified game time.
/// </summary>
/// <param name="gameTime">The game time.</param>
/// <param name="world">The world.</param>
/// <param name="render">The render.</param>
protected void Draw(GameTime gameTime, IWorld world, RenderHelper render)
{
Matrix view = world.CameraManager.ActiveCamera.View;
Matrix projection = world.CameraManager.ActiveCamera.Projection;
world.Culler.StartFrame(ref view, ref projection, world.CameraManager.ActiveCamera.BoundingFrustum);
List<IObject> AllnotCulledObjectsList = world.Culler.GetNotCulledObjectsList(null);
List<IObject> DeferrednotCulledObjectsList = world.Culler.GetNotCulledObjectsList(MaterialType.DEFERRED, CullerComparer.ComparerFrontToBack,world.CameraManager.ActiveCamera.Position);
List<IObject> ForwardnotCulledObjectsList = world.Culler.GetNotCulledObjectsList(MaterialType.FORWARD, CullerComparer.ComparerBackToFront, world.CameraManager.ActiveCamera.Position);
if (desc.OrderAllObjectsBeforeDraw != null)
AllnotCulledObjectsList = desc.OrderAllObjectsBeforeDraw(AllnotCulledObjectsList,world);
if (desc.OrderDeferredObjectsBeforeDraw != null)
DeferrednotCulledObjectsList = desc.OrderDeferredObjectsBeforeDraw(DeferrednotCulledObjectsList, world);
if (desc.OrderForwardObjectsBeforeDraw != null)
ForwardnotCulledObjectsList = desc.OrderForwardObjectsBeforeDraw(ForwardnotCulledObjectsList, world);
render.SetSamplerStates(ginfo.SamplerState);
render.DettachBindedTextures();
deferredGBuffer.PreDrawScene(gameTime, world, render, ginfo, AllnotCulledObjectsList);
render.SetSamplerStates(ginfo.SamplerState);
render.DettachBindedTextures();
deferredGBuffer.SetGBuffer(render);
deferredGBuffer.ClearGBuffer(render);
deferredGBuffer.DrawScene(gameTime, world, render, ginfo, DeferrednotCulledObjectsList);
deferredGBuffer.ResolveGBuffer(render);
render.DettachBindedTextures();
render.ValidateSamplerStates();
deferredLightMap.SetLightMap(render);
deferredLightMap.DrawLights(gameTime, world, deferredGBuffer, render);
deferredLightMap.ResolveLightMap(render);
render.DettachBindedTextures(5);
render.ValidateSamplerStates();
deferredFinalCombination.SetFinalCombination(render);
deferredFinalCombination.DrawScene(gameTime, world, deferredGBuffer, deferredLightMap,render);
render.DettachBindedTextures(3);
render.ValidateSamplerStates();
if (desc.ExtraForwardPass)
{
render[PrincipalConstants.colorRT] = deferredGBuffer[GBufferTypes.COLOR];
render[PrincipalConstants.normalRt] = deferredGBuffer[GBufferTypes.NORMAL];
render[PrincipalConstants.lightRt] = deferredLightMap[DeferredLightMapType.LIGHTMAP];
render[PrincipalConstants.DephRT] = deferredGBuffer[GBufferTypes.DEPH];
render[PrincipalConstants.extra1RT] = deferredGBuffer[GBufferTypes.Extra1];
render[PrincipalConstants.CombinedImage] = deferredFinalCombination[GBufferTypes.FINALIMAGE];
render[PrincipalConstants.CurrentImage] = deferredFinalCombination[GBufferTypes.FINALIMAGE];
if (desc.RestoreDepthOption == RestoreDepthOption.BEFORE_POSTEFFECT)
{
restoreDepth.PerformForwardPass(render[PrincipalConstants.CombinedImage], render[PrincipalConstants.DephRT], render,ginfo);
render.DettachBindedTextures(2);
render.ValidateSamplerStates();
if (world.PhysicWorld.isDebugDraw)
{
world.PhysicWorld.iDebugDrawn(render, gameTime, world.CameraManager.ActiveCamera);
}
if (world.ParticleManager != null)
{
world.ParticleManager.iDraw(gameTime, world.CameraManager.ActiveCamera.View, world.CameraManager.ActiveCamera.Projection, render);
render.ResyncStates();
render.SetSamplerStates(ginfo.SamplerState);
}
render.DettachBindedTextures(6);
render.ValidateSamplerStates();
forwardPass.Draw(gameTime, world, render,DeferrednotCulledObjectsList,ForwardnotCulledObjectsList);
render.DettachBindedTextures(6);
render.ValidateSamplerStates();
render.RenderPosWithDepthComponents(gameTime, ref view, ref projection);
render.DettachBindedTextures(6);
render.ValidateSamplerStates();
render[PrincipalConstants.CurrentImage] = restoreDepth.EndForwardPass(render);
render[PrincipalConstants.CombinedImage] = render[PrincipalConstants.CurrentImage];
for (int i = 0; i < PostEffects.Count; i++)
{
if (PostEffects[i].Enabled)
{
render.PushRenderTarget(PostEffectTarget);
render.Clear(Color.Black);
PostEffects[i].Draw(render[PrincipalConstants.CurrentImage], render, gameTime, ginfo, world, desc.UseFloatingBufferForLightMap);
Texture2D tex = render.PopRenderTarget()[0].RenderTarget as Texture2D;
render[PrincipalConstants.CurrentImage] = tex;
SwapTargetBuffers();
}
}
render.SetSamplerStates(ginfo.SamplerState);
render.DettachBindedTextures(6);
if (desc.UseFloatingBufferForLightMap)
{
render.Clear(Color.Black);
render.RenderTextureComplete(render[PrincipalConstants.CurrentImage], Color.White, ginfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.PointClamp);
}
else
{
render.Clear(Color.Black);
render.RenderTextureComplete(render[PrincipalConstants.CurrentImage], Color.White, ginfo.FullScreenRectangle, Matrix.Identity,null,true,SpriteSortMode.Deferred,ginfo.SamplerState);
}
}
else if (desc.RestoreDepthOption == RestoreDepthOption.AFTER_POSTEFFECT)
{
for (int i = 0; i < PostEffects.Count; i++)
{
if (PostEffects[i].Enabled)
{
render.PushRenderTarget(PostEffectTarget);
render.Clear(Color.Black);
PostEffects[i].Draw(render[PrincipalConstants.CurrentImage], render, gameTime, ginfo, world, desc.UseFloatingBufferForLightMap);
Texture2D tex = render.PopRenderTarget()[0].RenderTarget as Texture2D;
render[PrincipalConstants.CurrentImage] = tex;
SwapTargetBuffers();
}
}
render.SetSamplerStates(ginfo.SamplerState);
render.DettachBindedTextures(16);
restoreDepth.PerformForwardPass(render[PrincipalConstants.CurrentImage], render[PrincipalConstants.DephRT], render, ginfo);
render.DettachBindedTextures(2);
if (world.PhysicWorld.isDebugDraw)
{
world.PhysicWorld.iDebugDrawn(render, gameTime, world.CameraManager.ActiveCamera);
}
if (world.ParticleManager != null)
{
world.ParticleManager.iDraw(gameTime, world.CameraManager.ActiveCamera.View, world.CameraManager.ActiveCamera.Projection, render);
render.ResyncStates();
render.SetSamplerStates(ginfo.SamplerState);
}
render.DettachBindedTextures(16);
forwardPass.Draw(gameTime, world, render,DeferrednotCulledObjectsList,ForwardnotCulledObjectsList);
render.DettachBindedTextures(16);
render.RenderPosWithDepthComponents(gameTime, ref view, ref projection);
render.DettachBindedTextures(16);
render[PrincipalConstants.CurrentImage] = restoreDepth.EndForwardPass(render);
if (desc.UseFloatingBufferForLightMap)
{
System.Diagnostics.Debug.Assert(render.PeekBlendState() == BlendState.Opaque);
render.Clear(Color.Black);
render.RenderTextureComplete(render[PrincipalConstants.CurrentImage], Color.White, ginfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.PointClamp);
System.Diagnostics.Debug.Assert(render.PeekBlendState() == BlendState.Opaque);
}
else
{
render.Clear(Color.Black);
render.RenderTextureComplete(render[PrincipalConstants.CurrentImage], Color.White, ginfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, ginfo.SamplerState);
}
}
else if (desc.RestoreDepthOption == RestoreDepthOption.NONE)
{
for (int i = 0; i < PostEffects.Count ; i++)
{
if (PostEffects[i].Enabled)
{
render.PushRenderTarget(PostEffectTarget);
render.Clear(Color.Black);
PostEffects[i].Draw(render[PrincipalConstants.CurrentImage], render, gameTime, ginfo, world, desc.UseFloatingBufferForLightMap);
Texture2D tex = render.PopRenderTarget()[0].RenderTarget as Texture2D;
System.Diagnostics.Debug.Assert(tex != null);
render[PrincipalConstants.CurrentImage] = tex;
SwapTargetBuffers();
}
}
if (desc.UseFloatingBufferForLightMap)
{
render.Clear(Color.Black);
render.RenderTextureComplete(render[PrincipalConstants.CurrentImage], Color.White, ginfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, SamplerState.PointClamp);
}
else
{
render.Clear(Color.Black);
render.RenderTextureComplete(render[PrincipalConstants.CurrentImage], Color.White, ginfo.FullScreenRectangle, Matrix.Identity, null, true, SpriteSortMode.Deferred, ginfo.SamplerState);
}
}
render.RenderPosComponents(gameTime, ref view, ref projection);
if (desc.DefferedDebug)
{
render.Clear(Color.Black);
if (desc.UseFloatingBufferForLightMap)
render.RenderBegin(Matrix.Identity,null,SpriteSortMode.Immediate,SamplerState.PointClamp);
else
render.RenderBegin(Matrix.Identity, null, SpriteSortMode.Immediate, ginfo.SamplerState);
render.RenderTexture(render[desc.RenderTargetsNameToDefferedDebug[0]] ,Color.White, new Rectangle(0, 0, halfWidth, halfHeight));
render.RenderTexture(render[desc.RenderTargetsNameToDefferedDebug[1]], Color.White, new Rectangle(0, halfHeight, halfWidth, halfHeight));
render.RenderTexture(render[desc.RenderTargetsNameToDefferedDebug[2]], Color.White, new Rectangle(halfWidth, 0, halfWidth, halfHeight));
render.RenderTexture(render[desc.RenderTargetsNameToDefferedDebug[3]], Color.White, new Rectangle(halfWidth, halfHeight, halfWidth, halfHeight));
render.RenderEnd();
}
}
else
{
render.RenderPosComponents(gameTime, ref view, ref projection);
}
render.ValidateSamplerStates();
}
