Example #1
0
        public Sampler(Filter magFilter, Filter minFilter, SamplerMipmapMode mipmapMode, SamplerAddressMode addressModeU, SamplerAddressMode addressModeV, SamplerAddressMode addressModeW, float mipLodBias, float maxAnisotropy, float minLod, float maxLod, BorderColor aBorderColor)
        {
            SamplerCreateInfo sampler = new SamplerCreateInfo();

            sampler.MagFilter     = magFilter;
            sampler.MinFilter     = minFilter;
            sampler.MipmapMode    = mipmapMode;
            sampler.AddressModeU  = addressModeU;
            sampler.AddressModeV  = addressModeV;
            sampler.AddressModeW  = addressModeW;
            sampler.MipLodBias    = mipLodBias;
            sampler.MaxAnisotropy = maxAnisotropy;
            sampler.MinLod        = minLod;
            sampler.MaxLod        = maxLod;
            sampler.BorderColor   = aBorderColor;
            VulkanRenderer.SelectedLogicalDevice.CreateSampler(this, sampler);
        }
Example #2
0
 /// <param name="MagFilter">Filter mode for magnification</param>
 /// <param name="MinFilter">Filter mode for minifiation</param>
 /// <param name="MipmapMode">Mipmap selection mode</param>
 public SamplerCreateInfo(Filter MagFilter, Filter MinFilter, SamplerMipmapMode MipmapMode, SamplerAddressMode AddressModeU, SamplerAddressMode AddressModeV, SamplerAddressMode AddressModeW, Single MipLodBias, Bool32 AnisotropyEnable, Single MaxAnisotropy, Bool32 CompareEnable, CompareOp CompareOp, Single MinLod, Single MaxLod, BorderColor BorderColor, Bool32 UnnormalizedCoordinates) : this()
 {
     this.MagFilter               = MagFilter;
     this.MinFilter               = MinFilter;
     this.MipmapMode              = MipmapMode;
     this.AddressModeU            = AddressModeU;
     this.AddressModeV            = AddressModeV;
     this.AddressModeW            = AddressModeW;
     this.MipLodBias              = MipLodBias;
     this.AnisotropyEnable        = AnisotropyEnable;
     this.MaxAnisotropy           = MaxAnisotropy;
     this.CompareEnable           = CompareEnable;
     this.CompareOp               = CompareOp;
     this.MinLod                  = MinLod;
     this.MaxLod                  = MaxLod;
     this.BorderColor             = BorderColor;
     this.UnnormalizedCoordinates = UnnormalizedCoordinates;
 }
 public SamplerCreateInfo
 (
     StructureType sType             = StructureType.SamplerCreateInfo,
     void *pNext                     = default,
     SamplerCreateFlags flags        = default,
     Filter magFilter                = default,
     Filter minFilter                = default,
     SamplerMipmapMode mipmapMode    = default,
     SamplerAddressMode addressModeU = default,
     SamplerAddressMode addressModeV = default,
     SamplerAddressMode addressModeW = default,
     float mipLodBias                = default,
     Bool32 anisotropyEnable         = default,
     float maxAnisotropy             = default,
     Bool32 compareEnable            = default,
     CompareOp compareOp             = default,
     float minLod                    = default,
     float maxLod                    = default,
     BorderColor borderColor         = default,
     Bool32 unnormalizedCoordinates  = default
 )
 {
     SType                   = sType;
     PNext                   = pNext;
     Flags                   = flags;
     MagFilter               = magFilter;
     MinFilter               = minFilter;
     MipmapMode              = mipmapMode;
     AddressModeU            = addressModeU;
     AddressModeV            = addressModeV;
     AddressModeW            = addressModeW;
     MipLodBias              = mipLodBias;
     AnisotropyEnable        = anisotropyEnable;
     MaxAnisotropy           = maxAnisotropy;
     CompareEnable           = compareEnable;
     CompareOp               = compareOp;
     MinLod                  = minLod;
     MaxLod                  = maxLod;
     BorderColor             = borderColor;
     UnnormalizedCoordinates = unnormalizedCoordinates;
 }
Example #4
0
        private void ConvertMinFilter(TextureFilter filter, out Filter minFilter, out Filter magFilter, out SamplerMipmapMode mipmapMode, out RawBool enableComparison, out RawBool enableAnisotropy)
        {
            minFilter        = magFilter = Filter.Nearest;
            mipmapMode       = SamplerMipmapMode.Nearest;
            enableComparison = false;
            enableAnisotropy = false;

            switch (filter)
            {
            // Mip point
            case TextureFilter.Point:
                break;

            case TextureFilter.MinLinearMagMipPoint:
                minFilter = Filter.Linear;
                break;

            case TextureFilter.MinPointMagLinearMipPoint:
                magFilter = Filter.Linear;
                break;

            case TextureFilter.MinMagLinearMipPoint:
                minFilter = Filter.Linear;
                magFilter = Filter.Linear;
                break;

            // Mip linear
            case TextureFilter.MinMagPointMipLinear:
                mipmapMode = SamplerMipmapMode.Linear;
                break;

            case TextureFilter.MinLinearMagPointMipLinear:
                mipmapMode = SamplerMipmapMode.Linear;
                minFilter  = Filter.Linear;
                break;

            case TextureFilter.MinPointMagMipLinear:
                mipmapMode = SamplerMipmapMode.Linear;
                magFilter  = Filter.Linear;
                break;

            case TextureFilter.Linear:
                mipmapMode = SamplerMipmapMode.Linear;
                minFilter  = Filter.Linear;
                magFilter  = Filter.Linear;
                break;

            case TextureFilter.Anisotropic:
                enableAnisotropy = true;
                mipmapMode       = SamplerMipmapMode.Linear;
                minFilter        = Filter.Linear;
                magFilter        = Filter.Linear;
                break;

            // Comparison mip point
            case TextureFilter.ComparisonPoint:
                enableComparison = true;
                break;

            case TextureFilter.ComparisonMinLinearMagMipPoint:
                enableComparison = true;
                minFilter        = Filter.Linear;
                break;

            case TextureFilter.ComparisonMinPointMagLinearMipPoint:
                enableComparison = true;
                magFilter        = Filter.Linear;
                break;

            case TextureFilter.ComparisonMinMagLinearMipPoint:
                enableComparison = true;
                minFilter        = Filter.Linear;
                magFilter        = Filter.Linear;
                break;

            // Comparison mip linear
            case TextureFilter.ComparisonMinMagPointMipLinear:
                enableComparison = true;
                mipmapMode       = SamplerMipmapMode.Linear;
                break;

            case TextureFilter.ComparisonMinLinearMagPointMipLinear:
                enableComparison = true;
                mipmapMode       = SamplerMipmapMode.Linear;
                minFilter        = Filter.Linear;
                break;

            case TextureFilter.ComparisonMinPointMagMipLinear:
                enableComparison = true;
                mipmapMode       = SamplerMipmapMode.Linear;
                magFilter        = Filter.Linear;
                break;

            case TextureFilter.ComparisonLinear:
                enableComparison = true;
                mipmapMode       = SamplerMipmapMode.Linear;
                minFilter        = Filter.Linear;
                magFilter        = Filter.Linear;
                break;

            case TextureFilter.ComparisonAnisotropic:
                enableComparison = true;
                enableAnisotropy = true;
                mipmapMode       = SamplerMipmapMode.Linear;
                minFilter        = Filter.Linear;
                magFilter        = Filter.Linear;
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
        private void ConvertMinFilter(TextureFilter filter, out Filter minFilter, out Filter magFilter, out SamplerMipmapMode mipmapMode, out RawBool enableComparison, out RawBool enableAnisotropy)
        {
            minFilter = magFilter = Filter.Nearest;
            mipmapMode = SamplerMipmapMode.Nearest;
            enableComparison = false;
            enableAnisotropy = false;

            switch (filter)
            {
                // Mip point
                case TextureFilter.Point:
                    break;
                case TextureFilter.MinLinearMagMipPoint:
                    minFilter = Filter.Linear;
                    break;
                case TextureFilter.MinPointMagLinearMipPoint:
                    magFilter = Filter.Linear;
                    break;
                case TextureFilter.MinMagLinearMipPoint:
                    minFilter = Filter.Linear;
                    magFilter = Filter.Linear;
                    break;

                // Mip linear
                case TextureFilter.MinMagPointMipLinear:
                    mipmapMode = SamplerMipmapMode.Linear;
                    break;
                case TextureFilter.MinLinearMagPointMipLinear:
                    mipmapMode = SamplerMipmapMode.Linear;
                    minFilter = Filter.Linear;
                    break;
                case TextureFilter.MinPointMagMipLinear:
                    mipmapMode = SamplerMipmapMode.Linear;
                    magFilter = Filter.Linear;
                    break;
                case TextureFilter.Linear:
                    mipmapMode = SamplerMipmapMode.Linear;
                    minFilter = Filter.Linear;
                    magFilter = Filter.Linear;
                    break;
                case TextureFilter.Anisotropic:
                    enableAnisotropy = true;
                    mipmapMode = SamplerMipmapMode.Linear;
                    minFilter = Filter.Linear;
                    magFilter = Filter.Linear;
                    break;

                // Comparison mip point
                case TextureFilter.ComparisonPoint:
                    enableComparison = true;
                    break;
                case TextureFilter.ComparisonMinLinearMagMipPoint:
                    enableComparison = true;
                    minFilter = Filter.Linear;
                    break;
                case TextureFilter.ComparisonMinPointMagLinearMipPoint:
                    enableComparison = true;
                    magFilter = Filter.Linear;
                    break;
                case TextureFilter.ComparisonMinMagLinearMipPoint:
                    enableComparison = true;
                    minFilter = Filter.Linear;
                    magFilter = Filter.Linear;
                    break;

                // Comparison mip linear
                case TextureFilter.ComparisonMinMagPointMipLinear:
                    enableComparison = true;
                    mipmapMode = SamplerMipmapMode.Linear;
                    break;
                case TextureFilter.ComparisonMinLinearMagPointMipLinear:
                    enableComparison = true;
                    mipmapMode = SamplerMipmapMode.Linear;
                    minFilter = Filter.Linear;
                    break;
                case TextureFilter.ComparisonMinPointMagMipLinear:
                    enableComparison = true;
                    mipmapMode = SamplerMipmapMode.Linear;
                    magFilter = Filter.Linear;
                    break;
                case TextureFilter.ComparisonLinear:
                    enableComparison = true;
                    mipmapMode = SamplerMipmapMode.Linear;
                    minFilter = Filter.Linear;
                    magFilter = Filter.Linear;
                    break;
                case TextureFilter.ComparisonAnisotropic:
                    enableComparison = true;
                    enableAnisotropy = true;
                    mipmapMode = SamplerMipmapMode.Linear;
                    minFilter = Filter.Linear;
                    magFilter = Filter.Linear;
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
            }
        }
Example #6
0
        public static Sampler CreateSampler(Context ctx, Filter magFilter, Filter minFilter, SamplerMipmapMode mipmapMode)
        {
            var createInfo = new SamplerCreateInfo
            {
                MagFilter  = magFilter,
                MinFilter  = minFilter,
                MipmapMode = mipmapMode
            };

            // We also enable anisotropic filtering. Because that feature is optional, it must be
            // checked if it is supported by the device.
            if (ctx.Features.SamplerAnisotropy)
            {
                createInfo.AnisotropyEnable = true;
                createInfo.MaxAnisotropy    = ctx.Properties.Limits.MaxSamplerAnisotropy;
            }
            else
            {
                createInfo.MaxAnisotropy = 1.0f;
            }
            return(ctx.Device.CreateSampler(createInfo));
        }