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); }
/// <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(); }