private Accumulator CompareExpression() { var result = AddSubstractExpression(); var first = _runEnvironment.CurrentLine.NextToken(); IToken secondary = null; switch (first.Seperator) { case TokenType.Equal: break; case TokenType.LessThan: case TokenType.GreaterThan: secondary = _runEnvironment.CurrentLine.NextToken(); break; default: _runEnvironment.CurrentLine.PushToken(first); return(result); } if (secondary != null) { switch (secondary.Seperator) { case TokenType.GreaterThan: case TokenType.Equal: break; default: _runEnvironment.CurrentLine.PushToken(secondary); secondary = null; break; } } int comparisonResult; if (result.Type == typeof(string)) { comparisonResult = result.ValueAsString().CompareTo(AddSubstractExpression().ValueAsString()); } else { comparisonResult = result.ValueAsDouble().CompareTo(AddSubstractExpression().ValueAsDouble()); } return(new Accumulator(ComparisonFunction(first, secondary)(comparisonResult) ? 1.0 : 0.0)); }
/// <summary> /// Sorts an array using specified comparison function /// </summary> /// <param name="a">Array</param> /// <param name="compare">Comparison function</param> public static void MergeSort(T[] a, ComparisonFunction <T> compare) //2nd fastest algorithm after quicksort //only with one array instead { //The core idea is to split array into pairs of elements and sort them //during the merge a = Merged(a, compare); }
// Perform the compare operation. private void compareImagesButton_Click(object sender, EventArgs e) { ComparisonFunction function = ComparisonFunction.ClearEqual; switch (comparisonBox.SelectedIndex) { case 0: function = ComparisonFunction.ClearLess; break; case 1: function = ComparisonFunction.ClearLessOrEqual; break; case 2: function = ComparisonFunction.ClearEqual; break; case 3: function = ComparisonFunction.ClearGreaterOrEqual; break; case 4: function = ComparisonFunction.ClearGreater; break; } Algorithms.Compare(imageViewer1.Image, imageViewer2.Image, imageViewer3.Image, function); }
/// <summary>To initialize this structure with default value, use this constructor. The argument value is ignored.</summary> /// <remarks>This is only here because C# doesn’t support parameterless constructors for structures.</remarks> public StencilOpDesc(bool unused) { StencilFailOp = StencilOp.Keep; StencilDepthFailOp = StencilOp.Keep; StencilPassOp = StencilOp.Keep; StencilFunc = ComparisonFunction.Always; }
/// <summary> /// Initializes a new instance of the <see cref="DepthStencilOperationDescription"/> struct. /// </summary> /// <param name="stencilFailOp">A <see cref="StencilOperation"/> value that identifies the stencil operation to perform when stencil testing fails.</param> /// <param name="stencilDepthFailOp">A <see cref="StencilOperation"/> value that identifies the stencil operation to perform when stencil testing passes and depth testing fails.</param> /// <param name="stencilPassOp">A <see cref="StencilOperation"/> value that identifies the stencil operation to perform when stencil testing and depth testing both pass.</param> /// <param name="stencilFunc">A <see cref="ComparisonFunction"/> value that identifies the function that compares stencil data against existing stencil data.</param> public DepthStencilOperationDescription(StencilOperation stencilFailOp, StencilOperation stencilDepthFailOp, StencilOperation stencilPassOp, ComparisonFunction stencilFunc) { StencilFailOp = stencilFailOp; StencilDepthFailOp = stencilDepthFailOp; StencilPassOp = stencilPassOp; StencilFunc = stencilFunc; }
internal static XFG.CompareFunction ToXNACompareFunction(ComparisonFunction func) { switch (func) { case ComparisonFunction.Always: return(XFG.CompareFunction.Always); case ComparisonFunction.Equal: return(XFG.CompareFunction.Equal); case ComparisonFunction.Greater: return(XFG.CompareFunction.Greater); case ComparisonFunction.GreaterEqual: return(XFG.CompareFunction.GreaterEqual); case ComparisonFunction.Less: return(XFG.CompareFunction.Less); case ComparisonFunction.LessEqual: return(XFG.CompareFunction.LessEqual); case ComparisonFunction.Never: return(XFG.CompareFunction.Never); case ComparisonFunction.NotEqual: return(XFG.CompareFunction.NotEqual); default: throw new InvalidCastException(); } }
/// <summary> /// Initializes a new instance of the <see cref="DepthStencilDescription"/> struct. /// </summary> /// <param name="depthEnable">Specifies whether to enable depth testing. Set this member to <b>true</b> to enable depth testing.</param> /// <param name="depthWriteEnable">Specifies a value that identifies a portion of the depth-stencil buffer that can be modified by depth data.</param> /// <param name="depthFunc">A <see cref="ComparisonFunction"/> value that identifies a function that compares depth data against existing depth data.</param> /// <param name="stencilEnable">Specifies whether to enable stencil testing. Set this member to <b>true</b> to enable stencil testing.</param> /// <param name="stencilReadMask">Identify a portion of the depth-stencil buffer for reading stencil data.</param> /// <param name="stencilWriteMask">Identify a portion of the depth-stencil buffer for writing stencil data.</param> /// <param name="frontStencilFailOp"></param> /// <param name="frontStencilDepthFailOp"></param> /// <param name="frontStencilPassOp"></param> /// <param name="frontStencilFunc"></param> /// <param name="backStencilFailOp"></param> /// <param name="backStencilDepthFailOp"></param> /// <param name="backStencilPassOp"></param> /// <param name="backStencilFunc"></param> public DepthStencilDescription( bool depthEnable, bool depthWriteEnable, ComparisonFunction depthFunc, bool stencilEnable, byte stencilReadMask, byte stencilWriteMask, StencilOperation frontStencilFailOp, StencilOperation frontStencilDepthFailOp, StencilOperation frontStencilPassOp, ComparisonFunction frontStencilFunc, StencilOperation backStencilFailOp, StencilOperation backStencilDepthFailOp, StencilOperation backStencilPassOp, ComparisonFunction backStencilFunc) { DepthEnable = depthEnable; DepthWriteMask = depthWriteEnable ? DepthWriteMask.All : DepthWriteMask.Zero; DepthFunc = depthFunc; StencilEnable = stencilEnable; StencilReadMask = stencilReadMask; StencilWriteMask = stencilWriteMask; FrontFace.StencilFailOp = frontStencilFailOp; FrontFace.StencilDepthFailOp = frontStencilDepthFailOp; FrontFace.StencilPassOp = frontStencilPassOp; FrontFace.StencilFunc = frontStencilFunc; BackFace.StencilFailOp = backStencilFailOp; BackFace.StencilDepthFailOp = backStencilDepthFailOp; BackFace.StencilPassOp = backStencilPassOp; BackFace.StencilFunc = backStencilFunc; }
internal static D3D.Comparison ToD3DComparison(ComparisonFunction func) { switch (func) { case ComparisonFunction.Always: return(D3D.Comparison.Always); case ComparisonFunction.Equal: return(D3D.Comparison.Equal); case ComparisonFunction.Greater: return(D3D.Comparison.Greater); case ComparisonFunction.GreaterEqual: return(D3D.Comparison.GreaterEqual); case ComparisonFunction.Less: return(D3D.Comparison.Less); case ComparisonFunction.LessEqual: return(D3D.Comparison.LessEqual); case ComparisonFunction.Never: return(D3D.Comparison.Never); case ComparisonFunction.NotEqual: return(D3D.Comparison.NotEqual); default: throw new ArgumentException("Invalid compare function"); } }
public SortInfo(PropertyInfo property, string sortPropertyName) { this.property = property; propertyType = property.PropertyType; switch (propertyType.Name.ToString()) { case "Int16": case "Int32": case "Int64": comparisonFunction = FirstMoreOrEqInt; break; case "String": comparisonFunction = FirstMoreOrEqString; break; case "DateTime": comparisonFunction = FirstMoreOrEqDate; break; case "Double": comparisonFunction = FirstMoreOrEqDouble; break; default: comparisonFunction = null; break; } }
/// <summary> /// Initializes a new instance of the <see cref="SamplerDescription"/> struct. /// </summary> /// <param name="filter">Filtering method to use when sampling a texture.</param> /// <param name="addressU">Method to use for resolving a u texture coordinate that is outside the 0 to 1 range.</param> /// <param name="addressV">Method to use for resolving a v texture coordinate that is outside the 0 to 1 range.</param> /// <param name="addressW">Method to use for resolving a w texture coordinate that is outside the 0 to 1 range.</param> /// <param name="mipLODBias">Offset from the calculated mipmap level.</param> /// <param name="maxAnisotropy">Clamping value used if <see cref="Filter.Anisotropic"/> or <see cref="Filter.ComparisonAnisotropic"/> is specified in Filter. Valid values are between 1 and 16.</param> /// <param name="comparisonFunction">A function that compares sampled data against existing sampled data. </param> /// <param name="borderColor">Border color to use if <see cref="TextureAddressMode.Border"/> is specified for AddressU, AddressV, or AddressW.</param> /// <param name="minLOD">Lower end of the mipmap range to clamp access to, where 0 is the largest and most detailed mipmap level and any level higher than that is less detailed.</param> /// <param name="maxLOD">Upper end of the mipmap range to clamp access to, where 0 is the largest and most detailed mipmap level and any level higher than that is less detailed. This value must be greater than or equal to MinLOD. </param> public SamplerDescription( Filter filter, TextureAddressMode addressU, TextureAddressMode addressV, TextureAddressMode addressW, float mipLODBias, int maxAnisotropy, ComparisonFunction comparisonFunction, in Color4 borderColor,
/// <summary> /// Sorts array with a specified comparison function. /// Uses new thread. /// </summary> public static void NewThreadSort(T[] array, ComparisonFunction <T> compare) { //Creating new Thread incapsulating sorting method Thread thread = new Thread(() => MergeSort(array, compare)); //Starting method in a new thread thread.Start(); //It's a shame that this approach does not have anything with another CPU core. }
public void IsFinite() { // arrange var device = HostDevice.Instance; var source = NdArray <int> .Zeros(device, new[] { 2, 3, 4 }); // action var result = ComparisonFunction <int> .IsFinite(source); // assert Assert.IsTrue(NdArray <int> .All(result)); }
public void IsClose_DifferentDoubleVectorsWithBigTolerence_ReturnTrue() { // arrange var device = HostDevice.Instance; var source = NdArray <double> .Arange(device, 0, 10, 1); // action var close = ComparisonFunction <double> .IsClose(source, source + 1.0, 2.0); // assert CollectionAssert.AreEqual(new[] { 10 }, close.Shape); }
public void IsClose_SameDoubleVectors_ReturnTrues() { // arrange var device = HostDevice.Instance; var source = NdArray <double> .Arange(device, 0, 10, 1); // action var close = ComparisonFunction <double> .IsClose(source, source); // assert CollectionAssert.AreEqual(new[] { 10 }, close.Shape); }
public void NotEqual() { // arrange var device = HostDevice.Instance; var sourceA = NdArray <int> .Arange(device, 0, 10, 1); var sourceB = NdArray <int> .Arange(device, 0, 10, 1); // action var result = ComparisonFunction <int> .NotEqual(sourceA, sourceB); // assert CollectionAssert.AreEqual(new[] { 10 }, result.Shape); }
public void AlmostEqual_DifferentIntVectors_ReturnFalse() { // arrange var device = HostDevice.Instance; var sourceA = NdArray <int> .Zeros(device, new[] { 2, 3, 4 }); var sourceB = NdArray <int> .Zeros(device, new[] { 2, 3, 4 }) + 1; // action var almostEqual = ComparisonFunction <int> .AlmostEqual(sourceA, sourceB); // assert Assert.IsFalse(almostEqual); }
/// <summary> /// Sorts array with a specified comparison function. /// </summary> public static new void MergeSort(T[] array, ComparisonFunction <T> compare) { //Subscription to event onSortingDone += SortingDoneSubscriber; //Invoking sort method from the base class CustomSort <T> .MergeSort(array, compare); //Invoking all subscribed methods onSortingDone?.Invoke(new object(), new SortingEventArgs <T>(array)); //Unsubscription to event if (onSortingDone != null) { onSortingDone -= SortingDoneSubscriber; } }
/// <summary>To initialize this structure with default value, use this constructor. The argument value is ignored.</summary> /// <remarks>This is only here because C# doesn’t support parameterless constructors for structures.</remarks> public SamplerDesc(bool unused) { baseStruct = new DeviceObjectAttribs(true); MinFilter = FilterType.Linear; MagFilter = FilterType.Linear; MipFilter = FilterType.Linear; AddressU = TextureAddressMode.Clamp; AddressV = TextureAddressMode.Clamp; AddressW = TextureAddressMode.Clamp; MipLODBias = 0; MaxAnisotropy = 0; ComparisonFunc = ComparisonFunction.Never; BorderColor = Vector4.Zero; MinLOD = 0; MaxLOD = float.MaxValue; }
public void FillNotEqual() { // arrange var device = HostDevice.Instance; var sourceA = NdArray <int> .Arange(device, 0, 10, 1); var sourceB = NdArray <int> .Arange(device, 0, 10, 1); var result = NdArray <bool> .Zeros(device, new[] { 10 }); // action ComparisonFunction <bool> .FillNotEqual(result, sourceA, sourceB); // assert CollectionAssert.AreEqual(new[] { 10 }, result.Shape); }
public StaticSamplerDescription(ShaderVisibility shaderVisibility, int shaderRegister, int registerSpace) { Filter = Filter.MinMagMipLinear; AddressU = TextureAddressMode.Clamp; AddressV = TextureAddressMode.Clamp; AddressW = TextureAddressMode.Clamp; MipLodBias = 0.0f; MaxAnisotropy = 1; ComparisonFunction = ComparisonFunction.Never; BorderColor = StaticBorderColor.TransparentBlack; MinLod = float.MinValue; MaxLod = float.MaxValue; ShaderRegister = shaderRegister; RegisterSpace = registerSpace; ShaderVisibility = shaderVisibility; }
private void AddComparisonFunction(string name, ComparisonFunction compFunc) { // Register the built-in function as a symbol in the root environment rootEnv.Symbols[name] = new BuiltInFunction((env, args) => { int argCount = args.Count(); // Comparison functions require at least two arguments if (argCount < 2) { throw new UnexpectedNumberOfArgumentsException(name, ">= 2", argCount); } // Convert all arguments to number expression IEnumerable <NumberExpression> numArgs = args.Select(x => x as NumberExpression); // If any of the arguments cannot be converted to a number if (numArgs.Any(x => x == null)) { throw new UnexpectedArgumentTypeException(name); } // Convert the number expressions to integers IEnumerable <int> intArgs = numArgs.Select(x => x.Value); // Get the first expression int previous = intArgs.First(); // Check if the comparison function applies to all of the values // Every value is compared to the value before it foreach (int val in intArgs.Skip(1)) { if (compFunc(previous, val)) { previous = val; } else { return(new NumberExpression(false)); } } // All of the values have passed the comparison test return(new NumberExpression(true)); }); }
public D3D11Sampler(ID3D11Device device, ref SamplerDescription description) { ComparisonFunction comparision = description.ComparisonKind == null ? ComparisonFunction.Never : D3D11Formats.VdToD3D11ComparisonFunc(description.ComparisonKind.Value); Vortice.Direct3D11.SamplerDescription samplerStateDesc = new Vortice.Direct3D11.SamplerDescription { AddressU = D3D11Formats.VdToD3D11AddressMode(description.AddressModeU), AddressV = D3D11Formats.VdToD3D11AddressMode(description.AddressModeV), AddressW = D3D11Formats.VdToD3D11AddressMode(description.AddressModeW), Filter = D3D11Formats.ToD3D11Filter(description.Filter, description.ComparisonKind.HasValue), MinLOD = description.MinimumLod, MaxLOD = description.MaximumLod, MaxAnisotropy = (int)description.MaximumAnisotropy, ComparisonFunction = comparision, MipLODBias = description.LodBias, BorderColor = ToRawColor4(description.BorderColor) }; DeviceSampler = device.CreateSamplerState(samplerStateDesc); }
internal SharpDX.Direct3D11.SamplerState GetState(GraphicsDevice device) { if (_state == null) { // Build the description. var desc = new SharpDX.Direct3D11.SamplerStateDescription { AddressU = GetAddressMode(AddressU), AddressV = GetAddressMode(AddressV), AddressW = GetAddressMode(AddressW), #if WINDOWS_UAP desc.BorderColor = new SharpDX.Mathematics.Interop.RawColor4( BorderColor.R / 255.0f, BorderColor.G / 255.0f, BorderColor.B / 255.0f, BorderColor.A / 255.0f); #else BorderColor = BorderColor.ToColor4(), #endif Filter = GetFilter(Filter, FilterMode), MaximumAnisotropy = Math.Min(MaxAnisotropy, device.Capabilities.MaxTextureAnisotropy), MipLodBias = MipMapLevelOfDetailBias, ComparisonFunction = ComparisonFunction.ToComparison(), // TODO: How do i do this? MinimumLod = 0.0f, // To support feature level 9.1 these must // be set to these exact values. MaximumLod = float.MaxValue }; // Create the state. _state = new SharpDX.Direct3D11.SamplerState(GraphicsDevice._d3dDevice, desc); } Debug.Assert(GraphicsDevice == device, "The state was created for a different device!"); return(_state); }
/// <summary> /// Initializes a new instance of the <see cref="SamplerDescription"/> struct. /// </summary> /// <param name="filter">Filtering method to use when sampling a texture.</param> /// <param name="addressU">Method to use for resolving a u texture coordinate that is outside the 0 to 1 range.</param> /// <param name="addressV">Method to use for resolving a v texture coordinate that is outside the 0 to 1 range.</param> /// <param name="addressW">Method to use for resolving a w texture coordinate that is outside the 0 to 1 range.</param> /// <param name="mipLODBias">Offset from the calculated mipmap level.</param> /// <param name="maxAnisotropy">Clamping value used if <see cref="Filter.Anisotropic"/> or <see cref="Filter.ComparisonAnisotropic"/> is specified in Filter. Valid values are between 1 and 16.</param> /// <param name="comparisonFunction">A function that compares sampled data against existing sampled data. </param> /// <param name="minLOD">Lower end of the mipmap range to clamp access to, where 0 is the largest and most detailed mipmap level and any level higher than that is less detailed.</param> /// <param name="maxLOD">Upper end of the mipmap range to clamp access to, where 0 is the largest and most detailed mipmap level and any level higher than that is less detailed. This value must be greater than or equal to MinLOD. </param> public SamplerDescription( Filter filter, TextureAddressMode addressU, TextureAddressMode addressV, TextureAddressMode addressW, float mipLODBias = 0.0f, int maxAnisotropy = 1, ComparisonFunction comparisonFunction = ComparisonFunction.Never, float minLOD = float.MinValue, float maxLOD = float.MaxValue) { Filter = filter; AddressU = addressU; AddressV = addressV; AddressW = addressW; MipLODBias = mipLODBias; MaxAnisotropy = maxAnisotropy; ComparisonFunction = comparisonFunction; BorderColor = new RawColor4(1.0f, 1.0f, 1.0f, 1.0f); MinLOD = minLOD; MaxLOD = maxLOD; }
/// <summary> /// Initializes a new instance of the <see cref="SamplerDescription"/> struct. /// </summary> /// <param name="filter">Filtering method to use when sampling a texture.</param> /// <param name="addressU">Method to use for resolving a u texture coordinate that is outside the 0 to 1 range.</param> /// <param name="addressV">Method to use for resolving a v texture coordinate that is outside the 0 to 1 range.</param> /// <param name="addressW">Method to use for resolving a w texture coordinate that is outside the 0 to 1 range.</param> /// <param name="mipLODBias">Offset from the calculated mipmap level.</param> /// <param name="maxAnisotropy">Clamping value used if <see cref="Filter.Anisotropic"/> or <see cref="Filter.ComparisonAnisotropic"/> is specified in Filter. Valid values are between 1 and 16.</param> /// <param name="comparisonFunction">A function that compares sampled data against existing sampled data. </param> /// <param name="borderColor">Border color to use if <see cref="TextureAddressMode.Border"/> is specified for AddressU, AddressV, or AddressW.</param> /// <param name="minLOD">Lower end of the mipmap range to clamp access to, where 0 is the largest and most detailed mipmap level and any level higher than that is less detailed.</param> /// <param name="maxLOD">Upper end of the mipmap range to clamp access to, where 0 is the largest and most detailed mipmap level and any level higher than that is less detailed. This value must be greater than or equal to MinLOD. </param> public SamplerDescription( Filter filter, TextureAddressMode addressU, TextureAddressMode addressV, TextureAddressMode addressW, float mipLODBias, int maxAnisotropy, ComparisonFunction comparisonFunction, RawColor4 borderColor, float minLOD, float maxLOD) { Filter = filter; AddressU = addressU; AddressV = addressV; AddressW = addressW; MipLODBias = mipLODBias; MaxAnisotropy = maxAnisotropy; ComparisonFunction = comparisonFunction; BorderColor = borderColor; MinLOD = minLOD; MaxLOD = maxLOD; }
private void Update(EvaluationContext context) { var samplerDesc = new SamplerStateDescription() { Filter = Filter.GetValue(context), AddressU = AddressU.GetValue(context), AddressV = AddressV.GetValue(context), AddressW = AddressW.GetValue(context), MipLodBias = MipLoadBias.GetValue(context), MaximumAnisotropy = MaximumAnisotropy.GetValue(context), ComparisonFunction = ComparisonFunction.GetValue(context), // BorderColor = BorderColor.GetValue(context), MinimumLod = MinimumLod.GetValue(context), MaximumLod = MaximumLod.GetValue(context) }; try { var samplerState = new SamplerState(ResourceManager.Instance().Device, samplerDesc); // todo: put into resource manager SamplerState.Value?.Dispose(); SamplerState.Value = samplerState; } catch (SharpDXException e) { Log.Error($"{Parent.Symbol.Name}.SamplerStateOp: Invalid sampler state " + e.Message); if (SamplerState.Value == null) { // there was no previous valid sampler state, so set default sampler state SamplerState.Value = ResourceManager.Instance().DefaultSamplerState; Log.Error("Using the default sampler state instead."); } else { Log.Error("Using the last valid sampler state instead."); } } }
internal void Activate(GraphicsDevice device, TextureTarget target, bool useMipmaps = false) { if (GraphicsDevice == null) { // We're now bound to a device... no one should // be changing the state of this object now! GraphicsDevice = device; } Debug.Assert(GraphicsDevice == device, "The state was created for a different device!"); switch (Filter) { case TextureFilter.Point: if (GraphicsDevice.GraphicsCapabilities.SupportsTextureFilterAnisotropic) { GL.TexParameter(target, TextureParameterNameTextureMaxAnisotropy, 1.0f); GraphicsExtensions.CheckGLError(); } GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.NearestMipmapNearest : TextureMinFilter.Nearest)); GraphicsExtensions.CheckGLError(); GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest); GraphicsExtensions.CheckGLError(); break; case TextureFilter.Linear: if (GraphicsDevice.GraphicsCapabilities.SupportsTextureFilterAnisotropic) { GL.TexParameter(target, TextureParameterNameTextureMaxAnisotropy, 1.0f); GraphicsExtensions.CheckGLError(); } GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.LinearMipmapLinear : TextureMinFilter.Linear)); GraphicsExtensions.CheckGLError(); GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear); GraphicsExtensions.CheckGLError(); break; case TextureFilter.Anisotropic: if (GraphicsDevice.GraphicsCapabilities.SupportsTextureFilterAnisotropic) { GL.TexParameter(target, TextureParameterNameTextureMaxAnisotropy, MathHelper.Clamp(this.MaxAnisotropy, 1.0f, GraphicsDevice.GraphicsCapabilities.MaxTextureAnisotropy)); GraphicsExtensions.CheckGLError(); } GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.LinearMipmapLinear : TextureMinFilter.Linear)); GraphicsExtensions.CheckGLError(); GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear); GraphicsExtensions.CheckGLError(); break; case TextureFilter.PointMipLinear: if (GraphicsDevice.GraphicsCapabilities.SupportsTextureFilterAnisotropic) { GL.TexParameter(target, TextureParameterNameTextureMaxAnisotropy, 1.0f); GraphicsExtensions.CheckGLError(); } GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.NearestMipmapLinear : TextureMinFilter.Nearest)); GraphicsExtensions.CheckGLError(); GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest); GraphicsExtensions.CheckGLError(); break; case TextureFilter.LinearMipPoint: if (GraphicsDevice.GraphicsCapabilities.SupportsTextureFilterAnisotropic) { GL.TexParameter(target, TextureParameterNameTextureMaxAnisotropy, 1.0f); GraphicsExtensions.CheckGLError(); } GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.LinearMipmapNearest : TextureMinFilter.Linear)); GraphicsExtensions.CheckGLError(); GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear); GraphicsExtensions.CheckGLError(); break; case TextureFilter.MinLinearMagPointMipLinear: if (GraphicsDevice.GraphicsCapabilities.SupportsTextureFilterAnisotropic) { GL.TexParameter(target, TextureParameterNameTextureMaxAnisotropy, 1.0f); GraphicsExtensions.CheckGLError(); } GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.LinearMipmapLinear : TextureMinFilter.Linear)); GraphicsExtensions.CheckGLError(); GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest); GraphicsExtensions.CheckGLError(); break; case TextureFilter.MinLinearMagPointMipPoint: if (GraphicsDevice.GraphicsCapabilities.SupportsTextureFilterAnisotropic) { GL.TexParameter(target, TextureParameterNameTextureMaxAnisotropy, 1.0f); GraphicsExtensions.CheckGLError(); } GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.LinearMipmapNearest: TextureMinFilter.Linear)); GraphicsExtensions.CheckGLError(); GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest); GraphicsExtensions.CheckGLError(); break; case TextureFilter.MinPointMagLinearMipLinear: if (GraphicsDevice.GraphicsCapabilities.SupportsTextureFilterAnisotropic) { GL.TexParameter(target, TextureParameterNameTextureMaxAnisotropy, 1.0f); GraphicsExtensions.CheckGLError(); } GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.NearestMipmapLinear: TextureMinFilter.Nearest)); GraphicsExtensions.CheckGLError(); GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear); GraphicsExtensions.CheckGLError(); break; case TextureFilter.MinPointMagLinearMipPoint: if (GraphicsDevice.GraphicsCapabilities.SupportsTextureFilterAnisotropic) { GL.TexParameter(target, TextureParameterNameTextureMaxAnisotropy, 1.0f); GraphicsExtensions.CheckGLError(); } GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.NearestMipmapNearest: TextureMinFilter.Nearest)); GraphicsExtensions.CheckGLError(); GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear); GraphicsExtensions.CheckGLError(); break; default: throw new NotSupportedException(); } // Set up texture addressing. GL.TexParameter(target, TextureParameterName.TextureWrapS, (int)GetWrapMode(AddressU)); GraphicsExtensions.CheckGLError(); GL.TexParameter(target, TextureParameterName.TextureWrapT, (int)GetWrapMode(AddressV)); GraphicsExtensions.CheckGLError(); #if !GLES // Border color is not supported by glTexParameter in OpenGL ES 2.0 _openGLBorderColor[0] = BorderColor.R / 255.0f; _openGLBorderColor[1] = BorderColor.G / 255.0f; _openGLBorderColor[2] = BorderColor.B / 255.0f; _openGLBorderColor[3] = BorderColor.A / 255.0f; GL.TexParameter(target, TextureParameterName.TextureBorderColor, _openGLBorderColor); GraphicsExtensions.CheckGLError(); // LOD bias is not supported by glTexParameter in OpenGL ES 2.0 GL.TexParameter(target, TextureParameterName.TextureLodBias, MipMapLevelOfDetailBias); GraphicsExtensions.CheckGLError(); // Comparison samplers are not supported in OpenGL ES 2.0 (without an extension, anyway) switch (FilterMode) { case TextureFilterMode.Comparison: GL.TexParameter(target, TextureParameterName.TextureCompareMode, (int)TextureCompareMode.CompareRefToTexture); GraphicsExtensions.CheckGLError(); GL.TexParameter(target, TextureParameterName.TextureCompareFunc, (int)ComparisonFunction.GetDepthFunction()); GraphicsExtensions.CheckGLError(); break; case TextureFilterMode.Default: GL.TexParameter(target, TextureParameterName.TextureCompareMode, (int)TextureCompareMode.None); GraphicsExtensions.CheckGLError(); break; default: throw new InvalidOperationException("Invalid filter mode!"); } #endif if (GraphicsDevice.GraphicsCapabilities.SupportsTextureMaxLevel) { if (this.MaxMipLevel > 0) { GL.TexParameter(TextureTarget.Texture2D, TextureParameterNameTextureMaxLevel, this.MaxMipLevel); } else { GL.TexParameter(TextureTarget.Texture2D, TextureParameterNameTextureMaxLevel, 1000); } GraphicsExtensions.CheckGLError(); } }
public AlphaTest(ComparisonFunction function, double reference) { Function = function; Reference = reference; }
public static extern int imaqCompare(IntPtr dest, IntPtr source, IntPtr compareImage, ComparisonFunction compare);
public ISampler CreateSampler(TextureAddressMode addressModeU, TextureAddressMode addressModeV, Filter filter, ComparisonFunction comparisonFunction) { throw new System.NotImplementedException(); }
public ISampler CreateSampler(TextureAddressMode addressModeU, TextureAddressMode addressModeV, Filter filter, ComparisonFunction comparisonFunction) { return(new D3D11Sampler(_graphicsDevice, addressModeU, addressModeV, filter, comparisonFunction)); }
public ISampler CreateSampler(TextureAddressMode addressModeU, TextureAddressMode addressModeV, Filter filter, ComparisonFunction comparisonFunction) { return(null); }