Example #1
0
 public SamplerCreateInfo(
     MinFilter minFilter,
     MagFilter magFilter,
     bool seamlessCubemap,
     AddressMode addressU,
     AddressMode addressV,
     AddressMode addressP,
     CompareMode compareMode,
     CompareOp compareOp,
     ColorF borderColor,
     float minLod,
     float maxLod,
     float mipLodBias,
     float maxAnisotropy)
 {
     MinFilter       = minFilter;
     MagFilter       = magFilter;
     SeamlessCubemap = seamlessCubemap;
     AddressU        = addressU;
     AddressV        = addressV;
     AddressP        = addressP;
     CompareMode     = compareMode;
     CompareOp       = compareOp;
     BorderColor     = borderColor;
     MinLod          = minLod;
     MaxLod          = maxLod;
     MipLodBias      = mipLodBias;
     MaxAnisotropy   = maxAnisotropy;
 }
 void ISerializationCallbackReceiver.OnBeforeSerialize()
 {
     magFilter = MagFilter.ToString();
     minFilter = MinFilter.ToString();
     wrapT     = WrapT.ToString();
     wrapS     = WrapS.ToString();
 }
Example #3
0
        public static TextureMinFilter Convert(this MinFilter filter)
        {
            switch (filter)
            {
            case MinFilter.Nearest:
                return(TextureMinFilter.Nearest);

            case MinFilter.Linear:
                return(TextureMinFilter.Linear);

            case MinFilter.NearestMipmapNearest:
                return(TextureMinFilter.NearestMipmapNearest);

            case MinFilter.LinearMipmapNearest:
                return(TextureMinFilter.LinearMipmapNearest);

            case MinFilter.NearestMipmapLinear:
                return(TextureMinFilter.NearestMipmapLinear);

            case MinFilter.LinearMipmapLinear:
                return(TextureMinFilter.LinearMipmapLinear);
            }

            Logger.Debug?.Print(LogClass.Gpu, $"Invalid {nameof(MinFilter)} enum value: {filter}.");

            return(TextureMinFilter.Nearest);
        }
Example #4
0
 // Use LookupOrCreate() instead
 private GlTF_Sampler(GlTF_Globals globals,
                      string name, MagFilter magFilter, MinFilter minFilter, Wrap wrap)
     : base(globals)
 {
     this.name      = name;
     this.magFilter = magFilter;
     this.minFilter = minFilter;
     this.wrap      = wrap;
 }
Example #5
0
 internal ShaderTextureStateFilterStateBlockBase(BinaryReader binaryReader)
 {
     this.magFilter      = (MagFilter)binaryReader.ReadInt16();
     this.minFilter      = (MinFilter)binaryReader.ReadInt16();
     this.mipFilter      = (MipFilter)binaryReader.ReadInt16();
     this.invalidName_   = binaryReader.ReadBytes(2);
     this.mipmapBias     = binaryReader.ReadSingle();
     this.maxMipmapIndex = binaryReader.ReadInt16();
     this.anisotropy     = (Anisotropy)binaryReader.ReadInt16();
 }
Example #6
0
    /// Use this instead of the constructor, in order to share samplers.
    public static GlTF_Sampler LookupOrCreate(
        GlTF_Globals G, MagFilter magFilter, MinFilter minFilter, Wrap wrap = Wrap.REPEAT)
    {
        // Samplers are only distinguished by their filter settings, so no need for
        // unique naming beyond that.
        string name = "sampler_" + magFilter + "_" + minFilter + "_" + wrap;

        if (!G.samplers.ContainsKey(name))
        {
            G.samplers[name] = new GlTF_Sampler(G, name, magFilter, minFilter, wrap);
        }
        return(G.samplers[name]);
    }
Example #7
0
        public override int GetHashCode()
        {
            int hash = 23;

            hash = hash * 37 + BorderColor.GetHashCode();
            hash = hash * 37 + MinFilter.GetHashCode();
            hash = hash * 37 + MagFilter.GetHashCode();
            hash = hash * 37 + LodMin.GetHashCode();
            hash = hash * 37 + LodMax.GetHashCode();
            hash = hash * 37 + LodBias.GetHashCode();
            hash = hash * 37 + WrapS.GetHashCode();
            hash = hash * 37 + WrapT.GetHashCode();
            hash = hash * 37 + WrapR.GetHashCode();
            return(hash);
        }
Example #8
0
        /// <summary>
        /// Creates a new instance of the cached sampler.
        /// </summary>
        /// <param name="context">The GPU context the sampler belongs to</param>
        /// <param name="descriptor">The Maxwell sampler descriptor</param>
        public Sampler(GpuContext context, SamplerDescriptor descriptor)
        {
            MinFilter minFilter = descriptor.UnpackMinFilter();
            MagFilter magFilter = descriptor.UnpackMagFilter();

            bool seamlessCubemap = descriptor.UnpackSeamlessCubemap();

            AddressMode addressU = descriptor.UnpackAddressU();
            AddressMode addressV = descriptor.UnpackAddressV();
            AddressMode addressP = descriptor.UnpackAddressP();

            CompareMode compareMode = descriptor.UnpackCompareMode();
            CompareOp   compareOp   = descriptor.UnpackCompareOp();

            ColorF color = new ColorF(
                descriptor.BorderColorR,
                descriptor.BorderColorG,
                descriptor.BorderColorB,
                descriptor.BorderColorA);

            float minLod     = descriptor.UnpackMinLod();
            float maxLod     = descriptor.UnpackMaxLod();
            float mipLodBias = descriptor.UnpackMipLodBias();

            float maxRequestedAnisotropy = GraphicsConfig.MaxAnisotropy >= 0 && GraphicsConfig.MaxAnisotropy <= 16 ? GraphicsConfig.MaxAnisotropy : descriptor.UnpackMaxAnisotropy();
            float maxSupportedAnisotropy = context.Capabilities.MaximumSupportedAnisotropy;

            if (maxRequestedAnisotropy > maxSupportedAnisotropy)
            {
                maxRequestedAnisotropy = maxSupportedAnisotropy;
            }

            HostSampler = context.Renderer.CreateSampler(new SamplerCreateInfo(
                                                             minFilter,
                                                             magFilter,
                                                             seamlessCubemap,
                                                             addressU,
                                                             addressV,
                                                             addressP,
                                                             compareMode,
                                                             compareOp,
                                                             color,
                                                             minLod,
                                                             maxLod,
                                                             mipLodBias,
                                                             maxRequestedAnisotropy));
        }
Example #9
0
 static GAL.SamplerCreateInfo GetSamplerCreateInfo(MinFilter minFilter, MagFilter magFilter)
 {
     return(new GAL.SamplerCreateInfo(
                minFilter,
                magFilter,
                false,
                AddressMode.ClampToEdge,
                AddressMode.ClampToEdge,
                AddressMode.ClampToEdge,
                CompareMode.None,
                GAL.CompareOp.Always,
                new ColorF(0f, 0f, 0f, 0f),
                0f,
                0f,
                0f,
                1f));
 }
Example #10
0
        /// <summary>
        /// Creates a new instance of the cached sampler.
        /// </summary>
        /// <param name="context">The GPU context the sampler belongs to</param>
        /// <param name="descriptor">The Maxwell sampler descriptor</param>
        public Sampler(GpuContext context, SamplerDescriptor descriptor)
        {
            MinFilter minFilter = descriptor.UnpackMinFilter();
            MagFilter magFilter = descriptor.UnpackMagFilter();

            AddressMode addressU = descriptor.UnpackAddressU();
            AddressMode addressV = descriptor.UnpackAddressV();
            AddressMode addressP = descriptor.UnpackAddressP();

            CompareMode compareMode = descriptor.UnpackCompareMode();
            CompareOp   compareOp   = descriptor.UnpackCompareOp();

            ColorF color = new ColorF(
                descriptor.BorderColorR,
                descriptor.BorderColorG,
                descriptor.BorderColorB,
                descriptor.BorderColorA);

            float minLod     = descriptor.UnpackMinLod();
            float maxLod     = descriptor.UnpackMaxLod();
            float mipLodBias = descriptor.UnpackMipLodBias();

            float maxAnisotropy = descriptor.UnpackMaxAnisotropy();

            HostSampler = context.Renderer.CreateSampler(new SamplerCreateInfo(
                                                             minFilter,
                                                             magFilter,
                                                             addressU,
                                                             addressV,
                                                             addressP,
                                                             compareMode,
                                                             compareOp,
                                                             color,
                                                             minLod,
                                                             maxLod,
                                                             mipLodBias,
                                                             maxAnisotropy));
        }
Example #11
0
        public Fx_sampler_common(XPathNodeIterator iterator, string uri)
        {
            XPathNodeIterator nodeIterator;

            nodeIterator = iterator.Current.SelectChildren(XmlCollada.Fx_sampler_common.source, uri);
            if (nodeIterator.MoveNext())
            {
                _source = new Source(nodeIterator, uri);
            }
            nodeIterator = iterator.Current.SelectChildren(XmlCollada.Fx_sampler_common.minfilter, uri);
            if (nodeIterator.MoveNext())
            {
                _minfilter = new MinFilter(nodeIterator, uri);
            }
            nodeIterator = iterator.Current.SelectChildren(XmlCollada.Fx_sampler_common.magfilter, uri);
            if (nodeIterator.MoveNext())
            {
                _magfilter = new MagFilter(nodeIterator, uri);
            }
        }
Example #12
0
 public Fx_sampler_common(Source source, MinFilter minfilter, MagFilter magfilter)
 {
     _source = source;
     _minfilter = minfilter;
     _magfilter = magfilter;
 }
Example #13
0
 public Sampler2D(Source source, MinFilter minfilter, MagFilter magfilter)
     : base(source, minfilter, magfilter)
 {
 }
Example #14
0
    public GlTF_Sampler(Texture tex)
    {
        bool      hasMipMap = false;
        Texture2D t         = tex as Texture2D;

        if (t != null)
        {
            if (t.mipmapCount > 0)
            {
                hasMipMap = true;
            }
        }

        switch (tex.filterMode)
        {
        case FilterMode.Point:
        {
            magFilter = MagFilter.NEAREST;
            if (hasMipMap)
            {
                minFilter = MinFilter.NEAREST_MIPMAP_NEAREST;
            }
            else
            {
                minFilter = MinFilter.NEAREST;
            }
        }
        break;

        case FilterMode.Bilinear:
        {
            magFilter = MagFilter.LINEAR;
            if (hasMipMap)
            {
                minFilter = MinFilter.LINEAR_MIPMAP_NEAREST;
            }
            else
            {
                minFilter = MinFilter.LINEAR;
            }
        }
        break;

        case FilterMode.Trilinear:
        {
            magFilter = MagFilter.LINEAR;
            if (hasMipMap)
            {
                minFilter = MinFilter.LINEAR;
            }
            else
            {
                minFilter = MinFilter.LINEAR_MIPMAP_LINEAR;
            }
        }
        break;
        }

        switch (tex.wrapMode)
        {
        case TextureWrapMode.Clamp:
        {
            wrap = Wrap.CLAMP_TO_EDGE;
        }
        break;

        case TextureWrapMode.Repeat:
        {
            wrap = Wrap.REPEAT;
        }
        break;
        }
    }