public void Begin(SpriteSortMode sortMode, SpriteBlendMode blendMode, SaveStateMode stateMode, Matrix transformMatrix)
 {
     _blendMode = blendMode;
     _sortMode = sortMode;
     _saveMode = stateMode;
     _matrix = transformMatrix;
 }

        /// <summary>
        /// Begins a new sprite and text batch with the specified render state.
        /// </summary>
        /// <param name="sortMode">The drawing order for sprite and text drawing. <see cref="SpriteSortMode.Deferred"/> by default.</param>
        /// <param name="blendState">State of the blending. Uses <see cref="BlendState.AlphaBlend"/> if null.</param>
        /// <param name="samplerState">State of the sampler. Uses <see cref="SamplerState.LinearClamp"/> if null.</param>
        /// <param name="depthStencilState">State of the depth-stencil buffer. Uses <see cref="DepthStencilState.None"/> if null.</param>
        /// <param name="rasterizerState">State of the rasterization. Uses <see cref="RasterizerState.CullCounterClockwise"/> if null.</param>
        /// <param name="effect">A custom <see cref="Effect"/> to override the default sprite effect. Uses default sprite effect if null.</param>
        /// <param name="transformMatrix">An optional matrix used to transform the sprite geometry. Uses <see cref="Matrix.Identity"/> if null.</param>
        /// <exception cref="InvalidOperationException">Thrown if <see cref="Begin"/> is called next time without previous <see cref="End"/>.</exception>
        /// <remarks>This method uses optional parameters.</remarks>
        /// <remarks>The <see cref="Begin"/> Begin should be called before drawing commands, and you cannot call it again before subsequent <see cref="End"/>.</remarks>
        public void Begin
        (
             SpriteSortMode sortMode = SpriteSortMode.Deferred,
             BlendState blendState = null,
             SamplerState samplerState = null,
             DepthStencilState depthStencilState = null,
             RasterizerState rasterizerState = null,
             Effect effect = null,
             Matrix? transformMatrix = null
        )
        {
            if (_beginCalled)
                throw new InvalidOperationException("Begin cannot be called again until End has been successfully called.");

            // defaults
            _sortMode = sortMode;
            _blendState = blendState ?? BlendState.AlphaBlend;
            _samplerState = samplerState ?? SamplerState.LinearClamp;
            _depthStencilState = depthStencilState ?? DepthStencilState.None;
            _rasterizerState = rasterizerState ?? RasterizerState.CullCounterClockwise;
            _effect = effect;
            _matrix = transformMatrix ?? Matrix.Identity;

            // Setup things now so a user can change them.
            if (sortMode == SpriteSortMode.Immediate)
            {
                Setup();
            }

            _beginCalled = true;
        }

        public void DrawBatch(SpriteSortMode sortMode)
        {
            if (_items.Count == 0) return;

            SortItems(sortMode);

            var index = 0;

            // build the vertices array to send to the GPU
            foreach (var item in _items)
            {
                _vertices[index++] = item.Vertices[0];
                _vertices[index++] = item.Vertices[1];
                _vertices[index++] = item.Vertices[2];
                _vertices[index++] = item.Vertices[3];

                //add this item back to the pool
                _itemPool.Enqueue(item);
            }

            GL.BindVertexArray(_vertexHandle);
            GL.BindBuffer(BufferTarget.ElementArrayBuffer, _indexHandle);

            Draw(index, _items.Count);

            _items.Clear();
        }

        /// <summary>
        /// Starts the specified batch.
        /// </summary>
        /// <param name="batch">The batch.</param>
        /// <param name="useCamera">if set to <c>true</c> camera matrix will be applied.</param>
        /// <param name="sortMode">The sort mode.</param>
        /// <param name="blendState">State of the blend.</param>
        /// <param name="samplerState">State of the sampler.</param>
        /// <param name="depthStencilState">State of the depth stencil.</param>
        /// <param name="rasterizerState">State of the rasterizer.</param>
        /// <param name="effect">The effect.</param>
        /// <param name="transform">The transformation matrix.</param>
        public static void Start(this SpriteBatch batch,
            bool useCamera = false,
            SpriteSortMode sortMode = SpriteSortMode.Deferred,
            BlendState blendState = null,
            SamplerState samplerState = null,
            DepthStencilState depthStencilState = null,
            RasterizerState rasterizerState = null,
            Effect effect = null,
            Matrix? transform = null)
        {
            Matrix matrix = AlmiranteEngine.IsWinForms ? Matrix.Identity : AlmiranteEngine.Settings.Resolution.Matrix;

            if (useCamera)
            {
                matrix = AlmiranteEngine.Camera.Matrix * matrix;
            }

            if (transform.HasValue)
            {
                matrix = transform.Value * matrix;
            }

            BatchExtensions._sortMode = sortMode;
            BatchExtensions._blendState = blendState;
            BatchExtensions._samplerState = samplerState;
            BatchExtensions._depthStencilState = depthStencilState;
            BatchExtensions._rasterizerState = rasterizerState;
            BatchExtensions._effect = effect;
            BatchExtensions._matrix = matrix;

            batch.Begin(sortMode, blendState, samplerState, depthStencilState, rasterizerState, effect, matrix);
        }

 public override void Begin(GraphicsDevice device, SpriteBlendMode blendMode, SpriteSortMode sortMode, SaveStateMode stateMode, Local.Matrix transformMatrix)
 {
     _childRenderer = GetCurrentRenderer();
     _childRenderer.Begin(device, blendMode, sortMode, stateMode, transformMatrix);
     currentSortMode = sortMode;
     base.Begin(device, blendMode, sortMode, stateMode, transformMatrix);
 }

        internal static void StartBatch(BlendState blendState = null, SpriteSortMode sortMode = SpriteSortMode.Texture)
        {
            if (blendState == null)
            blendState = BlendState.NonPremultiplied;

             MainGame.SpriteBatch.Begin (sortMode, blendState, SamplerState.PointWrap, DepthStencilState.None, RasterizerState.CullNone);

             IsBatching = true;
        }

 public void Begin()
 {
     _sortMode = SpriteSortMode.Deferred;
     _blendState = BlendState.AlphaBlend;
     _depthStencilState = DepthStencilState.None;
     _samplerState = SamplerState.LinearClamp;
     _rasterizerState = RasterizerState.CullCounterClockwise;
     _matrix = Matrix.Identity;
 }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="spriteBatchName">The string name used to access the sprite batch</param>
 /// <param name="desiredBlendMode">The blend mode to use for the sprite batch</param>
 /// <param name="desiredSortMode">The sort mode to use for the sprite batch</param>
 /// <param name="desiredSaveMode">The save mode to use for the sprite batch</param>
 /// <param name="updateCameraMatrix">The flag used to denote if the matrix needs to be updated every update cycle</param>
 public SpriteBatchDescription(string spriteBatchName, SpriteBlendMode desiredBlendMode, 
     SpriteSortMode desiredSortMode, SaveStateMode desiredSaveMode, bool updateCameraMatrix)
 {
     this.spriteBatchName = spriteBatchName;
     this.desiredBlendMode = desiredBlendMode;
     this.desiredSortMode = desiredSortMode;
     this.desiredStateMode = desiredSaveMode;
     this.updateCameraMatrix = updateCameraMatrix;
     this.currentMatrix = Matrix.Identity;
 }

 /// <summary>
 /// construct a TTSpriteBatch with custom rendering parameters for the batch
 /// </summary>
 public TTSpriteBatch(GraphicsDevice gfx, SpriteSortMode ssm, BlendState bs, SamplerState ss, DepthStencilState dss, RasterizerState rs, Effect fx)
     : base(gfx)
 {
     spriteSortMode = ssm;
     blendState = bs;
     samplerState = ss;
     depthStencilState = dss;
     rasterizerState = rs;
     effect = fx;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="SpriteBatchState"/> structure.
 /// </summary>
 /// <param name="sortMode">The sprite batch's sort mode.</param>
 /// <param name="blendState">The sprite batch's blend state.</param>
 /// <param name="samplerState">The sprite batch's sampler state.</param>
 /// <param name="rasterizerState">The sprite batch's rasterizer state.</param>
 /// <param name="depthStencilState">The sprite batch's depth/stencil state.</param>
 /// <param name="effect">The sprite batch's custom effect.</param>
 /// <param name="transformMatrix">The sprite batch's transformation matrix.</param>
 public SpriteBatchState(SpriteSortMode sortMode, BlendState blendState, SamplerState samplerState, RasterizerState rasterizerState, DepthStencilState depthStencilState, Effect effect, Matrix transformMatrix)
 {
     this.sortMode          = sortMode;
     this.blendState        = blendState;
     this.samplerState      = samplerState;
     this.rasterizerState   = rasterizerState;
     this.depthStencilState = depthStencilState;
     this.customEffect      = effect;
     this.transformMatrix   = transformMatrix;
 }

 /// <summary>
 /// Begin the SpriteBatch
 /// </summary>
 /// <param name="SortMode">Self-explanatory.</param>
 /// <param name="BlendState">Self-explanatory.</param>
 /// <param name="SamplerState">Self-explanatory.</param>
 /// <param name="DepthStencilState">Self-explanatory.</param>
 /// <param name="RasterizerState">Self-explanatory.</param>
 /// <param name="Effect">Self-explanatory.</param>
 /// <param name="Matrix">Self-explanatory.</param>
 public void Begin(SpriteSortMode SortMode = SpriteSortMode.Deferred, BlendState BlendState = null,
     SamplerState SamplerState = null, DepthStencilState DepthStencilState = null,
     RasterizerState RasterizerState = null, Effect Effect = null, Matrix? Matrix = null, bool Backup = false)
 {
     if (Begun) End();
     Begun = true;
     if (Backup)
         this.Backup(SortMode, BlendState, SamplerState, DepthStencilState, RasterizerState, Effect, Matrix);
     SpriteBatch.Begin(SortMode, BlendState, SamplerState, DepthStencilState, RasterizerState, Effect, Matrix);
 }

        public void Begin(TextureAtlas atlas, Camera camera)
        {
            if (_beginCalled) throw new Exception("Begin called twice without a call to end.");

            _atlas = atlas;
            _camera = camera;
            _blendState = BlendState.AlphaBlend;
            _sortMode = SpriteSortMode.None;
            _beginCalled = true;
        }

        /// <summary>
        /// Begins a sprite batch operation using the specified sort and blend state
        ///    object and default state objects (DepthStencilState.None, SamplerState.LinearClamp,
        ///    RasterizerState.CullCounterClockwise). If you pass a null blend state, the
        ///    default is BlendState.AlphaBlend.
        /// </summary>
        /// <param name="sortMode">Sprite drawing order.</param>
        /// <param name="blendState">Blending options.</param>
        public new void Begin(SpriteSortMode sortMode, BlendState blendState)
        {
            if (Camera.main == null)
                return;

            if (!active)
            {
                base.Begin(sortMode, blendState, SamplerState.AnisotropicClamp, DepthStencilState.Default, RasterizerState.CullCounterClockwise, null, Camera.main.TransformMatrix);
                active = true;
            }
        }

        public SBNode(batchEnum _name, SpriteSortMode _sort, BlendState _blend)
        {
            spriteBatch = new SpriteBatch(Game1.GameInstance.GraphicsDevice);

            batchName = _name;

            sort = _sort;
            blend = _blend;

            spriteListHead = null;
        }

 public void Backup(SpriteSortMode SortMode = SpriteSortMode.Deferred, BlendState BlendState = null,
     SamplerState SamplerState = null, DepthStencilState DepthStencilState = null,
     RasterizerState RasterizerState = null, Effect Effect = null, Matrix? Matrix = null)
 {
     this.SortMode = SortMode;
     this.BlendState = BlendState;
     this.SamplerState = SamplerState;
     this.DepthStencilState = DepthStencilState;
     this.RasterizerState = RasterizerState;
     this.Effect = Effect;
     this.Matrix = Matrix;
 }

		public void Begin(SpriteSortMode sortMode, BlendState blendState, SamplerState samplerState, DepthStencilState depthStencilState, RasterizerState rasterizerState, Effect effect, Matrix transformMatrix)
		{
			_sortMode = sortMode;
			
			_blendState = (blendState == null) ? BlendState.AlphaBlend : blendState;
			_depthStencilState = (depthStencilState == null) ? DepthStencilState.None : depthStencilState;
			_samplerState = (samplerState == null) ? SamplerState.LinearClamp : samplerState;
			_rasterizerState =  (rasterizerState == null) ? RasterizerState.CullCounterClockwise : rasterizerState;
			
			_effect = effect;
			_matrix = transformMatrix;
		}

        public void Begin(SpriteSortMode sortMode, BlendState blendState, SamplerState samplerState, DepthStencilState depthStencilState, RasterizerState rasterizerState, Effect effect, Matrix transformMatrix)
        {
            _sortMode = sortMode;

            _blendState = blendState ?? BlendState.AlphaBlend;
            _depthStencilState = depthStencilState ?? DepthStencilState.None;
            _samplerState = samplerState ?? SamplerState.LinearClamp;
            _rasterizerState = rasterizerState ?? RasterizerState.CullCounterClockwise;

            if(effect != null)
                _effect = effect;
            _matrix = transformMatrix;
        }

 public void Begin(SpriteSortMode sortMode, BlendState blendState, SamplerState samplerState, DepthStencilState depthStencilState, RasterizerState rasterizerState, Effect effect, Matrix transformMatrix)
 {
   this._sortMode = sortMode;
   this._blendState = blendState ?? BlendState.AlphaBlend;
   this._samplerState = samplerState ?? SamplerState.LinearClamp;
   this._depthStencilState = depthStencilState ?? DepthStencilState.None;
   this._rasterizerState = rasterizerState ?? RasterizerState.CullCounterClockwise;
   this._effect = effect;
   this._matrix = transformMatrix;
   if (sortMode == SpriteSortMode.Immediate)
     this.Setup();
   this._beginCalled = true;
 }

 public SpriteBatchStruct(SpriteSortMode sortMode, BlendState blendState, SamplerState samplerState,
                               DepthStencilState depthStencilState, RasterizerState rasterizerState,
                               Effect effect, Camera camera)
 {
     SB = new SpriteBatch(Drawing.StaticGraphicsDevice);
     SB_SpriteSortMode = sortMode;
     SB_BlendState = blendState;
     SB_SamplerState = samplerState;
     SB_DepthStencilState = depthStencilState;
     SB_RasterizerState = rasterizerState;
     SB_Effect = effect;
     SB_Camera = camera;
     wasBegin = false;
 }

        /// <summary>
        /// Begins a new sprite batch using the appropriate settings for rendering UPF.
        /// </summary>
        /// <param name="sortMode">The sorting mode to use when rendering interface elements.</param>
        /// <param name="blendState">The blend state to apply to the rendered elements.</param>
        /// <param name="samplerState">The sampler state to apply to the rendered interface elements.</param>
        /// <param name="effect">The custom effect to apply to the rendered interface elements.</param>
        /// <param name="localTransform">The transform matrix to apply to the rendered interface elements.</param>
        public void Begin(SpriteSortMode sortMode, BlendState blendState, SamplerState samplerState, Effect effect, Matrix localTransform)
        {
            if (SpriteBatch == null)
                throw new InvalidOperationException(PresentationStrings.DrawingContextDoesNotHaveSpriteBatch);

            this.localTransform = localTransform;
            this.combinedTransform = Matrix.Identity;
            Matrix.Concat(ref localTransform, ref globalTransform, out combinedTransform);

            SpriteBatch.Begin(sortMode, 
                blendState ?? BlendState.AlphaBlend,
                samplerState ?? SamplerState.LinearClamp, 
                StencilReadDepthState, RasterizerState.CullCounterClockwise, effect, combinedTransform);
        }