Пример #1
0
 /// <summary>
 /// Initializes a new instance of the <see cref="DepthOfFieldEffect"/> class.
 /// </summary>
 public DepthOfFieldEffect(GraphicsDevice graphics)
 {
     Material = combine = new DepthOfFieldMaterial(graphics);
     Passes.Add(new PostEffectChain(TextureUsage.Blur,
                                    depthScaleEffect = new PostEffect()
     {
         Material = depthScale = new DepthOfFieldMaterial(graphics)
         {
             IsDownScale = true
         }, RenderTargetScale = 0.5f
     },
                                    scaleEffect = new PostEffect()
     {
         Material = new ScaleMaterial(graphics), RenderTargetScale = 0.5f, Enabled = false
     },
                                    blur = new BlurEffect(graphics)
     {
         DepthBufferEnabled = true
     },
                                    new PostEffect()
     {
         Material = new ScaleMaterial(graphics), RenderTargetScale = 2.0f
     }
                                    ));
 }
Пример #2
0
        private void DrawWithoutCombineMaterial(DrawingContext context, IList <IDrawableObject> drawables)
        {
            RenderTargetPool.Lock(InputTexture as RenderTarget2D);

            int i, p;

            for (p = 0; p < passes.Count; p++)
            {
                passes[p].GetActivePasses(workingPasses);

                RenderTarget2D intermediate = InputTexture as RenderTarget2D;
                for (i = 0; i < workingPasses.Count - 1; ++i)
                {
                    var workingPass = (PostEffect)workingPasses[i];

                    RenderTarget2D previous = intermediate;
                    RenderTargetPool.Lock(previous);
                    intermediate = workingPass.PrepareRenderTarget(context.graphics, intermediate, null);
                    intermediate.Begin();

                    workingPass.InputTexture = previous;
                    workingPass.Draw(context, drawables);

                    intermediate.End();
                    RenderTargetPool.Unlock(previous);
                }

                PostEffect lastEffect;
                RenderTargetPool.Lock(intermediate);

                if (workingPasses.Count > 0)
                {
                    lastEffect = (PostEffect)workingPasses[workingPasses.Count - 1];
                }
                else
                {
                    if (basicPostEffect == null)
                    {
                        basicPostEffect          = new PostEffect();
                        basicPostEffect.Material = new TextureMaterial(context.graphics);
                    }
                    lastEffect = basicPostEffect;
                }

                lastEffects.Add(lastEffect);
                passResults.Add(intermediate);

                workingPasses.Clear();
            }

            RenderTargetPool.Unlock(InputTexture as RenderTarget2D);

            for (i = 0, p = 0; p < passes.Count; p++)
            {
                if (passes[p].Enabled)
                {
                    lastEffects[i].BlendState   = passes[p].BlendState;
                    lastEffects[i].InputTexture = passResults[i];
                    lastEffects[i].Draw(context, drawables);

                    RenderTargetPool.Unlock(passResults[i]);
                    i++;
                }
            }

            lastEffects.Clear();
            passResults.Clear();
        }