ParallaxMap.h

浏览该文件的文档.

#pragma once
 
#include <algorithm>
#include <cmath>
 
namespace eve::graphics {
 
struct ParallaxParams {
    float scale = 0.f;      // 0 = off
    float minLayers = 8.f;  // adaptive POM min steps
    float maxLayers = 32.f; // adaptive POM max steps
    bool silhouette = false; // SilPOM: discard when displaced UV leaves mesh UV bounds
};
 
inline void parallaxOffsetUV(float u, float v, float height01, float viewTSx, float viewTSy,
                             float viewTSz, float scale, float &ou, float &ov) {
    if (scale < 1e-5f) {
        ou = u;
        ov = v;
        return;
    }
    const float depth = 1.f - height01;
    const float vz = std::max(std::fabs(viewTSz), 0.08f);
    ou = u - (viewTSx / vz) * depth * scale;
    ov = v - (viewTSy / vz) * depth * scale;
}
 
inline float silPomCoverage(float displacedU, float displacedV, float padding = 0.f) {
    // padding expands the keep region to [-pad, 1+pad].
    const float pad = std::max(0.f, padding);
    return (displacedU >= -pad && displacedV >= -pad && displacedU <= 1.f + pad &&
            displacedV <= 1.f + pad)
               ? 1.f
               : 0.f;
}
 
inline float silPomCoverageSoft(float displacedU, float displacedV, float feather) {
    const float f = std::max(feather, 1e-4f);
    auto edge = [f](float t) {
        if (t <= 0.f) return 0.f;
        if (t >= f) return 1.f;
        const float x = t / f;
        return x * x * (3.f - 2.f * x); // smoothstep
    };
    const float cx = std::min(edge(displacedU), edge(1.f - displacedU));
    const float cy = std::min(edge(displacedV), edge(1.f - displacedV));
    return cx * cy;
}
 
inline float silPomHorizonTrim(float height01, float ndotv, float strength,
                               float bias = 0.02f) {
    const float t = std::clamp(1.f - std::fabs(ndotv) / 0.35f, 0.f, 1.f);
    const float threshold = std::clamp(std::pow(t, 1.5f) * strength, 0.f, 1.f);
    return (height01 - bias >= threshold) ? 1.f : 0.f;
}
 
inline void ssdmScreenOffset(float height01, float viewNdcX, float viewNdcY, float scale,
                             float &outX, float &outY) {
    if (scale < 1e-5f) {
        outX = 0.f;
        outY = 0.f;
        return;
    }
    // Raised texels push toward the viewer in screen space (opposite to POM's UV dig).
    const float h = std::clamp(height01, 0.f, 1.f);
    const float len = std::sqrt(viewNdcX * viewNdcX + viewNdcY * viewNdcY);
    if (len < 1e-5f) {
        outX = 0.f;
        outY = 0.f;
        return;
    }
    outX = (viewNdcX / len) * h * scale;
    outY = (viewNdcY / len) * h * scale;
}
 
inline float ssdmCoverage(float baseU, float baseV, float offsetU, float offsetV,
                          float padding = 0.f) {
    return silPomCoverage(baseU + offsetU, baseV + offsetV, padding);
}
 
inline void clampParallaxParams(ParallaxParams &p) {
    if (p.scale < 0.f) p.scale = 0.f;
    if (p.scale > 0.25f) p.scale = 0.25f;
    if (p.minLayers < 1.f) p.minLayers = 1.f;
    if (p.maxLayers < p.minLayers) p.maxLayers = p.minLayers;
    if (p.maxLayers > 64.f) p.maxLayers = 64.f;
}
 
}  // namespace eve::graphics