SMAASearchTex.h

Go to the documentation of this file.

#pragma once
 
#include <cmath>
#include <cstring>
 
static constexpr int SMAA_SEARCHTEX_WIDTH = 66;
static constexpr int SMAA_SEARCHTEX_HEIGHT = 33;
static constexpr int SMAA_SEARCHTEX_PITCH = SMAA_SEARCHTEX_WIDTH; // R8 = 1 byte/pixel
 
static constexpr int SMAA_SEARCHTEX_PACKED_WIDTH = 64;
static constexpr int SMAA_SEARCHTEX_PACKED_HEIGHT = 16;
 
// ---------------------------------------------------------------------------
// Internal helpers
// ---------------------------------------------------------------------------
namespace smaa_search_detail
{
 
 
inline unsigned char calcSearchValue(int e1, int e2, float bias)
{
    // Bilinear interpolation result of two adjacent edge values.
    float bilinear = float(e1) * (1.0f - bias) + float(e2) * bias;
 
    // If both edges are active (bilinear ~= 1.0), the search should continue.
    // If only one is active (bilinear ~= 0.5), we've found an endpoint.
    // If neither is active (bilinear ~= 0.0), there's no edge -- stop.
 
    if (bilinear < 0.25f) {
        return 0;   // No edge: stop
    } else if (bilinear < 0.75f) {
        return 127; // Endpoint found: return fractional offset
    } else {
        return 255; // Edge continues: keep searching
    }
}
 
} // namespace smaa_search_detail
 
inline void generateSearchTex(unsigned char* out)
{
    std::memset(out, 0, SMAA_SEARCHTEX_WIDTH * SMAA_SEARCHTEX_HEIGHT);
 
    // The search texture is organised as two halves:
    //   Top half  (y = 0..15):  left/up search direction
    //   Bottom half (y = 16..32): right/down search direction
    //
    // Within each half:
    //   x axis (0..63): bilinear result of adjacent edge pixel pair, quantised
    //   y axis (0..15): crossing edge flag (0 or 1) and sub-type
    //
    // The extra 2 columns (64, 65) are padding for safe bilinear filtering.
 
    // For each possible combination of two adjacent edge texels:
    for (int e1 = 0; e1 < 2; e1++) {     // Current pixel edge
        for (int e2 = 0; e2 < 2; e2++) { // Adjacent pixel edge
            // Horizontal search patterns:
            // The bilinear filter result when sampling between e1 and e2
            // depends on the sub-pixel offset.
 
            // Generate entries for the search direction (left/up).
            for (int step = 0; step < SMAA_SEARCHTEX_PACKED_WIDTH; step++) {
                float bias = float(step) / float(SMAA_SEARCHTEX_PACKED_WIDTH - 1);
 
                unsigned char val = smaa_search_detail::calcSearchValue(e1, e2, bias);
 
                // Left/up half of texture.
                int x = step;
                int y = e1 * 8 + e2 * 4;
 
                // Fill a 4-row band for this pattern (provides filtering margin).
                for (int dy = 0; dy < 4; dy++) {
                    int py = y + dy;
                    if (py < SMAA_SEARCHTEX_PACKED_HEIGHT && x < SMAA_SEARCHTEX_WIDTH) {
                        out[py * SMAA_SEARCHTEX_WIDTH + x] = val;
                    }
                }
 
                // Right/down half of texture (y offset by PACKED_HEIGHT + 1).
                int y2 = SMAA_SEARCHTEX_PACKED_HEIGHT + 1 + e1 * 8 + e2 * 4;
                unsigned char val2 = smaa_search_detail::calcSearchValue(e2, e1, 1.0f - bias);
                for (int dy = 0; dy < 4; dy++) {
                    int py = y2 + dy;
                    if (py < SMAA_SEARCHTEX_HEIGHT && x < SMAA_SEARCHTEX_WIDTH) {
                        out[py * SMAA_SEARCHTEX_WIDTH + x] = val2;
                    }
                }
            }
        }
    }
 
    // Fill the padding columns (64, 65) by repeating column 63.
    for (int y = 0; y < SMAA_SEARCHTEX_HEIGHT; y++) {
        for (int px = SMAA_SEARCHTEX_PACKED_WIDTH; px < SMAA_SEARCHTEX_WIDTH; px++) {
            out[y * SMAA_SEARCHTEX_WIDTH + px] = out[y * SMAA_SEARCHTEX_WIDTH + (SMAA_SEARCHTEX_PACKED_WIDTH - 1)];
        }
    }
}