Axiom.RenderSystems.DirectX9.D3DHelper.ConvertEnum C# (CSharp) Method

ConvertEnum() public static method

public static ConvertEnum ( FilterType type, FilterOptions options, SlimDX.Direct3D9 devCaps, D3DTextureType texType ) : SlimDX.Direct3D9.TextureFilter
type FilterType
options FilterOptions
devCaps SlimDX.Direct3D9
texType D3DTextureType
return SlimDX.Direct3D9.TextureFilter
		public static D3D.TextureFilter ConvertEnum( FilterType type, FilterOptions options, D3D.Capabilities devCaps, D3DTextureType texType )
		{
			// setting a default val here to keep compiler from complaining about using unassigned value types
			D3D.FilterCaps filterCaps = devCaps.TextureFilterCaps;

			switch ( texType )
			{
				case D3DTextureType.Normal:
					filterCaps = devCaps.TextureFilterCaps;
					break;
				case D3DTextureType.Cube:
					filterCaps = devCaps.CubeTextureFilterCaps;
					break;
				case D3DTextureType.Volume:
					filterCaps = devCaps.VolumeTextureFilterCaps;
					break;
			}

			switch ( type )
			{
				case FilterType.Min:
					{
						switch ( options )
						{
							case FilterOptions.Anisotropic:
								if ( ( filterCaps & D3D.FilterCaps.MinAnisotropic ) == D3D.FilterCaps.MinAnisotropic )
								{
									return D3D.TextureFilter.Anisotropic;
								}
								else
								{
									return D3D.TextureFilter.Linear;
								}

							case FilterOptions.Linear:
								if ( ( filterCaps & D3D.FilterCaps.MinLinear ) == D3D.FilterCaps.MinLinear )
								{
									return D3D.TextureFilter.Linear;
								}
								else
								{
									return D3D.TextureFilter.Point;
								}

							case FilterOptions.Point:
							case FilterOptions.None:
								return D3D.TextureFilter.Point;
						}
						break;
					}
				case FilterType.Mag:
					{
						switch ( options )
						{
							case FilterOptions.Anisotropic:
								if ( ( filterCaps & D3D.FilterCaps.MagAnisotropic ) == D3D.FilterCaps.MagAnisotropic )
								{
									return D3D.TextureFilter.Anisotropic;
								}
								else
								{
									return D3D.TextureFilter.Linear;
								}

							case FilterOptions.Linear:
								if ( ( filterCaps & D3D.FilterCaps.MagLinear ) == D3D.FilterCaps.MagLinear )
								{
									return D3D.TextureFilter.Linear;
								}
								else
								{
									return D3D.TextureFilter.Point;
								}

							case FilterOptions.Point:
							case FilterOptions.None:
								return D3D.TextureFilter.Point;
						}
						break;
					}
				case FilterType.Mip:
					{
						switch ( options )
						{
							case FilterOptions.Anisotropic:
							case FilterOptions.Linear:
								if ( ( filterCaps & D3D.FilterCaps.MipLinear ) == D3D.FilterCaps.MipLinear )
								{
									return D3D.TextureFilter.Linear;
								}
								else
								{
									return D3D.TextureFilter.Point;
								}

							case FilterOptions.Point:
								if ( ( filterCaps & D3D.FilterCaps.MipPoint ) == D3D.FilterCaps.MipPoint )
								{
									return D3D.TextureFilter.Point;
								}
								else
								{
									return D3D.TextureFilter.None;
								}

							case FilterOptions.None:
								return D3D.TextureFilter.None;
						}
						break;
					}
			}

			// should never get here
			return 0;
		}

Same methods

D3DHelper::ConvertEnum ( SlimDX.Direct3D9 format ) : Axiom.Media.PixelFormat
D3DHelper::ConvertEnum ( SceneBlendFactor factor ) : SlimDX.Direct3D9.Blend
D3DHelper::ConvertEnum ( SceneBlendOperation op ) : SlimDX.Direct3D9.BlendOperation
D3DHelper::ConvertEnum ( CompareFunction func ) : SlimDX.Direct3D9.Compare
D3DHelper::ConvertEnum ( Axiom mode, bool flip ) : SlimDX.Direct3D9.Cull
D3DHelper::ConvertEnum ( TextureType type ) : D3DTextureType
D3DHelper::ConvertEnum ( VertexElementType type ) : SlimDX.Direct3D9.DeclarationType
D3DHelper::ConvertEnum ( VertexElementSemantic semantic ) : SlimDX.Direct3D9.DeclarationUsage
D3DHelper::ConvertEnum ( PolygonMode mode ) : SlimDX.Direct3D9.FillMode
D3DHelper::ConvertEnum ( Axiom mode ) : SlimDX.Direct3D9.FogMode
D3DHelper::ConvertEnum ( Axiom format ) : SlimDX.Direct3D9.Format
D3DHelper::ConvertEnum ( BufferLocking locking ) : SlimDX.Direct3D9.LockFlags
D3DHelper::ConvertEnum ( BufferLocking locking, BufferUsage usage ) : SlimDX.Direct3D9.LockFlags
D3DHelper::ConvertEnum ( FilterType type ) : SlimDX.Direct3D9.SamplerState
D3DHelper::ConvertEnum ( ShadeOptions opt ) : SlimDX.Direct3D9.ShadeMode
D3DHelper::ConvertEnum ( Shading shading ) : SlimDX.Direct3D9.ShadeMode
D3DHelper::ConvertEnum ( SlimDX.Direct3D9 shading ) : Shading
D3DHelper::ConvertEnum ( Axiom op ) : SlimDX.Direct3D9.StencilOperation
D3DHelper::ConvertEnum ( Axiom op, bool invert ) : SlimDX.Direct3D9.StencilOperation
D3DHelper::ConvertEnum ( TextureAddressing type ) : SlimDX.Direct3D9.TextureAddress
D3DHelper::ConvertEnum ( LayerBlendSource lbs, bool perStageConstants ) : TextureArgument
D3DHelper::ConvertEnum ( LayerBlendSource blendSource ) : SlimDX.Direct3D9.TextureArgument
D3DHelper::ConvertEnum ( LayerBlendOperationEx lbo, SlimDX devCaps ) : TextureOperation
D3DHelper::ConvertEnum ( LayerBlendOperationEx blendop ) : SlimDX.Direct3D9.TextureOperation
D3DHelper::ConvertEnum ( BufferUsage usage ) : SlimDX.Direct3D9.Usage
D3DHelper::ConvertEnum ( TexCoordCalcMethod method, SlimDX.Direct3D9 caps ) : int

Usage Example

 //---------------------------------------------------------------------
 public bool RecreateIfDefaultPool(D3D.Device device)
 {
     if (d3dPool == Pool.Default)
     {
         // Create the d3d vertex buffer
         d3dBuffer = new D3D.VertexBuffer(
             typeof(byte),
             sizeInBytes,
             device,
             D3DHelper.ConvertEnum(usage),
             VertexFormats.None,
             d3dPool);
         return(true);
     }
     return(false);
 }
All Usage Examples Of Axiom.RenderSystems.DirectX9.D3DHelper::ConvertEnum