////  Sampler.h//  libraries/shared/src////  Created by HifiExperiments on 8/21/25//  Copyright 2025 Overte e.V.////  Distributed under the Apache License, Version 2.0.//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html// #ifndef hifi_Sampler_h#define hifi_Sampler_h #include <glm/glm.hpp> #include "RegisteredMetaTypes.h"#include "SerDes.h" enum class ComparisonFunction {    NEVER = 0,    LESS,    EQUAL,    LESS_EQUAL,    GREATER,    NOT_EQUAL,    GREATER_EQUAL,    ALWAYS,     NUM_COMPARISON_FUNCS,}; class Sampler {public:     enum Filter {        FILTER_MIN_MAG_POINT, // top mip only        FILTER_MIN_POINT_MAG_LINEAR, // top mip only        FILTER_MIN_LINEAR_MAG_POINT, // top mip only        FILTER_MIN_MAG_LINEAR, // top mip only         FILTER_MIN_MAG_MIP_POINT,        FILTER_MIN_MAG_POINT_MIP_LINEAR,        FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT,        FILTER_MIN_POINT_MAG_MIP_LINEAR,        FILTER_MIN_LINEAR_MAG_MIP_POINT,        FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR,        FILTER_MIN_MAG_LINEAR_MIP_POINT,        FILTER_MIN_MAG_MIP_LINEAR,        FILTER_ANISOTROPIC,         NUM_FILTERS,    };     enum WrapMode {        WRAP_REPEAT = 0,        WRAP_MIRROR,        WRAP_CLAMP,        WRAP_BORDER,        WRAP_MIRROR_ONCE,         NUM_WRAP_MODES    };     static const uint8_t MAX_MIP_LEVEL = 0xFF;     class Desc {    public:        glm::vec4 _borderColor{ 1.0f };        uint32_t _maxAnisotropy = 16;         uint8_t _filter = FILTER_MIN_MAG_MIP_LINEAR;        uint8_t _comparisonFunc = (uint8_t)ComparisonFunction::ALWAYS;         uint8_t _wrapModeU = WRAP_REPEAT;        uint8_t _wrapModeV = WRAP_REPEAT;        uint8_t _wrapModeW = WRAP_REPEAT;         uint8_t _mipOffset = 0;        uint8_t _minMip = 0;        uint8_t _maxMip = MAX_MIP_LEVEL;         Desc() {}        Desc(const Filter filter, const WrapMode wrap = WRAP_REPEAT) : _filter(filter), _wrapModeU(wrap), _wrapModeV(wrap), _wrapModeW(wrap) {}         bool operator==(const Desc& other) const {            return _borderColor == other._borderColor &&                _maxAnisotropy == other._maxAnisotropy &&                _filter == other._filter &&                _comparisonFunc == other._comparisonFunc &&                _wrapModeU == other._wrapModeU &&                _wrapModeV == other._wrapModeV &&                _wrapModeW == other._wrapModeW &&                _mipOffset == other._mipOffset &&                _minMip == other._minMip &&                _maxMip == other._maxMip;        }    };    static_assert(sizeof(Desc) == 28, "Sampler::Desc size doesn't match.");     Sampler() {}    Sampler(const Filter filter, const WrapMode wrap = WRAP_REPEAT) : _desc(filter, wrap) {}    Sampler(const Desc& desc) : _desc(desc) {}    ~Sampler() {}     const glm::vec4& getBorderColor() const { return _desc._borderColor; }     uint32_t getMaxAnisotropy() const { return _desc._maxAnisotropy; }     WrapMode getWrapModeU() const { return WrapMode(_desc._wrapModeU); }    WrapMode getWrapModeV() const { return WrapMode(_desc._wrapModeV); }    WrapMode getWrapModeW() const { return WrapMode(_desc._wrapModeW); }     Filter getFilter() const { return Filter(_desc._filter); }    ComparisonFunction getComparisonFunction() const { return ComparisonFunction(_desc._comparisonFunc); }    bool doComparison() const { return getComparisonFunction() != ComparisonFunction::ALWAYS; }     uint8_t getMipOffset() const { return _desc._mipOffset; }    uint8_t getMinMip() const { return _desc._minMip; }    uint8_t getMaxMip() const { return _desc._maxMip; }     const Desc& getDesc() const { return _desc; }     bool operator==(const Sampler& other) const {        return _desc == other._desc;    }    bool operator!=(const Sampler& other) const {        return !(*this == other);    }     static Sampler parseSampler(const QJsonObject& object); protected:    Desc _desc;}; inline DataSerializer& operator<<(DataSerializer& ser, const Sampler::Desc& d) {    DataSerializer::SizeTracker tracker(ser);    ser << d._borderColor;    ser << d._maxAnisotropy;    ser << d._filter;    ser << d._comparisonFunc;    ser << d._wrapModeU;    ser << d._wrapModeV;    ser << d._wrapModeW;    ser << d._mipOffset;    ser << d._minMip;    ser << d._maxMip;    return ser;} inline DataDeserializer& operator>>(DataDeserializer& dsr, Sampler::Desc& d) {    DataDeserializer::SizeTracker tracker(dsr);    dsr >> d._borderColor;    dsr >> d._maxAnisotropy;    dsr >> d._filter;    dsr >> d._comparisonFunc;    dsr >> d._wrapModeU;    dsr >> d._wrapModeV;    dsr >> d._wrapModeW;    dsr >> d._mipOffset;    dsr >> d._minMip;    dsr >> d._maxMip;    return dsr;} template <>struct std::hash<Sampler> {    size_t operator()(const Sampler& sampler) const noexcept {        size_t result = 0;        const auto& desc = sampler.getDesc();        hash_combine(result, desc._comparisonFunc, desc._filter, desc._maxAnisotropy, desc._maxMip, desc._minMip,                     desc._wrapModeU, desc._wrapModeV, desc._wrapModeW);        return result;    }}; QDebug& operator<<(QDebug& dbg, const Sampler& s); QString wrapModeToString(Sampler::WrapMode mode);Sampler::WrapMode wrapModeFromString(const QString& string); #endif  // hifi_Sampler_h