GrSamplerState.h

Go to the documentation of this file.

/*
 * Copyright 2015 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
#ifndef GrSamplerState_DEFINED
#define GrSamplerState_DEFINED
 
#include "include/core/SkSamplingOptions.h"
#include "include/gpu/GpuTypes.h"
#include "include/private/base/SkTPin.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkMathPriv.h"
 
#include <limits>
 
/**
 * Represents the filtering and tile modes used to access a texture.
 */
class GrSamplerState {
public:
    using Filter = SkFilterMode;
    using MipmapMode = SkMipmapMode;
 
    enum class WrapMode : uint8_t {
        kClamp,
        kRepeat,
        kMirrorRepeat,
        kClampToBorder,
        kLast = kClampToBorder
    };
 
    static constexpr int kFilterCount     = static_cast<int>(Filter::kLast)     + 1;
    static constexpr int kWrapModeCount   = static_cast<int>(WrapMode::kLast)   + 1;
    static constexpr int kMipmapModeCount = static_cast<int>(MipmapMode::kLast) + 1;
 
    constexpr GrSamplerState() = default;
 
    constexpr GrSamplerState(WrapMode wrapXAndY, Filter filter, MipmapMode mm = MipmapMode::kNone)
            : fWrapModes{wrapXAndY, wrapXAndY}, fFilter(filter), fMipmapMode(mm) {}
 
    constexpr GrSamplerState(WrapMode wrapX,
                             WrapMode wrapY,
                             Filter filter,
                             MipmapMode mm = MipmapMode::kNone)
            : fWrapModes{wrapX, wrapY}, fFilter(filter), fMipmapMode(mm) {}
 
    constexpr GrSamplerState(const WrapMode wrapModes[2],
                             Filter filter,
                             MipmapMode mm = MipmapMode::kNone)
            : fWrapModes{wrapModes[0], wrapModes[1]}, fFilter(filter), fMipmapMode(mm) {}
 
    constexpr /*explicit*/ GrSamplerState(Filter filter) : fFilter(filter) {}
    constexpr GrSamplerState(Filter filter, MipmapMode mm) : fFilter(filter), fMipmapMode(mm) {}
 
    // We require 'viewIsMipped' for APIs that allow MIP filtering to be specified orthogonally
    // to aniso.
    static constexpr GrSamplerState Aniso(WrapMode wrapX,
                                          WrapMode wrapY,
                                          int maxAniso,
                                          skgpu::Mipmapped viewIsMipped) {
        GrSamplerState sampler;
        sampler.fWrapModes[0] = wrapX;
        sampler.fWrapModes[1] = wrapY;
        sampler.fMaxAniso     = SkTPin(maxAniso, 1, kMaxMaxAniso);
        sampler.fFilter       = Filter::kLinear;
        sampler.fMipmapMode   = viewIsMipped == skgpu::Mipmapped::kYes ? MipmapMode::kLinear
                                                                       : MipmapMode::kNone;
        return sampler;
    }
 
    constexpr GrSamplerState(const GrSamplerState&) = default;
 
    constexpr GrSamplerState& operator=(const GrSamplerState&) = default;
 
    constexpr WrapMode wrapModeX() const { return fWrapModes[0]; }
 
    constexpr WrapMode wrapModeY() const { return fWrapModes[1]; }
 
    constexpr bool isRepeatedX() const {
        return fWrapModes[0] == WrapMode::kRepeat || fWrapModes[0] == WrapMode::kMirrorRepeat;
    }
 
    constexpr bool isRepeatedY() const {
        return fWrapModes[1] == WrapMode::kRepeat || fWrapModes[1] == WrapMode::kMirrorRepeat;
    }
 
    constexpr bool isRepeated() const {
        return this->isRepeatedX() || this->isRepeatedY();
    }
 
    constexpr Filter filter() const { return fFilter; }
 
    constexpr MipmapMode mipmapMode() const { return fMipmapMode; }
 
    constexpr skgpu::Mipmapped mipmapped() const {
        return skgpu::Mipmapped(fMipmapMode != MipmapMode::kNone);
    }
 
    int maxAniso() const { return fMaxAniso; }
    bool isAniso() const { return fMaxAniso > 1; }
 
    constexpr bool operator==(GrSamplerState that) const {
        return fWrapModes[0] == that.fWrapModes[0] && fWrapModes[1] == that.fWrapModes[1] &&
               fFilter == that.fFilter && fMipmapMode == that.fMipmapMode;
    }
 
    constexpr bool operator!=(const GrSamplerState& that) const { return !(*this == that); }
 
    /**
     * Turn the sampler state into an integer for use as a key. How that works for aniso depends
     * on whether the underlying API defines aniso as orthogonal to other filter settings or
     * as a replacement for them.
     */
    uint32_t asKey(bool anisoIsOrthogonal) const {
        constexpr int kNumWrapBits       = SkNextLog2_portable(kWrapModeCount);
        constexpr int kNumMaxAnisoBits   = SkNextLog2_portable(kMaxMaxAniso);
        constexpr int kNumFilterBits     = SkNextLog2_portable(kFilterCount);
        constexpr int kNumMipmapModeBits = SkNextLog2_portable(kMipmapModeCount);
 
        constexpr int kWrapXShift      = 0;
        constexpr int kWrapYShift      = kWrapXShift    + kNumWrapBits;
        constexpr int kMaxAnisoShift   = kWrapYShift    + kNumWrapBits;
        constexpr int kFilterShift     = kMaxAnisoShift + kNumMaxAnisoBits;
        constexpr int kMipmapModeShift = kFilterShift   + kNumFilterBits;
 
        static_assert(kMipmapModeShift + kNumMipmapModeBits <= 32);
 
        uint32_t key = (static_cast<uint32_t>(fWrapModes[0]) << kWrapXShift)
                     | (static_cast<uint32_t>(fWrapModes[1]) << kWrapYShift)
                     | (static_cast<uint32_t>(fMaxAniso)     << kMaxAnisoShift);
        if (fMaxAniso == 1 || anisoIsOrthogonal) {
            key |= (static_cast<uint32_t>(fFilter)     << kFilterShift)
                |  (static_cast<uint32_t>(fMipmapMode) << kMipmapModeShift);
        }
        return key;
    }
 
private:
    // This is here to support turning the sampler state into a key. Presumably this is way larger
    // than any HW limits. Also, WebGPU accepts this as an unsigned short.
    static constexpr int kMaxMaxAniso = 1024;
 
    WrapMode   fWrapModes[2] = {WrapMode::kClamp, WrapMode::kClamp};
    Filter     fFilter       = GrSamplerState::Filter::kNearest;
    MipmapMode fMipmapMode   = GrSamplerState::MipmapMode::kNone;
    int        fMaxAniso     = 1;
};
 
#endif