public static void PrepareStencilReadWrite(this GraphicsDevice _, CompareFunction comparison, StencilMask reference)
 {
   GraphicsDeviceExtensions.dssCombiner.StencilEnable = true;
   GraphicsDeviceExtensions.dssCombiner.StencilPass = StencilOperation.Replace;
   GraphicsDeviceExtensions.dssCombiner.StencilFunction = comparison;
   GraphicsDeviceExtensions.dssCombiner.ReferenceStencil = (int) reference;
 }

        static private SharpDX.Direct3D11.Comparison GetComparison( CompareFunction compare)
        {
            switch (compare)
            {
                case CompareFunction.Always:
                    return SharpDX.Direct3D11.Comparison.Always;

                case CompareFunction.Equal:
                    return SharpDX.Direct3D11.Comparison.Equal;

                case CompareFunction.Greater:
                    return SharpDX.Direct3D11.Comparison.Greater;

                case CompareFunction.GreaterEqual:
                    return SharpDX.Direct3D11.Comparison.GreaterEqual;

                case CompareFunction.Less:
                    return SharpDX.Direct3D11.Comparison.Less;

                case CompareFunction.LessEqual:
                    return SharpDX.Direct3D11.Comparison.LessEqual;

                case CompareFunction.Never:
                    return SharpDX.Direct3D11.Comparison.Never;

                case CompareFunction.NotEqual:
                    return SharpDX.Direct3D11.Comparison.NotEqual;

                default:
                    throw new ArgumentException("Invalid comparison!");
            }
        }

        /// <summary>
        /// Sets default values for this instance.
        /// </summary>
        public DepthStencilStateDescription SetDefault()
        {
            DepthBufferEnable = true;
            DepthBufferWriteEnable = true;
            DepthBufferFunction = CompareFunction.LessEqual;
            StencilEnable = false;

            FrontFace.StencilFunction = CompareFunction.Always;
            FrontFace.StencilPass = StencilOperation.Keep;
            FrontFace.StencilFail = StencilOperation.Keep;
            FrontFace.StencilDepthBufferFail = StencilOperation.Keep;

            BackFace.StencilFunction = CompareFunction.Always;
            BackFace.StencilPass = StencilOperation.Keep;
            BackFace.StencilFail = StencilOperation.Keep;
            BackFace.StencilDepthBufferFail = StencilOperation.Keep;
            
            StencilMask = byte.MaxValue;
            StencilWriteMask = byte.MaxValue;
            return this;
        }

 int INativeLibraryFacade.mdb_set_dupsort(IntPtr txn, uint dbi, CompareFunction cmp)
 {
     return FallbackLibraryFacade.mdb_set_dupsort(txn, dbi, cmp);
 }

 public CompositionPass(CompositionTargetPass parent)
 {
     this.parent = parent;
     type = CompositorPassType.RenderQuad;
     identifier = 0;
     firstRenderQueue = RenderQueueGroupID.SkiesEarly;
     lastRenderQueue = RenderQueueGroupID.SkiesLate;
     clearBuffers = FrameBuffer.Color | FrameBuffer.Depth;
     clearColor = new ColorEx(0f, 0f, 0f, 0f);
     clearDepth = 1.0f;
     clearStencil = 0;
     stencilCheck = false;
     stencilFunc = CompareFunction.AlwaysPass;
     stencilRefValue = 0;
     stencilMask = (int)0x7FFFFFFF;
     stencilFailOp = StencilOperation.Keep;
     stencilDepthFailOp = StencilOperation.Keep;
     stencilPassOp = StencilOperation.Keep;
     stencilTwoSidedOperation = false;
 }

		/// <summary>
		/// Sets the way the pass will have use alpha to totally reject pixels from the pipeline.
		/// </summary>
		/// <remarks>
		/// The default is <see ref="CompareFunction.AlwaysPass" /> i.e. alpha is not used to reject pixels.
		/// <para>This option applies in both the fixed function and the programmable pipeline.</para></remarks>
		/// <param name="alphaRejectFunction">The comparison which must pass for the pixel to be written.</param>
		/// <param name="value">value against which alpha values will be tested [(0-255]</param>
		public void SetAlphaRejectSettings( CompareFunction alphaRejectFunction, int value )
		{
			_alphaRejectFunction = alphaRejectFunction;
			_alphaRejectValue = value;
		}

        public override void SetAlphaRejectSettings( CompareFunction func, byte value, bool alphaToCoverage)
        {
            var a2C = false;

            if ( func != CompareFunction.AlwaysPass )
            {
                SetRenderState( RenderState.AlphaTestEnable, true );
                a2C = alphaToCoverage;
            }
            else
            {
                SetRenderState( RenderState.AlphaTestEnable, false );
            }

            // Set always just be sure
            SetRenderState(RenderState.AlphaFunc, (int)D3DHelper.ConvertEnum(func));
            SetRenderState(RenderState.AlphaRef, value);

            // Alpha to coverage
            if ( !Capabilities.HasCapability( Graphics.Capabilities.AlphaToCoverage ) )
                return;

            // Vendor-specific hacks on renderstate, gotta love 'em
            switch ( Capabilities.Vendor )
            {
                case GPUVendor.Nvidia:
                    if ( a2C )
                    {
                        SetRenderState( RenderState.AdaptiveTessY, ( 'A' | ( 'T' ) << 8 | ( 'O' ) << 16 | ( 'C' ) << 24 ) );
                    }
                    else
                    {
                        SetRenderState( RenderState.AdaptiveTessY, (int)Format.Unknown );
                    }
                    break;
                case GPUVendor.Ati:
                    if ( a2C )
                    {
                        SetRenderState( RenderState.AdaptiveTessY, ( 'A' | ( '2' ) << 8 | ( 'M' ) << 16 | ( '1' ) << 24 ) );
                    }
                    else
                    {
                        // discovered this through trial and error, seems to work
                        SetRenderState( RenderState.AdaptiveTessY, ( 'A' | ( '2' ) << 8 | ( 'M' ) << 16 | ( '0' ) << 24 ) );
                    }
                    break;
            }
            // no hacks available for any other vendors?
            //lasta2c = a2c;
        }

        public override void SetStencilBufferParams( CompareFunction function = CompareFunction.AlwaysPass, 
            int refValue = 0, int mask = -1, 
            StencilOperation stencilFailOp = StencilOperation.Keep, StencilOperation depthFailOp = StencilOperation.Keep, 
            StencilOperation passOp = StencilOperation.Keep, bool twoSidedOperation = false )
        {
            bool flip;

            // 2 sided operation?
            if ( twoSidedOperation )
            {
                if (!currentCapabilities.HasCapability(Graphics.Capabilities.TwoSidedStencil))
                {
                    throw new AxiomException( "2-sided stencils are not supported on this hardware!" );
                }

                SetRenderState( RenderState.TwoSidedStencilMode, true );

                // NB: We should always treat CCW as front face for consistent with default
                // culling mode. Therefore, we must take care with two-sided stencil settings.
                flip = (invertVertexWinding && activeRenderTarget.RequiresTextureFlipping) ||
                    (!invertVertexWinding && !activeRenderTarget.RequiresTextureFlipping);

                SetRenderState( RenderState.CcwStencilFail, (int)D3DHelper.ConvertEnum( stencilFailOp, !flip ) );
                SetRenderState( RenderState.CcwStencilZFail, (int)D3DHelper.ConvertEnum( depthFailOp, !flip ) );
                SetRenderState( RenderState.CcwStencilPass, (int)D3DHelper.ConvertEnum( passOp, !flip ) );
            }
            else
            {
                SetRenderState( RenderState.TwoSidedStencilMode, false );
                flip = false;
            }

            // configure standard version of the stencil operations
            SetRenderState( RenderState.StencilFunc, (int)D3DHelper.ConvertEnum( function ) );
            SetRenderState( RenderState.StencilRef, refValue );
            SetRenderState( RenderState.StencilMask, mask );
            SetRenderState( RenderState.StencilFail, (int)D3DHelper.ConvertEnum( stencilFailOp, flip ) );
            SetRenderState( RenderState.StencilZFail, (int)D3DHelper.ConvertEnum( depthFailOp, flip ) );
            SetRenderState( RenderState.StencilPass, (int)D3DHelper.ConvertEnum( passOp, flip ) );
        }

 public override void SetDepthBufferParams( bool depthTest, bool depthWrite, CompareFunction depthFunction )
 {
     DepthBufferCheckEnabled = depthTest;
     DepthBufferWriteEnabled = depthWrite;
     DepthBufferFunction = depthFunction;
 }

 public static int mdb_set_dupsort(IntPtr txn, uint dbi, CompareFunction cmp)
 {
     return check(LmdbMethods.mdb_set_dupsort(txn, dbi, cmp));
 }

		public GLenum ConvertCompareFunction( CompareFunction func )
		{
			switch ( func )
			{
				case CompareFunction.AlwaysFail:
					return GLenum.Never;
				case CompareFunction.AlwaysPass:
					return GLenum.Always;
				case CompareFunction.Less:
					return GLenum.Less;
				case CompareFunction.LessEqual:
					return GLenum.Lequal;
				case CompareFunction.Equal:
					return GLenum.Equal;
				case CompareFunction.NotEqual:
					return GLenum.Notequal;
				case CompareFunction.GreaterEqual:
					return GLenum.Gequal;
				case CompareFunction.Greater:
					return GLenum.Greater;
				default:
					return GLenum.Always; //To keep compiler happy
			}
		}

		public override void SetAlphaRejectSettings( CompareFunction func, byte value, bool alphaToCoverage )
		{
			bool a2c = false;

			if ( func != CompareFunction.AlwaysPass )
			{
				a2c = alphaToCoverage;
			}

			if ( a2c != this.lasta2c && Capabilities.HasCapability( Graphics.Capabilities.AlphaToCoverage ) )
			{
				if ( a2c )
				{
					GL.Enable( All.SampleAlphaToCoverage );
					GLES2Config.GlCheckError( this );
				}
				else
				{
					GL.Disable( All.SampleAlphaToCoverage );
					GLES2Config.GlCheckError( this );
				}

				this.lasta2c = a2c;
			}
		}

 public GL()
 {
     int num;
     camera = new GLExCamera();
     camera.viewMatrix = camera.Result;
     this.rstateScissor = new RasterizerState();
     this.rstateScissor.CullMode = CullMode.None;
     this.rstateScissor.ScissorTestEnable = true;
     this.color = new float[4];
     this.clearColor = Color.Black;
     this.ColorWriteChannels = Microsoft.Xna.Framework.Graphics.ColorWriteChannels.All;
     this.AlphaDestinationBlend = Blend.InverseSourceAlpha;
     this.depthFunc = CompareFunction.Always;
     this.vertex = new Vertex[8];
     sTextures.Add(null);
     this.matrixStack = new Stack<Matrix>();
     this.matrixStack.Push(Matrix.Identity);
     this.effect = new BasicEffect(device);
     this.effect.VertexColorEnabled = true;
     this.effect.Projection = Microsoft.Xna.Framework.Matrix.CreateOrthographicOffCenter(0f, LSystem.screenRect.width, LSystem.screenRect.height, 0f, -1.0f, 1.0f);
     this.alphaTestEffect = new AlphaTestEffect(device);
     this.alphaTestEffect.VertexColorEnabled = true;
     device.RasterizerState = RasterizerState.CullNone;
     device.DepthStencilState = DepthStencilState.None;
     for (num = 0; num < this.vertex.Length; num++)
     {
         this.vertex[num] = new Vertex();
     }
     for (num = 0; num < 4; num++)
     {
         this.color[num] = 1f;
     }
     EnableTextures();
 }

        public void GLDepthFunc(int func)
        {
            switch (func)
            {
                case 0x206:
                    this.depthFunc = CompareFunction.GreaterEqual;
                    break;

                case 0x207:
                    this.depthFunc = CompareFunction.Always;
                    break;

                case 0x202:
                    this.depthFunc = CompareFunction.Equal;
                    break;
            }
        }

 public static CompareOperation ConvertComparisonFunction(CompareFunction comparison)
 {
     switch (comparison)
     {
         case CompareFunction.Always:
             return CompareOperation.Always;
         case CompareFunction.Never:
             return CompareOperation.Never;
         case CompareFunction.Equal:
             return CompareOperation.Equal;
         case CompareFunction.Greater:
             return CompareOperation.Greater;
         case CompareFunction.GreaterEqual:
             return CompareOperation.GreaterOrEqual;
         case CompareFunction.Less:
             return CompareOperation.Less;
         case CompareFunction.LessEqual:
             return CompareOperation.LessOrEqual;
         case CompareFunction.NotEqual:
             return CompareOperation.NotEqual;
         default:
             throw new ArgumentOutOfRangeException();
     }
 }

 public static extern int mdb_set_compare(IntPtr txn, uint dbi, CompareFunction cmp);

 public static Material Add(Material baseMat, int stencilID, StencilOp operation, CompareFunction compareFunction, ColorWriteMask colorWriteMask)
 {
   return StencilMaterial.Add(baseMat, stencilID, operation, compareFunction, colorWriteMask, (int) byte.MaxValue, (int) byte.MaxValue);
 }

		/// <summary>
		///    Default constructor.
		/// </summary>
		/// <param name="parent">Technique that owns this Pass.</param>
		/// <param name="index">Index of this pass.</param>
		public Pass( Technique parent, int index )
		{
			this._parent = parent;
			this._index = index;

			lock ( passLock )
			{
				this.passId = nextPassId++;
			}

			// color defaults
			_ambient = ColorEx.White;
			_diffuse = ColorEx.White;
			_specular = ColorEx.Black;
			_emissive = ColorEx.Black;

			// by default, don't override the scene's fog settings
			_fogOverride = false;
			_fogMode = FogMode.None;
			_fogColor = ColorEx.White;
			_fogStart = 0;
			_fogEnd = 1;
			_fogDensity = 0.001f;

			// default blending (overwrite)
			_sourceBlendFactor = SceneBlendFactor.One;
			_destinationBlendFactor = SceneBlendFactor.Zero;



			// depth buffer settings
			_depthCheck = true;
			_depthWrite = true;
			_colorWriteEnabled = true;
			_depthFunction = CompareFunction.LessEqual;

			// cull settings
			_cullingMode = CullingMode.Clockwise;
			_manualCullingMode = ManualCullingMode.Back;

			// light settings
			_lightingEnabled = true;
			_runOnlyForOneLightType = true;
			_onlyLightType = LightType.Point;
			_shadingMode = Shading.Gouraud;

			// Default max lights to the global max
			_maxSimultaneousLights = Config.MaxSimultaneousLights;

			_name = index.ToString();

            IterationCount = 1;

			DirtyHash();
		}

 private static GLStencilFunction GetStencilFunc(CompareFunction function)
 {
     switch (function)
     {
     case CompareFunction.Always:
         return GLStencilFunction.Always;
     case CompareFunction.Equal:
         return GLStencilFunction.Equal;
     case CompareFunction.Greater:
         return GLStencilFunction.Greater;
     case CompareFunction.GreaterEqual:
         return GLStencilFunction.Gequal;
     case CompareFunction.Less:
         return GLStencilFunction.Less;
     case CompareFunction.LessEqual:
         return GLStencilFunction.Lequal;
     case CompareFunction.Never:
         return GLStencilFunction.Never;
     case CompareFunction.NotEqual:
         return GLStencilFunction.Notequal;
     default:
         return GLStencilFunction.Always;
     }
 }

 public GL10()
 {
     int num;
     this.color = new float[4];
     this.clearColor = Color.Black;
     this.ColorWriteChannels = ColorWriteChannels.All;
     this.AlphaDestinationBlend = Blend.InverseSourceAlpha;
     this.depthFunc = CompareFunction.Always;
     this.textureFilter = TextureFilter.Linear;
     this.textureAddressU = TextureAddressMode.Clamp;
     this.textureAddressV = TextureAddressMode.Clamp;
     this.vertex = new Vertex[8];
     this.texture = new Texture[0x100];
     this.matrixStack = new Stack<Matrix>();
     this.effect = new BasicEffect(GLEx.device);
     this.effect.VertexColorEnabled = true;
     this.alphaTestEffect = new AlphaTestEffect(GLEx.device);
     this.alphaTestEffect.VertexColorEnabled = true;
     for (num = 0; num < this.vertex.Length; num++)
     {
         this.vertex[num] = new Vertex();
     }
     for (num = 0; num < 4; num++)
     {
         this.color[num] = 1f;
     }
 }