TextureSampler.h

浏览该文件的文档.

#pragma once
 
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <string>
 
namespace eve::graphics {
 
enum class FilterMode {
    Nearest,
    Linear,
};
 
enum class MipmapMode {
    Disabled,
    Nearest,
    Linear,
};
 
struct TextureSampler {
    FilterMode min = FilterMode::Linear;
    FilterMode mag = FilterMode::Linear;
    MipmapMode mipmap = MipmapMode::Disabled;
    bool repeatU = false;
    bool repeatV = false;
    bool repeatW = false;
    float maxAnisotropy = 1.f;
    float lodBias = 0.f;
    float minLod = 0.f;
    float maxLod = 1000.f;
 
    static TextureSampler nearest() {
        TextureSampler s;
        s.min = FilterMode::Nearest;
        s.mag = FilterMode::Nearest;
        s.mipmap = MipmapMode::Disabled;
        return s;
    }
 
    static TextureSampler linear() {
        TextureSampler s;
        s.min = FilterMode::Linear;
        s.mag = FilterMode::Linear;
        s.mipmap = MipmapMode::Disabled;
        return s;
    }
 
    static TextureSampler linearMipmap() {
        TextureSampler s;
        s.min = FilterMode::Linear;
        s.mag = FilterMode::Linear;
        s.mipmap = MipmapMode::Linear;
        return s;
    }
 
    static TextureSampler anisotropic(float maxAniso = 16.f) {
        TextureSampler s = linearMipmap();
        s.maxAnisotropy = maxAniso;
        return s;
    }
 
    static FilterMode parseFilter(const std::string &name) {
        if (name == "nearest" || name == "Nearest" || name == "NEAREST") return FilterMode::Nearest;
        return FilterMode::Linear;
    }
 
    static MipmapMode parseMipmap(const std::string &name) {
        if (name == "none" || name == "None" || name == "NONE" || name.empty()) return MipmapMode::Disabled;
        if (name == "nearest" || name == "Nearest" || name == "NEAREST") return MipmapMode::Nearest;
        return MipmapMode::Linear;
    }
 
    static const char *filterName(FilterMode m) {
        return m == FilterMode::Nearest ? "nearest" : "linear";
    }
 
    static const char *mipmapName(MipmapMode m) {
        switch (m) {
        case MipmapMode::Disabled:
            return "none";
        case MipmapMode::Nearest:
            return "nearest";
        default:
            return "linear";
        }
    }
};
 
struct TextureCreateInfo {
    TextureSampler sampler{};
    bool generateMipmaps = false;
 
    static TextureCreateInfo defaults() { return {}; }
 
    static TextureCreateInfo withMipmaps(bool aniso = true, float maxAniso = 16.f) {
        TextureCreateInfo info;
        info.generateMipmaps = true;
        info.sampler = aniso ? TextureSampler::anisotropic(maxAniso) : TextureSampler::linearMipmap();
        return info;
    }
};
 
inline int mipmapCountForSize(int width, int height) {
    if (width <= 0 || height <= 0) return 1;
    const int m = std::max(width, height);
    return static_cast<int>(std::floor(std::log2(static_cast<double>(m)))) + 1;
}
 
}  // namespace eve::graphics