Пример #1
0
 public void AddEffect(BasePostProcessingEffect ppEfect)
 {
     postProcessingEffects.Add(ppEfect);
 }
Пример #2
0
        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
            kbm.PreUpdate(gameTime);
            base.Update(gameTime);

            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || kbm.KeyDown(Keys.Escape))
            {
                Exit();
            }

            earth.Rotate(Vector3.Up, .0001f);

            // Camera controls..
            float speedTran = .1f;
            float speedRot  = .01f;

            if (kbm.KeyDown(Keys.W) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y > 0)
            {
                camera.Translate(Vector3.Forward * speedTran);
            }
            if (kbm.KeyDown(Keys.S) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y < 0)
            {
                camera.Translate(Vector3.Backward * speedTran);
            }
            if (kbm.KeyDown(Keys.A) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X < 0)
            {
                camera.Translate(Vector3.Left * speedTran);
            }
            if (kbm.KeyDown(Keys.D) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X > 0)
            {
                camera.Translate(Vector3.Right * speedTran);
            }

            if (kbm.KeyDown(Keys.Left) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X < 0)
            {
                camera.Rotate(Vector3.Up, speedRot);
            }
            if (kbm.KeyDown(Keys.Right) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X > 0)
            {
                camera.Rotate(Vector3.Up, -speedRot);
            }
            if (kbm.KeyDown(Keys.Up) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.Y > 0)
            {
                camera.Rotate(Vector3.Right, speedRot);
            }
            if (kbm.KeyDown(Keys.Down) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.Y < 0)
            {
                camera.Rotate(Vector3.Right, -speedRot);
            }

            if (kbm.KeyPress(Keys.F1))
            {
                selectedEffect = bloom;
            }

            if (kbm.KeyPress(Keys.F2))
            {
                selectedEffect = GodRays;
            }

            if (kbm.KeyPress(Keys.F3))
            {
                selectedEffect = dof;
            }

            if (kbm.KeyPress(Keys.F4))
            {
                selectedEffect = fog;
            }

            if (kbm.KeyPress(Keys.F5))
            {
                selectedEffect = haze;
            }

            if (kbm.KeyPress(Keys.F6))
            {
                selectedEffect = radialBlur;
            }

            if (kbm.KeyPress(Keys.F7))
            {
                selectedEffect = ripple;
            }

            if (kbm.KeyPress(Keys.F8))
            {
                selectedEffect = sun;
            }

            if (kbm.KeyPress(Keys.F9))
            {
                selectedEffect = sepia;
            }

            if (kbm.KeyPress(Keys.F10))
            {
                selectedEffect = greyScale;
            }

            if (kbm.KeyPress(Keys.F11))
            {
                selectedEffect = invert;
            }

            if (kbm.KeyPress(Keys.F12))
            {
                selectedEffect = deRezed;
            }

            if (kbm.KeyPress(Keys.D1))
            {
                selectedEffect = colorFilter;
            }

            if (kbm.KeyPress(Keys.D2))
            {
                selectedEffect = bleach;
            }

            if (kbm.KeyPress(Keys.D3))
            {
                selectedEffect = scanLines;
            }


            if (selectedEffect != null)
            {
                if (kbm.KeyPress(Keys.Space))
                {
                    selectedEffect.Enabled = !selectedEffect.Enabled;
                }

                if (selectedEffect == bloom)
                {
                    if (kbm.KeyPress(Keys.G))
                    {
                        bloom.Glare = !bloom.Glare;
                    }

                    if (kbm.KeyDown(Keys.Y))
                    {
                        bloom.BloomThreshold = MathHelper.Min(bloom.BloomThreshold + .001f, 1f);
                    }
                    if (kbm.KeyDown(Keys.H))
                    {
                        bloom.BloomThreshold = MathHelper.Max(bloom.BloomThreshold - .001f, 0.0f);
                    }

                    if (kbm.KeyDown(Keys.U))
                    {
                        bloom.BlurAmount = MathHelper.Min(bloom.BlurAmount + .1f, 4);
                    }
                    if (kbm.KeyDown(Keys.J))
                    {
                        bloom.BlurAmount = MathHelper.Max(bloom.BlurAmount - .1f, 0.1f);
                    }
                }
                else if (selectedEffect == GodRays)
                {
                    if (kbm.KeyDown(Keys.R))
                    {
                        GodRays.LightSourceSize = MathHelper.Min(GodRays.LightSourceSize + .5f, 10000);
                    }
                    if (kbm.KeyDown(Keys.F))
                    {
                        GodRays.LightSourceSize = MathHelper.Max(GodRays.LightSourceSize - .5f, .5f);
                    }

                    if (kbm.KeyDown(Keys.T))
                    {
                        GodRays.Density = MathHelper.Min(GodRays.Density + .01f, 1);
                    }
                    if (kbm.KeyDown(Keys.G))
                    {
                        GodRays.Density = MathHelper.Max(GodRays.Density - .01f, 0);
                    }

                    if (kbm.KeyDown(Keys.Y))
                    {
                        GodRays.Decay = MathHelper.Min(GodRays.Decay + .0001f, 1);
                    }
                    if (kbm.KeyDown(Keys.H))
                    {
                        GodRays.Decay = MathHelper.Max(GodRays.Decay - .0001f, 0);
                    }

                    if (kbm.KeyDown(Keys.U))
                    {
                        GodRays.Weight = MathHelper.Min(GodRays.Weight + .001f, 1);
                    }
                    if (kbm.KeyDown(Keys.J))
                    {
                        GodRays.Weight = MathHelper.Max(GodRays.Weight - .001f, 0);
                    }

                    if (kbm.KeyDown(Keys.I))
                    {
                        GodRays.Exposure = MathHelper.Min(GodRays.Exposure + .001f, 1);
                    }
                    if (kbm.KeyDown(Keys.K))
                    {
                        GodRays.Exposure = MathHelper.Max(GodRays.Exposure - .001f, 0);
                    }

                    if (kbm.KeyDown(Keys.O))
                    {
                        GodRays.BrightThreshold = MathHelper.Min(GodRays.BrightThreshold + .01f, .999f);
                    }
                    if (kbm.KeyDown(Keys.L))
                    {
                        GodRays.BrightThreshold = MathHelper.Max(GodRays.BrightThreshold - .01f, 0);
                    }
                }
                else if (selectedEffect == dof)
                {
                    if (kbm.KeyDown(Keys.R))
                    {
                        dof.DiscRadius = MathHelper.Min(dof.DiscRadius + .1f, camera.Viewport.MaxDepth);
                    }
                    if (kbm.KeyDown(Keys.F))
                    {
                        dof.DiscRadius = MathHelper.Max(dof.DiscRadius - .1f, 0);
                    }

                    if (kbm.KeyDown(Keys.T))
                    {
                        dof.FocalDistance = MathHelper.Min(dof.FocalDistance + .1f, camera.Viewport.MaxDepth);
                    }
                    if (kbm.KeyDown(Keys.G))
                    {
                        dof.FocalDistance = MathHelper.Max(dof.FocalDistance - .1f, 0);
                    }

                    if (kbm.KeyDown(Keys.Y))
                    {
                        dof.FocalRange = MathHelper.Min(dof.FocalRange + .1f, camera.Viewport.MaxDepth);
                    }
                    if (kbm.KeyDown(Keys.H))
                    {
                        dof.FocalRange = MathHelper.Max(dof.FocalRange - .1f, 0);
                    }
                }
                else if (selectedEffect == fog)
                {
                    if (kbm.KeyDown(Keys.R))
                    {
                        fog.FogDistance = MathHelper.Min(fog.FogDistance + .1f, camera.Viewport.MaxDepth);
                    }
                    if (kbm.KeyDown(Keys.F))
                    {
                        fog.FogDistance = MathHelper.Max(fog.FogDistance - .1f, 1);
                    }

                    if (kbm.KeyDown(Keys.T))
                    {
                        fog.FogRange = MathHelper.Min(fog.FogRange + .1f, camera.Viewport.MaxDepth);
                    }
                    if (kbm.KeyDown(Keys.G))
                    {
                        fog.FogRange = MathHelper.Max(fog.FogRange - .1f, 1);
                    }

                    if (kbm.KeyDown(Keys.Y))
                    {
                        fog.FogColor = SetColor(fog.FogColor.ToVector4() + new Vector4(.01f, 0, 0, 0));
                    }
                    if (kbm.KeyDown(Keys.H))
                    {
                        fog.FogColor = SetColor(fog.FogColor.ToVector4() - new Vector4(.01f, 0, 0, 0));
                    }

                    if (kbm.KeyDown(Keys.U))
                    {
                        fog.FogColor = SetColor(fog.FogColor.ToVector4() + new Vector4(0, .01f, 0, 0));
                    }
                    if (kbm.KeyDown(Keys.J))
                    {
                        fog.FogColor = SetColor(fog.FogColor.ToVector4() - new Vector4(0, .01f, 0, 0));
                    }

                    if (kbm.KeyDown(Keys.I))
                    {
                        fog.FogColor = SetColor(fog.FogColor.ToVector4() + new Vector4(0, 0, .01f, 0));
                    }
                    if (kbm.KeyDown(Keys.K))
                    {
                        fog.FogColor = SetColor(fog.FogColor.ToVector4() - new Vector4(0, 0, .01f, 0));
                    }

                    if (kbm.KeyDown(Keys.O))
                    {
                        fog.FogColor = SetColor(fog.FogColor.ToVector4() + new Vector4(0, 0, 0, .01f));
                    }
                    if (kbm.KeyDown(Keys.L))
                    {
                        fog.FogColor = SetColor(fog.FogColor.ToVector4() - new Vector4(0, 0, 0, .01f));
                    }
                }
                else if (selectedEffect == haze)
                {
                    if (kbm.KeyPress(Keys.H))
                    {
                        haze.High = !haze.High;
                    }
                }
                else if (selectedEffect == radialBlur)
                {
                    if (kbm.KeyDown(Keys.R))
                    {
                        radialBlur.Scale = MathHelper.Min(radialBlur.Scale + .001f, 1);
                    }
                    if (kbm.KeyDown(Keys.F))
                    {
                        radialBlur.Scale = MathHelper.Max(radialBlur.Scale - .001f, 0);
                    }
                }
                else if (selectedEffect == ripple)
                {
                    if (kbm.KeyDown(Keys.T))
                    {
                        ripple.Distortion = MathHelper.Min(ripple.Distortion + .01f, 100);
                    }
                    if (kbm.KeyDown(Keys.G))
                    {
                        ripple.Distortion = MathHelper.Max(ripple.Distortion - .01f, 0);
                    }

                    if (kbm.KeyDown(Keys.Y))
                    {
                        ripple.ScreenPosition = SetVector2(ripple.ScreenPosition + new Vector2(.001f, 0));
                    }
                    if (kbm.KeyDown(Keys.H))
                    {
                        ripple.ScreenPosition = SetVector2(ripple.ScreenPosition - new Vector2(.001f, 0));
                    }

                    if (kbm.KeyDown(Keys.U))
                    {
                        ripple.ScreenPosition = SetVector2(ripple.ScreenPosition + new Vector2(0, .001f));
                    }
                    if (kbm.KeyDown(Keys.J))
                    {
                        ripple.ScreenPosition = SetVector2(ripple.ScreenPosition + new Vector2(0, .001f));
                    }
                }
                else if (selectedEffect == colorFilter)
                {
                    if (kbm.KeyDown(Keys.R))
                    {
                        colorFilter.Bright = MathHelper.Min(colorFilter.Bright + .001f, 1);
                    }
                    if (kbm.KeyDown(Keys.F))
                    {
                        colorFilter.Bright = MathHelper.Max(colorFilter.Bright - .001f, 0);
                    }

                    if (kbm.KeyDown(Keys.T))
                    {
                        colorFilter.Saturation = MathHelper.Min(colorFilter.Saturation + .001f, 1);
                    }
                    if (kbm.KeyDown(Keys.G))
                    {
                        colorFilter.Saturation = MathHelper.Max(colorFilter.Saturation - .001f, 0);
                    }

                    if (kbm.KeyDown(Keys.Y))
                    {
                        colorFilter.Burn = MathHelper.Min(colorFilter.Burn + .001f, 1);
                    }
                    if (kbm.KeyDown(Keys.H))
                    {
                        colorFilter.Burn = MathHelper.Max(colorFilter.Burn - .001f, 0);
                    }

                    if (kbm.KeyDown(Keys.U))
                    {
                        colorFilter.Color = SetColor(colorFilter.Color.ToVector4() + new Vector4(.01f, 0, 0, 0));
                    }
                    if (kbm.KeyDown(Keys.J))
                    {
                        colorFilter.Color = SetColor(colorFilter.Color.ToVector4() - new Vector4(.01f, 0, 0, 0));
                    }

                    if (kbm.KeyDown(Keys.I))
                    {
                        colorFilter.Color = SetColor(colorFilter.Color.ToVector4() + new Vector4(0, .01f, 0, 0));
                    }
                    if (kbm.KeyDown(Keys.K))
                    {
                        colorFilter.Color = SetColor(colorFilter.Color.ToVector4() - new Vector4(0, .01f, 0, 0));
                    }

                    if (kbm.KeyDown(Keys.O))
                    {
                        colorFilter.Color = SetColor(colorFilter.Color.ToVector4() + new Vector4(0, 0, .01f, 0));
                    }
                    if (kbm.KeyDown(Keys.L))
                    {
                        colorFilter.Color = SetColor(colorFilter.Color.ToVector4() - new Vector4(0, 0, .01f, 0));
                    }
                }
                else if (selectedEffect == bleach)
                {
                    if (kbm.KeyDown(Keys.R))
                    {
                        bleach.Opacity = MathHelper.Min(bleach.Opacity + .001f, 1);
                    }
                    if (kbm.KeyDown(Keys.F))
                    {
                        bleach.Opacity = MathHelper.Max(bleach.Opacity - .001f, 0);
                    }
                }
                else if (selectedEffect == scanLines)
                {
                    if (kbm.KeyDown(Keys.R))
                    {
                        scanLines.NoiseIntensity = MathHelper.Min(scanLines.NoiseIntensity + .001f, 1);
                    }
                    if (kbm.KeyDown(Keys.F))
                    {
                        scanLines.NoiseIntensity = MathHelper.Max(scanLines.NoiseIntensity - .001f, 0);
                    }

                    if (kbm.KeyDown(Keys.T))
                    {
                        scanLines.LineIntensity = MathHelper.Min(scanLines.LineIntensity + .001f, 1);
                    }
                    if (kbm.KeyDown(Keys.G))
                    {
                        scanLines.LineIntensity = MathHelper.Max(scanLines.LineIntensity - .001f, 0);
                    }

                    if (kbm.KeyDown(Keys.Y))
                    {
                        scanLines.LineCount = MathHelper.Min(scanLines.LineCount + 1, 20000);
                    }
                    if (kbm.KeyDown(Keys.H))
                    {
                        scanLines.LineCount = MathHelper.Max(scanLines.LineCount - 1, 0);
                    }
                }
                else if (selectedEffect == deRezed)
                {
                    if (kbm.KeyDown(Keys.R))
                    {
                        deRezed.NumberOfTiles = MathHelper.Min(deRezed.NumberOfTiles + 1, 1024);
                    }
                    if (kbm.KeyDown(Keys.F))
                    {
                        deRezed.NumberOfTiles = MathHelper.Max(deRezed.NumberOfTiles - 1, 1);
                    }
                }
            }
        }