public RenderTargetBinding(RenderTarget2D renderTarget)
 {
   if (renderTarget == null)
     throw new ArgumentNullException("renderTarget");
   this._renderTarget = (Texture) renderTarget;
   this.isTargetCube = false;
 }

 public static int GetIdFromCharacterWorldTexture(Texture tex)
 {
     if (tex == MCGirlWorld) return 1;
     if (tex == MCBoyWorld) return 2;
     if (tex == ChristmanWorld) return 3;
     return 0;
 }

 public void InitWithTextureBlock(Texture.TexturePacket.TextureBlock tb)
 {
     block = tb;
     seedsize.X = (float)tb.parent.texture.Width * tb.uv.Width;
     seedsize.Y = (float)tb.parent.texture.Height * tb.uv.Height;
     seedorient = new Vector2(0, 0);
 }

 public override void Draw(GameTime gameTime)
 {
   if (this.RtHandle != null && this.TargetRenderer.IsHooked(this.RtHandle.Target))
   {
     this.TargetRenderer.Resolve(this.RtHandle.Target, false);
     this.capturedScreen = (Texture) this.RtHandle.Target;
     if (this.ScreenCaptured != null)
       this.ScreenCaptured();
   }
   GraphicsDeviceExtensions.PrepareStencilRead(this.GraphicsDevice, CompareFunction.Always, StencilMask.None);
   if (this.capturedScreen != null)
   {
     SettingsManager.SetupViewport(this.GraphicsDevice, false);
     this.TargetRenderer.DrawFullscreen(this.capturedScreen);
   }
   this.Elapsed += gameTime.ElapsedGameTime;
   float num = (float) this.Elapsed.TotalSeconds / this.Duration;
   float amount = FezMath.Saturate(this.EaseOut ? Easing.EaseOut((double) num, this.EasingType) : Easing.EaseIn((double) num, this.EasingType));
   if ((double) amount == 1.0 && (this.WaitUntil == null || this.WaitUntil()))
   {
     if (this.Faded != null)
     {
       this.Faded();
       this.Faded = (Action) null;
     }
     this.WaitUntil = (Func<bool>) null;
     ServiceHelper.RemoveComponent<ScreenFade>(this);
   }
   this.TargetRenderer.DrawFullscreen(Color.Lerp(this.FromColor, this.ToColor, amount));
 }

 public RenderTargetBinding(RenderTarget2D renderTarget)
 {
   if (renderTarget == null)
     throw new ArgumentNullException("renderTarget");
   this._renderTarget = (Texture) renderTarget;
   this._cubeMapFace = CubeMapFace.PositiveX;
 }

        public Player( GamerEntity owner, string entityName, Vector3 position, float orientation)
            : base("characters", entityName, position, orientation, Color.White, 0)
        {
            this.owner = owner;

            entityState = tEntityState.Active;
            setCollisions();

            // life stuff
            initializeLifeStuff();

            // actions stuff
            fastShotCooldownTime = 0.0f;
            dashCooldownTime = 0.0f;
            dashVelocity = Vector2.Zero;
            dashParticleTimer = 0.0f;
            bigShotChargeTimer = 0.0f;
            bigShotCharging = false;
            bigShotCooldownTime = 0.0f;

            mode = tMode.Arcade;

            if (bigShotBall == null) bigShotBall = TextureManager.Instance.getTexture("projectiles/bigShotPlayer");
            if (starXP == null) starXP = TextureManager.Instance.getTexture("GUI/menu/starXP");
            if (garlicGunTexture == null) garlicGunTexture = TextureManager.Instance.getTexture("characters/garlicGun");
            if (garlicGunBandTexture == null) garlicGunBandTexture = TextureManager.Instance.getTexture("characters/garlicGunBand");
            if (wishLife == null) wishLife = TextureManager.Instance.getTexture("GUI/ingame/wishLife");
            if (wishLifePortion == null) wishLifePortion = TextureManager.Instance.getTexture("GUI/ingame/wishLifePortion");
            if (wishLifePortionEmpty == null) wishLifePortionEmpty = TextureManager.Instance.getTexture("GUI/ingame/wishLifePortionEmpty");
        }

 public Munitions(Rectangle position, Texture2D texture, Direction direction, int spriteWidth, int spriteHeigth)
     : base(PlayerType.Munition, spriteWidth, spriteHeigth)
 {
     this.Hitbox = position;
     this.texture = texture;
     this.Direction = direction;
 }

 public GUIElement(Vector2 min, Vector2 max, Texture image, Vector4 color)
 {
     Color = color;
     ScaleOffset = Vector4.Zero;
     Image = image;
     SetDimensions(min, max);
 }

 public void InitWithSeed(Seed seed, Texture.TextureMgr tmgr)
 {
     var block = tmgr.GetTexture(seed.texname);
     tex = block.parent.texture;
     srcuv = block.uv;
     seedsize = seed.size;
     seedorient = seed.orient;
 }

 public GUIElement(Vector2 min, Vector2 max, Texture image, Vector3 color)
 {
     Color = new Vector4(color,1.0f);
     ScaleOffset = Vector4.Zero;
     Image = image;
     UseAlphaOnly = false;
     SetDimensions(min, max);
 }

 public static void Init()
 {
     Color[] colors = new Color[1];
     colors[0] = new Color(255, 255, 255, 255);
     Texture2D tempTexture = new Texture2D(Stator.device, 1, 1, false, SurfaceFormat.Color);
     tempTexture.SetData(colors);
     particleTexture = new Graphics.Texture("#ParticleTexture", tempTexture);
 }

 public void LoadContent()
 {
     if (!String.IsNullOrEmpty(_fileName))
     {
         _baseTexture = EngineManager.Game.Content.Load<Texture>(_fileName);
         _readyToRender = true;
     }
 }

 public GUIElementTC(Vector2 min, Vector2 max, Texture image, Vector2 minTC, Vector2 maxTC)
 {
     Color = Vector4.One;
     ScaleOffset = Vector4.Zero;
     TCMinMax = new Vector4(minTC.X, minTC.Y, maxTC.X, maxTC.Y);
     Image = image;
     SetDimensions(min, max);
 }

 public BillboardRenderComponent(Actor owner)
     : base(owner)
 {
     Effect = null;
     mDepthOnlyEffect = null;
     mTexture = null;
     mGeometry = null;
     mCurrentTime = 0.0f;
 }

 protected override void Dispose(bool disposing)
 {
   base.Dispose(disposing);
   if (this.RtHandle != null)
   {
     this.TargetRenderer.ReturnTarget(this.RtHandle);
     this.RtHandle = (RenderTargetHandle) null;
   }
   this.Faded = (Action) null;
   this.ScreenCaptured = (Action) null;
   this.WaitUntil = (Func<bool>) null;
   this.capturedScreen = (Texture) null;
   this.IsDisposed = true;
 }

        public void Initialize(Player player, Texture2D textura, Texture texturaFrameProyectil, float daño, Vector2 pos, Vector2 incremento, Colision colision)
        {
            _player = player;
            _textura = textura;
            _daño = (int)daño;
            _pos = pos;
            _colision = colision;
            _incremento = incremento;

            //Datos de color de la textura
            _texturaFrame = textura;
            textureData = new Color[_texturaFrame.Width * _texturaFrame.Height];
            _texturaFrame.GetData(textureData);
        }

        public override void Initialize(ContentManager contentLoader, ComponentManifest manifest)
        {
            Effect genericEffect = contentLoader.Load<Effect>("shaders\\PhongShadow");

            // If we have several of these objects, the content manager will return
            // a single shared effect instance to them all. But we want to preconfigure
            // the effect with parameters that are specific to this particular
            // object. By cloning the effect, we prevent one
            // from stomping over the parameter settings of another.

            Effect = genericEffect.Clone();
            mTexture = contentLoader.Load<Texture>((string)(manifest.Properties[ManifestKeys.TEXTURE]));

            base.Initialize(contentLoader, manifest);
        }

        public QuadTree(Game game, Vector3 position, Matrix view, Matrix projection)
        {
            this.graphicsDevice = game.GraphicsDevice;
            this.position = position;
            effect = game.Content.Load<Effect>("Multitexture");
            sand = game.Content.Load<Texture>("Dirt cracked 00 seamless");
            grass = game.Content.Load<Texture>("grass0026_1_l2");
            rock = game.Content.Load<Texture>("Tileable stone texture (2)");
            snow = game.Content.Load<Texture>("snow");

            View = view;
            Projection = projection;

            InitializeEffect();
        }

 public override void DrawVertices(VerticesMode mode, VertexPositionColorTextured[] vertices)
 {
     CheckCreatePositionColorTextureBuffer();
     positionColorUvVertexBuffer.SetData(vertices, 0, vertices.Length, SetDataOptions.Discard);
     BindVertexBuffer(positionColorUvVertexBuffer);
     if (lastTexture != device.NativeDevice.Textures[0])
     {
         ApplyEffect(true);
         lastTexture = device.NativeDevice.Textures[0];
     }
     if (lastIndicesCount == -1)
         DoDraw(mode, vertices.Length);
     else
         DoDrawIndexed(mode, vertices.Length, lastIndicesCount);
 }

        /// <summary>
        /// This is called after the scene has been rendered to actually perform the post processing effect.
        /// The base implementation simply calls SceneRenderer.RenderManager.RenderQuad, passing it the
        /// material, position, and size to use for rendering.
        /// </summary>
        /// <param name="texture">The texture containing the rendered scene.</param>
        /// <param name="position">The position on the screen to render at.</param>
        /// <param name="size">The size of the quad to render.</param>
        public virtual void Run(Texture texture, Vector2 position, Vector2 size)
        {
            if (_material == null)
            {
                TorqueConsole.Warn("\nPostProcessor.Run - Cannot perform post processing. No material.");
                return;
            }

            GFXDevice.Instance.Device.RenderState.AlphaBlendEnable = false;

            _material.Texture = texture;
            SceneRenderer.RenderManager.RenderQuad(_material, position, size);

            GFXDevice.Instance.Device.RenderState.AlphaBlendEnable = true;
        }