using System;
using System.Collections.Generic;
using System.Text;

using SlimDX.Direct3D9;

namespace Tsukikage.GameSDK.Direct3D
{
    /// <summary>
    /// 描画の諸設定。
    /// Render states define set-up states for all kinds of vertex and pixel processing.
    /// Some render states set up vertex processing, and some set up pixel processing.
    /// Render states can be saved and restored using stateblocks.
    /// Applications use the methods of the StateBlock class to encapsulate render states.
    /// </summary>
    public sealed class RenderStateManager
    {
        Device device;
        internal RenderStateManager(Device device)
        {
            this.device = device;
        }

        /// <summary>
        /// A floating point value that specifies the amount to adaptively tessellate, in the W direction.
        /// The default value is 1.0f.
        /// </summary>
        public float AdaptiveTessellateW
        {
            get { return device.GetRenderState<float>(RenderState.AdaptiveTessW); }
            set { device.SetRenderState(RenderState.AdaptiveTessW, value); }
        }

        /// <summary>
        /// A floating point value that specifies the amount to adaptively tessellate, in the X direction.
        /// The default value is 0.0f.
        /// </summary>
        public float AdaptiveTessellateX
        {
            get { return device.GetRenderState<float>(RenderState.AdaptiveTessX); }
            set { device.SetRenderState(RenderState.AdaptiveTessX, value); }
        }

        /// <summary>
        /// A floating point value that specifies the amount to adaptively tessellate, in the Y direction.
        /// The default value is 0.0f.
        /// </summary>
        public float AdaptiveTessellateY
        {
            get { return device.GetRenderState<float>(RenderState.AdaptiveTessY); }
            set { device.SetRenderState(RenderState.AdaptiveTessY, value); }
        }

        /// <summary>
        /// A floating point value that specifies the amount to adaptively tessellate, in the Z direction.
        /// The default value is 0.0f.
        /// </summary>
        public float AdaptiveTessellateZ
        {
            get { return device.GetRenderState<float>(RenderState.AdaptiveTessZ); }
            set { device.SetRenderState(RenderState.AdaptiveTessZ, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable alpha blending, and <c>false</c> to disable it. The default
        /// value is <c>false</c>.
        /// </summary>
        public bool AlphaBlendEnable
        {
            get { return device.GetRenderState<bool>(RenderState.AlphaBlendEnable); }
            set { device.SetRenderState(RenderState.AlphaBlendEnable, value); }
        }

        /// <summary>
        /// Specifies the operation to perform for separate alpha blending. Use values from <see cref="BlendOperation"/>
        /// to set this state. The default value is <see cref="BlendOperation"/>.Add.
        /// </summary>
        public BlendOperation AlphaBlendOperation
        {
            get { return device.GetRenderState<BlendOperation>(RenderState.BlendOperationAlpha); }
            set { device.SetRenderState<BlendOperation>(RenderState.BlendOperationAlpha, value); }
        }

        /// <summary>
        /// Specifies the destination alpha blending function. Use values from <see cref="Blend"/> to set this state.
        /// The default value is <see cref="SlimDX.Direct3D9.Blend"/>.Zero.
        /// </summary>
        public Blend AlphaDestinationBlend
        {
            get { return device.GetRenderState<Blend>(RenderState.DestinationBlendAlpha); }
            set { device.SetRenderState<Blend>(RenderState.DestinationBlendAlpha, value); }
        }

        /// <summary>
        /// Specifies the current alpha testing function. Use values from <see cref="SlimDX.Direct3D9.Compare"/> to
        /// set this state. The default value is <see cref="SlimDX.Direct3D9.Compare"/>.Always.
        /// </summary>
        public Compare AlphaFunction
        {
            get { return device.GetRenderState<Compare>(RenderState.AlphaFunc); }
            set { device.SetRenderState<Compare>(RenderState.AlphaFunc, value); }
        }

        /// <summary>
        /// Specifies the source alpha blending function. Use values from <see cref="Blend"/> to set this state.
        /// The default value is <see cref="SlimDX.Direct3D9.Blend"/>.One.
        /// </summary>
        public Blend AlphaSourceBlend
        {
            get { return device.GetRenderState<Blend>(RenderState.SourceBlendAlpha); }
            set { device.SetRenderState<Blend>(RenderState.SourceBlendAlpha, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable alpha testing, and <c>false</c> to disable it. The
        /// default value is <c>false</c>.
        /// </summary>
        public bool AlphaTestEnable
        {
            get { return device.GetRenderState<bool>(RenderState.AlphaTestEnable); }
            set { device.SetRenderState(RenderState.AlphaTestEnable, value); }
        }

        /// <summary>
        /// Specifies the ambient light color. Use integer color values to set this state. The default value 
        /// is 0 (black).
        /// </summary>
        public int Ambient
        {
            get { return device.GetRenderState<int>(RenderState.Ambient); }
            set { device.SetRenderState(RenderState.Ambient, value); }
        }

        /// <summary>
        /// Specifies the ambient light color. Use integer color values to set this state. The default value 
        /// is 0 (black).
        /// </summary>
        public int AmbientColor
        {
            get { return device.GetRenderState<int>(RenderState.Ambient); }
            set { device.SetRenderState(RenderState.Ambient, value); }
        }

        /// <summary>
        /// Specifies the source for ambient colors. Use values from <see cref="ColorSource"/> to set
        /// this state. The default value is <see cref="SlimDX.Direct3D9.ColorSource"/>.Material.
        /// </summary>
        public ColorSource AmbientMaterialSource
        {
            get { return device.GetRenderState<ColorSource>(RenderState.AmbientMaterialSource); }
            set { device.SetRenderState<ColorSource>(RenderState.AmbientMaterialSource, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable antialiased lines, and <c>false</c>
        /// to disable them. The default value is <c>false</c>.
        /// </summary>
        public bool AntiAliasedLineEnable
        {
            get { return device.GetRenderState<bool>(RenderState.AntialiasedLineEnable); }
            set { device.SetRenderState(RenderState.AntialiasedLineEnable, value); }
        }

        /// <summary>
        /// Specifies a color to use as a constant blend factor for alpha blending. Use integer color values 
        /// to set this state. The default value is 0xFFFFFFFF (white).
        /// </summary>
        public int BlendFactor
        {
            get { return device.GetRenderState<int>(RenderState.BlendFactor); }
            set { device.SetRenderState(RenderState.BlendFactor, value); }
        }

        /// <summary>
        /// Specifies a color to use as a constant blend factor for alpha blending. Use integer color values 
        /// to set this state. The default value is 0xFFFFFFFF (white).
        /// </summary>
        public int BlendFactorColor
        {
            get { return device.GetRenderState<int>(RenderState.BlendFactor); }
            set { device.SetRenderState(RenderState.BlendFactor, value); }
        }

        /// <summary>
        /// Specifies the blending operation to use when alpha blending is enabled. Use values from
        /// <see cref="BlendOperation"/> to set this state. The default value is <see cref="BlendOperation"/>.Add".
        /// </summary>
        public BlendOperation BlendOperation
        {
            get { return device.GetRenderState<BlendOperation>(RenderState.BlendOperation); }
            set { device.SetRenderState<BlendOperation>(RenderState.BlendOperation, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable primitive clipping, and <c>false</c>
        /// to disable it. The default value is <c>true</c>.
        /// </summary>
        public bool Clipping
        {
            get { return device.GetRenderState<bool>(RenderState.Clipping); }
            set { device.SetRenderState(RenderState.Clipping, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable colored vertices, and <c>false</c>
        /// to disable them. The default value is <c>true</c>.
        /// </summary>
        public bool ColorVertex
        {
            get { return device.GetRenderState<bool>(RenderState.ColorVertex); }
            set { device.SetRenderState(RenderState.ColorVertex, value); }
        }

        /// <summary>
        /// Specifies the current color write state of the device. Use values from <see cref="ColorWriteEnable"/>
        /// to set this state. The default value is <see cref="ColorWriteEnable"/>.All".
        /// </summary>
        public ColorWriteEnable ColorWriteEnable
        {
            get { return device.GetRenderState<ColorWriteEnable>(RenderState.ColorWriteEnable); }
            set { device.SetRenderState<ColorWriteEnable>(RenderState.ColorWriteEnable, value); }
        }

        /// <summary>
        /// Specifies additional color write enable settings for the device. Use values from <see cref="ColorWriteEnable"/>
        /// to set this state. The default value is <see cref="ColorWriteEnable"/>.All".
        /// </summary>
        public ColorWriteEnable ColorWriteEnable1
        {
            get { return device.GetRenderState<ColorWriteEnable>(RenderState.ColorWriteEnable1); }
            set { device.SetRenderState<ColorWriteEnable>(RenderState.ColorWriteEnable1, value); }
        }

        /// <summary>
        /// Specifies additional color write enable settings for the device. Use values from <see cref="ColorWriteEnable"/>
        /// to set this state. The default value is <see cref="ColorWriteEnable"/>.All".
        /// </summary>
        public ColorWriteEnable ColorWriteEnable2
        {
            get { return device.GetRenderState<ColorWriteEnable>(RenderState.ColorWriteEnable2); }
            set { device.SetRenderState<ColorWriteEnable>(RenderState.ColorWriteEnable2, value); }
        }

        /// <summary>
        /// Specifies additional color write enable settings for the device. Use values from <see cref="ColorWriteEnable"/>
        /// to set this state. The default value is <see cref="ColorWriteEnable"/>.All".
        /// </summary>
        public ColorWriteEnable ColorWriteEnable3
        {
            get { return device.GetRenderState<ColorWriteEnable>(RenderState.ColorWriteEnable3); }
            set { device.SetRenderState<ColorWriteEnable>(RenderState.ColorWriteEnable3, value); }
        }

        /// <summary>
        /// Specifies the operation to perform if the stencil test fails. Use values from
        /// <see cref="StencilOperation"/> to set the state. The default value is <see cref="StencilOperation"/>.Keep".
        /// </summary>
        public StencilOperation CounterClockwiseStencilFail
        {
            get { return device.GetRenderState<StencilOperation>(RenderState.CcwStencilFail); }
            set { device.SetRenderState<StencilOperation>(RenderState.CcwStencilFail, value); }
        }

        /// <summary>
        /// Specifies the comparison function for stencil tests.. Use values from
        /// <see cref="Compare"/> to set the state. The default value is <see cref="Compare"/>.Always".
        /// </summary>
        public Compare CounterClockwiseStencilFunction
        {
            get { return device.GetRenderState<Compare>(RenderState.CcwStencilFunc); }
            set { device.SetRenderState<Compare>(RenderState.CcwStencilFunc, value); }
        }

        /// <summary>
        /// Specifies the operation to perform if both the stencil and depth tests pass. Use values from
        /// <see cref="StencilOperation"/> to set the state. The default value is <see cref="StencilOperation"/>.Keep".
        /// </summary>
        public StencilOperation CounterClockwiseStencilPass
        {
            get { return device.GetRenderState<StencilOperation>(RenderState.CcwStencilPass); }
            set { device.SetRenderState<StencilOperation>(RenderState.CcwStencilPass, value); }
        }

        /// <summary>
        /// Specifies the operation to perform if the stencil test passes and depth test fails. Use values from
        /// <see cref="StencilOperation"/> to set the state. The default value is <see cref="StencilOperation"/>.Keep".
        /// </summary>
        public StencilOperation CounterClockwiseStencilZBufferFail
        {
            get { return device.GetRenderState<StencilOperation>(RenderState.CcwStencilZFail); }
            set { device.SetRenderState<StencilOperation>(RenderState.CcwStencilZFail, value); }
        }

        /// <summary>
        /// Specifies how back-facing triangles are culled. Use values from <see cref="SlimDX.Direct3D9.Cull"/> to
        /// set this state. The default value is <see cref="SlimDX.Direct3D9.Cull"/>.Counterclockwise.
        /// </summary>
        public Cull CullMode
        {
            get { return device.GetRenderState<Cull>(RenderState.CullMode); }
            set { device.SetRenderState<Cull>(RenderState.CullMode, value); }
        }

        /// <summary>
        /// Specifies the current debug monitor token. Use values from <see cref="DebugMonitorToken"/> to
        /// set this state. The default value is <see cref="DebugMonitorToken"/>.Enable".
        /// </summary>
        public DebugMonitorTokens DebugMonitorTokenEnabled
        {
            get { return device.GetRenderState<DebugMonitorTokens>(RenderState.DebugMonitorToken); }
            set { device.SetRenderState<DebugMonitorTokens>(RenderState.DebugMonitorToken, value); }
        }

        /// <summary>
        /// A floating point value that is used for comparison of depth values.
        /// </summary>
        public float DepthBias
        {
            get { return device.GetRenderState<float>(RenderState.DepthBias); }
            set { device.SetRenderState(RenderState.DepthBias, value); }
        }

        /// <summary>
        /// Defines the current destination blending mode of the device. Use values from <see cref="SlimDX.Direct3D9.Blend"/> to
        /// set this state. The default value is <see cref="SlimDX.Direct3D9.Blend"/>.Zero.
        /// </summary>
        public Blend DestinationBlend
        {
            get { return device.GetRenderState<Blend>(RenderState.DestinationBlend); }
            set { device.SetRenderState<Blend>(RenderState.DestinationBlend, value); }
        }

        /// <summary>
        /// Specifies the source for diffuse colors. Use values from <see cref="ColorSource"/> to set
        /// this state. The default value is <see cref="SlimDX.Direct3D9.ColorSource"/>.Color1.
        /// </summary>
        public ColorSource DiffuseMaterialSource
        {
            get { return device.GetRenderState<ColorSource>(RenderState.DiffuseMaterialSource); }
            set { device.SetRenderState<ColorSource>(RenderState.DiffuseMaterialSource, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable dithering, and <c>false</c> to disable it. The default
        /// value is <c>false</c>.
        /// </summary>
        public bool DitherEnable
        {
            get { return device.GetRenderState<bool>(RenderState.DitherEnable); }
            set { device.SetRenderState(RenderState.DitherEnable, value); }
        }

        /// <summary>
        /// Specifies the source for emissive colors. Use values from <see cref="ColorSource"/> to set
        /// this state. The default value is <see cref="SlimDX.Direct3D9.ColorSource"/>.Material.
        /// </summary>
        public ColorSource EmissiveMaterialSource
        {
            get { return device.GetRenderState<ColorSource>(RenderState.EmissiveMaterialSource); }
            set { device.SetRenderState<ColorSource>(RenderState.EmissiveMaterialSource, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable adaptive tessellation, and <c>false</c>
        /// to disable it. The default value is <c>false</c>.
        /// </summary>
        public bool EnableAdaptiveTessellation
        {
            get { return device.GetRenderState<bool>(RenderState.EnableAdaptiveTessellation); }
            set { device.SetRenderState(RenderState.EnableAdaptiveTessellation, value); }
        }

        /// <summary>
        /// Defines the current fill mode of the device. Use values from <see cref="FillMode"/> to set this state.
        /// The default value is <see cref="SlimDX.Direct3D9.FillMode"/>.Solid.
        /// </summary>
        public FillMode FillMode
        {
            get { return device.GetRenderState<FillMode>(RenderState.FillMode); }
            set { device.SetRenderState<FillMode>(RenderState.FillMode, value); }
        }

        /// <summary>
        /// Specifies current fog color. Use integer color values to set this state. The default value is
        /// 0 (black).
        /// </summary>
        public int FogColor
        {
            get { return device.GetRenderState<int>(RenderState.FogColor); }
            set { device.SetRenderState(RenderState.FogColor, value); }
        }

        /// <summary>
        /// Specifies current fog color. Use integer color values to set this state. The default value is
        /// 0 (black).
        /// </summary>
        public int FogColorValue
        {
            get { return device.GetRenderState<int>(RenderState.FogColor); }
            set { device.SetRenderState(RenderState.FogColor, value); }
        }

        /// <summary>
        /// A floating point value that defines the density of fog used in exponential fog modes.
        /// The default value is 1.0f.
        /// </summary>
        public float FogDensity
        {
            get { return device.GetRenderState<float>(RenderState.FogDensity); }
            set { device.SetRenderState(RenderState.FogDensity, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable fog blending, and <c>false</c> to disable it. The default
        /// value is <c>false</c>.
        /// </summary>
        public bool FogEnable
        {
            get { return device.GetRenderState<bool>(RenderState.FogEnable); }
            set { device.SetRenderState(RenderState.FogEnable, value); }
        }

        /// <summary>
        /// A floating point value that defines the depth at which pixel or vertex fog effects end.
        /// The default value is 1.0f.
        /// </summary>
        public float FogEnd
        {
            get { return device.GetRenderState<float>(RenderState.FogEnd); }
            set { device.SetRenderState(RenderState.FogEnd, value); }
        }

        /// <summary>
        /// A floating point value that defines the depth at which pixel or vertex fog effects begin.
        /// The default value is 0.0f.
        /// </summary>
        public float FogStart
        {
            get { return device.GetRenderState<float>(RenderState.FogStart); }
            set { device.SetRenderState(RenderState.FogStart, value); }
        }

        /// <summary>
        /// Specifies the current fog formula to be used for pixel fog. Use values from <see cref="SlimDX.Direct3D9.FogMode"/>
        /// to set this state. The default value is <see cref="SlimDX.Direct3D9.FogMode"/>.None.
        /// </summary>
        public FogMode FogTableMode
        {
            get { return device.GetRenderState<FogMode>(RenderState.FogTableMode); }
            set { device.SetRenderState<FogMode>(RenderState.FogTableMode, value); }
        }

        /// <summary>
        /// Specifies the current fog formula to be used for vertex fog. Use values from <see cref="FogMode"/>
        /// to set this state. The default value is <see cref="SlimDX.Direct3D9.FogMode"/>.None.
        /// </summary>
        public FogMode FogVertexMode
        {
            get { return device.GetRenderState<FogMode>(RenderState.FogVertexMode); }
            set { device.SetRenderState<FogMode>(RenderState.FogVertexMode, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable indexed vertex blending, and <c>false</c>
        /// to disable it. The default value is <c>false</c>.
        /// </summary>
        public bool IndexedVertexBlendEnable
        {
            get { return device.GetRenderState<bool>(RenderState.IndexedVertexBlendEnable); }
            set { device.SetRenderState(RenderState.IndexedVertexBlendEnable, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable drawing of the last pixel in a line, and <c>false</c>
        /// to disable it. The default value is <c>true</c>.
        /// </summary>
        public bool LastPixel
        {
            get { return device.GetRenderState<bool>(RenderState.LastPixel); }
            set { device.SetRenderState(RenderState.LastPixel, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable lighting, and <c>false</c>
        /// to disable it. The default value is <c>true</c>.
        /// </summary>
        public bool Lighting
        {
            get { return device.GetRenderState<bool>(RenderState.Lighting); }
            set { device.SetRenderState(RenderState.Lighting, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable camera-relative specular highlights, and <c>false</c>
        /// to use orthogonal specular highlights. The default value is <c>true</c>.
        /// </summary>
        public bool LocalViewer
        {
            get { return device.GetRenderState<bool>(RenderState.LocalViewer); }
            set { device.SetRenderState(RenderState.LocalViewer, value); }
        }

        /// <summary>
        /// A floating point value that specifies the maximum tessellation level. The default value is 1.0f.
        /// </summary>
        public float MaxTessellationLevel
        {
            get { return device.GetRenderState<float>(RenderState.MaxTessellationLevel); }
            set { device.SetRenderState(RenderState.MaxTessellationLevel, value); }
        }

        /// <summary>
        /// A floating point value that specifies the minium tessellation level. The default value is 1.0f.
        /// </summary>
        public float MinTessellationLevel
        {
            get { return device.GetRenderState<float>(RenderState.MinTessellationLevel); }
            set { device.SetRenderState(RenderState.MinTessellationLevel, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable point multisampling, and <c>false</c>
        /// to disable it. The default value is <c>false</c>.
        /// </summary>
        public bool MultiSampleAntiAlias
        {
            get { return device.GetRenderState<bool>(RenderState.MultisampleAntialias); }
            set { device.SetRenderState(RenderState.MultisampleAntialias, value); }
        }

        /// <summary>
        /// An integer mask that controls the samples in a multisampling render target.
        /// </summary>
        public int MultiSampleMask
        {
            get { return device.GetRenderState<int>(RenderState.MultisampleMask); }
            set { device.SetRenderState(RenderState.MultisampleMask, value); }
        }

        /// <summary>
        /// Specifies the N-patch normal interpolation degree. Use values from <see cref="Degree"/> to
        /// set this state. The default value is <see cref="Degree"/>.Linear".
        /// </summary>
        public Degree NormalDegree
        {
            get { return device.GetRenderState<Degree>(RenderState.NormalDegree); }
            set { device.SetRenderState<Degree>(RenderState.NormalDegree, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable automatic normalization of vertex normals, and <c>false</c>
        /// to disable it. The default value is <c>false</c>.
        /// </summary>
        public bool NormalizeNormals
        {
            get { return device.GetRenderState<bool>(RenderState.NormalizeNormals); }
            set { device.SetRenderState(RenderState.NormalizeNormals, value); }
        }

        /// <summary>
        /// Specifies the current patch edge style. Use values from <see cref="PatchEdgeStyle"/> to
        /// set this state. The default value is <see cref="PatchEdgeStyle"/>.Discrete".
        /// </summary>
        public PatchEdgeStyle PatchEdgeStyle
        {
            get { return device.GetRenderState<PatchEdgeStyle>(RenderState.PatchEdgeStyle); }
            set { device.SetRenderState<PatchEdgeStyle>(RenderState.PatchEdgeStyle, value); }
        }

        /// <summary>
        /// A floating point value that specifies attenuation when point scaling is applied. The default
        /// value is 1.0f.
        /// </summary>
        public float PointScaleA
        {
            get { return device.GetRenderState<float>(RenderState.PointScaleA); }
            set { device.SetRenderState(RenderState.PointScaleA, value); }
        }

        /// <summary>
        /// A floating point value that specifies attenuation when point scaling is applied. The default
        /// value is 0.0f.
        /// </summary>
        public float PointScaleB
        {
            get { return device.GetRenderState<float>(RenderState.PointScaleB); }
            set { device.SetRenderState(RenderState.PointScaleB, value); }
        }

        /// <summary>
        /// A floating point value that specifies attenuation when point scaling is applied. The default
        /// value is 0.0f.
        /// </summary>
        public float PointScaleC
        {
            get { return device.GetRenderState<float>(RenderState.PointScaleC); }
            set { device.SetRenderState(RenderState.PointScaleC, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable point scaling, and <c>false</c>
        /// to disable it. The default value is <c>false</c>.
        /// </summary>
        public bool PointScaleEnable
        {
            get { return device.GetRenderState<bool>(RenderState.PointScaleEnable); }
            set { device.SetRenderState(RenderState.PointScaleEnable, value); }
        }

        /// <summary>
        /// A floating point value that specifies the size of points.
        /// </summary>
        public float PointSize
        {
            get { return device.GetRenderState<float>(RenderState.PointSize); }
            set { device.SetRenderState(RenderState.PointSize, value); }
        }

        /// <summary>
        /// A floating point value that specifies the maximum size of point primitives.
        /// </summary>
        public float PointSizeMax
        {
            get { return device.GetRenderState<float>(RenderState.PointSizeMax); }
            set { device.SetRenderState(RenderState.PointSizeMax, value); }
        }

        /// <summary>
        /// A floating point value that specifies the minimum size of point primitives.
        /// </summary>
        public float PointSizeMin
        {
            get { return device.GetRenderState<float>(RenderState.PointSizeMin); }
            set { device.SetRenderState(RenderState.PointSizeMin, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable point sprites, and <c>false</c>
        /// to disable them. The default value is <c>false</c>.
        /// </summary>
        public bool PointSpriteEnable
        {
            get { return device.GetRenderState<bool>(RenderState.PointSpriteEnable); }
            set { device.SetRenderState(RenderState.PointSpriteEnable, value); }
        }

        /// <summary>
        /// Specifies the N-patch position interpolation degree. Use values from <see cref="Degree"/> to
        /// set this state. The default value is <see cref="Degree"/>.Cubic".
        /// </summary>
        public Degree PositionDegree
        {
            get { return device.GetRenderState<Degree>(RenderState.PositionDegree); }
            set { device.SetRenderState<Degree>(RenderState.PositionDegree, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable range based fog, and <c>false</c> to use depth based fog. 
        /// The default value is <c>false</c>.
        /// </summary>
        public bool RangeFogEnable
        {
            get { return device.GetRenderState<bool>(RenderState.RangeFogEnable); }
            set { device.SetRenderState(RenderState.RangeFogEnable, value); }
        }

        /// <summary>
        /// An integer value that specifies the reference alpha against which pixels are tested when
        /// alpha blending is enabled. The default value is 0.
        /// </summary>
        public int ReferenceAlpha
        {
            get { return device.GetRenderState<int>(RenderState.AlphaRef); }
            set { device.SetRenderState(RenderState.AlphaRef, value); }
        }

        /// <summary>
        /// An integer value that specifies the reference value against which pixels are tested when
        /// stencil testing is enabled. The default value is 0.
        /// </summary>
        public int ReferenceStencil
        {
            get { return device.GetRenderState<int>(RenderState.StencilRef); }
            set { device.SetRenderState(RenderState.StencilRef, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable scissor testing, and <c>false</c>
        /// to disable it. The default value is <c>false</c>.
        /// </summary>
        public bool ScissorTestEnable
        {
            get { return device.GetRenderState<bool>(RenderState.ScissorTestEnable); }
            set { device.SetRenderState(RenderState.ScissorTestEnable, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable separate blending modes for the alpha channel, and <c>false</c>
        /// to disable them. The default value is <c>false</c>.
        /// </summary>
        public bool SeparateAlphaBlendEnabled
        {
            get { return device.GetRenderState<bool>(RenderState.SeparateAlphaBlendEnable); }
            set { device.SetRenderState(RenderState.SeparateAlphaBlendEnable, value); }
        }

        /// <summary>
        /// Defines the current shade mode of the device. Use values from <see cref="SlimDX.Direct3D9.ShadeMode"/> to set this state.
        /// The default value is <see cref="SlimDX.Direct3D9.ShadeMode"/>.Gouraud.
        /// </summary>
        public ShadeMode ShadeMode
        {
            get { return device.GetRenderState<ShadeMode>(RenderState.ShadeMode); }
            set { device.SetRenderState<ShadeMode>(RenderState.ShadeMode, value); }
        }

        /// <summary>An integer value that specifies how much bias can be applied to co-planar primitives to reduce Z-fighting. The default value is 0.</summary>
        public float SlopeScaleDepthBias
        {
            get { return device.GetRenderState<float>(RenderState.SlopeScaleDepthBias); }
            set { device.SetRenderState(RenderState.SlopeScaleDepthBias, value); }
        }

        /// <summary>
        /// Defines the current source blending mode of the device. Use values from <see cref="Blend"/> to
        /// set this state. The default value is <see cref="SlimDX.Direct3D9.Blend"/>.One.
        /// </summary>
        public Blend SourceBlend
        {
            get { return device.GetRenderState<Blend>(RenderState.SourceBlend); }
            set { device.SetRenderState<Blend>(RenderState.SourceBlend, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable specular highlights, and <c>false</c> to disable them. 
        /// The default value is <c>false</c>.
        /// </summary>
        public bool SpecularEnable
        {
            get { return device.GetRenderState<bool>(RenderState.SpecularEnable); }
            set { device.SetRenderState(RenderState.SpecularEnable, value); }
        }

        /// <summary>
        /// Specifies the source for specular colors. Use values from <see cref="ColorSource"/> to set
        /// this state. The default value is <see cref="SlimDX.Direct3D9.ColorSource"/>.Color2.
        /// </summary>
        public ColorSource SpecularMaterialSource
        {
            get { return device.GetRenderState<ColorSource>(RenderState.SpecularMaterialSource); }
            set { device.SetRenderState<ColorSource>(RenderState.SpecularMaterialSource, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable sRGB gamma correction, and <c>false</c>
        /// to disable it. The default value is <c>false</c>.
        /// </summary>
        public bool SrgbWriteEnable
        {
            get { return device.GetRenderState<bool>(RenderState.SrgbWriteEnable); }
            set { device.SetRenderState(RenderState.SrgbWriteEnable, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable stenciling, and <c>false</c> to disable it. 
        /// The default value is <c>false</c>.
        /// </summary>
        public bool StencilEnable
        {
            get { return device.GetRenderState<bool>(RenderState.StencilEnable); }
            set { device.SetRenderState(RenderState.StencilEnable, value); }
        }

        /// <summary>
        /// Specifies the stencil operation to perform if the stencil test fails. Use values from 
        /// <see cref="SlimDX.Direct3D9.StencilOperation"/> to set this state. The default value is <see cref="SlimDX.Direct3D9.StencilOperation"/>.Keep.
        /// </summary>
        public StencilOperation StencilFail
        {
            get { return device.GetRenderState<StencilOperation>(RenderState.StencilFail); }
            set { device.SetRenderState<StencilOperation>(RenderState.StencilFail, value); }
        }

        /// <summary>
        /// Specifies the comparison function for stencil tests. Use values from <see cref="SlimDX.Direct3D9.Compare"/> 
        /// to set this state. The default value is <see cref="SlimDX.Direct3D9.Compare"/>.Always.
        /// </summary>
        public Compare StencilFunction
        {
            get { return device.GetRenderState<Compare>(RenderState.StencilFunc); }
            set { device.SetRenderState<Compare>(RenderState.StencilFunc, value); }
        }

        /// <summary>
        /// An integer value that specifies the mask for stencil values. The default value is 0xFFFFFFFF.
        /// </summary>
        public int StencilMask
        {
            get { return device.GetRenderState<int>(RenderState.StencilMask); }
            set { device.SetRenderState(RenderState.StencilMask, value); }
        }

        /// <summary>
        /// Specifies the stencil operation to perform if both the stencil and depth tests pass. Use values from 
        /// <see cref="SlimDX.Direct3D9.StencilOperation"/> to set this state. The default value is <see cref="SlimDX.Direct3D9.StencilOperation"/>.Keep.
        /// </summary>
        public StencilOperation StencilPass
        {
            get { return device.GetRenderState<StencilOperation>(RenderState.StencilPass); }
            set { device.SetRenderState<StencilOperation>(RenderState.StencilPass, value); }
        }

        /// <summary>
        /// An integer value that specifies the write mask used for values written into the stencil buffer.
        /// The default value is 0xFFFFFFFF.
        /// </summary>
        public int StencilWriteMask
        {
            get { return device.GetRenderState<int>(RenderState.StencilWriteMask); }
            set { device.SetRenderState(RenderState.StencilWriteMask, value); }
        }

        /// <summary>
        /// Specifies the stencil operation to perform if the stencil test passes and the depth test fails. 
        /// Use values from <see cref="SlimDX.Direct3D9.StencilOperation"/> to set this state. The default value is 
        /// <see cref="SlimDX.Direct3D9.StencilOperation"/>.Keep.
        /// </summary>
        public StencilOperation StencilZBufferFail
        {
            get { return device.GetRenderState<StencilOperation>(RenderState.StencilZFail); }
            set { device.SetRenderState<StencilOperation>(RenderState.StencilZFail, value); }
        }

        /// <summary>
        /// Specifies the color used for multiple texture blending. Use integer color values to set this 
        /// state. The default value is 0xFFFFFFFF (white).
        /// </summary>
        public int TextureFactor
        {
            get { return device.GetRenderState<int>(RenderState.TextureFactor); }
            set { device.SetRenderState(RenderState.TextureFactor, value); }
        }

        /// <summary>
        /// A floating point value that specifies the tweening factor. The default value is 0.0f.
        /// </summary>
        public float TweenFactor
        {
            get { return device.GetRenderState<float>(RenderState.TweenFactor); }
            set { device.SetRenderState(RenderState.TweenFactor, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable two sided stenciling, and <c>false</c>
        /// to disable it. The default value is <c>false</c>.
        /// </summary>
        public bool TwoSidedStencilMode
        {
            get { return device.GetRenderState<bool>(RenderState.TwoSidedStencilMode); }
            set { device.SetRenderState(RenderState.TwoSidedStencilMode, value); }
        }

        ///// <summary>Enables or disables w-buffering.</summary>
        //public bool UseWBuffer
        //{
        //    get { }
        //    set { }
        //}

        /// <summary>
        /// An integer value that specifies the number of matrices to use to perform geometry blending.
        /// Use values from <see cref="VertexBlend"/> to set this state. The default value is
        /// <see cref="SlimDX.Direct3D9.VertexBlend"/>.Disable.
        /// </summary>
        public VertexBlend VertexBlend
        {
            get { return device.GetRenderState<VertexBlend>(RenderState.VertexBlend); }
            set { device.SetRenderState<VertexBlend>(RenderState.VertexBlend, value); }
        }

        /// <summary>
        /// Texture wrapping behavior for multiple sets of texture coordinates. Use values from
        /// <see cref="SlimDX.Direct3D9.TextureWrapping"/> to set this state. The default value for this state is <see cref="SlimDX.Direct3D9.TextureWrapping"/>.None.
        /// </summary>
        public TextureWrapping Wrap0
        {
            get { return device.GetRenderState<TextureWrapping>(RenderState.Wrap0); }
            set { device.SetRenderState<TextureWrapping>(RenderState.Wrap0, value); }
        }

        /// <summary>
        /// Texture wrapping behavior for multiple sets of texture coordinates. Use values from
        /// <see cref="SlimDX.Direct3D9.TextureWrapping"/> to set this state. The default value for this state is <see cref="SlimDX.Direct3D9.TextureWrapping"/>.None.
        /// </summary>
        public TextureWrapping Wrap1
        {
            get { return device.GetRenderState<TextureWrapping>(RenderState.Wrap1); }
            set { device.SetRenderState<TextureWrapping>(RenderState.Wrap1, value); }
        }

        /// <summary>
        /// Texture wrapping behavior for multiple sets of texture coordinates. Use values from
        /// <see cref="SlimDX.Direct3D9.TextureWrapping"/> to set this state. The default value for this state is <see cref="SlimDX.Direct3D9.TextureWrapping"/>.None.
        /// </summary>
        public TextureWrapping Wrap10
        {
            get { return device.GetRenderState<TextureWrapping>(RenderState.Wrap10); }
            set { device.SetRenderState<TextureWrapping>(RenderState.Wrap10, value); }
        }

        /// <summary>
        /// Texture wrapping behavior for multiple sets of texture coordinates. Use values from
        /// <see cref="SlimDX.Direct3D9.TextureWrapping"/> to set this state. The default value for this state is <see cref="SlimDX.Direct3D9.TextureWrapping"/>.None.
        /// </summary>
        public TextureWrapping Wrap11
        {
            get { return device.GetRenderState<TextureWrapping>(RenderState.Wrap11); }
            set { device.SetRenderState<TextureWrapping>(RenderState.Wrap11, value); }
        }

        /// <summary>
        /// Texture wrapping behavior for multiple sets of texture coordinates. Use values from
        /// <see cref="SlimDX.Direct3D9.TextureWrapping"/> to set this state. The default value for this state is <see cref="SlimDX.Direct3D9.TextureWrapping"/>.None.
        /// </summary>
        public TextureWrapping Wrap12
        {
            get { return device.GetRenderState<TextureWrapping>(RenderState.Wrap12); }
            set { device.SetRenderState<TextureWrapping>(RenderState.Wrap12, value); }
        }

        /// <summary>
        /// Texture wrapping behavior for multiple sets of texture coordinates. Use values from
        /// <see cref="SlimDX.Direct3D9.TextureWrapping"/> to set this state. The default value for this state is <see cref="SlimDX.Direct3D9.TextureWrapping"/>.None.
        /// </summary>
        public TextureWrapping Wrap13
        {
            get { return device.GetRenderState<TextureWrapping>(RenderState.Wrap13); }
            set { device.SetRenderState<TextureWrapping>(RenderState.Wrap13, value); }
        }

        /// <summary>
        /// Texture wrapping behavior for multiple sets of texture coordinates. Use values from
        /// <see cref="SlimDX.Direct3D9.TextureWrapping"/> to set this state. The default value for this state is <see cref="SlimDX.Direct3D9.TextureWrapping"/>.None.
        /// </summary>
        public TextureWrapping Wrap14
        {
            get { return device.GetRenderState<TextureWrapping>(RenderState.Wrap14); }
            set { device.SetRenderState<TextureWrapping>(RenderState.Wrap14, value); }
        }

        /// <summary>
        /// Texture wrapping behavior for multiple sets of texture coordinates. Use values from
        /// <see cref="SlimDX.Direct3D9.TextureWrapping"/> to set this state. The default value for this state is <see cref="SlimDX.Direct3D9.TextureWrapping"/>.None.
        /// </summary>
        public TextureWrapping Wrap15
        {
            get { return device.GetRenderState<TextureWrapping>(RenderState.Wrap15); }
            set { device.SetRenderState<TextureWrapping>(RenderState.Wrap15, value); }
        }

        /// <summary>
        /// Texture wrapping behavior for multiple sets of texture coordinates. Use values from
        /// <see cref="SlimDX.Direct3D9.TextureWrapping"/> to set this state. The default value for this state is <see cref="SlimDX.Direct3D9.TextureWrapping"/>.None.
        /// </summary>
        public TextureWrapping Wrap2
        {
            get { return device.GetRenderState<TextureWrapping>(RenderState.Wrap2); }
            set { device.SetRenderState<TextureWrapping>(RenderState.Wrap2, value); }
        }

        /// <summary>
        /// Texture wrapping behavior for multiple sets of texture coordinates. Use values from
        /// <see cref="SlimDX.Direct3D9.TextureWrapping"/> to set this state. The default value for this state is <see cref="SlimDX.Direct3D9.TextureWrapping"/>.None.
        /// </summary>
        public TextureWrapping Wrap3
        {
            get { return device.GetRenderState<TextureWrapping>(RenderState.Wrap3); }
            set { device.SetRenderState<TextureWrapping>(RenderState.Wrap3, value); }
        }

        /// <summary>
        /// Texture wrapping behavior for multiple sets of texture coordinates. Use values from
        /// <see cref="SlimDX.Direct3D9.TextureWrapping"/> to set this state. The default value for this state is <see cref="SlimDX.Direct3D9.TextureWrapping"/>.None.
        /// </summary>
        public TextureWrapping Wrap4
        {
            get { return device.GetRenderState<TextureWrapping>(RenderState.Wrap4); }
            set { device.SetRenderState<TextureWrapping>(RenderState.Wrap4, value); }
        }

        /// <summary>
        /// Texture wrapping behavior for multiple sets of texture coordinates. Use values from
        /// <see cref="SlimDX.Direct3D9.TextureWrapping"/> to set this state. The default value for this state is <see cref="SlimDX.Direct3D9.TextureWrapping"/>.None.
        /// </summary>
        public TextureWrapping Wrap5
        {
            get { return device.GetRenderState<TextureWrapping>(RenderState.Wrap5); }
            set { device.SetRenderState<TextureWrapping>(RenderState.Wrap5, value); }
        }

        /// <summary>
        /// Texture wrapping behavior for multiple sets of texture coordinates. Use values from
        /// <see cref="SlimDX.Direct3D9.TextureWrapping"/> to set this state. The default value for this state is <see cref="SlimDX.Direct3D9.TextureWrapping"/>.None.
        /// </summary>
        public TextureWrapping Wrap6
        {
            get { return device.GetRenderState<TextureWrapping>(RenderState.Wrap6); }
            set { device.SetRenderState<TextureWrapping>(RenderState.Wrap6, value); }
        }

        /// <summary>
        /// Texture wrapping behavior for multiple sets of texture coordinates. Use values from
        /// <see cref="SlimDX.Direct3D9.TextureWrapping"/> to set this state. The default value for this state is <see cref="SlimDX.Direct3D9.TextureWrapping"/>.None.
        /// </summary>
        public TextureWrapping Wrap7
        {
            get { return device.GetRenderState<TextureWrapping>(RenderState.Wrap7); }
            set { device.SetRenderState<TextureWrapping>(RenderState.Wrap7, value); }
        }

        /// <summary>
        /// Texture wrapping behavior for multiple sets of texture coordinates. Use values from
        /// <see cref="SlimDX.Direct3D9.TextureWrapping"/> to set this state. The default value for this state is <see cref="SlimDX.Direct3D9.TextureWrapping"/>.None.
        /// </summary>
        public TextureWrapping Wrap8
        {
            get { return device.GetRenderState<TextureWrapping>(RenderState.Wrap8); }
            set { device.SetRenderState<TextureWrapping>(RenderState.Wrap8, value); }
        }

        /// <summary>
        /// Texture wrapping behavior for multiple sets of texture coordinates. Use values from
        /// <see cref="SlimDX.Direct3D9.TextureWrapping"/> to set this state. The default value for this state is <see cref="SlimDX.Direct3D9.TextureWrapping"/>.None.
        /// </summary>
        public TextureWrapping Wrap9
        {
            get { return device.GetRenderState<TextureWrapping>(RenderState.Wrap9); }
            set { device.SetRenderState<TextureWrapping>(RenderState.Wrap9, value); }
        }

        /// <summary>
        /// Depth-buffering state. Use values from <see cref="SlimDX.Direct3D9.ZBufferType"/> to set this state. The
        /// default value for this state is <see cref="SlimDX.Direct3D9.ZBufferType"/>.UseZBuffer if a depth stencil was created
        /// along with the device, or <see cref="SlimDX.Direct3D9.ZBufferType"/>.DontUseZBuffer otherwise.
        /// </summary>
        public ZBufferType ZBufferEnable
        {
            get { return device.GetRenderState<ZBufferType>(RenderState.ZEnable); }
            set { device.SetRenderState<ZBufferType>(RenderState.ZEnable, value); }
        }

        /// <summary>
        /// Specifies the current depth testing function. Use values from <see cref="SlimDX.Direct3D9.Compare"/> to
        /// set this state. The default value is <see cref="SlimDX.Direct3D9.Compare"/>.LessEqual.
        /// </summary>
        public Compare ZBufferFunction
        {
            get { return device.GetRenderState<Compare>(RenderState.ZFunc); }
            set { device.SetRenderState<Compare>(RenderState.ZFunc, value); }
        }

        /// <summary>
        /// Set this state to <c>true</c> to enable writes to the depth buffer, and <c>false</c> to disable
        /// them. The default value is <c>true</c>.
        /// </summary>
        public bool ZBufferWriteEnable
        {
            get { return device.GetRenderState<bool>(RenderState.ZWriteEnable); }
            set { device.SetRenderState(RenderState.ZWriteEnable, value); }
        }

        private class StateBlockImpl : StateBlock { public StateBlockImpl(Device device) : base(device) { } }

        /// <summary>
        /// Render states define set-up states for all kinds of vertex and pixel processing.
        /// Some render states set up vertex processing, and some set up pixel processing.
        /// Render states can be saved and restored using stateblocks.
        /// Applications use the methods of the StateBlock class to encapsulate render states.
        /// </summary>
        public StateBlock StateBlock() { return new StateBlockImpl(device); }
    }

    
    /// <summary>
    /// Applications use the methods of the StateBlock class to encapsulate render states.
    /// </summary>
    public class StateBlock : SlimDX.Direct3D9.StateBlock { protected StateBlock(Device device) : base(device, StateBlockType.All) { } }
}