public WaterSubMesh(Mesh mesh, RenderTarget2D reflectionBuffer, RenderTarget2D refractionBuffer, Texture2D offsetMap, Texture2D normalMap) : base(mesh)
 {
     m_ReflectionTarget = reflectionBuffer;
     m_RefractionTarget = refractionBuffer;
     m_OffsetMap = offsetMap;
     m_NormalMap = normalMap;
 }

        public TileCanvas(TileLayer tileLayer)
        {
            TileLayer = tileLayer;

            //Init the textures array
            Size texSize = new Size(MAX_TEXTURE_SIZE - (MAX_TEXTURE_SIZE % TileLayer.Definition.Grid.Width), MAX_TEXTURE_SIZE - (MAX_TEXTURE_SIZE % TileLayer.Definition.Grid.Height));

            Size maxSize = new Size(TileLayer.Definition.Grid.Width * TileLayer.TileCellsX, TileLayer.Definition.Grid.Height * TileLayer.TileCellsY);

            // TODO: Clip the dimensions of the tiles that draw over the edges of the level.
            Textures = new List<TextureInfo>();
            for (int i = 0; i < maxSize.Width; i += texSize.Width)
            {
                for (int j = 0; j < maxSize.Height; j += texSize.Height)
                {
                    RenderTarget2D tex = new RenderTarget2D(
                        Ogmo.EditorDraw.GraphicsDevice,
                        Math.Min(maxSize.Width - i, texSize.Width),
                        Math.Min(maxSize.Height - j, texSize.Height));
                    Textures.Add(new TextureInfo(tex, new Point(i, j)));
                }
            }

            RefreshAll();
        }

 public ShallowWaterRC(Texture2D p_txTextre, Vector2 p_v2Pos)
     : base(p_txTextre, new TransformComponent(p_v2Pos))
 {
     this.enType = RenderComponent.ComponentType.StaticRenderComponent;
     this.graphics = Program.game.GraphicsDevice;
     this.rt2dDistortionMos = new RenderTarget2D(this.graphics, 640, 360);
 }

        private Texture2D CreateBackground(GraphicsDevice gd, SpriteBatch sb, ContentManager cm)
        {
            RenderTarget2D target = new RenderTarget2D(gd, 2048, 2048);
            //tell the GraphicsDevice we want to render to the gamesMenu rendertarget (an in-memory buffer)
            gd.SetRenderTarget(target);

            //clear the background
            gd.Clear(Color.Transparent);

            //begin drawing
            sb.Begin();
            for (int x = 0; x < 8; x++)
            {
                for (int y = 0; y < 8; y++)
                {
                    sb.Draw(cm.Load<Texture2D>("Backgrounds/" + _level.ToString()), new Vector2(x * 400, y * 256), Color.White);
                }
            }

            sb.End();
            //reset the GraphicsDevice to draw on the backbuffer (directly to the backbuffer)
            gd.SetRenderTarget(null);

            return (Texture2D)target;
        }

 public LightArea(GraphicsDevice graphicsDevice, ShadowmapSize size)
 {
     int baseSize = 2 << (int)size;
     LightAreaSize = new Vector2(baseSize);
     RenderTarget = new RenderTarget2D(graphicsDevice, baseSize, baseSize);
     this.graphicsDevice = graphicsDevice;
 }

        public KarmaWorld(GraphicsDevice device, ContentManager content)
        {
            KarmaWorld.World = this;

            GraphicsDevice = device;
            ContentManager = content;
            RenderedWorld = new RenderTarget2D(device, device.PresentationParameters.BackBufferWidth, device.PresentationParameters.BackBufferHeight,
                                               true, device.DisplayMode.Format, DepthFormat.Depth24);

            Timers = new Utilities.TimerManager();
            Input = new ButtonInputManager();

            Input.AddInput("Zoom In", new ComboButton(new KeyboardButton(Keys.LeftControl, false), new KeyboardButton(Keys.PageUp, true)));
            Input.AddInput("Zoom Out", new ComboButton(new KeyboardButton(Keys.LeftControl, false), new KeyboardButton(Keys.PageDown, true)));

            CurrentTime = new GameTime(TimeSpan.Zero, TimeSpan.Zero);

            currentZoom = ZoomLevels.Three;

            Camera = new KarmaCamera(device);
            Camera.Zoom = GetCameraZoom(currentZoom);

            CurrentZoom = currentZoom;
            ZoomingIn = false;
            ZoomingOut = false;
            foreach (ZoomLevels zooms in WorldData.AscendingZooms)
                if (WorldData.Minigames[zooms] != null)
                    WorldData.Minigames[zooms].ResetGame();

            JoustingInput.InitializeInput();

            Camera.Update(new GameTime(TimeSpan.FromSeconds(0.016667), TimeSpan.FromSeconds(0.016667)));
            Camera.Zoom = GetCameraZoom(currentZoom);
        }

 public RoomEditor()
 {
     editorSurface = new RenderTarget2D(Engine.Instance.GraphicsDevice, Engine.WINDOW_WIDTH * 2, Engine.WINDOW_HEIGHT * 2);
     Player p = new Player(Vector2.Zero, this);
     this.objects.Add(p);
     cameraTarget = p;
 }

        public Lightning(Vector2 p1, Vector2 p2, float width = 2f, int life = 60, int detailLevel = 6, bool sound = false, 
            float volume = 0.1f)
        {
            sound = false;//TODO rm

            MaxLife = life;
            w = width;
            GEN_DEPTH = detailLevel;

            Position = p1;

            float l = (p2 - p1).Length() * 4;
            rot = (float)Math.Atan2(p2.Y - p1.Y, p2.X - p1.X);
            transform = Matrix.CreateRotationZ(rot);
            fbo = new RenderTarget2D(GraphicsEngine.Renderer.GraphicsDevice, (int)l + 64, (int)l + 64);

            GenLightning(new Vector2(32, 32 + l / 2), new Vector2(32 + l, 32 + l / 2));
            var r = GraphicsEngine.Renderer;
            r.EnableFBO(fbo);
            r.GraphicsDevice.Clear(Color.Transparent);
            r.BeginUnscaled();
            DrawFBO(r);
            r.End();
            r.DisableFBO();

            if (sound)
                _sound = Sound.Sounds.tesla.Play(volume, (float)(new Random().Next(-250, 250)) / 1000f, 0f);
        }

        //Creates a white 1*1 Texture that is used for the lines by scaling and rotating it
        public void CreatePixelTexture()
        {
            int TargetWidth = 1;
            int TargetHeight = 1;

            RenderTarget2D LevelRenderTarget = new RenderTarget2D(graphicsDevice, TargetWidth, TargetHeight, 1,
                graphicsDevice.PresentationParameters.BackBufferFormat, graphicsDevice.PresentationParameters.MultiSampleType,
                graphicsDevice.PresentationParameters.MultiSampleQuality, RenderTargetUsage.PreserveContents);

            DepthStencilBuffer stencilBuffer = new DepthStencilBuffer(graphicsDevice, TargetWidth, TargetHeight,
                graphicsDevice.DepthStencilBuffer.Format, graphicsDevice.PresentationParameters.MultiSampleType,
                graphicsDevice.PresentationParameters.MultiSampleQuality);

            graphicsDevice.SetRenderTarget(0, LevelRenderTarget);

            // Cache the current depth buffer
            DepthStencilBuffer old = graphicsDevice.DepthStencilBuffer;
            // Set our custom depth buffer
            graphicsDevice.DepthStencilBuffer = stencilBuffer;

            graphicsDevice.Clear(Color.White);

            graphicsDevice.SetRenderTarget(0, null);

            // Reset the depth buffer
            graphicsDevice.DepthStencilBuffer = old;
            pixel = LevelRenderTarget.GetTexture();
        }

        public static Texture2D ConvertToPreMultipliedAlphaGPU(Texture2D texture)
        {
            // code borrowed from http://jakepoz.com/jake_poznanski__speeding_up_xna.html

            // Set up a render target to hold our final texture which will have premulitplied alpha values
            RenderTarget2D result = new RenderTarget2D(device, texture.Width, texture.Height);

            device.SetRenderTarget(result);
            device.Clear(Color.Black);

            // Multiply each color by the source alpha, and write in just the color values into the final texture
            SpriteBatch spriteBatch = new SpriteBatch(device);
            spriteBatch.Begin(SpriteSortMode.Immediate, blendColor);
            spriteBatch.Draw(texture, texture.Bounds, Color.White);
            spriteBatch.End();

            // Now copy over the alpha values from the PNG source texture to the final one, without multiplying them
            spriteBatch.Begin(SpriteSortMode.Immediate, blendAlpha);
            spriteBatch.Draw(texture, texture.Bounds, Color.White);
            spriteBatch.End();

            // Release the GPU back to drawing to the screen
            device.SetRenderTarget(null);

            return result as Texture2D;
        }

        public FireParticle(Vector3 pos, Game1 game, float dist)
        {
            this.model = TextureManager.dirSquare;
            this.game = game;
            startPos = pos;
            scalef = Utilities.nextFloat() + .25f;

            direction.X = (float)Utilities.random.NextDouble() * 2 - 1;
            direction.Y = (float)Utilities.random.NextDouble() * 1.5f - .5f;
            direction.Z = (float)Utilities.random.NextDouble() * 2 - 1;
            direction.Normalize();

            startPos += direction * Utilities.nextFloat() / 2;

            goalPos = pos + direction * dist;
            speed = 4.5f + Utilities.nextFloat();
            alpha = 1;

            rTarg = new RenderTarget2D(game.GraphicsDevice, 128, 128);
            sb = new SpriteBatch(game.GraphicsDevice);

            game.GraphicsDevice.SetRenderTarget(rTarg);
            sb.Begin();
            sb.Draw(TextureManager.pyroFlame, Vector2.Zero, Color.Lerp(Color.Red, Color.White, Utilities.nextFloat()));
            sb.End();
            game.GraphicsDevice.SetRenderTarget(null);
        }

        public void Apply(IPostEffectData data, RenderTarget2D target)
        {
            data.Effect.GraphicsDevice.SetRenderTargets(m_ParticleTarget, m_DataTarget);
            data.Effect.GraphicsDevice.Clear(Color.Transparent);

            data.Effect.CurrentTechnique = data.Effect.Techniques["DrawEmitters"];
            foreach(ParticleEmitter emitter in m_ParticleEngine.Emitters)
                DrawEmitter(data.Device, data.Effect, emitter);

            //merge particletarget with scene
            data.Effect.GraphicsDevice.SetRenderTarget(target);
            data.Effect.Parameters["SceneTexture"].SetValue(data.Scene);
            data.Effect.Parameters["ParticlesTexture"].SetValue(m_ParticleTarget); //debug this shit
            data.Effect.Parameters["ParticleDataTexture"].SetValue(m_DataTarget);

            if (Keyboard.GetState().IsKeyDown(Keys.P))
            {
                Thread.Sleep(1000);
                data.Scene.ToFile("Scene");
                m_ParticleTarget.ToFile("Particle");
                m_DataTarget.ToFile("Data");
            }

            data.Effect.GraphicsDevice.SetVertexBuffer(m_ScreenBuffer.Get().Buffer);
            data.Effect.CurrentTechnique = data.Effect.Techniques["MergeSceneAndParticles"];
            foreach (EffectPass pass in data.Effect.CurrentTechnique.Passes)
            {
                pass.Apply();
                data.Device.DrawPrimitives(PrimitiveType.TriangleList, 0, 2);
            }
        }

        public GaussianBlur(Game game)
        {
            this.game = game;
            this.device = game.GraphicsDevice;
            this.spriteBatch = (game as GameManager).spriteBatch;

            effect = game.Content.Load<Effect>(@"Effects\GaussianBlur");

            // Since we're performing a Gaussian blur on a texture image the
            // render targets are half the size of the source texture image.
            // This will help improve the blurring effect.
            renderTargetWidth = device.Viewport.Width / 4;
            renderTargetHeight = device.Viewport.Height / 4;

            blurHTarget = new RenderTarget2D(device, renderTargetWidth, renderTargetHeight,
                false, SurfaceFormat.Color, DepthFormat.Depth24);
            blurVTarget = new RenderTarget2D(device, renderTargetWidth, renderTargetHeight,
                false, SurfaceFormat.Color, DepthFormat.Depth24);

            Radius = 7;
            Amount = 3.0f;

            ComputeKernel(Radius, Amount);
            ComputeOffsets(renderTargetWidth, renderTargetHeight);
        }

        // 188/157!09
        #endregion

        #region Getter & Setter
        #endregion

        #region Constructor
        public CreditsScene()
        {
            isActiv = true;
            _name = "Credits";
            _backgroundColor = Color.Black;

            _partikelTop = new RectanglePartikelEmitter(@"Partikel\circle",new Vector4(0,1280,0,100), 220);
            _partikelTop.SetColor(new Color(255, 223, 76), new Color(145, 24, 25));
            _partikelBottom = new RectanglePartikelEmitter(@"Partikel\circle", new Vector4(0, 1280, 620, 720), 220);
            _partikelBottom.SetColor(new Color(255, 223, 76), new Color(145, 24, 25));
            _partikelLeft = new RectanglePartikelEmitter(@"Partikel\circle", new Vector4(0, 100, 100, 620), 140);
            _partikelLeft.SetColor(new Color(255, 223, 76), new Color(145, 24, 25));
            _partikelRight = new RectanglePartikelEmitter(@"Partikel\circle", new Vector4(1180, 1280, 100, 620), 140);
            _partikelRight.SetColor(new Color(255, 223, 76), new Color(145, 24, 25));

            //_partikelCenter = new CirclePartikelEmitter("circle", new Vector2(640, 360), 500, 180, 0, false);
            //_partikelCenter.SetColor(Color.Green, Color.Yellow);
            //_partikelCenter2 = new CirclePartikelEmitter("circle", new Vector2(640, 360), 500, 220, 0, true);
            //_partikelCenter2.SetColor(Color.Green, Color.Yellow);

            _spriteBatch = new SpriteBatch(SceneManager.Graphics.GraphicsDevice);
            _renderTarget = new RenderTarget2D(SceneManager.Graphics.GraphicsDevice, 1280, 720);

            for(int i = 0; i < 3; i++)
                TextureManager.Instance.LoadContentFromStream(@"\Content\Credits\" + i + ".png", "credits" + i);

            _backgroundColor = new Color(188, 157, 109, 255);
 }

        public Water(GraphicsDevice device, Texture2D particleTexture)
        {
            pb = new PrimitiveBatch(device);
            this.particleTexture = particleTexture;
            spriteBatch = new SpriteBatch(device);
            metaballTarget = new RenderTarget2D(device, device.Viewport.Width, device.Viewport.Height);
            particlesTarget = new RenderTarget2D(device, device.Viewport.Width, device.Viewport.Height);
            drawTarget = new RenderTarget2D(device, device.Viewport.Width, device.Viewport.Height);
            alphaTest = new AlphaTestEffect(device);
            alphaTest.ReferenceAlpha = 175;

            var view = device.Viewport;
            alphaTest.Projection = Matrix.CreateTranslation(-0.5f, -0.5f, 0) *
                Matrix.CreateOrthographicOffCenter(0, view.Width, view.Height, 0, 0, 1);

            for (int i = 0; i < columns.Length; i++)
            {
                columns[i] = new WaterColumn()
                {
                    Height = 240,
                    TargetHeight = 240,
                    Speed = 0
                };
            }
        }

        public void Process(RenderTarget2D scene, IntermediateBuffer show = IntermediateBuffer.Result)
        {
            device.SetRenderTarget(scene);

            device.SamplerStates[1] = SamplerState.LinearClamp;

            bloomExtract.Parameters["BloomThreshold"].SetValue(0.25F);

            RenderQuad(scene, primary, bloomExtract, IntermediateBuffer.PreBloom);

            SetBlurParameters(0, 1.0f / (float)primary.Width);

            RenderQuad(primary, secondary, blurGaussian, IntermediateBuffer.BlurHorizontal);

            SetBlurParameters(0, 1.0f / (float)primary.Height);

            RenderQuad(secondary, primary, blurGaussian, IntermediateBuffer.BlurAll);

            device.SetRenderTarget(null);

            var parameters = bloomCombine.Parameters;
            parameters["BloomIntensity"].SetValue(1.25F);
            parameters["BaseIntensity"].SetValue(1.0F);
            parameters["BloomSaturation"].SetValue(1.0F);
            parameters["BaseSaturation"].SetValue(1.0F);

            device.Textures[1] = scene;

            var view = device.Viewport;
            RenderQuad(primary, view.Width, view.Height, bloomCombine, IntermediateBuffer.Result);
        }

 /// <summary>
 /// Creates a new RenderTargetImageSource.
 /// </summary>
 /// <param name="graphics">The GraphicsDevice to use.</param>
 /// <param name="width">The width of the image source.</param>
 /// <param name="height">The height of the image source.</param>
 public RenderTargetImageSource(GraphicsDevice graphics, int width, int height)
 {
     // create the render target and buffer to hold the data
     renderTarget = new RenderTarget2D(graphics, width, height, false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8);
     buffer = new byte[width * height * 4];
     writeableBitmap = new WriteableBitmap(width, height, 96, 96, PixelFormats.Bgra32, null);
 }

        public Edge(SpriteBatch spriteBatch, Settings settings, Effect normalDepthMapEffect, Effect edgeEffect)
            : base(spriteBatch)
        {
            if (settings == null) throw new ArgumentNullException("settings");
            if (normalDepthMapEffect == null) throw new ArgumentNullException("normalDepthMapEffect");
            if (edgeEffect == null) throw new ArgumentNullException("edgeEffect");

            this.settings = settings;

            var pp = GraphicsDevice.PresentationParameters;
            var width = (int) (pp.BackBufferWidth * settings.MapScale);
            var height = (int) (pp.BackBufferHeight * settings.MapScale);

            //----------------------------------------------------------------
            // エフェクト

            // 法線深度マップ
            this.normalDepthMapEffect = new NormalDepthMapEffect(normalDepthMapEffect);

            // エッジ強調
            this.edgeEffect = new EdgeEffect(edgeEffect);
            this.edgeEffect.MapWidth = width;
            this.edgeEffect.MapHeight = height;

            //----------------------------------------------------------------
            // レンダ ターゲット

            normalDepthMap = new RenderTarget2D(GraphicsDevice, width, height,
                false, SurfaceFormat.Vector4, DepthFormat.Depth24, 0, RenderTargetUsage.DiscardContents);
        }

 public DefaultLightContext(
     Texture2D deferredColorMap, 
     Texture2D deferredNormalMap,
     Texture2D deferredDepthMap, 
     Texture2D deferredSpecularMap,
     RenderTarget2D diffuseLightRenderTarget,
     RenderTarget2D specularLightRenderTarget,
     BlendState lightBlendState,
     RasterizerState rasterizerStateCullNone,
     RasterizerState rasterizerStateCullClockwiseFace, 
     RasterizerState rasterizerStateCullCounterClockwiseFace, 
     Vector2 halfPixel)
 {
     DeferredColorMap = deferredColorMap;
     DeferredNormalMap = deferredNormalMap;
     DeferredDepthMap = deferredDepthMap;
     DeferredSpecularMap = deferredSpecularMap;
     DiffuseLightRenderTarget = diffuseLightRenderTarget;
     SpecularLightRenderTarget = specularLightRenderTarget;
     LightBlendState = lightBlendState;
     RasterizerStateCullNone = rasterizerStateCullNone;
     RasterizerStateCullClockwiseFace = rasterizerStateCullClockwiseFace;
     RasterizerStateCullCounterClockwiseFace = rasterizerStateCullCounterClockwiseFace;
     HalfPixel = halfPixel;
 }

 /// <summary>
 /// Bakes the specified <c>RenderTarget2D</c>.
 /// </summary>
 /// <param name="drawProvider">The RenderTarget to draw.</param>
 /// <exception cref="System.Exception">BeginBake must be called before Bake</exception>
 public void Bake(RenderTarget2D drawProvider)
 {
     if (_state != 1)
         if (_state == 0)
             throw new Exception("BeginBake must be called before Bake");
     Game1.Instance.SpriteBatch.Draw(drawProvider, Vector2.Zero, Color.White);
 }