#include "RenderImageAudit.h"

#include "zeroerr/assert.h"
#include "zeroerr/unittest.h"

#include <SDL2/SDL.h>
#include "filesystem/FileData.h"

#include <algorithm>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <filesystem>
#include <fstream>
#include <functional>
#include <memory>
#include <string>
#include <vector>

#include <assimp/mesh.h>
#include <glm/gtc/matrix_transform.hpp>

#include "animation/AnimClip.h"
#include "animation/AnimImporter.h"
#include "animation/AnimPose.h"
#include "animation/AnimSkeleton.h"
#include "animation/AnimSkin.h"
#include "avatar/Avatar.h"
#include "data/ByteData.h"
#include "filesystem/Filesystem.h"
#include "font/Font.h"
#include "font/FontData.h"
#include "graphics/AmbientOcclusion.h"
#include "graphics/AntiAliasing.h"
#include "graphics/Canvas.h"
#include "graphics/ClipSpace.h"
#include "graphics/DrawItem2D.h"
#include "graphics/Font.h"
#include "graphics/GBuffer.h"
#include "graphics/GlobalIllumination.h"
#include "graphics/Graphics.h"
#include "graphics/Grass.h"
#include "graphics/Outline.h"
#include "graphics/ScreenSpaceReflection.h"
#include "graphics/Shader.h"
#include "graphics/Texture.h"
#include "graphics/Water.h"
#include "graphics/Waterfall.h"
// Color lives in eve::graphics (see graphics/Canvas.h); keep the unqualified form.
using eve::graphics::Color;
#include "graphics/Light.h"
#include "graphics/Material.h"
#include "graphics/Mesh.h"
#include "graphics/Quad.h"
#include "graphics/RenderControl.h"
#include "graphics/RenderSystem.h"
#include "graphics/RenderSystem3D.h"
#include "graphics/TextureSampler.h"
#include "graphics/Volumetric.h"
#include "graphics/shaders/custom2d_frag_spv.inc"
#include "image/Image.h"
#include "image/ImageData.h"
#include "map/DualGrid.h"
#include "map/Fov.h"
#include "map/Map.h"
#include "map/TileLayer.h"
#include "map/TileOrientation.h"
#include "model3d/Model3D.h"
#include "model3d/ModelData.h"
#include "particles/ParticleEmitter.h"
#include "particles/ParticleSystem.h"
#include "particles/Particles.h"
#include "physics/Body.h"
#include "physics/Cloth.h"
#include "physics/Fluid2D.h"
#include "physics/Physics.h"
#include "physics/World.h"
#include "procgen/Params.h"
#include "procgen/Procgen.h"
#include "scene/NodeDesc.h"
#include "scene/SceneHost.h"
#include "scene/TransformSystem.h"
#include "stylize/Stylize.h"
#include "ui/UI.h"
#include "voxel/VoxelWorld.h"
#include "window/Window.h"

using eve::image::ImageData;
using namespace eve::graphics;

namespace {

constexpr int kTile = 16;
constexpr int kMaxDefects = 32;
constexpr int kEmptyDist2 = 14 * 14;  // ~0.055 in 8-bit
constexpr int kDeadLumaSum = 15;      // (r+2g+b) < 15 ≈ luma 0.02
constexpr float kOccTile = 0.40f;
constexpr float kEmptyTile = 0.12f;
constexpr float kFlickerTile = 0.07f;
constexpr float kFlickerSevere = 0.15f;

int lumaSumU8(const uint8_t *p) { return int(p[0]) + 2 * int(p[1]) + int(p[2]); }

float lumaU8(const uint8_t *p) {
    return (0.2126f * p[0] + 0.7152f * p[1] + 0.0722f * p[2]) / 255.f;
}

struct BgBytes {
    int r, g, b;
};

BgBytes toBytes(const RenderAuditBg &bg) {
    return BgBytes{int(bg.r * 255.f + 0.5f), int(bg.g * 255.f + 0.5f), int(bg.b * 255.f + 0.5f)};
}

bool pixelEmpty(const uint8_t *p, const BgBytes &bg) {
    const int dr = int(p[0]) - bg.r;
    const int dg = int(p[1]) - bg.g;
    const int db = int(p[2]) - bg.b;
    return dr * dr + dg * dg + db * db < kEmptyDist2 || lumaSumU8(p) < kDeadLumaSum;
}

bool pixelMagenta(const uint8_t *p) { return p[0] > 200 && p[1] < 40 && p[2] > 200; }

bool pixelCyan(const uint8_t *p) { return p[0] < 40 && p[1] > 200 && p[2] > 200; }

const uint8_t *pxAt(const uint8_t *rgba, int w, int x, int y) {
    return rgba + (size_t(y) * size_t(w) + size_t(x)) * 4u;
}

std::string jsonEscape(const std::string &s) {
    std::string o;
    o.reserve(s.size());
    for (char c : s) {
        if (c == '"' || c == '\\') {
            o.push_back('\\');
            o.push_back(c);
        } else if (c == '\n') {
            o += "\\n";
        } else {
            o.push_back(c);
        }
    }
    return o;
}

void addDefect(RenderAuditResult &r, RenderDefect::Kind kind, int x, int y, int w, int h,
               float score, const std::string &detail) {
    if (int(r.defects.size()) >= kMaxDefects) return;
    x = std::max(0, x);
    y = std::max(0, y);
    RenderDefect d;
    d.kind = kind;
    d.x = x;
    d.y = y;
    d.w = std::max(1, w);
    d.h = std::max(1, h);
    d.score = score;
    d.detail = detail;
    r.defects.push_back(std::move(d));
}

struct TileStat {
    float occ = 0.f;
    float meanL = 0.f;
};

int occupiedNeighbors(const std::vector<TileStat> &tiles, int tilesX, int tilesY, int tx, int ty) {
    int n = 0;
    for (int dy = -1; dy <= 1; ++dy) {
        for (int dx = -1; dx <= 1; ++dx) {
            if (dx == 0 && dy == 0) continue;
            const int nx = tx + dx;
            const int ny = ty + dy;
            if (nx < 0 || ny < 0 || nx >= tilesX || ny >= tilesY) continue;
            if (tiles[size_t(ny * tilesX + nx)].occ > kOccTile) ++n;
        }
    }
    return n;
}

void detectHoles(const std::vector<TileStat> &tiles, int tilesX, int tilesY, int w, int h,
                 RenderAuditResult &r) {
    std::vector<uint8_t> hole(size_t(tilesX * tilesY), 0);
    for (int ty = 1; ty < tilesY - 1; ++ty) {
        for (int tx = 1; tx < tilesX - 1; ++tx) {
            const TileStat &t = tiles[size_t(ty * tilesX + tx)];
            if (t.occ > kEmptyTile) continue;
            if (occupiedNeighbors(tiles, tilesX, tilesY, tx, ty) >= 5) hole[size_t(ty * tilesX + tx)] = 1;
        }
    }
    std::vector<uint8_t> seen(size_t(tilesX * tilesY), 0);
    for (int ty = 1; ty < tilesY - 1; ++ty) {
        for (int tx = 1; tx < tilesX - 1; ++tx) {
            const int seed = ty * tilesX + tx;
            if (!hole[size_t(seed)] || seen[size_t(seed)]) continue;
            int minX = tx, maxX = tx, minY = ty, maxY = ty, count = 0;
            std::vector<int> stack{seed};
            seen[size_t(seed)] = 1;
            while (!stack.empty()) {
                const int i = stack.back();
                stack.pop_back();
                ++count;
                const int cx = i % tilesX;
                const int cy = i / tilesX;
                minX = std::min(minX, cx);
                maxX = std::max(maxX, cx);
                minY = std::min(minY, cy);
                maxY = std::max(maxY, cy);
                const int nb[4] = {i - 1, i + 1, i - tilesX, i + tilesX};
                for (int n : nb) {
                    if (n < 0 || n >= tilesX * tilesY) continue;
                    if (!hole[size_t(n)] || seen[size_t(n)]) continue;
                    seen[size_t(n)] = 1;
                    stack.push_back(n);
                }
            }
            const int px = minX * kTile;
            const int py = minY * kTile;
            const int pw = std::min(w, (maxX + 1) * kTile) - px;
            const int ph = std::min(h, (maxY + 1) * kTile) - py;
            char buf[96];
            std::snprintf(buf, sizeof(buf), "interior hole tiles=%d occ=%.2f", count,
                          tiles[size_t(ty * tilesX + tx)].occ);
            addDefect(r, RenderDefect::Kind::Incomplete, px, py, pw, ph, float(count), buf);
        }
    }
}

void detectCoarseIncomplete(const std::vector<TileStat> &tiles, int tilesX, int tilesY, int w, int h,
                            float occupancy, RenderAuditResult &r) {
    // Sparse frames (small object + lots of sky) have empty quadrants by design.
    // Only look for missing chunks when the frame is mostly filled.
    if (occupancy < 0.40f) return;
    const int gx = 4, gy = 4;
    for (int gyi = 0; gyi < gy; ++gyi) {
        for (int gxi = 0; gxi < gx; ++gxi) {
            const int tx0 = (tilesX * gxi) / gx;
            const int tx1 = (tilesX * (gxi + 1)) / gx;
            const int ty0 = (tilesY * gyi) / gy;
            const int ty1 = (tilesY * (gyi + 1)) / gy;
            if (tx1 <= tx0 || ty1 <= ty0) continue;
            double occSum = 0.0;
            int n = 0;
            for (int ty = ty0; ty < ty1; ++ty) {
                for (int tx = tx0; tx < tx1; ++tx) {
                    occSum += tiles[size_t(ty * tilesX + tx)].occ;
                    ++n;
                }
            }
            const float cellOcc = n ? float(occSum / n) : 0.f;
            if (cellOcc > 0.08f) continue;
            int richN = 0;
            const int nbs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
            for (auto &d : nbs) {
                const int nx = gxi + d[0];
                const int ny = gyi + d[1];
                if (nx < 0 || ny < 0 || nx >= gx || ny >= gy) continue;
                const int ntx0 = (tilesX * nx) / gx;
                const int ntx1 = (tilesX * (nx + 1)) / gx;
                const int nty0 = (tilesY * ny) / gy;
                const int nty1 = (tilesY * (ny + 1)) / gy;
                double nOcc = 0.0;
                int nn = 0;
                for (int ty = nty0; ty < nty1; ++ty) {
                    for (int tx = ntx0; tx < ntx1; ++tx) {
                        nOcc += tiles[size_t(ty * tilesX + tx)].occ;
                        ++nn;
                    }
                }
                if (nn && float(nOcc / nn) > 0.30f) ++richN;
            }
            if (richN < 2) continue;
            const int px = (w * gxi) / gx;
            const int py = (h * gyi) / gy;
            const int pw = (w * (gxi + 1)) / gx - px;
            const int ph = (h * (gyi + 1)) / gy - py;
            char buf[80];
            std::snprintf(buf, sizeof(buf), "coarse empty cell occ=%.2f neighbors=%d", cellOcc, richN);
            addDefect(r, RenderDefect::Kind::Incomplete, px, py, pw, ph, 1.f - cellOcc, buf);
        }
    }
}

struct ScanAccum {
    std::vector<TileStat> tiles;
    int tilesX = 0;
    int tilesY = 0;
    double sumL = 0.0;
    int n = 0;
    int occ = 0;
    int interiorOcc = 0;
    int interiorN = 0;
    int magN = 0, cyanN = 0;
    int magX0 = 0, magY0 = 0, magX1 = 0, magY1 = 0;
    int cyanX0 = 0, cyanY0 = 0, cyanX1 = 0, cyanY1 = 0;
    std::vector<int> rowLit;
    std::vector<int> rowN;
    std::vector<int> colLit;
    std::vector<int> colN;
};

ScanAccum scanFrame(const uint8_t *rgba, int w, int h, const BgBytes &bg, int step) {
    ScanAccum a;
    a.tilesX = (w + kTile - 1) / kTile;
    a.tilesY = (h + kTile - 1) / kTile;
    a.tiles.assign(size_t(a.tilesX * a.tilesY), {});
    a.rowLit.assign(size_t(h), 0);
    a.rowN.assign(size_t(h), 0);
    a.colLit.assign(size_t(w), 0);
    a.colN.assign(size_t(w), 0);
    a.magX0 = w;
    a.magY0 = h;
    a.cyanX0 = w;
    a.cyanY0 = h;
    const int ix0 = w / 10, ix1 = w - w / 10;
    const int iy0 = h / 10, iy1 = h - h / 10;
    std::vector<int> tileOcc(size_t(a.tilesX * a.tilesY), 0);
    std::vector<int> tileN(size_t(a.tilesX * a.tilesY), 0);
    std::vector<double> tileL(size_t(a.tilesX * a.tilesY), 0.0);

    for (int y = 0; y < h; y += step) {
        for (int x = 0; x < w; x += step) {
            const uint8_t *p = pxAt(rgba, w, x, y);
            const float L = lumaU8(p);
            const bool emptyPx = pixelEmpty(p, bg);
            a.sumL += L;
            ++a.n;
            if (!emptyPx) ++a.occ;
            if (x >= ix0 && x < ix1 && y >= iy0 && y < iy1) {
                ++a.interiorN;
                if (!emptyPx) ++a.interiorOcc;
            }
            const int tx = x / kTile;
            const int ty = y / kTile;
            const int ti = ty * a.tilesX + tx;
            ++tileN[size_t(ti)];
            tileL[size_t(ti)] += L;
            if (!emptyPx) ++tileOcc[size_t(ti)];
            ++a.rowN[size_t(y)];
            ++a.colN[size_t(x)];
            if (!emptyPx) {
                ++a.rowLit[size_t(y)];
                ++a.colLit[size_t(x)];
            }
            if (pixelMagenta(p)) {
                ++a.magN;
                a.magX0 = std::min(a.magX0, x);
                a.magY0 = std::min(a.magY0, y);
                a.magX1 = std::max(a.magX1, x);
                a.magY1 = std::max(a.magY1, y);
            }
            if (pixelCyan(p)) {
                ++a.cyanN;
                a.cyanX0 = std::min(a.cyanX0, x);
                a.cyanY0 = std::min(a.cyanY0, y);
                a.cyanX1 = std::max(a.cyanX1, x);
                a.cyanY1 = std::max(a.cyanY1, y);
            }
        }
    }
    for (int i = 0; i < a.tilesX * a.tilesY; ++i) {
        const int n = tileN[size_t(i)];
        a.tiles[size_t(i)].occ = n ? float(tileOcc[size_t(i)]) / float(n) : 0.f;
        a.tiles[size_t(i)].meanL = n ? float(tileL[size_t(i)] / n) : 0.f;
    }
    return a;
}

void emitDamage(const ScanAccum &a, int w, int h, int step, RenderAuditResult &r) {
    const int magMin = std::max(2, 8 / (step * step));
    if (a.magN >= magMin) {
        char buf[64];
        std::snprintf(buf, sizeof(buf), "debug magenta samples=%d", a.magN);
        addDefect(r, RenderDefect::Kind::Damage, a.magX0, a.magY0, a.magX1 - a.magX0 + 1,
                  a.magY1 - a.magY0 + 1, float(a.magN), buf);
    }
    if (a.cyanN >= magMin) {
        char buf[64];
        std::snprintf(buf, sizeof(buf), "debug cyan samples=%d", a.cyanN);
        addDefect(r, RenderDefect::Kind::Damage, a.cyanX0, a.cyanY0, a.cyanX1 - a.cyanX0 + 1,
                  a.cyanY1 - a.cyanY0 + 1, float(a.cyanN), buf);
    }

    auto tornRun = [&](const std::vector<int> &lit, const std::vector<int> &nn, int n, bool rows) {
        auto occAt = [&](int i) -> float {
            return nn[size_t(i)] ? float(lit[size_t(i)]) / float(nn[size_t(i)]) : -1.f;
        };
        int y = step;
        while (y < n - step) {
            const float o = occAt(y);
            const float prev = occAt(y - step);
            const float next = occAt(y + step);
            if (!(o >= 0.f && o < 0.05f && prev > 0.35f && next > 0.35f)) {
                y += step;
                continue;
            }
            const int start = y;
            y += step;
            while (y < n - step) {
                const float cur = occAt(y);
                if (!(cur >= 0.f && cur < 0.05f)) break;
                y += step;
            }
            const int len = std::max(step, y - start);
            char buf[72];
            if (rows) {
                std::snprintf(buf, sizeof(buf), "torn scanlines y=%d..%d", start, start + len - 1);
                addDefect(r, RenderDefect::Kind::Damage, 0, start, w, len, float(len), buf);
            } else {
                std::snprintf(buf, sizeof(buf), "torn columns x=%d..%d", start, start + len - 1);
                addDefect(r, RenderDefect::Kind::Damage, start, 0, len, h, float(len), buf);
            }
        }
    };
    tornRun(a.rowLit, a.rowN, h, true);
    tornRun(a.colLit, a.colN, w, false);
}

}  // namespace

bool RenderAuditResult::hasSevere() const {
    if (empty) return true;
    int holeArea = 0;
    int imgArea = std::max(1, cfg.width * cfg.height);
    for (const auto &d : defects) {
        if (d.kind == RenderDefect::Kind::Damage) return true;
        if (d.kind == RenderDefect::Kind::Flicker && d.score >= kFlickerSevere) return true;
        if (d.kind == RenderDefect::Kind::Incomplete) holeArea += d.w * d.h;
    }
    if (flickerMad >= 0.12f) return true;
    return holeArea > imgArea / 16;
}

RenderAuditResult auditRgba8(const uint8_t *rgba, int w, int h, const RenderAuditConfig &cfg,
                             const RenderAuditBg &bg, int step) {
    RenderAuditResult r;
    r.cfg = cfg;
    r.cfg.width = w;
    r.cfg.height = h;
    if (!rgba || w <= 0 || h <= 0) {
        r.empty = true;
        return r;
    }
    step = std::max(1, step);
    const ScanAccum a = scanFrame(rgba, w, h, toBytes(bg), step);
    r.meanLuma = a.n ? float(a.sumL / a.n) : 0.f;
    r.occupancy = a.n ? float(a.occ) / float(a.n) : 0.f;
    r.interiorOccupancy = a.interiorN ? float(a.interiorOcc) / float(a.interiorN) : 0.f;
    r.empty = r.interiorOccupancy < 0.02f;

    detectHoles(a.tiles, a.tilesX, a.tilesY, w, h, r);
    detectCoarseIncomplete(a.tiles, a.tilesX, a.tilesY, w, h, r.occupancy, r);
    emitDamage(a, w, h, step, r);
    if (r.empty) {
        addDefect(r, RenderDefect::Kind::Incomplete, 0, 0, w, h, 1.f - r.interiorOccupancy,
                  "empty interior (occupancy < 2%)");
    }
    return r;
}

RenderAuditResult auditImage(const ImageData &img, const RenderAuditConfig &cfg,
                             const RenderAuditBg &bg, int step) {
    return auditRgba8(static_cast<const uint8_t *>(img.getData()), img.getWidth(), img.getHeight(),
                      cfg, bg, step);
}

RenderAuditResult auditFlickerRgba8(const uint8_t *a, const uint8_t *b, int w, int h,
                                    const RenderAuditConfig &cfg, const RenderAuditBg &bg, int step) {
    RenderAuditResult r;
    r.cfg = cfg;
    r.cfg.width = w;
    r.cfg.height = h;
    r.cfg.extra = r.cfg.extra.empty() ? "flicker" : r.cfg.extra + "+flicker";
    if (!a || !b || w <= 0 || h <= 0) return r;
    step = std::max(1, step);

    double sumMad = 0.0;
    int nAll = 0;
    const int tilesX = (w + kTile - 1) / kTile;
    const int tilesY = (h + kTile - 1) / kTile;
    for (int ty = 0; ty < tilesY; ++ty) {
        for (int tx = 0; tx < tilesX; ++tx) {
            const int x0 = tx * kTile;
            const int y0 = ty * kTile;
            const int x1 = std::min(w, x0 + kTile);
            const int y1 = std::min(h, y0 + kTile);
            double tileMad = 0.0;
            int n = 0;
            for (int y = y0; y < y1; y += step) {
                for (int x = x0; x < x1; x += step) {
                    const float d = std::fabs(lumaU8(pxAt(a, w, x, y)) - lumaU8(pxAt(b, w, x, y)));
                    tileMad += d;
                    sumMad += d;
                    ++n;
                }
            }
            nAll += n;
            const float mad = n ? float(tileMad / n) : 0.f;
            if (mad < kFlickerTile) continue;
            char buf[80];
            std::snprintf(buf, sizeof(buf), "static-camera tile MAD=%.3f", mad);
            addDefect(r, RenderDefect::Kind::Flicker, x0, y0, x1 - x0, y1 - y0, mad, buf);
        }
    }
    r.flickerMad = nAll ? float(sumMad / double(nAll)) : 0.f;
    (void)bg;
    return r;
}

RenderAuditResult auditFlicker(const ImageData &a, const ImageData &b, const RenderAuditConfig &cfg,
                               const RenderAuditBg &bg, int step) {
    if (a.getWidth() != b.getWidth() || a.getHeight() != b.getHeight()) {
        RenderAuditResult r;
        r.cfg = cfg;
        addDefect(r, RenderDefect::Kind::Flicker, 0, 0, a.getWidth(), a.getHeight(), 1.f,
                  "flicker compare size mismatch");
        return r;
    }
    return auditFlickerRgba8(static_cast<const uint8_t *>(a.getData()),
                             static_cast<const uint8_t *>(b.getData()), a.getWidth(), a.getHeight(),
                             cfg, bg, step);
}

void mergeAudit(RenderAuditResult &dst, const RenderAuditResult &src) {
    dst.flickerMad = std::max(dst.flickerMad, src.flickerMad);
    for (const auto &d : src.defects) {
        if (int(dst.defects.size()) >= kMaxDefects) break;
        dst.defects.push_back(d);
    }
}

void paintDefectOverlay(ImageData &img, const std::vector<RenderDefect> &defs) {
    const int w = img.getWidth();
    const int h = img.getHeight();
    auto *data = static_cast<uint8_t *>(img.getData());
    auto plot = [&](int x, int y, uint8_t r, uint8_t g, uint8_t b) {
        if (x < 0 || y < 0 || x >= w || y >= h) return;
        uint8_t *p = data + (size_t(y) * size_t(w) + size_t(x)) * 4u;
        p[0] = r;
        p[1] = g;
        p[2] = b;
        p[3] = 255;
    };
    for (const auto &d : defs) {
        uint8_t cr = 255, cg = 40, cb = 40;
        if (d.kind == RenderDefect::Kind::Damage) {
            cr = 255;
            cg = 220;
            cb = 0;
        } else if (d.kind == RenderDefect::Kind::Flicker) {
            cr = 40;
            cg = 180;
            cb = 255;
        }
        const int x1 = std::min(w - 1, d.x + d.w - 1);
        const int y1 = std::min(h - 1, d.y + d.h - 1);
        for (int t = 0; t < 2; ++t) {
            for (int x = d.x; x <= x1; ++x) {
                plot(x, d.y + t, cr, cg, cb);
                plot(x, y1 - t, cr, cg, cb);
            }
            for (int y = d.y; y <= y1; ++y) {
                plot(d.x + t, y, cr, cg, cb);
                plot(x1 - t, y, cr, cg, cb);
            }
        }
    }
}

bool saveImagePng(const ImageData &img, const std::string &path) {
    [[maybe_unused]] auto *const imageModule = eve::image::Image::create();
    eve::filesystem::FileData *png =
        img.encode(medialoader::FormatHandler::ENCODED_PNG, path.c_str(), false);
    if (!png) return false;
    std::error_code ec;
    std::filesystem::create_directories(std::filesystem::path(path).parent_path(), ec);
    std::ofstream out(path, std::ios::binary);
    const bool ok = out.good();
    if (ok) {
        out.write(static_cast<const char *>(png->getData()),
                  static_cast<std::streamsize>(png->getSize()));
    }
    delete png;
    return ok && out.good();
}

void appendAuditReport(const std::string &outDir, const RenderAuditResult &r) {
    std::error_code ec;
    std::filesystem::create_directories(outDir, ec);
    const std::string mdPath = outDir + "/image_audit.md";
    const std::string jsPath = outDir + "/image_audit.jsonl";

    {
        std::ofstream md(mdPath, std::ios::app);
        if (md.tellp() == 0) {
            md << "# Render image audit\n\n"
               << "Generated by unit_test. Boxes are pixel coordinates `(x,y,w,h)`.\n"
               << "Kinds: `incomplete` (holes / missing tiles), `damage` (magenta/cyan / tearing), "
                  "`flicker` (static-camera MAD).\n\n";
        }
        md << "## " << r.cfg.scene << " / " << r.cfg.phase;
        if (!r.cfg.extra.empty()) md << " / " << r.cfg.extra;
        md << "\n\n";
        md << "- size=" << r.cfg.width << "x" << r.cfg.height;
        if (r.cfg.frame >= 0) md << " frame=" << r.cfg.frame;
        md << "\n- meanLuma=" << r.meanLuma << " occupancy=" << r.occupancy
           << " interiorOcc=" << r.interiorOccupancy << " flickerMad=" << r.flickerMad << "\n";
        if (r.empty) md << "- **empty interior**\n";
        if (r.defects.empty()) {
            md << "- no defects\n\n";
        } else {
            for (const auto &d : r.defects) {
                md << "- DEFECT `" << RenderDefect::kindName(d.kind) << "` bbox=(" << d.x << ","
                   << d.y << "," << d.w << "," << d.h << ") score=" << d.score << " " << d.detail
                   << "\n";
            }
            md << "\n";
        }
    }

    {
        std::ofstream js(jsPath, std::ios::app);
        js << "{\"scene\":\"" << jsonEscape(r.cfg.scene) << "\",\"phase\":\""
           << jsonEscape(r.cfg.phase) << "\",\"extra\":\"" << jsonEscape(r.cfg.extra)
           << "\",\"width\":" << r.cfg.width << ",\"height\":" << r.cfg.height
           << ",\"frame\":" << r.cfg.frame << ",\"meanLuma\":" << r.meanLuma
           << ",\"occupancy\":" << r.occupancy << ",\"interiorOccupancy\":" << r.interiorOccupancy
           << ",\"flickerMad\":" << r.flickerMad << ",\"empty\":" << (r.empty ? "true" : "false")
           << ",\"severe\":" << (r.hasSevere() ? "true" : "false") << ",\"defects\":[";
        for (size_t i = 0; i < r.defects.size(); ++i) {
            const auto &d = r.defects[i];
            if (i) js << ",";
            js << "{\"kind\":\"" << RenderDefect::kindName(d.kind) << "\",\"x\":" << d.x
               << ",\"y\":" << d.y << ",\"w\":" << d.w << ",\"h\":" << d.h << ",\"score\":" << d.score
               << ",\"detail\":\"" << jsonEscape(d.detail) << "\"}";
        }
        js << "]}\n";
    }

    std::printf("RenderImageAudit[%s/%s] defects=%zu severe=%d meanLuma=%.4f occ=%.3f flickerMad=%.4f\n",
                r.cfg.scene.c_str(), r.cfg.phase.c_str(), r.defects.size(), int(r.hasSevere()),
                r.meanLuma, r.occupancy, r.flickerMad);
    for (const auto &d : r.defects) {
        std::printf("  %s bbox=(%d,%d,%d,%d) score=%.3f %s\n", RenderDefect::kindName(d.kind), d.x,
                    d.y, d.w, d.h, d.score, d.detail.c_str());
    }
}

std::string saveAuditOverlay(ImageData &img, const RenderAuditResult &r, const std::string &outDir) {
    if (!r.hasDefects()) return {};
    paintDefectOverlay(img, r.defects);
    std::string name = r.cfg.scene + "_" + r.cfg.phase;
    if (!r.cfg.extra.empty()) name += "_" + r.cfg.extra;
    name += "_audit.png";
    const std::string path = outDir + "/" + name;
    if (!saveImagePng(img, path)) return {};
    std::printf("RenderImageAudit overlay: %s\n", path.c_str());
    return path;
}

namespace {

ImageData *makeRgba(int w, int h, uint8_t r, uint8_t g, uint8_t b) {
    auto *img = new ImageData(w, h, "RGBA8");
    auto *p = static_cast<uint8_t *>(img->getData());
    for (int i = 0; i < w * h; ++i) {
        p[i * 4 + 0] = r;
        p[i * 4 + 1] = g;
        p[i * 4 + 2] = b;
        p[i * 4 + 3] = 255;
    }
    return img;
}

void fillRect(ImageData *img, int x0, int y0, int rw, int rh, uint8_t r, uint8_t g, uint8_t b) {
    const int w = img->getWidth();
    const int h = img->getHeight();
    auto *p = static_cast<uint8_t *>(img->getData());
    for (int y = y0; y < y0 + rh && y < h; ++y) {
        for (int x = x0; x < x0 + rw && x < w; ++x) {
            uint8_t *q = p + (y * w + x) * 4;
            q[0] = r;
            q[1] = g;
            q[2] = b;
            q[3] = 255;
        }
    }
}

bool hasKind(const RenderAuditResult &r, RenderDefect::Kind k) {
    for (const auto &d : r.defects)
        if (d.kind == k) return true;
    return false;
}

std::string auditOutDir() {
    return std::string(EVENGINE_TEST_BINARY_DIR) + "/out/classic_scenes";
}

Texture *makeSolid(Graphics *gfx, uint8_t r, uint8_t g, uint8_t b) {
    const uint8_t px[4] = {r, g, b, 255};
    return gfx->newTexture(1, 1, px);
}

Texture *makeStudioCubemap(Graphics *gfx, int face = 8) {
    const uint8_t faceRgb[6][3] = {
        {220, 180, 140}, {120, 150, 210}, {245, 245, 250}, {40, 40, 45}, {200, 210, 230}, {180, 160, 140},
    };
    const size_t faceBytes = size_t(face) * size_t(face) * 4u;
    std::vector<uint8_t> faces(faceBytes * 6u);
    for (int f = 0; f < 6; ++f) {
        uint8_t *dst = faces.data() + size_t(f) * faceBytes;
        for (size_t i = 0; i < faceBytes; i += 4) {
            dst[i + 0] = faceRgb[f][0];
            dst[i + 1] = faceRgb[f][1];
            dst[i + 2] = faceRgb[f][2];
            dst[i + 3] = 255;
        }
    }
    return gfx->newCubemap(face, faces.data());
}

void resetScene3D() {
    if (ecs::current()->getManager<Renderable3D>() != nullptr) {
        auto view = ecs::View<Renderable3D, Renderable3D::MeshRenderer>();
        for (auto it = view.begin(); it != view.end(); ++it) {
            auto [mr] = *it;
            mr->visible = false;
        }
    }
    if (ecs::current()->getManager<Camera3D>() != nullptr) {
        auto camView = ecs::View<Camera3D, Camera3D::Data>();
        for (auto it = camView.begin(); it != camView.end(); ++it) {
            auto [data] = *it;
            data->active = false;
            data->envMap = nullptr;
            data->envIntensity = 1.f;
        }
    }
    if (ecs::current()->getManager<Light3D>() != nullptr) {
        auto lightView = ecs::View<Light3D, Light3D::Data>();
        for (auto it = lightView.begin(); it != lightView.end(); ++it) {
            auto [d] = *it;
            d->enabled = false;
        }
    }
    if (ecs::current()->getManager<Renderable2D>() != nullptr) {
        auto view = ecs::View<Renderable2D, Renderable2D::Sprite>();
        for (auto it = view.begin(); it != view.end(); ++it) {
            auto [sp] = *it;
            sp->visible = false;
        }
    }
    if (ecs::current()->getManager<Light2D>() != nullptr) {
        auto lightView = ecs::View<Light2D, Light2D::Data>();
        for (auto it = lightView.begin(); it != lightView.end(); ++it) {
            auto [d] = *it;
            d->enabled = false;
        }
    }
    if (ecs::current()->getManager<Camera2D>() != nullptr) {
        auto camView = ecs::View<Camera2D, Camera2D::Data>();
        for (auto it = camView.begin(); it != camView.end(); ++it) {
            auto [d] = *it;
            d->active = false;
        }
    }
    if (ecs::current()->getManager<eve::particles::ParticleEmitter>() != nullptr) {
        auto view = ecs::View<eve::particles::ParticleEmitter, eve::particles::ParticleEmitter::Draw>();
        for (auto it = view.begin(); it != view.end(); ++it) {
            auto [d] = *it;
            d->visible = false;
        }
    }
    if (ecs::current()->getManager<eve::map::TileLayer>() != nullptr) {
        auto view = ecs::View<eve::map::TileLayer, eve::map::TileLayer::Draw>();
        for (auto it = view.begin(); it != view.end(); ++it) {
            auto [d] = *it;
            d->visible = false;
        }
    }
}

void auditGpuFrame(Graphics *gfx, const char *scene, const char *phase, const RenderAuditBg &bg,
                   bool flicker = false, const std::function<void()> &after3D = {},
                   const char *rawCaptureName = nullptr) {
    auto drawOnce = [&]() {
        RenderSystem3D::render(*gfx);
        if (after3D) after3D();
        RenderSystem::render(*gfx);
    };
    gfx->setScreenReadbackEnabled(false);
    for (int i = 0; i < 2; ++i) drawOnce();
    gfx->setScreenReadbackEnabled(true);
    drawOnce();
    std::unique_ptr<ImageData> a(gfx->newImageData());
    REQUIRE(a.get() != nullptr);
    if (rawCaptureName)
        REQUIRE(saveImagePng(*a, auditOutDir() + "/" + rawCaptureName));
    RenderAuditConfig cfg{scene, phase, "", 0};
    auto result = auditImage(*a, cfg, bg, /*step=*/2);
    if (flicker) {
        drawOnce();
        std::unique_ptr<ImageData> b(gfx->newImageData());
        REQUIRE(b.get() != nullptr);
        mergeAudit(result, auditFlicker(*a, *b, cfg, bg, /*step=*/2));
    }
    gfx->setScreenReadbackEnabled(false);
    if (result.hasDefects()) {
        appendAuditReport(auditOutDir(), result);
        saveAuditOverlay(*a, result, auditOutDir());
    }
    REQUIRE(result.interiorOccupancy > 0.03f);
    REQUIRE(!result.hasSevere());
}

void auditGpu2D(Graphics *gfx, const char *scene, const char *phase, const RenderAuditBg &bg) {
    gfx->setScreenReadbackEnabled(false);
    for (int i = 0; i < 2; ++i) RenderSystem::render(*gfx);
    gfx->setScreenReadbackEnabled(true);
    RenderSystem::render(*gfx);
    std::unique_ptr<ImageData> a(gfx->newImageData());
    REQUIRE(a.get() != nullptr);
    RenderAuditConfig cfg{scene, phase, "", 0};
    auto result = auditImage(*a, cfg, bg, /*step=*/2);
    gfx->setScreenReadbackEnabled(false);
    if (result.hasDefects()) {
        appendAuditReport(auditOutDir(), result);
        saveAuditOverlay(*a, result, auditOutDir());
    }
    REQUIRE(result.interiorOccupancy > 0.03f);
    REQUIRE(!result.hasSevere());
}

void blitAndPresent(Graphics *gfx, Texture *tex) {
    gfx->setScreenReadbackEnabled(true);
    gfx->setBackgroundColorRGBA(0.08f, 0.09f, 0.11f, 1.f);
    gfx->clearScreen();
    gfx->drawTexturedRectRGBA(tex, 0, 0, float(gfx->getWidth()), float(gfx->getHeight()), 1, 1, 1, 1);
    gfx->present();
}

void auditSwapchain(Graphics *gfx, const char *scene, const char *phase, const RenderAuditBg &bg) {
    std::unique_ptr<ImageData> a(gfx->newImageData());
    REQUIRE(a.get() != nullptr);
    RenderAuditConfig cfg{scene, phase, "", 0};
    auto result = auditImage(*a, cfg, bg, /*step=*/2);
    gfx->setScreenReadbackEnabled(false);
    if (result.hasDefects()) {
        appendAuditReport(auditOutDir(), result);
        saveAuditOverlay(*a, result, auditOutDir());
    }
    REQUIRE(result.interiorOccupancy > 0.03f);
    REQUIRE(!result.hasSevere());
}

Texture *makeChecker(Graphics *gfx, int w, int h, bool repeat = false) {
    std::vector<uint8_t> px(size_t(w * h * 4));
    for (int y = 0; y < h; ++y) {
        for (int x = 0; x < w; ++x) {
            const bool on = ((x / 4) + (y / 4)) & 1;
            const size_t i = size_t((y * w + x) * 4);
            px[i + 0] = on ? 210 : 50;
            px[i + 1] = on ? 210 : 50;
            px[i + 2] = on ? 215 : 55;
            px[i + 3] = 255;
        }
    }
    // Studio / classic-style 3D audits: mipmaps + anisotropy (engine default stays off).
    TextureCreateInfo info = TextureCreateInfo::withMipmaps(true);
    info.sampler.repeatU = repeat;
    info.sampler.repeatV = repeat;
    return gfx->newTexture(w, h, px.data(), info);
}

struct CloseWin {
    eve::window::Window *w = nullptr;
    ~CloseWin() {
        if (w) w->close();
    }
};

#include "PathBesideSource.h"
EVE_DEFINE_PATH_BESIDE_SOURCE()

Mesh *makeFloor(Graphics *gfx, float half = 4.5f) {
    const float pos[] = {
        -half, 0.f, -half, -half, 0.f, half, half, 0.f, half, half, 0.f, -half,
    };
    const float nrm[] = {
        0.f, 1.f, 0.f, 0.f, 1.f, 0.f, 0.f, 1.f, 0.f, 0.f, 1.f, 0.f,
    };
    const float uv[] = {0.f, 0.f, 0.f, 4.f, 4.f, 4.f, 4.f, 0.f};
    const uint32_t idx[] = {0, 1, 2, 0, 2, 3};
    return gfx->newMeshFromArrays(pos, nrm, uv, 4, idx, 6);
}

Texture *makeAtlas4(Graphics *gfx, int cell = 16) {
    const int w = cell * 2;
    const int h = cell * 2;
    std::vector<uint8_t> px(size_t(w * h * 4));
    const uint8_t cols[4][3] = {{220, 70, 60}, {60, 180, 80}, {60, 90, 220}, {230, 200, 50}};
    for (int y = 0; y < h; ++y) {
        for (int x = 0; x < w; ++x) {
            const int ci = (y < cell ? 0 : 2) + (x < cell ? 0 : 1);
            const size_t i = size_t((y * w + x) * 4);
            px[i + 0] = cols[ci][0];
            px[i + 1] = cols[ci][1];
            px[i + 2] = cols[ci][2];
            px[i + 3] = 255;
        }
    }
    return gfx->newTexture(w, h, px.data());
}

Texture *makeFlatNormal(Graphics *gfx) {
    const uint8_t px[4] = {128, 128, 255, 255};
    return gfx->newTexture(1, 1, px);
}

struct Studio3D {
    Camera3D *cam = nullptr;
    Renderable3D *ground = nullptr;
    Renderable3D *subject = nullptr;
    Light3D *sun = nullptr;
    Renderable2D *hud = nullptr;
    Mesh *sphere = nullptr;
    Mesh *floor = nullptr;
};

Studio3D makeStudio3D(Graphics *gfx) {
    Studio3D s;
    gfx->setBackgroundColor(Color(0.08f, 0.09f, 0.11f, 1.f));
    s.cam = Camera3D::createCamera();
    s.cam->setEye(0.f, 1.5f, 4.0f);
    s.cam->setTarget(0.f, 0.15f, 0.f);
    s.cam->data()->nearZ = 0.05f;
    s.cam->data()->farZ = 40.f;
    s.cam->setAmbient(0.06f, 0.06f, 0.07f);
    s.cam->setEnvMap(makeStudioCubemap(gfx));
    s.cam->setEnvIntensity(0.f);
    s.floor = makeFloor(gfx, 4.5f);
    s.sphere = gfx->newMeshSphere(18, 12);
    s.ground = Renderable3D::create();
    s.ground->setMesh(s.floor);
    s.ground->setTexture(makeSolid(gfx, 70, 72, 78));
    s.ground->setPosition(0.f, -0.7f, 0.f);
    s.ground->setMetallic(0.f);
    s.ground->setRoughness(0.92f);
    s.ground->setCastShadow(false);
    s.ground->setReceiveShadow(true);
    s.subject = Renderable3D::create();
    s.subject->setMesh(s.sphere);
    s.subject->setTexture(makeSolid(gfx, 210, 210, 215));
    s.subject->setPosition(0.f, 0.15f, 0.f);
    s.subject->setScale(0.55f, 0.55f, 0.55f);
    s.subject->setMetallic(0.15f);
    s.subject->setRoughness(0.45f);
    s.subject->setCastShadow(true);
    s.subject->setReceiveShadow(true);
    s.sun = Light3D::createLight("dir");
    s.sun->setDirection(0.45f, 1.f, 0.35f);
    s.sun->setColor(1.f, 0.97f, 0.92f, 2.4f);
    s.sun->setCastShadow(true);
    s.sun->setEnabled(true);
    s.hud = Renderable2D::create();
    s.hud->transform()->x = 0;
    s.hud->transform()->y = 0;
    s.hud->sprite()->width = 2;
    s.hud->sprite()->height = 2;
    s.hud->sprite()->receiveLight = false;
    s.hud->sprite()->castOcclusion = false;
    return s;
}

Texture *capturePresented(Graphics *gfx) {
    gfx->setScreenReadbackEnabled(false);
    for (int i = 0; i < 2; ++i) {
        RenderSystem3D::render(*gfx);
        RenderSystem::render(*gfx);
    }
    gfx->setScreenReadbackEnabled(true);
    RenderSystem3D::render(*gfx);
    RenderSystem::render(*gfx);
    std::unique_ptr<ImageData> img(gfx->newImageData());
    REQUIRE(img.get() != nullptr);
    Texture *tex = gfx->newTexture(img.get());
    gfx->setScreenReadbackEnabled(false);
    return tex;
}

Renderable2D *makeSprite(Texture *tex, float x, float y, float w, float h, bool receiveLight = false) {
    auto *sp = Renderable2D::create();
    sp->transform()->x = x;
    sp->transform()->y = y;
    sp->sprite()->width = w;
    sp->sprite()->height = h;
    sp->sprite()->texture = tex;
    sp->sprite()->receiveLight = receiveLight;
    sp->sprite()->castOcclusion = false;
    return sp;
}

Texture *makeAtlasGrid(Graphics *gfx, int cells, int cell = 8) {
    const int w = cell * cells;
    const int h = cell * cells;
    std::vector<uint8_t> px(size_t(w * h * 4));
    for (int y = 0; y < h; ++y) {
        for (int x = 0; x < w; ++x) {
            const int cx = x / cell;
            const int cy = y / cell;
            const int id = cy * cells + cx;
            const size_t i = size_t((y * w + x) * 4);
            px[i + 0] = uint8_t(40 + (id * 37) % 200);
            px[i + 1] = uint8_t(50 + (id * 53) % 190);
            px[i + 2] = uint8_t(70 + (id * 19) % 180);
            px[i + 3] = 255;
        }
    }
    return gfx->newTexture(w, h, px.data());
}

Mesh *makeHairCard(Graphics *gfx) {
    const float pos[] = {-0.45f, 0.f, 0.f, 0.45f, 0.f, 0.f, 0.45f, 1.3f, 0.f, -0.45f, 1.3f, 0.f};
    const float nrm[] = {0.f, 0.f, 1.f, 0.f, 0.f, 1.f, 0.f, 0.f, 1.f, 0.f, 0.f, 1.f};
    const float uv[] = {0.f, 1.f, 1.f, 1.f, 1.f, 0.f, 0.f, 0.f};
    const uint32_t idx[] = {0, 1, 2, 0, 2, 3};
    return gfx->newMeshFromArrays(pos, nrm, uv, 4, idx, 6);
}

Mesh *uploadSkinnedAiMesh(Graphics *gfx, const aiMesh *src, const std::vector<float> &posXYZ) {
    REQUIRE(src != nullptr);
    const int vc = int(src->mNumVertices);
    REQUIRE(vc > 0);
    REQUIRE(int(posXYZ.size()) == vc * 3);
    std::vector<float> nrm(size_t(vc) * 3u, 0.f);
    std::vector<float> uv(size_t(vc) * 2u, 0.f);
    for (int i = 0; i < vc; ++i) {
        if (src->mNormals) {
            nrm[size_t(i) * 3u + 0] = src->mNormals[i].x;
            nrm[size_t(i) * 3u + 1] = src->mNormals[i].y;
            nrm[size_t(i) * 3u + 2] = src->mNormals[i].z;
        } else {
            nrm[size_t(i) * 3u + 1] = 1.f;
        }
        if (src->mTextureCoords[0]) {
            uv[size_t(i) * 2u + 0] = src->mTextureCoords[0][i].x;
            uv[size_t(i) * 2u + 1] = src->mTextureCoords[0][i].y;
        }
    }
    std::vector<uint32_t> idx;
    idx.reserve(size_t(src->mNumFaces) * 3u);
    for (unsigned f = 0; f < src->mNumFaces; ++f) {
        const aiFace &face = src->mFaces[f];
        if (face.mNumIndices < 3) continue;
        for (unsigned k = 1; k + 1 < face.mNumIndices; ++k) {
            idx.push_back(face.mIndices[0]);
            idx.push_back(face.mIndices[k]);
            idx.push_back(face.mIndices[k + 1]);
        }
    }
    REQUIRE(!idx.empty());
    return gfx->newMeshFromArrays(posXYZ.data(), nrm.data(), uv.data(), vc, idx.data(),
                                  int(idx.size()));
}

eve::model3d::ModelData *loadCesiumMan(const char *fsIdentity) {
    const std::string dir = pathBesideThisSource("assets/skinned/cesium_man/glTF");
    REQUIRE(std::filesystem::is_regular_file(dir + "/CesiumMan.gltf"));
    auto *fs = eve::filesystem::Filesystem::create();
    REQUIRE(fs != nullptr);
    REQUIRE(fs->setIdentity(fsIdentity, true));
    REQUIRE(fs->setupWriteDirectory());
    fs->allowMountingForPath(dir);
    REQUIRE(fs->mount(dir, "", false));
    auto *mod = eve::model3d::Model3D::create();
    return mod->newModelDataFromFile("CesiumMan.gltf");
}

int findFirstSkinnedMesh(const eve::model3d::ModelData *model) {
    for (int i = 0; i < model->getMeshCount(); ++i) {
        if (model->hasBones(i)) return i;
    }
    return -1;
}

bool printOverlayThunk(void *userdata, void *commandBuffer) {
    auto *gfx = static_cast<Graphics *>(userdata);
    if (!gfx || !gfx->getFont()) return false;
    if (!commandBuffer) return true;
    Font *font = gfx->getFont();
    const char *icon = "\xEF\x80\x80";
    std::string row;
    for (int i = 0; i < 8; ++i) row += icon;
    gfx->drawText(font, row, 8.f, 8.f, Color(1.f, 0.82f, 0.2f, 1.f), 2.4f);
    return true;
}

}  // namespace

TEST_CASE("graphics.imageAudit.syntheticDefects") {
    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    const uint8_t geoR = 180, geoG = 180, geoB = 185;

    {
        std::unique_ptr<ImageData> img(makeRgba(64, 64, geoR, geoG, geoB));
        RenderAuditConfig cfg{"synthetic", "clean", "", 0};
        auto r = auditImage(*img, cfg, bg);
        CHECK(!r.empty);
        CHECK(r.defects.empty());
        CHECK(r.occupancy > 0.9f);
    }

    {
        std::unique_ptr<ImageData> img(makeRgba(64, 64, geoR, geoG, geoB));
        // One full interior 16x16 tile; unaligned holes split across tiles and
        // stay above kEmptyTile so detectHoles never fires.
        fillRect(img.get(), 16, 16, 16, 16, 0, 0, 0);
        RenderAuditConfig cfg{"synthetic", "hole", "", 0};
        auto r = auditImage(*img, cfg, bg);
        REQUIRE(hasKind(r, RenderDefect::Kind::Incomplete));
        bool locOk = false;
        for (const auto &d : r.defects) {
            if (d.kind != RenderDefect::Kind::Incomplete) continue;
            const int cx = d.x + d.w / 2;
            const int cy = d.y + d.h / 2;
            if (cx >= 16 && cx < 48 && cy >= 16 && cy < 48) locOk = true;
        }
        CHECK(locOk);
        appendAuditReport(auditOutDir(), r);
        saveAuditOverlay(*img, r, auditOutDir());
    }

    {
        std::unique_ptr<ImageData> img(makeRgba(64, 64, geoR, geoG, geoB));
        fillRect(img.get(), 8, 8, 12, 12, 255, 0, 255);
        RenderAuditConfig cfg{"synthetic", "magenta", "", 0};
        auto r = auditImage(*img, cfg, bg);
        REQUIRE(hasKind(r, RenderDefect::Kind::Damage));
        REQUIRE(r.hasSevere());
        appendAuditReport(auditOutDir(), r);
    }

    {
        std::unique_ptr<ImageData> img(makeRgba(64, 64, geoR, geoG, geoB));
        fillRect(img.get(), 0, 30, 64, 1, 20, 23, 28);
        RenderAuditConfig cfg{"synthetic", "tearing", "", 0};
        auto r = auditImage(*img, cfg, bg);
        REQUIRE(hasKind(r, RenderDefect::Kind::Damage));
        appendAuditReport(auditOutDir(), r);
    }

    {
        std::unique_ptr<ImageData> a(makeRgba(64, 64, geoR, geoG, geoB));
        std::unique_ptr<ImageData> b(makeRgba(64, 64, geoR, geoG, geoB));
        fillRect(b.get(), 16, 16, 24, 24, 40, 40, 40);
        RenderAuditConfig cfg{"synthetic", "flicker", "", 0};
        auto r = auditFlicker(*a, *b, cfg, bg);
        REQUIRE(hasKind(r, RenderDefect::Kind::Flicker));
        bool locOk = false;
        for (const auto &d : r.defects) {
            if (d.kind != RenderDefect::Kind::Flicker) continue;
            const int cx = d.x + d.w / 2;
            const int cy = d.y + d.h / 2;
            if (cx >= 12 && cx < 44 && cy >= 12 && cy < 44) locOk = true;
        }
        CHECK(locOk);
        appendAuditReport(auditOutDir(), r);
    }

    {
        std::unique_ptr<ImageData> img(makeRgba(64, 64, 20, 23, 28));
        RenderAuditConfig cfg{"synthetic", "empty", "", 0};
        auto r = auditImage(*img, cfg, bg);
        REQUIRE(r.empty);
        REQUIRE(r.hasSevere());
        appendAuditReport(auditOutDir(), r);
    }
}

TEST_CASE("graphics.imageAudit.pipelineConfigs") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 480;
    s.height = 360;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    gfx->setBackgroundColor(Color(0.08f, 0.09f, 0.11f, 1.f));
    RenderAuditBg bg{0.08f, 0.09f, 0.11f};

    auto *cam = Camera3D::createCamera();
    cam->setEye(0.f, 1.6f, 4.2f);
    cam->setTarget(0.f, 0.2f, 0.f);
    cam->data()->nearZ = 0.05f;
    cam->data()->farZ = 40.f;
    cam->setAmbient(0.06f, 0.06f, 0.07f);
    cam->setEnvMap(makeStudioCubemap(gfx));
    cam->setEnvIntensity(0.f);

    auto *ground = Renderable3D::create();
    ground->setMesh(gfx->newMeshSphere(16, 8));
    ground->setTexture(makeSolid(gfx, 70, 72, 78));
    ground->setPosition(0.f, -0.7f, 0.f);
    ground->setScale(3.2f, 0.08f, 3.2f);
    ground->setMetallic(0.f);
    ground->setRoughness(0.92f);
    ground->setCastShadow(false);
    ground->setReceiveShadow(true);

    auto *box = Renderable3D::create();
    box->setMesh(gfx->newMeshSphere(20, 12));
    box->setTexture(makeSolid(gfx, 210, 210, 215));
    box->setPosition(0.f, 0.15f, 0.f);
    box->setScale(0.55f, 0.55f, 0.55f);
    box->setMetallic(0.15f);
    box->setRoughness(0.45f);
    box->setCastShadow(true);
    box->setReceiveShadow(true);

    auto *hud = Renderable2D::create();
    hud->transform()->x = 0;
    hud->transform()->y = 0;
    hud->sprite()->width = 2;
    hud->sprite()->height = 2;
    hud->sprite()->r = 0.f;
    hud->sprite()->g = 0.f;
    hud->sprite()->b = 0.f;

    auto *sun = Light3D::createLight("dir");
    sun->setDirection(0.45f, 1.f, 0.35f);
    sun->setColor(1.f, 0.97f, 0.92f, 2.4f);
    sun->setCastShadow(false);
    sun->setEnabled(false);

    auto *point = Light3D::createLight("point");
    point->setPosition(-1.2f, 1.1f, 1.0f);
    point->setColor(1.f, 0.6f, 0.4f, 5.f);
    point->setRadius(6.f);
    point->setEnabled(false);

    auto *pointB = Light3D::createLight("point");
    pointB->setPosition(1.1f, 0.9f, -0.8f);
    pointB->setColor(0.4f, 0.55f, 1.f, 4.5f);
    pointB->setRadius(6.f);
    pointB->setEnabled(false);

    std::vector<Light3D *> clusterLights;
    clusterLights.reserve(10);
    for (int i = 0; i < 10; ++i) {
        auto *l = Light3D::createLight("point");
        const float a = float(i) / 10.f * 6.2831853f;
        l->setPosition(std::cos(a) * 1.7f, 0.55f + 0.15f * std::sin(a * 2.f), std::sin(a) * 1.7f);
        l->setColor(0.85f, 0.9f, 1.f, 2.2f);
        l->setRadius(3.2f);
        l->setEnabled(false);
        clusterLights.push_back(l);
    }

    RenderControl *rc = gfx->getRenderControl();
    REQUIRE(rc != nullptr);
    auto resetRc = [&]() {
        rc->enable("depthTest");
        rc->enable("shadow");
        rc->enable("forward");
        rc->enable("hair");
        rc->enable("clustered");
        rc->disable("gbuffer");
        rc->compile();
    };
    resetRc();

    struct Phase {
        const char *name;
        int light;  // 0 amb 1 dir 2 shadows 3 point 4 ibl 5 dir+point 6 shadows+ibl 7 full
        const char *enableFeat;
        const char *disableFeat;
        bool manyPoints;
        bool flicker;
    };
    const Phase phases[] = {
        {"ambient", 0, nullptr, nullptr, false, true},
        {"dir_lit", 1, nullptr, nullptr, false, true},
        {"dir_shadows", 2, nullptr, nullptr, false, true},
        {"point_lit", 3, nullptr, nullptr, false, false},
        {"ibl_reflect", 4, nullptr, nullptr, false, true},
        {"dir_point", 5, nullptr, nullptr, false, false},
        {"shadows_ibl", 6, nullptr, nullptr, false, false},
        {"full_lit", 7, nullptr, nullptr, false, true},
        {"gbuffer", 1, "gbuffer", nullptr, false, false},
        {"gbuffer_albedo", 1, "gbufferAlbedo", nullptr, false, false},
        {"no_shadow_pass", 2, nullptr, "shadow", false, false},
        {"clustered_many", 1, "clustered", nullptr, true, false},
        {"packed_only", 1, nullptr, "clustered", true, false},
    };

    const std::string outDir = auditOutDir();

    for (const auto &ph : phases) {
        sun->setEnabled(false);
        sun->setCastShadow(false);
        point->setEnabled(false);
        pointB->setEnabled(false);
        for (auto *l : clusterLights) l->setEnabled(false);
        cam->setEnvIntensity(0.f);
        cam->setAmbient(0.18f, 0.18f, 0.2f);
        resetRc();
        if (ph.enableFeat) {
            rc->enable(ph.enableFeat);
            rc->compile();
        }
        if (ph.disableFeat) {
            rc->disable(ph.disableFeat);
            rc->compile();
        }

        auto enableSun = [&](bool shadows) {
            cam->setAmbient(0.05f, 0.05f, 0.06f);
            sun->setEnabled(true);
            sun->setCastShadow(shadows);
            sun->setShadowStrength(1.f);
            sun->setColor(1.f, 0.97f, 0.92f, 2.4f);
        };
        switch (ph.light) {
        case 1:
            enableSun(false);
            break;
        case 2:
            enableSun(true);
            break;
        case 3:
            cam->setAmbient(0.04f, 0.04f, 0.05f);
            point->setEnabled(true);
            break;
        case 4:
            cam->setAmbient(0.03f, 0.03f, 0.04f);
            sun->setEnabled(true);
            cam->setEnvIntensity(1.2f);
            break;
        case 5:
            enableSun(false);
            point->setEnabled(true);
            pointB->setEnabled(true);
            break;
        case 6:
            enableSun(true);
            cam->setEnvIntensity(1.1f);
            break;
        case 7:
            enableSun(true);
            point->setEnabled(true);
            pointB->setEnabled(true);
            cam->setEnvIntensity(1.0f);
            break;
        default:
            break;
        }
        if (ph.manyPoints) {
            for (auto *l : clusterLights) l->setEnabled(true);
        }

        gfx->setScreenReadbackEnabled(false);
        for (int i = 0; i < 2; ++i) {
            RenderSystem3D::render(*gfx);
            RenderSystem::render(*gfx);
        }
        gfx->setScreenReadbackEnabled(true);
        RenderSystem3D::render(*gfx);
        RenderSystem::render(*gfx);
        std::unique_ptr<ImageData> a(gfx->newImageData());
        REQUIRE(a.get() != nullptr);
        RenderAuditConfig cfg{"pipeline_cube", ph.name, "", 0};
        auto result = auditImage(*a, cfg, bg, /*step=*/2);

        if (ph.flicker) {
            RenderSystem3D::render(*gfx);
            RenderSystem::render(*gfx);
            std::unique_ptr<ImageData> b(gfx->newImageData());
            REQUIRE(b.get() != nullptr);
            mergeAudit(result, auditFlicker(*a, *b, cfg, bg, /*step=*/2));
        }
        gfx->setScreenReadbackEnabled(false);

        if (result.hasDefects()) {
            appendAuditReport(outDir, result);
            saveAuditOverlay(*a, result, outDir);
        } else {
            saveImagePng(*a, outDir + "/pipeline_cube_" + std::string(ph.name) + ".png");
        }

        REQUIRE(result.interiorOccupancy > 0.04f);
        REQUIRE(!result.hasSevere());
    }

    resetRc();
    win->close();
}

TEST_CASE("graphics.imageAudit.materialsAndCamera") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    gfx->setBackgroundColor(Color(0.08f, 0.09f, 0.11f, 1.f));
    RenderAuditBg bg{0.08f, 0.09f, 0.11f};

    auto *cam = Camera3D::createCamera();
    cam->setEye(0.f, 1.5f, 4.0f);
    cam->setTarget(0.f, 0.15f, 0.f);
    cam->data()->nearZ = 0.05f;
    cam->data()->farZ = 40.f;
    cam->setAmbient(0.06f, 0.06f, 0.07f);
    cam->setEnvMap(makeStudioCubemap(gfx));
    cam->setEnvIntensity(0.f);

    Mesh *sphere = gfx->newMeshSphere(18, 12);
    Mesh *cyl = gfx->newMeshCylinder(16, 1, true);
    Texture *checker = makeChecker(gfx, 32, 32);
    Texture *height = makeChecker(gfx, 32, 32);

    auto *ground = Renderable3D::create();
    ground->setMesh(sphere);
    ground->setTexture(makeSolid(gfx, 70, 72, 78));
    ground->setPosition(0.f, -0.7f, 0.f);
    ground->setScale(3.0f, 0.08f, 3.0f);
    ground->setMetallic(0.f);
    ground->setRoughness(0.92f);
    ground->setCastShadow(false);
    ground->setReceiveShadow(true);

    auto *box = Renderable3D::create();
    box->setMesh(sphere);
    box->setTexture(makeSolid(gfx, 210, 210, 215));
    box->setPosition(0.f, 0.15f, 0.f);
    box->setScale(0.55f, 0.55f, 0.55f);
    box->setMetallic(0.15f);
    box->setRoughness(0.45f);
    box->setCastShadow(true);
    box->setReceiveShadow(true);

    auto *hud = Renderable2D::create();
    hud->transform()->x = 0;
    hud->transform()->y = 0;
    hud->sprite()->width = 2;
    hud->sprite()->height = 2;

    auto *sun = Light3D::createLight("dir");
    sun->setDirection(0.45f, 1.f, 0.35f);
    sun->setColor(1.f, 0.97f, 0.92f, 2.4f);
    sun->setCastShadow(true);
    sun->setShadowStrength(1.f);
    sun->setEnabled(true);

    Material *unlit = gfx->newMaterial();
    unlit->setShadingModel("unlit");
    unlit->setAlbedoTexture(makeSolid(gfx, 200, 50, 50));
    unlit->setReceiveLight(false);

    auditGpuFrame(gfx, "materials", "pbr_default", bg, true);

    box->setMaterial(unlit);
    box->setReceiveLight(false);
    auditGpuFrame(gfx, "materials", "unlit", bg);
    box->setMaterial(nullptr);
    box->setReceiveLight(true);
    box->setTexture(makeSolid(gfx, 210, 210, 215));

    box->setMetallic(1.f);
    box->setRoughness(0.08f);
    cam->setEnvIntensity(1.3f);
    auditGpuFrame(gfx, "materials", "metal_ibl", bg);
    cam->setEnvIntensity(0.f);
    box->setMetallic(0.f);
    box->setRoughness(0.95f);
    auditGpuFrame(gfx, "materials", "dielectric_rough", bg);
    box->setMetallic(0.15f);
    box->setRoughness(0.45f);

    box->setTexture(checker);
    box->setTexCellBomb(4.f, 0.85f, 1.f);
    auditGpuFrame(gfx, "materials", "tex_cell_bomb", bg);
    box->setTexCellBomb(4.f, 0.f, 1.f);
    box->setHeightTexture(height);
    box->setParallax(0.06f, 8.f, 24.f);
    auditGpuFrame(gfx, "materials", "parallax", bg);
    box->setParallax(0.f);
    box->setHeightTexture(nullptr);
    box->setTexture(makeSolid(gfx, 210, 210, 215));

    box->setHair(true);
    auditGpuFrame(gfx, "materials", "hair", bg);
    box->setHair(false);

    box->setMesh(cyl);
    auditGpuFrame(gfx, "materials", "cylinder", bg);
    box->setMesh(sphere);

    ground->setReceiveShadow(false);
    auditGpuFrame(gfx, "materials", "receive_shadow_off", bg);
    ground->setReceiveShadow(true);

    sun->setShadowBias(0.02f);
    auditGpuFrame(gfx, "materials", "shadow_bias_high", bg);
    sun->setShadowBias(0.002f);

    cam->setFov(28.f);
    auditGpuFrame(gfx, "materials", "fov_narrow", bg);
    cam->setFov(75.f);
    auditGpuFrame(gfx, "materials", "fov_wide", bg);
    cam->setFov(60.f);

    cam->data()->nearZ = 0.8f;
    cam->data()->farZ = 6.f;
    auditGpuFrame(gfx, "materials", "near_far_tight", bg);
    cam->data()->nearZ = 0.05f;
    cam->data()->farZ = 40.f;

    delete unlit;
    win->close();
}

TEST_CASE("graphics.imageAudit.postFx") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    gfx->setBackgroundColor(Color(0.08f, 0.09f, 0.11f, 1.f));
    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    const int w = 400;
    const int h = 300;

    auto *cam = Camera3D::createCamera();
    cam->setEye(0.f, 1.5f, 4.0f);
    cam->setTarget(0.f, 0.15f, 0.f);
    cam->data()->nearZ = 0.05f;
    cam->data()->farZ = 40.f;
    cam->setAmbient(0.05f, 0.05f, 0.06f);
    cam->setEnvMap(makeStudioCubemap(gfx));
    cam->setEnvIntensity(0.f);

    Mesh *sphere = gfx->newMeshSphere(18, 12);
    auto *ground = Renderable3D::create();
    ground->setMesh(sphere);
    ground->setTexture(makeSolid(gfx, 70, 72, 78));
    ground->setPosition(0.f, -0.7f, 0.f);
    ground->setScale(3.0f, 0.08f, 3.0f);
    ground->setRoughness(0.92f);
    ground->setCastShadow(false);
    ground->setReceiveShadow(true);

    auto *box = Renderable3D::create();
    box->setMesh(sphere);
    box->setTexture(makeSolid(gfx, 210, 210, 215));
    box->setPosition(0.f, 0.15f, 0.f);
    box->setScale(0.55f, 0.55f, 0.55f);
    box->setCastShadow(true);

    auto *hud = Renderable2D::create();
    hud->transform()->x = 0;
    hud->transform()->y = 0;
    hud->sprite()->width = 2;
    hud->sprite()->height = 2;

    auto *sun = Light3D::createLight("dir");
    sun->setDirection(0.45f, 1.f, 0.35f);
    sun->setColor(1.f, 0.97f, 0.92f, 2.4f);
    sun->setCastShadow(true);
    sun->setEnabled(true);

    RenderControl *rc = gfx->getRenderControl();
    REQUIRE(rc != nullptr);
    rc->enable("gbuffer");
    rc->enable("gbufferAlbedo");
    rc->compile();

    gfx->setScreenReadbackEnabled(false);
    for (int i = 0; i < 2; ++i) {
        RenderSystem3D::render(*gfx);
        RenderSystem::render(*gfx);
    }
    gfx->setScreenReadbackEnabled(true);
    RenderSystem3D::render(*gfx);
    RenderSystem::render(*gfx);

    std::unique_ptr<ImageData> sceneImg(gfx->newImageData());
    REQUIRE(sceneImg.get() != nullptr);
    Texture *sceneTex = gfx->newTexture(sceneImg.get());
    REQUIRE(sceneTex != nullptr);

    GBuffer *gb = rc->getGBuffer();
    REQUIRE(gb != nullptr);
    Texture *depth = gb->getDepthTexture();
    REQUIRE(depth != nullptr);

    std::unique_ptr<AntiAliasing> aa(gfx->newAntiAliasing());
    aa->setQuality("low");
    Canvas *aaDest = gfx->newCanvas(w, h);
    REQUIRE(aaDest != nullptr);
    const char *aaModes[] = {"fxaa", "smaa", "nfaa"};
    for (const char *mode : aaModes) {
        aa->setMode(mode);
        aa->applyTo(gfx, sceneTex, aaDest);
        blitAndPresent(gfx, aaDest->getTexture());
        auditSwapchain(gfx, "postfx", (std::string("aa_") + mode).c_str(), bg);
    }

    std::unique_ptr<AmbientOcclusion> ao(gfx->newAmbientOcclusion());
    ao->setQuality("low");
    ao->setCamera(0.f, 1.5f, 4.0f, 0.f, 0.15f, 0.f, 0.f, 1.f, 0.f, 60.f, float(w) / float(h), 0.05f,
                  40.f);
    Canvas *aoMap = gfx->newCanvas(ao->resolutionFor(w), ao->resolutionFor(h));
    Canvas *composed = gfx->newCanvas(w, h);
    REQUIRE(aoMap != nullptr);
    REQUIRE(composed != nullptr);
    const char *aoModes[] = {"ssao", "hbao", "gtao"};
    for (const char *mode : aoModes) {
        ao->setMode(mode);
        ao->computeTo(gfx, depth, aoMap);
        gfx->setCanvas(composed);
        gfx->setBackgroundColorRGBA(0.08f, 0.09f, 0.11f, 1.f);
        gfx->clearScreen();
        gfx->drawTexturedRectRGBA(sceneTex, 0, 0, float(w), float(h), 1, 1, 1, 1);
        ao->applyOverlay(gfx, aoMap->getTexture());
        gfx->setCanvas();
        blitAndPresent(gfx, composed->getTexture());
        auditSwapchain(gfx, "postfx", (std::string("ao_") + mode).c_str(), bg);
    }

    std::unique_ptr<Volumetric> vol(gfx->newVolumetric());
    vol->setQuality("low");
    vol->setCamera(0.f, 1.5f, 4.0f, 0.f, 0.15f, 0.f, 0.f, 1.f, 0.f, 60.f, float(w) / float(h), 0.05f,
                   40.f);
    vol->setFogColor(0.45f, 0.5f, 0.55f);
    vol->setFogHeight(-0.7f);
    vol->setFogHeightFalloff(0.8f);
    vol->setFogStart(1.2f);
    vol->setFogEnd(9.f);
    vol->setDensity(0.35f);
    vol->setMode("fog");
    gfx->setCanvas(composed);
    gfx->clearScreen();
    gfx->drawTexturedRectRGBA(sceneTex, 0, 0, float(w), float(h), 1, 1, 1, 1);
    vol->applyFog(gfx, depth);
    gfx->setCanvas();
    blitAndPresent(gfx, composed->getTexture());
    auditSwapchain(gfx, "postfx", "vol_fog", bg);

    vol->setMode("raymarch");
    vol->setLightDirection(0.45f, 1.f, 0.35f);
    vol->setLightScreenUV(0.62f, 0.28f);
    vol->setIntensity(0.8f);
    gfx->setCanvas(composed);
    gfx->clearScreen();
    gfx->drawTexturedRectRGBA(sceneTex, 0, 0, float(w), float(h), 1, 1, 1, 1);
    vol->rayMarch(gfx, depth);
    gfx->setCanvas();
    blitAndPresent(gfx, composed->getTexture());
    auditSwapchain(gfx, "postfx", "vol_raymarch", bg);

    vol->setMode("screenspace");
    vol->applyFromSceneTo(gfx, sceneTex, composed);
    blitAndPresent(gfx, composed->getTexture());
    auditSwapchain(gfx, "postfx", "vol_screenspace", bg);

    rc->disable("gbuffer");
    rc->compile();
    win->close();
}

TEST_CASE("graphics.imageAudit.composite2d3d") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    studio.hud->sprite()->visible = false;

    Texture *cells[4] = {
        makeSolid(gfx, 220, 80, 70),
        makeSolid(gfx, 70, 190, 90),
        makeSolid(gfx, 70, 110, 220),
        makeSolid(gfx, 230, 200, 60),
    };
    Texture *flatN = makeFlatNormal(gfx);
    Renderable2D *packed[4];
    const float ox = 80.f, oy = 60.f, cw = 120.f, ch = 90.f;
    for (int i = 0; i < 4; ++i) {
        packed[i] = makeSprite(cells[i], ox + float(i % 2) * cw, oy + float(i / 2) * ch, cw, ch, false);
        packed[i]->sprite()->normalTexture = flatN;
    }
    auditGpuFrame(gfx, "composite", "sprites_over_3d", bg);

    auto *pt = Light2D::createLight("point");
    pt->setPosition(200.f, 150.f);
    pt->setColor(1.f, 0.95f, 0.85f, 2.2f);
    pt->setRadius(280.f);
    pt->setEnabled(true);
    for (auto *sp : packed) sp->sprite()->receiveLight = true;
    auditGpuFrame(gfx, "composite", "lit2d_normal", bg);

    pt->setEnabled(false);
    auto *dir2 = Light2D::createLight("dir");
    dir2->setDirection(0.6f, -0.4f);
    dir2->setColor(0.95f, 0.9f, 1.f, 1.6f);
    dir2->setEnabled(true);
    auditGpuFrame(gfx, "composite", "dir2d", bg);

    dir2->setEnabled(false);
    for (auto *sp : packed) sp->sprite()->visible = false;
    Texture *atlas = makeAtlas4(gfx, 16);
    auto *atlasSp = makeSprite(atlas, 80.f, 60.f, 240.f, 180.f, false);
    atlasSp->sprite()->quad = gfx->newQuad(0, 0, 16, 16);
    auditGpuFrame(gfx, "composite", "atlas_quad", bg);
}

TEST_CASE("graphics.imageAudit.stylizeAndSsaa") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    Mesh *cyl = gfx->newMeshCylinder(24, 1, true);
    studio.subject->setMesh(cyl);
    studio.subject->setTexture(makeChecker(gfx, 32, 32));
    studio.subject->setScale(0.45f, 0.7f, 0.45f);

    auto *stylize = eve::stylize::Stylize::create();
    Shader *toon = stylize->newMeshShader(gfx, "cartoon");
    REQUIRE(toon != nullptr);
    if (toon->hasUniform("bands")) toon->sendFloat("bands", 3.f);
    if (toon->hasUniform("rimPower")) toon->sendFloat("rimPower", 2.6f);
    if (toon->hasUniform("rimStrength")) toon->sendFloat("rimStrength", 0.45f);
    studio.subject->setShader(toon);
    auditGpuFrame(gfx, "stylize", "mesh_cartoon", bg);

    Shader *ink = stylize->newMeshShader(gfx, "ink");
    REQUIRE(ink != nullptr);
    studio.subject->setShader(ink);
    auditGpuFrame(gfx, "stylize", "mesh_ink", bg);
    studio.subject->setShader(nullptr);

    Texture *sceneTex = capturePresented(gfx);
    REQUIRE(sceneTex != nullptr);
    const int w = 400, h = 300;
    Canvas *dest = gfx->newCanvas(w, h);
    REQUIRE(dest != nullptr);
    const char *posts[] = {"cartoon", "watercolor", "ink", "pixel"};
    for (const char *id : posts) {
        eve::stylize::StylePass *pass = stylize->newPass(gfx, id);
        REQUIRE(pass != nullptr);
        pass->applyTo(gfx, sceneTex, dest);
        blitAndPresent(gfx, dest->getTexture());
        auditSwapchain(gfx, "stylize", (std::string("post_") + id).c_str(), bg);
        delete pass;
    }

    std::unique_ptr<AntiAliasing> aa(gfx->newAntiAliasing());
    aa->setQuality("low");
    aa->setMode("ssaa");
    aa->applyTo(gfx, sceneTex, dest);
    blitAndPresent(gfx, dest->getTexture());
    auditSwapchain(gfx, "stylize", "aa_ssaa", bg);
}

TEST_CASE("graphics.imageAudit.multiObjectLod") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    Mesh *cyl = gfx->newMeshCylinder(12, 1, true);
    Mesh *hi = gfx->newMeshSphere(20, 14);
    Mesh *lo = gfx->newMeshSphere(8, 6);

    auto *left = Renderable3D::create();
    left->setMesh(studio.sphere);
    left->setTexture(makeSolid(gfx, 210, 90, 80));
    left->setPosition(-1.1f, 0.2f, 0.f);
    left->setScale(0.4f, 0.4f, 0.4f);
    left->setCastShadow(true);

    auto *right = Renderable3D::create();
    right->setMesh(cyl);
    right->setTexture(makeSolid(gfx, 80, 160, 210));
    right->setPosition(1.1f, 0.25f, 0.f);
    right->setScale(0.35f, 0.55f, 0.35f);
    right->setCastShadow(true);

    auditGpuFrame(gfx, "multi", "gallery", bg);

    studio.subject->setTint(1.f, 0.25f, 0.2f, 1.f);
    auditGpuFrame(gfx, "multi", "tint_red", bg);
    studio.subject->setTint(1.f, 1.f, 1.f, 0.72f);
    auditGpuFrame(gfx, "multi", "tint_alpha", bg);
    studio.subject->setTint(1.f, 1.f, 1.f, 1.f);

    left->setVisible(false);
    right->setVisible(false);
    studio.subject->setMesh(nullptr);
    auto *matA = gfx->newMaterial();
    matA->setShadingModel("pbr");
    matA->setAlbedoTexture(makeSolid(gfx, 220, 180, 70));
    auto *matB = gfx->newMaterial();
    matB->setShadingModel("pbr");
    matB->setAlbedoTexture(makeSolid(gfx, 70, 140, 210));
    studio.subject->setPart(0, "body", hi, matA);
    studio.subject->setPart(1, "cap", cyl, matB);
    studio.subject->setScale(0.5f, 0.5f, 0.5f);
    auditGpuFrame(gfx, "multi", "mesh_parts", bg);
    studio.subject->clearParts();
    studio.subject->setMesh(hi);
    left->setVisible(true);
    right->setVisible(true);

    studio.subject->setMeshLod(0, hi);
    studio.subject->setMeshLod(1, lo, 3.2f);
    studio.cam->setEye(0.f, 1.2f, 2.2f);
    auditGpuFrame(gfx, "multi", "lod_near", bg);
    studio.cam->setEye(0.f, 2.2f, 7.5f);
    auditGpuFrame(gfx, "multi", "lod_far", bg);
    studio.cam->setEye(4.2f, 1.5f, 0.1f);
    studio.cam->setTarget(0.f, 0.15f, 0.f);
    auditGpuFrame(gfx, "multi", "camera_side", bg);
    studio.cam->setEye(0.f, 1.5f, 4.0f);

    Canvas *cv = gfx->newCanvas(400, 300);
    REQUIRE(cv != nullptr);
    Texture *cellA = makeSolid(gfx, 200, 90, 70);
    Texture *cellB = makeSolid(gfx, 70, 180, 110);
    auto *c0 = makeSprite(cellA, 40.f, 30.f, 160.f, 120.f);
    auto *c1 = makeSprite(cellB, 200.f, 30.f, 160.f, 120.f);
    auto *c2 = makeSprite(cellB, 40.f, 150.f, 160.f, 120.f);
    auto *c3 = makeSprite(cellA, 200.f, 150.f, 160.f, 120.f);
    c0->sprite()->canvas = cv;
    c1->sprite()->canvas = cv;
    c2->sprite()->canvas = cv;
    c3->sprite()->canvas = cv;
    RenderSystem::render(*gfx);
    blitAndPresent(gfx, cv->getTexture());
    auditSwapchain(gfx, "multi", "canvas_2d", bg);
}

TEST_CASE("graphics.imageAudit.lightsAndXform") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);

    auto *pR = Light3D::createLight("point");
    pR->setPosition(-1.3f, 1.0f, 0.8f);
    pR->setColor(1.f, 0.25f, 0.2f, 5.f);
    pR->setRadius(5.f);
    pR->setEnabled(true);
    auto *pG = Light3D::createLight("point");
    pG->setPosition(1.2f, 0.9f, 0.6f);
    pG->setColor(0.2f, 1.f, 0.35f, 4.5f);
    pG->setRadius(5.f);
    pG->setEnabled(true);
    auto *pB = Light3D::createLight("point");
    pB->setPosition(0.1f, 1.2f, -1.0f);
    pB->setColor(0.25f, 0.4f, 1.f, 5.f);
    pB->setRadius(5.f);
    pB->setEnabled(true);
    auditGpuFrame(gfx, "lights", "dir_rgb_points", bg);

    studio.sun->setShadowStrength(0.35f);
    auditGpuFrame(gfx, "lights", "shadow_soft", bg);
    studio.sun->setShadowStrength(1.f);
    studio.subject->setCastShadow(false);
    studio.subject->setReceiveShadow(false);
    studio.ground->setReceiveShadow(false);
    auditGpuFrame(gfx, "lights", "cast_receive_off", bg);
    studio.subject->setCastShadow(true);
    studio.subject->setReceiveShadow(true);
    studio.ground->setReceiveShadow(true);

    studio.subject->setRotation(0.9f, 0.4f, 0.15f);
    auditGpuFrame(gfx, "lights", "yaw_pitch_roll", bg);
    studio.subject->setRotation(0.f, 0.f, 0.f);

    studio.cam->setUp(0.25f, 0.97f, 0.f);
    auditGpuFrame(gfx, "lights", "camera_roll", bg);
    studio.cam->setUp(0.f, 1.f, 0.f);

    pR->setEnabled(false);
    pG->setEnabled(false);
    pB->setEnabled(false);
    studio.sun->setEnabled(false);
    studio.subject->setMetallic(1.f);
    studio.subject->setRoughness(0.12f);
    studio.cam->setEnvIntensity(1.8f);
    auditGpuFrame(gfx, "lights", "ibl_metal", bg);
}

TEST_CASE("graphics.imageAudit.samplerMorph") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    Texture *checker = makeChecker(gfx, 32, 32);
    studio.subject->setTexture(checker);

    gfx->setTextureSampler(checker, "nearest", "none", 1.f, 0.f);
    auditGpuFrame(gfx, "sampler", "nearest", bg);
    gfx->setTextureSampler(checker, "linear", "none", 1.f, 0.f);
    auditGpuFrame(gfx, "sampler", "linear", bg);

    TextureCreateInfo mip = TextureCreateInfo::withMipmaps(true, 8.f);
    std::vector<uint8_t> mipPx(32 * 32 * 4);
    for (int y = 0; y < 32; ++y) {
        for (int x = 0; x < 32; ++x) {
            const bool on = ((x / 4) + (y / 4)) & 1;
            const size_t i = size_t((y * 32 + x) * 4);
            mipPx[i + 0] = on ? 210 : 50;
            mipPx[i + 1] = on ? 210 : 50;
            mipPx[i + 2] = on ? 215 : 55;
            mipPx[i + 3] = 255;
        }
    }
    Texture *mipTex = gfx->newTexture(32, 32, mipPx.data(), mip);
    studio.subject->setTexture(mipTex);
    gfx->setTextureSampler(mipTex, "linear", "linear", 8.f, 2.5f);
    auditGpuFrame(gfx, "sampler", "mip_lod_bias", bg);

    Texture *rep = makeChecker(gfx, 16, 16, true);
    studio.ground->setTexture(rep);
    auditGpuFrame(gfx, "sampler", "repeat_uv", bg);

    const float hs = 0.45f;
    const float pos[] = {
        -hs, -hs, -hs, hs, -hs, -hs, hs, hs, -hs, -hs, hs, -hs,
        -hs, -hs,  hs, hs, -hs,  hs, hs, hs,  hs, -hs, hs,  hs,
    };
    float nrm[24];
    float uv[16];
    for (int i = 0; i < 8; ++i) {
        float x = pos[i * 3 + 0], y = pos[i * 3 + 1], z = pos[i * 3 + 2];
        float len = std::sqrt(x * x + y * y + z * z);
        if (len < 1e-5f) len = 1.f;
        nrm[i * 3 + 0] = x / len;
        nrm[i * 3 + 1] = y / len;
        nrm[i * 3 + 2] = z / len;
        uv[i * 2 + 0] = (i & 1) ? 1.f : 0.f;
        uv[i * 2 + 1] = (i & 2) ? 1.f : 0.f;
    }
    const uint32_t idx[] = {0, 1, 2, 0, 2, 3, 4, 6, 5, 4, 7, 6, 0, 4, 5, 0, 5, 1,
                            3, 2, 6, 3, 6, 7, 0, 3, 7, 0, 7, 4, 1, 5, 6, 1, 6, 2};
    Mesh *morphMesh = gfx->newMeshFromArrays(pos, nrm, uv, 8, idx, 36);
    morphMesh->initMorphBase(8, pos, nrm, uv);
    float delta[24];
    for (int i = 0; i < 8; ++i) {
        delta[i * 3 + 0] = nrm[i * 3 + 0] * 0.28f;
        delta[i * 3 + 1] = nrm[i * 3 + 1] * 0.28f;
        delta[i * 3 + 2] = nrm[i * 3 + 2] * 0.28f;
    }
    REQUIRE(morphMesh->addMorphTarget("inflate", delta));
    studio.subject->setMesh(morphMesh);
    studio.subject->setTexture(makeSolid(gfx, 200, 160, 90));
    gfx->bakeMeshMorph(morphMesh);
    auditGpuFrame(gfx, "sampler", "morph_base", bg);
    morphMesh->setMorphWeight("inflate", 1.f);
    gfx->bakeMeshMorph(morphMesh);
}

TEST_CASE("graphics.imageAudit.gbufferViews") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    (void)studio;
    RenderControl *rc = gfx->getRenderControl();
    REQUIRE(rc != nullptr);
    rc->enable("gbuffer");
    rc->enable("gbufferAlbedo");
    rc->compile();

    gfx->setScreenReadbackEnabled(false);
    for (int i = 0; i < 2; ++i) {
        RenderSystem3D::render(*gfx);
        RenderSystem::render(*gfx);
    }
    GBuffer *gb = rc->getGBuffer();
    REQUIRE(gb != nullptr);
    Texture *albedo = gb->getAlbedoTexture();
    Texture *normal = gb->getNormalTexture();
    Texture *depth = gb->getDepthTexture();
    REQUIRE(albedo != nullptr);
    REQUIRE(normal != nullptr);
    REQUIRE(depth != nullptr);

    blitAndPresent(gfx, albedo);
    auditSwapchain(gfx, "gbuffer", "albedo", bg);
    blitAndPresent(gfx, normal);
    auditSwapchain(gfx, "gbuffer", "normal", bg);

    rc->disable("gbuffer");
    rc->compile();
}

TEST_CASE("graphics.imageAudit.occlusionScatter") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    gfx->setBackgroundColor(Color(0.08f, 0.09f, 0.11f, 1.f));
    const int w = 400, h = 300;

    auto *plate = makeSprite(makeSolid(gfx, 190, 175, 150), 0.f, 0.f, float(w), float(h), false);
    plate->setCastOcclusion(false);
    auto *occA = makeSprite(makeSolid(gfx, 40, 40, 48), 70.f, 80.f, 90.f, 110.f, false);
    occA->setCastOcclusion(true);
    auto *occB = makeSprite(makeSolid(gfx, 48, 40, 40), 230.f, 90.f, 80.f, 100.f, false);
    occB->setCastOcclusion(true);

    gfx->setScreenReadbackEnabled(true);
    RenderSystem::render(*gfx);
    std::unique_ptr<ImageData> sceneImg(gfx->newImageData());
    REQUIRE(sceneImg.get() != nullptr);
    Texture *sceneTex = gfx->newTexture(sceneImg.get());
    gfx->setScreenReadbackEnabled(false);

    std::unique_ptr<Volumetric> vol(gfx->newVolumetric());
    vol->setQuality("low");
    vol->setMode("screenspace");
    vol->setLightScreenPos(320.f, 40.f, float(w), float(h));
    vol->setIntensity(0.9f);

    Canvas *occMap = gfx->newCanvas(w, h);
    Canvas *composed = gfx->newCanvas(w, h);
    REQUIRE(occMap != nullptr);
    REQUIRE(composed != nullptr);

    gfx->setCanvas(occMap);
    vol->beginOcclusionMap(gfx, 320.f, 40.f, 22.f);
    vol->drawOccluders2D(gfx);
    gfx->setCanvas();
    gfx->setCanvas(composed);
    gfx->clearScreen();
    gfx->drawTexturedRectRGBA(sceneTex, 0, 0, float(w), float(h), 1, 1, 1, 1);
    vol->scatter(gfx, occMap->getTexture());
    gfx->setCanvas();
    blitAndPresent(gfx, composed->getTexture());
    auditSwapchain(gfx, "scatter", "scatter_on", bg);

    occA->setCastOcclusion(false);
    occB->setCastOcclusion(false);
    gfx->setCanvas(occMap);
    vol->beginOcclusionMap(gfx, 320.f, 40.f, 22.f);
    vol->drawOccluders2D(gfx);
    gfx->setCanvas();
    gfx->setCanvas(composed);
    gfx->clearScreen();
    gfx->drawTexturedRectRGBA(sceneTex, 0, 0, float(w), float(h), 1, 1, 1, 1);
    vol->scatter(gfx, occMap->getTexture());
    gfx->setCanvas();
    blitAndPresent(gfx, composed->getTexture());
    auditSwapchain(gfx, "scatter", "scatter_off", bg);
}

TEST_CASE("graphics.imageAudit.textureSources") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);

    std::unique_ptr<ImageData> dst(makeRgba(32, 32, 50, 90, 160));
    std::unique_ptr<ImageData> src(makeRgba(16, 16, 220, 70, 40));
    dst->paste(src.get(), 8, 8, 0, 0, 16, 16);
    Texture *pasted = gfx->newTexture(dst.get());
    REQUIRE(pasted != nullptr);
    studio.subject->setTexture(pasted);
    auditGpuFrame(gfx, "texsrc", "imagedata_paste", bg);

    auto *fs = eve::filesystem::Filesystem::create();
    REQUIRE(fs != nullptr);
    REQUIRE(fs->setIdentity("ev_ut_image_audit_texfile", true));
    REQUIRE(fs->setupWriteDirectory());
    const std::string texDir = pathBesideThisSource("Textures");
    fs->allowMountingForPath(texDir);
    REQUIRE(fs->mount(texDir, "", false));
    std::unique_ptr<eve::filesystem::FileData> diffFile(fs->read("Rock1_Diffuse.png"));
    std::unique_ptr<eve::filesystem::FileData> nrmFile(fs->read("Rock_Normal.png"));
    REQUIRE(diffFile.get() != nullptr);
    REQUIRE(nrmFile.get() != nullptr);
    auto *imgMod = eve::image::Image::create();
    std::unique_ptr<ImageData> diffImg(imgMod->newImageData(diffFile.get()));
    std::unique_ptr<ImageData> nrmImg(imgMod->newImageData(nrmFile.get()));
    REQUIRE(diffImg.get() != nullptr);
    REQUIRE(nrmImg.get() != nullptr);
    Texture *diff = gfx->newTexture(diffImg.get(), TextureCreateInfo::withMipmaps(true));
    Texture *nrm = gfx->newTexture(nrmImg.get(), TextureCreateInfo::withMipmaps(true));
    REQUIRE(diff != nullptr);
    REQUIRE(nrm != nullptr);
    REQUIRE(diff->getMipmapCount() > 1);
    REQUIRE(diff->getSampler().maxAnisotropy > 1.f);
    studio.subject->setTexture(diff);
    studio.subject->setNormalTexture(nrm);
    auditGpuFrame(gfx, "texsrc", "file_rock", bg);
}

TEST_CASE("graphics.imageAudit.renderControlToggles") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    RenderControl *rc = gfx->getRenderControl();
    REQUIRE(rc != nullptr);

    rc->disable("depthTest");
    rc->compile();
    auditGpuFrame(gfx, "rctrl", "depth_test_off", bg);
    rc->enable("depthTest");

    rc->disable("hair");
    rc->compile();
    auditGpuFrame(gfx, "rctrl", "hair_off", bg);
    rc->enable("hair");

    Shader *hairSh = gfx->newHairShader();
    REQUIRE(hairSh != nullptr);
    auto *card = Renderable3D::create();
    card->setMesh(makeHairCard(gfx));
    card->setTexture(makeSolid(gfx, 210, 160, 70));
    card->setShader(hairSh);
    card->setHair(true);
    card->setPosition(0.f, 0.05f, 0.35f);
    card->setCastShadow(false);
    studio.subject->setVisible(false);
    rc->disable("forward");
    rc->compile();
    makeSprite(makeSolid(gfx, 90, 140, 200), 0.f, 0.f, 200.f, 150.f, false);
    makeSprite(makeSolid(gfx, 200, 90, 70), 200.f, 0.f, 200.f, 150.f, false);
    makeSprite(makeSolid(gfx, 70, 180, 110), 0.f, 150.f, 200.f, 150.f, false);
    makeSprite(makeSolid(gfx, 220, 200, 60), 200.f, 150.f, 200.f, 150.f, false);
    auditGpuFrame(gfx, "rctrl", "forward_off_hair", bg);
    rc->enable("forward");
    rc->compile();
    studio.subject->setVisible(true);
    card->setVisible(false);

    TextureCreateInfo mip = TextureCreateInfo::withMipmaps(true, 16.f);
    std::vector<uint8_t> px(32 * 32 * 4);
    for (int y = 0; y < 32; ++y) {
        for (int x = 0; x < 32; ++x) {
            const bool on = ((x / 4) + (y / 4)) & 1;
            const size_t i = size_t((y * 32 + x) * 4);
            px[i + 0] = on ? 210 : 50;
            px[i + 1] = on ? 180 : 70;
            px[i + 2] = on ? 90 : 160;
            px[i + 3] = 255;
        }
    }
    Texture *aniso = gfx->newTexture(32, 32, px.data(), mip);
    gfx->setTextureSampler(aniso, "linear", "linear", 16.f, 0.f);
    studio.ground->setTexture(aniso);
    studio.subject->setTexture(aniso);
    auditGpuFrame(gfx, "rctrl", "aniso_mip", bg);
}

TEST_CASE("graphics.imageAudit.sprite2dCamera") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    gfx->setBackgroundColor(Color(0.08f, 0.09f, 0.11f, 1.f));
    Texture *cells[4] = {
        makeSolid(gfx, 220, 80, 70),
        makeSolid(gfx, 70, 190, 90),
        makeSolid(gfx, 70, 110, 220),
        makeSolid(gfx, 230, 200, 60),
    };
    Renderable2D *packed[4];
    for (int i = 0; i < 4; ++i) {
        packed[i] = makeSprite(cells[i], float((i % 2) * 200), float((i / 2) * 150), 200.f, 150.f);
    }
    auditGpu2D(gfx, "sprite2d", "identity", bg);

    auto *cam = Camera2D::createCamera();
    cam->setPosition(200.f, 150.f);
    cam->setZoom(1.3f);
    const float visW = 400.f / 1.3f;
    const float visH = 300.f / 1.3f;
    const float x0 = 200.f - visW * 0.5f;
    const float y0 = 150.f - visH * 0.5f;
    const float cw = visW * 0.5f;
    const float ch = visH * 0.5f;
    for (int i = 0; i < 4; ++i) {
        packed[i]->transform()->x = x0 + float(i % 2) * cw;
        packed[i]->transform()->y = y0 + float(i / 2) * ch;
        packed[i]->sprite()->width = cw;
        packed[i]->sprite()->height = ch;
        packed[i]->transform()->sx = 1.f;
        packed[i]->transform()->sy = 1.f;
    }
    auditGpu2D(gfx, "sprite2d", "zoom_1_3", bg);

    cam->setZoom(1.f);
    for (int i = 0; i < 4; ++i) {
        packed[i]->transform()->x = float((i % 2) * 200);
        packed[i]->transform()->y = float((i / 2) * 150);
        packed[i]->sprite()->width = 100.f;
        packed[i]->sprite()->height = 75.f;
        packed[i]->transform()->sx = 2.f;
        packed[i]->transform()->sy = 2.f;
    }
    auditGpu2D(gfx, "sprite2d", "scale_sx_sy", bg);

    cam->data()->active = false;
    std::vector<uint32_t> frag(custom2d_frag_spv, custom2d_frag_spv + custom2d_frag_spv_count);
    Shader *sh = gfx->newShaderFromSpv({}, frag);
    REQUIRE(sh != nullptr);
    sh->declareFloat("factor");
    sh->sendFloat("factor", 0.55f);
    for (int i = 0; i < 4; ++i) {
        packed[i]->transform()->x = float((i % 2) * 200);
        packed[i]->transform()->y = float((i / 2) * 150);
        packed[i]->sprite()->width = 200.f;
        packed[i]->sprite()->height = 150.f;
        packed[i]->transform()->sx = 1.f;
        packed[i]->transform()->sy = 1.f;
        packed[i]->sprite()->shader = sh;
    }
    auditGpu2D(gfx, "sprite2d", "custom_spv", bg);
}

TEST_CASE("graphics.imageAudit.overlayFx") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    (void)studio;
    Texture *sceneTex = capturePresented(gfx);
    REQUIRE(sceneTex != nullptr);

    auto *stylize = eve::stylize::Stylize::create();
    eve::stylize::StyleChain *chain = stylize->newChain();
    eve::stylize::StylePass *cartoon = stylize->newPass(gfx, "cartoon");
    eve::stylize::StylePass *pixel = stylize->newPass(gfx, "pixel");
    REQUIRE(chain != nullptr);
    REQUIRE(cartoon != nullptr);
    REQUIRE(pixel != nullptr);
    chain->add(cartoon);
    chain->add(pixel);
    Canvas *dest = gfx->newCanvas(400, 300);
    Canvas *temp = gfx->newCanvas(400, 300);
    chain->apply(gfx, sceneTex, dest, temp);
    blitAndPresent(gfx, dest->getTexture());
    auditSwapchain(gfx, "overlay", "stylechain_cartoon_pixel", bg);
    delete pixel;
    delete cartoon;
    delete chain;

    auto raw = [&]() {
        std::ifstream in(pathBesideThisSource("fonts/FontAwesome.ttf"), std::ios::binary);
        return std::vector<char>((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
    }();
    REQUIRE(!raw.empty());
    eve::data::ByteData bytes(raw.data(), raw.size());
    std::unique_ptr<eve::font::FontData> fd(eve::font::Font::create()->newFontData(&bytes, 32));
    REQUIRE(fd.get() != nullptr);
    Font *gpuFont = gfx->newFont(fd.get(), std::string("\xEF\x80\x80"));
    REQUIRE(gpuFont != nullptr);
    gfx->setFont(gpuFont);
    gfx->setPresentOverlay(&printOverlayThunk, gfx);
    makeSprite(makeSolid(gfx, 180, 140, 70), 0.f, 0.f, 400.f, 84.f, false);
    auditGpuFrame(gfx, "overlay", "font_draw_text", bg);
    gfx->setPresentOverlay(nullptr, nullptr);

    auto *parts = eve::particles::Particles::create();
    eve::particles::ParticleEmitter *em = parts->newEmitter(64);
    em->setPosition(200.f, 140.f);
    em->setEmissionArea("rect", 120.f, 70.f);
    em->setParticleLifetime(8.f, 8.f);
    em->setSpeed(0.f, 0.f);
    em->setParticleSize(36.f, 36.f);
    em->setColorStart(1.f, 0.55f, 0.15f, 1.f);
    em->setColorEnd(1.f, 0.55f, 0.15f, 1.f);
    em->setTexture(makeSolid(gfx, 230, 140, 50));
    em->emit(48);
    auditGpuFrame(gfx, "overlay", "particles", bg, false, [&]() {
        eve::particles::ParticleRenderSystem::render(gfx);
    });
}

TEST_CASE("graphics.imageAudit.voxelAndHair") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    studio.subject->setVisible(false);
    makeSprite(makeSolid(gfx, 180, 140, 70), 0.f, 0.f, 400.f, 84.f, false);

    eve::voxel::VoxelWorld world;
    for (int z = 0; z < 14; ++z) {
        for (int x = 0; x < 14; ++x) world.setVoxel(x, 0, z, uint8_t(1 + (x + z) % 4));
    }
    for (int y = 1; y < 8; ++y) {
        for (int z = 5; z < 8; ++z)
            for (int x = 5; x < 8; ++x) world.setVoxel(x, y, z, 3);
    }
    REQUIRE(world.remeshDirty() > 0);
    Texture *atlas = makeAtlasGrid(gfx, 2, 16);
    studio.cam->setEye(7.f, 9.f, 18.f);
    studio.cam->setTarget(7.f, 2.f, 7.f);
    auto drawVoxels = [&]() {
        auto cd = studio.cam->data();
        const glm::vec3 eye(cd->eyeX, cd->eyeY, cd->eyeZ);
        const glm::vec3 target(cd->targetX, cd->targetY, cd->targetZ);
        const glm::vec3 up(cd->upX, cd->upY, cd->upZ);
        const glm::mat4 viewM = glm::lookAtRH(eye, target, up);
        const float aspect = float(gfx->getWidth()) / float(std::max(gfx->getHeight(), 1));
        const glm::mat4 projM =
            perspectiveVulkanRH_ZO(cd->fovYDeg * 0.017453292519943295f, aspect, cd->nearZ, cd->farZ);
        const glm::mat4 vp = projM * viewM;
        gfx->setMesh3DViewProj(vp);
        world.selectVisible(&vp[0][0], cd->eyeX, cd->eyeY, cd->eyeZ, 40.f, true);
        world.drawVisible(gfx, atlas, 2);
    };
    auditGpuFrame(gfx, "voxel_hair", "voxels", bg, false, drawVoxels);

    studio.cam->setEye(0.f, 1.5f, 4.0f);
    studio.cam->setTarget(0.f, 0.15f, 0.f);
    studio.ground->setVisible(true);
    Shader *hairSh = gfx->newHairShader();
    REQUIRE(hairSh != nullptr);
    auto *card = Renderable3D::create();
    card->setMesh(makeHairCard(gfx));
    card->setTexture(makeSolid(gfx, 200, 150, 80));
    card->setShader(hairSh);
    card->setHair(true);
    card->setPosition(0.f, 0.05f, 0.2f);
    card->setCastShadow(false);
    auditGpuFrame(gfx, "voxel_hair", "hair_cards", bg);
}

TEST_CASE("graphics.imageAudit.uiAndMap") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    gfx->setBackgroundColor(Color(0.08f, 0.09f, 0.11f, 1.f));
    auto *map = eve::map::Map::create();
    Texture *tiles = makeAtlasGrid(gfx, 4, 8);
    eve::map::TileLayer *layer = map->newLayer(25, 19, 16.f, 16.f);
    REQUIRE(layer != nullptr);
    layer->setTileset(tiles, 1, 4);
    layer->setTilesetTileSize(8, 8);
    for (int y = 0; y < 19; ++y)
        for (int x = 0; x < 25; ++x) layer->setTile(x, y, 1 + (x + y) % 15);

    auto *cam = Camera2D::createCamera();
    cam->setPosition(200.f, 150.f);
    cam->setZoom(1.f);
    layer->setCamera(cam);

    auto presentMap = [&]() {
        gfx->setScreenReadbackEnabled(true);
        gfx->setBackgroundColorRGBA(0.08f, 0.09f, 0.11f, 1.f);
        gfx->clearScreen();
        map->render(gfx);
        gfx->present();
    };
    presentMap();
    auditSwapchain(gfx, "uimap", "ortho_fill", bg);

    cam->setZoom(1.25f);
    presentMap();
    auditSwapchain(gfx, "uimap", "ortho_zoom", bg);
    cam->setZoom(1.f);

    auto *ui = eve::ui::UI::create();
    REQUIRE(ui->initBackend());
    ui->beginFrameAndRender();
    presentMap();
    auditSwapchain(gfx, "uimap", "imgui_hook", bg);
    ui->dispatchEvents();

    layer->setVisible(false);
    eve::map::TileLayer *logic = map->newLayer(16, 12, 16.f, 16.f);
    eve::map::TileLayer *display = map->newLayer(1, 1, 16.f, 16.f);
    logic->setTileset(tiles, 1, 4);
    display->setTileset(tiles, 1, 4);
    display->setTilesetTileSize(8, 8);
    for (int y = 0; y < 12; ++y)
        for (int x = 0; x < 16; ++x) logic->setTile(x, y, ((x + y) % 3 == 0) ? 1 : 0);
    eve::map::DualGridOptions opts;
    opts.filledGid = 1;
    opts.hideLogic = true;
    REQUIRE(eve::map::resolveDualGrid(logic, display, opts, nullptr));
    display->setCamera(cam);
    makeSprite(makeSolid(gfx, 70, 90, 130), 0.f, 0.f, 400.f, 300.f, false)->sprite()->layer = -1;
    presentMap();
    auditSwapchain(gfx, "uimap", "dual_grid", bg);

    display->setVisible(false);
    eve::map::TileLayer *iso = map->newLayer(18, 18, 32.f, 16.f);
    iso->config()->orientation = eve::map::MapOrientation::Isometric;
    iso->config()->originX = 200.f;
    iso->config()->originY = 16.f;
    iso->setTileset(tiles, 1, 4);
    iso->setTilesetTileSize(8, 8);
    iso->setCamera(cam);
    for (int y = 0; y < 18; ++y)
        for (int x = 0; x < 18; ++x) iso->setTile(x, y, 1 + (x * 3 + y) % 15);
    presentMap();
    auditSwapchain(gfx, "uimap", "isometric", bg);
}

TEST_CASE("graphics.imageAudit.skinnedStill") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    makeSprite(makeSolid(gfx, 180, 140, 70), 0.f, 0.f, 400.f, 84.f, false);

    eve::ref<eve::model3d::ModelData> model(loadCesiumMan("ev_ut_image_audit_skin_still"));
    REQUIRE(model.get() != nullptr);
    const int mi = findFirstSkinnedMesh(model.get());
    REQUIRE(mi >= 0);
    const aiMesh *src = model->getMesh(mi);
    REQUIRE(src != nullptr);
    Mesh *gpu = gfx->newMeshFromAssimp(*src);
    REQUIRE(gpu != nullptr);
    studio.subject->setMesh(gpu);
    studio.subject->setTexture(makeSolid(gfx, 200, 170, 120));
    studio.subject->setScale(1.15f, 1.15f, 1.15f);
    studio.subject->setPosition(0.f, 0.f, 0.f);
    studio.subject->setYaw(1.2f);
    studio.cam->setEye(0.f, 1.3f, 3.2f);
    studio.cam->setTarget(0.f, 0.7f, 0.f);
    studio.ground->setPosition(0.f, 0.f, 0.f);
    auditGpuFrame(gfx, "skinned", "bind_pose", bg);
}

TEST_CASE("graphics.imageAudit.skinnedPose") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    makeSprite(makeSolid(gfx, 180, 140, 70), 0.f, 0.f, 400.f, 84.f, false);

    eve::ref<eve::model3d::ModelData> model(loadCesiumMan("ev_ut_image_audit_skin_pose"));
    REQUIRE(model.get() != nullptr);
    const int mi = findFirstSkinnedMesh(model.get());
    REQUIRE(mi >= 0);
    const aiMesh *src = model->getMesh(mi);
    REQUIRE(src != nullptr);

    using eve::animation::AnimClip;
    using eve::animation::AnimImporter;
    using eve::animation::AnimPose;
    using eve::animation::AnimSkeleton;
    using eve::animation::AnimSkin;
    std::unique_ptr<AnimSkeleton> sk(AnimImporter::loadSkeletonFromModel(model.get()));
    REQUIRE(sk.get() != nullptr);
    std::unique_ptr<AnimClip> clip(AnimImporter::loadClipFromModel(model.get(), sk.get(), 0));
    REQUIRE(clip.get() != nullptr);
    std::unique_ptr<AnimSkin> skin(AnimSkin::fromModel(model.get(), mi, sk.get()));
    REQUIRE(skin.get() != nullptr);

    auto uploadAt = [&](float t) {
        AnimPose pose;
        clip->sample(t, &pose, sk.get());
        pose.computeWorld(sk.get());
        std::vector<float> pos;
        REQUIRE(skin->skinPositionsTo(&pose, pos));
        return uploadSkinnedAiMesh(gfx, src, pos);
    };

    studio.subject->setMesh(uploadAt(0.f));
    studio.subject->setTexture(makeSolid(gfx, 200, 170, 120));
    studio.subject->setScale(1.15f, 1.15f, 1.15f);
    studio.subject->setPosition(0.f, 0.f, 0.f);
    studio.subject->setYaw(1.2f);
    studio.cam->setEye(0.f, 1.3f, 3.2f);
    studio.cam->setTarget(0.f, 0.7f, 0.f);
    studio.ground->setPosition(0.f, 0.f, 0.f);
    auditGpuFrame(gfx, "skinned", "pose_t0", bg);

    studio.subject->setMesh(uploadAt(clip->getDuration() * 0.5f));
    auditGpuFrame(gfx, "skinned", "pose_tmid", bg);
}

TEST_CASE("graphics.imageAudit.reloadTex") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    auto *fs = eve::filesystem::Filesystem::create();
    REQUIRE(fs->setIdentity("ev_ut_image_audit_texreload", true));
    REQUIRE(fs->setupWriteDirectory());
    const std::string texDir = pathBesideThisSource("Textures");
    fs->allowMountingForPath(texDir);
    REQUIRE(fs->mount(texDir, "", false));
    Texture *diff = gfx->newTextureFromFile("Rock1_Diffuse.png");
    REQUIRE(diff != nullptr);
    studio.subject->setTexture(diff);
    auditGpuFrame(gfx, "reload", "before", bg);
    REQUIRE(gfx->reloadTextureFromFile("Rock1_Diffuse.png"));
    auditGpuFrame(gfx, "reload", "after", bg);
}

TEST_CASE("graphics.imageAudit.morphInflate") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    makeSprite(makeSolid(gfx, 180, 140, 70), 0.f, 0.f, 400.f, 84.f, false);

    const float hs = 0.45f;
    const float pos[] = {
        -hs, -hs, -hs, hs, -hs, -hs, hs, hs, -hs, -hs, hs, -hs,
        -hs, -hs,  hs, hs, -hs,  hs, hs, hs,  hs, -hs, hs,  hs,
    };
    float nrm[24];
    float uv[16];
    for (int i = 0; i < 8; ++i) {
        float x = pos[i * 3 + 0], y = pos[i * 3 + 1], z = pos[i * 3 + 2];
        float len = std::sqrt(x * x + y * y + z * z);
        if (len < 1e-5f) len = 1.f;
        nrm[i * 3 + 0] = x / len;
        nrm[i * 3 + 1] = y / len;
        nrm[i * 3 + 2] = z / len;
        uv[i * 2 + 0] = (i & 1) ? 1.f : 0.f;
        uv[i * 2 + 1] = (i & 2) ? 1.f : 0.f;
    }
    const uint32_t idx[] = {0, 1, 2, 0, 2, 3, 4, 6, 5, 4, 7, 6, 0, 4, 5, 0, 5, 1,
                            3, 2, 6, 3, 6, 7, 0, 3, 7, 0, 7, 4, 1, 5, 6, 1, 6, 2};
    Mesh *morphMesh = gfx->newMeshFromArrays(pos, nrm, uv, 8, idx, 36);
    morphMesh->initMorphBase(8, pos, nrm, uv);
    float delta[24];
    for (int i = 0; i < 8; ++i) {
        delta[i * 3 + 0] = nrm[i * 3 + 0] * 0.28f;
        delta[i * 3 + 1] = nrm[i * 3 + 1] * 0.28f;
        delta[i * 3 + 2] = nrm[i * 3 + 2] * 0.28f;
    }
    REQUIRE(morphMesh->addMorphTarget("inflate", delta));
    studio.subject->setMesh(morphMesh);
    studio.subject->setTexture(makeSolid(gfx, 200, 160, 90));
    gfx->bakeMeshMorph(morphMesh);
    auditGpuFrame(gfx, "morph", "base", bg);
    morphMesh->setMorphWeight("inflate", 1.f);
    gfx->bakeMeshMorph(morphMesh);
    auditGpuFrame(gfx, "morph", "inflate", bg);
    morphMesh->setMorphWeight("inflate", 0.45f);
    gfx->bakeMeshMorph(morphMesh);
    auditGpuFrame(gfx, "morph", "inflate_mid", bg);
}

TEST_CASE("graphics.imageAudit.procgenAssets") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    makeSprite(makeSolid(gfx, 180, 140, 70), 0.f, 0.f, 400.f, 84.f, false);

    auto *pg = eve::procgen::Procgen::create();
    REQUIRE(pg != nullptr);
    auto paramsResult = eve::procgen::Procgen::newParamsHandle();
    REQUIRE(paramsResult.ok());
    auto paramsHandle = std::move(paramsResult).takeValue();
    auto paramsView   = eve::procgen::Procgen::resolve(paramsHandle);
    REQUIRE(paramsView.isBound());
    eve::procgen::Params &params = *paramsView;
    params.setSeed(11);
    params.setSize(64, 64);
    params.setInt("colors", 6);
    params.setInt("pixelSize", 2);
    params.setInt("seamless", 1);
    const char *recipes[] = {"tex.soil", "tex.stone", "tex.marble"};
    for (const char *id : recipes) {
        auto textureView = pg->generateTextureBorrowed(id, paramsHandle, gfx);
        REQUIRE(textureView.isBound());
        studio.subject->setTexture(textureView.get());
        auditGpuFrame(gfx, "procgen", id, bg);
    }

    auto normalResult = pg->generateNormalImageHandle("tex.stone", paramsHandle);
    REQUIRE(normalResult.ok());
    auto normalHandle = std::move(normalResult).takeValue();
    CHECK(!eve::procgen::Procgen::isStale(normalHandle));
    auto normalView = eve::procgen::Procgen::resolve(normalHandle);
    REQUIRE(normalView.isBound());
    Texture *nrm = gfx->newTextureFromImageData(normalView.get(), true, true);
    REQUIRE(nrm != nullptr);
    studio.subject->setNormalTexture(nrm);
    auto stoneTextureView = pg->generateTextureBorrowed("tex.stone", paramsHandle, gfx);
    REQUIRE(stoneTextureView.isBound());
    studio.subject->setTexture(stoneTextureView.get());
    auditGpuFrame(gfx, "procgen", "stone_normal", bg);
    studio.subject->setNormalTexture(nullptr);
    auto releaseNormalResult = eve::procgen::Procgen::release(normalHandle);
    REQUIRE(releaseNormalResult.ok());
    CHECK(eve::procgen::Procgen::isStale(normalHandle));

    params.setSeed(1);
    params.setInt("resolution", 16);
    params.setString("field", "sphere");
    params.setFloat("radius", 0.7f);
    params.setFloat("isolevel", 0.f);
    auto meshView = pg->generateMeshBorrowed("mesh.marchingcubes", paramsHandle, gfx);
    REQUIRE(meshView.isBound());
    studio.subject->setMesh(meshView.get());
    auto marbleTextureView = pg->generateTextureBorrowed("tex.marble", paramsHandle, gfx);
    REQUIRE(marbleTextureView.isBound());
    studio.subject->setTexture(marbleTextureView.get());
    studio.subject->setScale(0.7f, 0.7f, 0.7f);
    auditGpuFrame(gfx, "procgen", "marching_cubes", bg);

    auto releaseParamsResult = eve::procgen::Procgen::release(paramsHandle);
    REQUIRE(releaseParamsResult.ok());

    Texture *sceneTex = capturePresented(gfx);
    REQUIRE(sceneTex != nullptr);
    Canvas *dest = gfx->newCanvas(400, 300);
    REQUIRE(dest != nullptr);
    std::unique_ptr<AntiAliasing> aa(gfx->newAntiAliasing());
    aa->setMode("ssaa");
    aa->setQuality("medium");
    aa->applyTo(gfx, sceneTex, dest);
    blitAndPresent(gfx, dest->getTexture());
    auditSwapchain(gfx, "procgen", "ssaa_medium", bg);
    aa->setQuality("high");
    aa->applyTo(gfx, sceneTex, dest);
    blitAndPresent(gfx, dest->getTexture());
    auditSwapchain(gfx, "procgen", "ssaa_high", bg);
}

TEST_CASE("graphics.imageAudit.mapFovHex") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    gfx->setBackgroundColor(Color(0.08f, 0.09f, 0.11f, 1.f));
    auto *map = eve::map::Map::create();
    Texture *tiles = makeAtlasGrid(gfx, 4, 8);
    eve::map::TileLayer *layer = map->newLayer(25, 19, 16.f, 16.f);
    REQUIRE(layer != nullptr);
    layer->setTileset(tiles, 1, 4);
    layer->setTilesetTileSize(8, 8);
    for (int y = 0; y < 19; ++y)
        for (int x = 0; x < 25; ++x) layer->setTile(x, y, 1 + (x + y) % 15);

    auto *cam = Camera2D::createCamera();
    cam->setPosition(200.f, 150.f);
    cam->setZoom(1.f);
    layer->setCamera(cam);

    auto presentMap = [&]() {
        gfx->setScreenReadbackEnabled(true);
        gfx->setBackgroundColorRGBA(0.08f, 0.09f, 0.11f, 1.f);
        gfx->clearScreen();
        map->render(gfx);
        gfx->present();
    };

    std::unique_ptr<eve::map::Fov> fov(map->newFov(layer));
    REQUIRE(fov.get() != nullptr);
    fov->setAlgorithm("shadowcast");
    fov->setRadiusMetric("chebyshev");
    for (int y = 0; y < 19; ++y) {
        if (y == 9) continue;
        fov->setOpaque(8, y, true);
        layer->setTile(8, y, 2);
    }
    fov->addRevealer(4, 9, 10);
    fov->compute();
    for (int y = 0; y < 19; ++y) {
        for (int x = 0; x < 25; ++x) {
            const bool vis = fov->isVisible(x, y);
            layer->setTile(x, y, vis ? (1 + (x + y) % 8) : (9 + (x * 3 + y) % 7));
        }
    }
    presentMap();
    auditSwapchain(gfx, "mapfov", "shadowcast", bg);

    fov->setAlgorithm("raycast");
    fov->compute();
    for (int y = 0; y < 19; ++y) {
        for (int x = 0; x < 25; ++x) {
            const bool vis = fov->isVisible(x, y);
            layer->setTile(x, y, vis ? (1 + (x + y) % 8) : (9 + (x * 3 + y) % 7));
        }
    }
    presentMap();
    auditSwapchain(gfx, "mapfov", "raycast", bg);

    std::vector<uint8_t> r8;
    REQUIRE(fov->fillMaskR8(r8));
    const int mw = fov->getWidth();
    const int mh = fov->getHeight();
    REQUIRE(mw == 25);
    REQUIRE(mh == 19);
    std::vector<uint8_t> rgba(size_t(mw * mh * 4));
    for (int i = 0; i < mw * mh; ++i) {
        const uint8_t v = r8[size_t(i)];
        const size_t o = size_t(i) * 4u;
        rgba[o + 0] = uint8_t(50 + int(v) * 180 / 255);
        rgba[o + 1] = uint8_t(90 + int(v) * 110 / 255);
        rgba[o + 2] = uint8_t(200 - int(v) * 70 / 255);
        rgba[o + 3] = 255;
    }
    Texture *maskVis = gfx->newTexture(mw, mh, rgba.data());
    REQUIRE(maskVis != nullptr);
    REQUIRE(fov->buildMaskTexture(gfx) != nullptr);
    layer->setVisible(false);
    auto *maskSp = makeSprite(maskVis, 0.f, 0.f, 400.f, 300.f, false);
    presentMap();
    auditSwapchain(gfx, "mapfov", "mask_vis", bg);
    maskSp->sprite()->visible = false;

    auto *pg = eve::procgen::Procgen::create();
    auto  paramsResult = eve::procgen::Procgen::newParamsHandle();
    REQUIRE(paramsResult.ok());
    auto paramsHandle = std::move(paramsResult).takeValue();
    auto paramsView   = eve::procgen::Procgen::resolve(paramsHandle);
    REQUIRE(paramsView.isBound());
    paramsView->setSeed(1);
    paramsView->setSize(25, 19);
    auto gridResult = pg->generateHandle("dungeon.bsp", paramsHandle);
    REQUIRE(gridResult.ok());
    auto gridHandle = std::move(gridResult).takeValue();
    auto gridView   = eve::procgen::Procgen::resolve(gridHandle);
    REQUIRE(gridView.isBound());
    pg->setPaletteGid("audit", "wall", 2);
    pg->setPaletteGid("audit", "floor", 5);
    pg->setPaletteGid("audit", "corridor", 6);
    layer->setVisible(true);
    auto applyResult = pg->applyToLayer(gridHandle, "audit", *layer);
    REQUIRE(applyResult.ok());
    for (int y = 0; y < 19; ++y)
        for (int x = 0; x < 25; ++x)
            if (layer->getTile(x, y) == 0) layer->setTile(x, y, 5);
    auto releaseGridResult = eve::procgen::Procgen::release(gridHandle);
    REQUIRE(releaseGridResult.ok());
    presentMap();
    auditSwapchain(gfx, "mapfov", "dungeon_bsp", bg);
    layer->setVisible(false);

    auto releaseParamsResult = eve::procgen::Procgen::release(paramsHandle);
    REQUIRE(releaseParamsResult.ok());

    eve::map::TileLayer *hex = map->newLayer(18, 16, 32.f, 28.f);
    hex->config()->orientation = eve::map::MapOrientation::Hexagonal;
    hex->config()->hexSideLength = 16.f;
    hex->config()->originX = 16.f;
    hex->config()->originY = 8.f;
    hex->setTileset(tiles, 1, 4);
    hex->setTilesetTileSize(8, 8);
    hex->setCamera(cam);
    for (int y = 0; y < 16; ++y)
        for (int x = 0; x < 18; ++x) hex->setTile(x, y, 1 + (x * 3 + y) % 15);
    makeSprite(makeSolid(gfx, 70, 90, 130), 0.f, 0.f, 400.f, 300.f, false)->sprite()->layer = -1;
    presentMap();
    auditSwapchain(gfx, "mapfov", "hexagonal", bg);
    hex->setVisible(false);

    eve::map::TileLayer *stag = map->newLayer(18, 20, 32.f, 16.f);
    stag->config()->orientation = eve::map::MapOrientation::Staggered;
    stag->config()->staggerAxis = eve::map::StaggerAxis::Y;
    stag->config()->staggerIndex = eve::map::StaggerIndex::Odd;
    stag->config()->originX = 0.f;
    stag->config()->originY = 0.f;
    stag->setTileset(tiles, 1, 4);
    stag->setTilesetTileSize(8, 8);
    stag->setCamera(cam);
    for (int y = 0; y < 20; ++y)
        for (int x = 0; x < 18; ++x) stag->setTile(x, y, 1 + (x + y * 2) % 15);
    presentMap();
    auditSwapchain(gfx, "mapfov", "staggered", bg);
}

TEST_CASE("graphics.imageAudit.particleSkin") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    makeSprite(makeSolid(gfx, 180, 140, 70), 0.f, 0.f, 400.f, 84.f, false);

    eve::ref<eve::model3d::ModelData> model(loadCesiumMan("ev_ut_image_audit_skin_part"));
    REQUIRE(model.get() != nullptr);
    const int mi = findFirstSkinnedMesh(model.get());
    REQUIRE(mi >= 0);
    const aiMesh *src = model->getMesh(mi);
    REQUIRE(src != nullptr);
    Mesh *gpu = gfx->newMeshFromAssimp(*src);
    REQUIRE(gpu != nullptr);
    studio.subject->setMesh(gpu);
    studio.subject->setTexture(makeSolid(gfx, 200, 170, 120));
    studio.subject->setScale(1.15f, 1.15f, 1.15f);
    studio.subject->setPosition(0.f, 0.f, 0.f);
    studio.subject->setYaw(1.2f);
    studio.cam->setEye(0.f, 1.3f, 3.2f);
    studio.cam->setTarget(0.f, 0.7f, 0.f);
    studio.ground->setPosition(0.f, 0.f, 0.f);

    using eve::animation::AnimClip;
    using eve::animation::AnimImporter;
    using eve::animation::AnimPose;
    using eve::animation::AnimSkeleton;
    using eve::animation::AnimSkin;
    std::unique_ptr<AnimSkeleton> sk(AnimImporter::loadSkeletonFromModel(model.get()));
    REQUIRE(sk.get() != nullptr);
    std::unique_ptr<AnimClip> clip(AnimImporter::loadClipFromModel(model.get(), sk.get(), 0));
    REQUIRE(clip.get() != nullptr);
    std::unique_ptr<AnimSkin> skin(AnimSkin::fromModel(model.get(), mi, sk.get()));
    REQUIRE(skin.get() != nullptr);
    std::unique_ptr<AnimPose> pose(new AnimPose());
    clip->sample(0.f, pose.get(), sk.get());
    pose->computeWorld(sk.get());
    REQUIRE(skin->updateSkinnedPositions(pose.get()));

    auto *parts = eve::particles::Particles::create();
    eve::particles::ParticleEmitter *em = parts->newEmitter(128);
    em->setParticleLifetime(8.f, 8.f);
    em->setSpeed(0.f, 0.f);
    em->setParticleSize(28.f, 28.f);
    em->setColorStart(1.f, 0.45f, 0.15f, 1.f);
    em->setColorEnd(1.f, 0.45f, 0.15f, 1.f);
    em->setTexture(makeSolid(gfx, 230, 120, 40));
    em->setEmissionArea("none", 0.f, 0.f);
    em->setSkinScale(90.f);
    em->setSkinPlane("xy");
    em->setSkinSource(skin.get(), pose.get());
    REQUIRE(em->hasSkinSource());
    em->emitFromSkin(64);
    REQUIRE(em->getCount() >= 16);
    auditGpuFrame(gfx, "partskin", "emit_from_skin", bg, false, [&]() {
        eve::particles::ParticleRenderSystem::render(gfx);
    });

    em->clearSkinSource();
    std::unique_ptr<AnimSkeleton> attachSk(new AnimSkeleton());
    const int root = attachSk->addBone("root", -1);
    std::unique_ptr<AnimPose> bonePose(new AnimPose());
    attachSk->applyBindPose(bonePose.get());
    bonePose->setLocalPosition(root, 200.f, 160.f, 0.f);
    bonePose->computeWorld(attachSk.get());
    em->setParticleSize(40.f, 40.f);
    em->attachToBone(bonePose.get(), root);
    em->syncAttach();
    em->emit(24);
    auditGpuFrame(gfx, "partskin", "attach_bone", bg, false, [&]() {
        eve::particles::ParticleRenderSystem::render(gfx);
    });
}

TEST_CASE("graphics.imageAudit.materialHair") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    auto *auditBanner =
        makeSprite(makeSolid(gfx, 180, 140, 70), 0.f, 0.f, 400.f, 84.f, false);

    studio.subject->setReceiveLight(false);
    studio.subject->setTexture(makeSolid(gfx, 220, 90, 70));
    auditGpuFrame(gfx, "mathair", "receive_off", bg);
    studio.subject->setReceiveLight(true);

    Material *hairMat = gfx->newMaterial();
    hairMat->setShadingModel("hair");
    hairMat->setAlbedoTexture(makeSolid(gfx, 210, 160, 70));
    Shader *hairSh = gfx->newHairShader();
    REQUIRE(hairSh != nullptr);
    hairMat->setShader(hairSh);
    auto *card = Renderable3D::create();
    card->setMesh(makeHairCard(gfx));
    card->setMaterial(hairMat);
    card->setPosition(0.f, 0.05f, 0.35f);
    card->setCastShadow(false);
    auditGpuFrame(gfx, "mathair", "hair_material", bg);

    // General-purpose transparent PBR materials must use the transparent
    // forward queue without pretending to be hair. Isolate this frame from the
    // preceding hair audit, then place one overlapping card behind the opaque
    // sphere and one in front to make depth testing and compositing unambiguous.
    card->setPosition(100.f, 100.f, 100.f);
    auditBanner->sprite()->visible = false;
    studio.subject->setTexture(makeSolid(gfx, 205, 210, 220));
    Material *glassBack = gfx->newMaterial();
    glassBack->setSurfaceMode("transparent");
    glassBack->setTint(0.08f, 0.35f, 1.f, 0.48f);
    glassBack->setSortPriority(0);
    auto *backCard = Renderable3D::create();
    backCard->setMesh(makeHairCard(gfx));
    backCard->setMaterial(glassBack);
    backCard->setPosition(-0.22f, -0.05f, -0.3f);
    backCard->setCastShadow(false);

    Material *glassFront = gfx->newMaterial();
    glassFront->setSurfaceMode("transparent");
    glassFront->setTint(1.f, 0.12f, 0.04f, 0.42f);
    glassFront->setSortPriority(0);
    auto *frontCard = Renderable3D::create();
    frontCard->setMesh(makeHairCard(gfx));
    frontCard->setMaterial(glassFront);
    frontCard->setPosition(0.22f, -0.05f, 0.65f);
    frontCard->setCastShadow(false);
    auditGpuFrame(gfx, "mathair", "transparent_pbr_overlap", bg, false, {},
                  "mathair_transparent_pbr_overlap.png");

    studio.subject->setVisible(false);
    makeSprite(makeSolid(gfx, 90, 140, 200), 0.f, 0.f, 200.f, 150.f, false);
    makeSprite(makeSolid(gfx, 200, 90, 70), 200.f, 0.f, 200.f, 150.f, false);
    makeSprite(makeSolid(gfx, 70, 180, 110), 0.f, 150.f, 200.f, 150.f, false);
    makeSprite(makeSolid(gfx, 220, 200, 60), 200.f, 150.f, 200.f, 150.f, false);
    auditGpuFrame(gfx, "mathair", "hair_only_packed", bg);
}

TEST_CASE("graphics.imageAudit.clusteredHair") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    makeSprite(makeSolid(gfx, 180, 140, 70), 0.f, 0.f, 400.f, 84.f, false);
    studio.sun->setEnabled(false);
    studio.cam->setAmbient(0.08f, 0.08f, 0.09f);

    RenderControl *rc = gfx->getRenderControl();
    REQUIRE(rc != nullptr);
    rc->enable("clustered");
    rc->enable("hair");
    rc->enable("forward");
    rc->compile();

    const float cols[12][3] = {
        {1.f, 0.25f, 0.2f}, {0.2f, 1.f, 0.3f}, {0.25f, 0.4f, 1.f}, {1.f, 0.9f, 0.2f},
        {1.f, 0.4f, 0.9f},  {0.2f, 0.95f, 0.9f}, {1.f, 0.55f, 0.15f}, {0.6f, 0.3f, 1.f},
        {0.4f, 1.f, 0.55f}, {1.f, 0.2f, 0.45f}, {0.55f, 0.75f, 1.f}, {0.95f, 0.95f, 0.7f},
    };
    for (int i = 0; i < 12; ++i) {
        auto *l = Light3D::createLight("point");
        const float a = float(i) / 12.f * 6.2831853f;
        l->setPosition(std::cos(a) * 1.6f, 0.5f + 0.2f * std::sin(a * 2.f), std::sin(a) * 1.6f);
        l->setColor(cols[i][0], cols[i][1], cols[i][2], 3.2f);
        l->setRadius(3.5f);
        l->setEnabled(true);
    }
    auditGpuFrame(gfx, "cluster", "twelve_points", bg);

    Shader *hairSh = gfx->newHairShader();
    REQUIRE(hairSh != nullptr);
    auto *card = Renderable3D::create();
    card->setMesh(makeHairCard(gfx));
    card->setTexture(makeSolid(gfx, 210, 160, 70));
    card->setShader(hairSh);
    card->setHair(true);
    card->setPosition(0.f, 0.05f, 0.4f);
    card->setCastShadow(false);
    auditGpuFrame(gfx, "cluster", "hair_plus_clustered", bg);

    rc->disable("clustered");
    rc->compile();
    auditGpuFrame(gfx, "cluster", "packed_fallback", bg);
    rc->enable("clustered");
    rc->compile();
}

TEST_CASE("graphics.imageAudit.clothFluid2D") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    gfx->setBackgroundColor(Color(0.08f, 0.09f, 0.11f, 1.f));
    makeSprite(makeSolid(gfx, 90, 140, 200), 0.f, 0.f, 200.f, 150.f, false);
    makeSprite(makeSolid(gfx, 200, 90, 70), 200.f, 0.f, 200.f, 150.f, false);
    makeSprite(makeSolid(gfx, 70, 180, 110), 0.f, 150.f, 200.f, 150.f, false);
    makeSprite(makeSolid(gfx, 220, 200, 60), 200.f, 150.f, 200.f, 150.f, false);

    auto presentExtra = [&](const std::function<void()> &extra) {
        gfx->setScreenReadbackEnabled(true);
        gfx->setBackgroundColorRGBA(0.08f, 0.09f, 0.11f, 1.f);
        gfx->clearScreen();
        std::vector<DrawItem2D> items;
        RenderSystem::collectSprites(items);
        RenderSystem::drawItems(*gfx, items, false);
        extra();
        gfx->present();
    };

    eve::physics::Cloth cloth(20, 16, 20.f, 8.f, 8.f);
    cloth.pinTopRow();
    cloth.setGravity(0.f, 0.f);
    cloth.setColor(0.95f, 0.35f, 0.2f, 1.f);
    cloth.update(0.016f);
    presentExtra([&]() { cloth.draw(gfx); });
    auditSwapchain(gfx, "phys2d", "cloth", bg);

    cloth.setGravity(0.f, 400.f);
    cloth.applyForce(80.f, 0.f);
    for (int i = 0; i < 8; ++i) cloth.update(0.016f);
    presentExtra([&]() { cloth.draw(gfx); });
    auditSwapchain(gfx, "phys2d", "cloth_wind", bg);

    eve::physics::Fluid2D fluid(512);
    fluid.setGravity(0.f, 0.f);
    fluid.setParticleSize(18.f);
    fluid.setColor(0.25f, 0.6f, 0.95f, 1.f);
    fluid.setBounds(0.f, 0.f, 400.f, 300.f);
    for (int y = 30; y < 280; y += 16)
        for (int x = 30; x < 380; x += 16) fluid.emit(float(x), float(y), 1);
    REQUIRE(fluid.getParticleCount() > 100);
    presentExtra([&]() { fluid.draw(gfx); });
    auditSwapchain(gfx, "phys2d", "fluid", bg);
}

TEST_CASE("graphics.imageAudit.particlePresets") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    (void)studio;
    makeSprite(makeSolid(gfx, 180, 140, 70), 0.f, 0.f, 400.f, 84.f, false);

    auto *parts = eve::particles::Particles::create();
    eve::particles::ParticleEmitter *em = parts->newEmitter(128);
    em->setTexture(makeSolid(gfx, 230, 160, 50));
    em->setPosition(200.f, 160.f);

    auto burst = [&](const char *preset, const char *phase, float r, float g, float b) {
        em->reset();
        em->applyPreset(preset);
        em->setParticleLifetime(8.f, 8.f);
        em->setSpeed(0.f, 0.f);
        em->setParticleSize(32.f, 32.f);
        em->setColorStart(r, g, b, 1.f);
        em->setColorEnd(r, g, b, 1.f);
        em->setEmissionArea("rect", 140.f, 80.f);
        em->emit(48);
        REQUIRE(em->getCount() >= 16);
        auditGpuFrame(gfx, "presets", phase, bg, false, [&]() {
            eve::particles::ParticleRenderSystem::render(gfx);
        });
    };
    burst("spark", "spark", 1.f, 0.85f, 0.25f);
    burst("smoke", "smoke", 0.75f, 0.78f, 0.82f);
    burst("fire", "fire", 1.f, 0.4f, 0.12f);

    em->reset();
    REQUIRE(em->applyConfig("{\"preset\":\"fire\",\"x\":200,\"y\":160,\"particleSize\":[36,36]}"));
    em->setParticleLifetime(8.f, 8.f);
    em->setSpeed(0.f, 0.f);
    em->setColorStart(1.f, 0.45f, 0.15f, 1.f);
    em->setColorEnd(1.f, 0.45f, 0.15f, 1.f);
    em->setEmissionArea("rect", 140.f, 80.f);
    em->emit(40);
    auditGpuFrame(gfx, "presets", "json_fire", bg, false, [&]() {
        eve::particles::ParticleRenderSystem::render(gfx);
    });
}

TEST_CASE("graphics.imageAudit.mapPath") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    gfx->setBackgroundColor(Color(0.08f, 0.09f, 0.11f, 1.f));
    auto *map = eve::map::Map::create();
    Texture *tiles = makeAtlasGrid(gfx, 4, 8);
    eve::map::TileLayer *layer = map->newLayer(25, 19, 16.f, 16.f);
    REQUIRE(layer != nullptr);
    layer->setTileset(tiles, 1, 4);
    layer->setTilesetTileSize(8, 8);
    for (int y = 0; y < 19; ++y)
        for (int x = 0; x < 25; ++x) layer->setTile(x, y, 5);

    auto *cam = Camera2D::createCamera();
    cam->setPosition(200.f, 150.f);
    cam->setZoom(1.f);
    layer->setCamera(cam);

    auto presentMap = [&]() {
        gfx->setScreenReadbackEnabled(true);
        gfx->setBackgroundColorRGBA(0.08f, 0.09f, 0.11f, 1.f);
        gfx->clearScreen();
        map->render(gfx);
        gfx->present();
    };

    std::unique_ptr<eve::map::Pathfinder> pf(map->newPathfinder(layer));
    REQUIRE(pf.get() != nullptr);
    pf->setDiagonal(true);
    for (int y = 0; y < 19; ++y) {
        if (y == 9) continue;
        pf->setBlocked(12, y, true);
        layer->setTile(12, y, 2);
    }
    std::unique_ptr<eve::map::Path> path(pf->findPath(1, 9, 23, 9));
    REQUIRE(path.get() != nullptr);
    REQUIRE(path->getLength() > 4);
    for (int i = 0; i < path->getLength(); ++i)
        layer->setTile(path->getX(i), path->getY(i), 4);
    layer->setTile(1, 9, 8);
    layer->setTile(23, 9, 12);
    presentMap();
    auditSwapchain(gfx, "mappath", "astar", bg);

    std::unique_ptr<eve::map::FlowField> field(pf->buildFlowField(23, 9));
    REQUIRE(field.get() != nullptr);
    for (int y = 0; y < 19; ++y) {
        for (int x = 0; x < 25; ++x) {
            if (layer->getTile(x, y) == 2) continue;
            layer->setTile(x, y, field->isReachable(x, y) ? (6 + (x + y) % 3) : 10);
        }
    }
    presentMap();
    auditSwapchain(gfx, "mappath", "flow_field", bg);

    std::unique_ptr<eve::map::Path> group(pf->findGroupPath(2, 2, 23, 9));
    REQUIRE(group.get() != nullptr);
    for (int y = 0; y < 19; ++y)
        for (int x = 0; x < 25; ++x)
            if (layer->getTile(x, y) != 2) layer->setTile(x, y, 5);
    for (int i = 0; i < group->getLength(); ++i)
        layer->setTile(group->getX(i), group->getY(i), 14);
    presentMap();
    auditSwapchain(gfx, "mappath", "group_flow", bg);
}

TEST_CASE("graphics.imageAudit.reloadTexBytes") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    makeSprite(makeSolid(gfx, 180, 140, 70), 0.f, 0.f, 400.f, 84.f, false);

    auto *fs = eve::filesystem::Filesystem::create();
    REQUIRE(fs->setIdentity("ev_ut_image_audit_texbytes", true));
    REQUIRE(fs->setupWriteDirectory());
    [[maybe_unused]] auto *const imageModule = eve::image::Image::create();

    auto writeSolidPng = [&](uint8_t r, uint8_t g, uint8_t b) {
        eve::image::ImageData img(32, 32, "RGBA8");
        auto *px = static_cast<uint8_t *>(img.getData());
        for (int i = 0; i < 32 * 32; ++i) {
            px[i * 4 + 0] = r;
            px[i * 4 + 1] = g;
            px[i * 4 + 2] = b;
            px[i * 4 + 3] = 255;
        }
        std::unique_ptr<eve::filesystem::FileData> encoded(
            img.encode(medialoader::FormatHandler::ENCODED_PNG, "audit_reload_swap.png", true));
        REQUIRE(encoded.get() != nullptr);
    };

    writeSolidPng(220, 60, 50);
    Texture *tex = gfx->newTextureFromFile("audit_reload_swap.png");
    REQUIRE(tex != nullptr);
    studio.subject->setTexture(tex);
    auditGpuFrame(gfx, "texbytes", "red", bg);

    writeSolidPng(50, 200, 80);
    REQUIRE(gfx->reloadTextureFromFile("audit_reload_swap.png"));
    auditGpuFrame(gfx, "texbytes", "green", bg);

    writeSolidPng(60, 90, 220);
    REQUIRE(gfx->reloadTextureFromFile("audit_reload_swap.png"));
    auditGpuFrame(gfx, "texbytes", "blue", bg);
}

TEST_CASE("graphics.imageAudit.postQuality") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    (void)studio;
    makeSprite(makeSolid(gfx, 180, 140, 70), 0.f, 0.f, 400.f, 84.f, false);
    const int w = 400, h = 300;

    RenderControl *rc = gfx->getRenderControl();
    REQUIRE(rc != nullptr);
    rc->enable("gbuffer");
    rc->enable("gbufferAlbedo");
    rc->compile();

    Texture *sceneTex = capturePresented(gfx);
    REQUIRE(sceneTex != nullptr);
    GBuffer *gb = rc->getGBuffer();
    REQUIRE(gb != nullptr);
    Texture *depth = gb->getDepthTexture();
    REQUIRE(depth != nullptr);

    Canvas *composed = gfx->newCanvas(w, h);
    REQUIRE(composed != nullptr);
    std::unique_ptr<AmbientOcclusion> ao(gfx->newAmbientOcclusion());
    ao->setCamera(0.f, 1.5f, 4.0f, 0.f, 0.15f, 0.f, 0.f, 1.f, 0.f, 60.f, float(w) / float(h), 0.05f,
                  40.f);
    ao->setMode("ssao");
    const char *qualities[] = {"low", "medium", "high"};
    for (const char *q : qualities) {
        ao->setQuality(q);
        Canvas *aoMap = gfx->newCanvas(ao->resolutionFor(w), ao->resolutionFor(h));
        REQUIRE(aoMap != nullptr);
        ao->computeTo(gfx, depth, aoMap);
        gfx->setCanvas(composed);
        gfx->setBackgroundColorRGBA(0.08f, 0.09f, 0.11f, 1.f);
        gfx->clearScreen();
        gfx->drawTexturedRectRGBA(sceneTex, 0, 0, float(w), float(h), 1, 1, 1, 1);
        ao->applyOverlay(gfx, aoMap->getTexture());
        gfx->setCanvas();
        blitAndPresent(gfx, composed->getTexture());
        auditSwapchain(gfx, "postq", (std::string("ssao_") + q).c_str(), bg);
    }

    std::unique_ptr<Volumetric> vol(gfx->newVolumetric());
    vol->setCamera(0.f, 1.5f, 4.0f, 0.f, 0.15f, 0.f, 0.f, 1.f, 0.f, 60.f, float(w) / float(h), 0.05f,
                   40.f);
    vol->setFogColor(0.45f, 0.5f, 0.55f);
    vol->setFogHeight(-0.7f);
    vol->setFogHeightFalloff(0.8f);
    vol->setFogStart(1.2f);
    vol->setFogEnd(9.f);
    vol->setDensity(0.35f);
    vol->setMode("fog");
    for (const char *q : qualities) {
        vol->setQuality(q);
        gfx->setCanvas(composed);
        gfx->clearScreen();
        gfx->drawTexturedRectRGBA(sceneTex, 0, 0, float(w), float(h), 1, 1, 1, 1);
        vol->applyFog(gfx, depth);
        gfx->setCanvas();
        blitAndPresent(gfx, composed->getTexture());
        auditSwapchain(gfx, "postq", (std::string("fog_") + q).c_str(), bg);
    }

    vol->setMode("raymarch");
    vol->setLightDirection(0.45f, 1.f, 0.35f);
    vol->setLightScreenUV(0.62f, 0.28f);
    vol->setIntensity(0.8f);
    vol->setQuality("high");
    gfx->setCanvas(composed);
    gfx->clearScreen();
    gfx->drawTexturedRectRGBA(sceneTex, 0, 0, float(w), float(h), 1, 1, 1, 1);
    vol->rayMarch(gfx, depth);
    gfx->setCanvas();
    blitAndPresent(gfx, composed->getTexture());
    auditSwapchain(gfx, "postq", "raymarch_high", bg);

    rc->disable("gbuffer");
    rc->compile();
}

TEST_CASE("graphics.imageAudit.dualIsoFov") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    gfx->setBackgroundColor(Color(0.08f, 0.09f, 0.11f, 1.f));
    auto *map = eve::map::Map::create();
    Texture *tiles = makeAtlasGrid(gfx, 4, 8);
    auto *cam = Camera2D::createCamera();
    cam->setPosition(200.f, 150.f);
    cam->setZoom(1.f);

    auto presentMap = [&]() {
        gfx->setScreenReadbackEnabled(true);
        gfx->setBackgroundColorRGBA(0.08f, 0.09f, 0.11f, 1.f);
        gfx->clearScreen();
        map->render(gfx);
        gfx->present();
    };

    eve::map::TileLayer *ortho = map->newLayer(25, 19, 16.f, 16.f);
    ortho->setTileset(tiles, 1, 4);
    ortho->setTilesetTileSize(8, 8);
    ortho->setCamera(cam);
    for (int y = 0; y < 19; ++y)
        for (int x = 0; x < 25; ++x) ortho->setTile(x, y, 1 + (x + y) % 15);

    std::unique_ptr<eve::map::Fov> fov(map->newFov(ortho));
    REQUIRE(fov.get() != nullptr);
    fov->setRadiusMetric("chebyshev");
    for (int y = 0; y < 19; ++y) {
        if (y == 9) continue;
        fov->setOpaque(8, y, true);
        ortho->setTile(8, y, 2);
    }
    fov->addRevealer(4, 9, 10);

    auto paintFov = [&]() {
        for (int y = 0; y < 19; ++y) {
            for (int x = 0; x < 25; ++x) {
                const bool vis = fov->isVisible(x, y);
                ortho->setTile(x, y, vis ? (1 + (x + y) % 8) : (9 + (x * 3 + y) % 7));
            }
        }
    };
    fov->setAlgorithm("permissive");
    fov->compute();
    paintFov();
    presentMap();
    auditSwapchain(gfx, "dualiso", "fov_permissive", bg);

    fov->setAlgorithm("rectangle");
    fov->compute();
    paintFov();
    presentMap();
    auditSwapchain(gfx, "dualiso", "fov_rectangle", bg);
    ortho->setVisible(false);

    eve::map::TileLayer *logic = map->newLayer(16, 16, 32.f, 16.f);
    eve::map::TileLayer *display = map->newLayer(1, 1, 32.f, 16.f);
    logic->config()->orientation = eve::map::MapOrientation::Isometric;
    logic->config()->originX = 200.f;
    logic->config()->originY = 16.f;
    logic->setTileset(tiles, 1, 4);
    display->setTileset(tiles, 1, 4);
    display->setTilesetTileSize(8, 8);
    for (int y = 0; y < 16; ++y)
        for (int x = 0; x < 16; ++x) logic->setTile(x, y, ((x + y) % 3 == 0) ? 1 : 2);
    eve::map::DualGridOptions opts;
    opts.filledGid = 1;
    opts.hideLogic = true;
    REQUIRE(eve::map::resolveDualGrid(logic, display, opts, nullptr));
    display->setCamera(cam);
    makeSprite(makeSolid(gfx, 70, 90, 130), 0.f, 0.f, 400.f, 300.f, false)->sprite()->layer = -1;
    presentMap();
    auditSwapchain(gfx, "dualiso", "dual_isometric", bg);
}

TEST_CASE("graphics.imageAudit.avatarImage") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    gfx->setBackgroundColor(Color(0.08f, 0.09f, 0.11f, 1.f));
    auto *mod = eve::avatar::Avatar::create();
    REQUIRE(mod != nullptr);
    eve::avatar::AvatarInstance *av = mod->newImageAvatar();
    REQUIRE(av != nullptr);
    av->setPosition(0.f, 0.f);
    REQUIRE(av->addLayer("tl", makeSolid(gfx, 90, 140, 200), 0));
    REQUIRE(av->addLayer("tr", makeSolid(gfx, 200, 90, 70), 1));
    REQUIRE(av->addLayer("bl", makeSolid(gfx, 70, 180, 110), 2));
    REQUIRE(av->addLayer("br", makeSolid(gfx, 220, 200, 60), 3));
    av->setLayerSize("tl", 200.f, 150.f);
    av->setLayerSize("tr", 200.f, 150.f);
    av->setLayerSize("bl", 200.f, 150.f);
    av->setLayerSize("br", 200.f, 150.f);
    av->setLayerOffset("tr", 200.f, 0.f);
    av->setLayerOffset("bl", 0.f, 150.f);
    av->setLayerOffset("br", 200.f, 150.f);
    av->sync();
    auditGpu2D(gfx, "avatar", "layers_packed", bg);

    av->setLayerColor("tl", 0.95f, 0.35f, 0.25f, 1.f);
    av->setLayerColor("tr", 0.25f, 0.55f, 0.95f, 1.f);
    av->sync();
    auditGpu2D(gfx, "avatar", "recolor", bg);

    REQUIRE(av->defineExpression("flash", "tl=1;tr=1;bl=1;br=1"));
    REQUIRE(av->applyExpression("flash"));
    av->setLayerColor("bl", 0.95f, 0.85f, 0.2f, 1.f);
    av->setLayerColor("br", 0.7f, 0.3f, 0.9f, 1.f);
    av->sync();
    auditGpu2D(gfx, "avatar", "expression", bg);
}

TEST_CASE("graphics.imageAudit.avatarVroid") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    makeSprite(makeSolid(gfx, 180, 140, 70), 0.f, 0.f, 400.f, 84.f, false);
    studio.subject->setVisible(false);

    eve::ref<eve::model3d::ModelData> model(loadCesiumMan("ev_ut_image_audit_vroid"));
    REQUIRE(model.get() != nullptr);
    const int mi = findFirstSkinnedMesh(model.get());
    REQUIRE(mi >= 0);
    const aiMesh *src = model->getMesh(mi);
    REQUIRE(src != nullptr);
    Mesh *gpu = gfx->newMeshFromAssimp(*src);
    REQUIRE(gpu != nullptr);

    auto *mod = eve::avatar::Avatar::create();
    eve::avatar::AvatarInstance *av = mod->newVroidAvatar();
    REQUIRE(av != nullptr);
    REQUIRE(av->bindVroidModelData(model.get()));
    av->setMesh(gpu);
    av->setTexture(makeSolid(gfx, 200, 170, 120));
    av->setPosition3D(0.f, 0.f, 0.f);
    av->setRotation3D(1.2f, 0.f, 0.f);
    av->setScale3D(1.15f, 1.15f, 1.15f);
    studio.cam->setEye(0.f, 1.3f, 3.2f);
    studio.cam->setTarget(0.f, 0.7f, 0.f);
    studio.ground->setPosition(0.f, 0.f, 0.f);
    av->sync();
    auditGpuFrame(gfx, "vroid", "bind_pose", bg);
    av->setRotation3D(0.4f, 0.15f, 0.f);
    av->sync();
    auditGpuFrame(gfx, "vroid", "yaw_pitch", bg);
}

TEST_CASE("graphics.imageAudit.box2dDebug") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    gfx->setBackgroundColor(Color(0.08f, 0.09f, 0.11f, 1.f));
    makeSprite(makeSolid(gfx, 90, 140, 200), 0.f, 0.f, 200.f, 150.f, false);
    makeSprite(makeSolid(gfx, 200, 90, 70), 200.f, 0.f, 200.f, 150.f, false);
    makeSprite(makeSolid(gfx, 70, 180, 110), 0.f, 150.f, 200.f, 150.f, false);
    makeSprite(makeSolid(gfx, 220, 200, 60), 200.f, 150.f, 200.f, 150.f, false);

    auto *phys = eve::physics::Physics::create();
    std::unique_ptr<eve::physics::World> world(phys->newWorld(0.f, 0.f, true));
    REQUIRE(world.get() != nullptr);
    eve::physics::Body *ground = world->newBody("static", 200.f, 260.f);
    ground->newRectangleFixture(360.f, 40.f, 0.f, 0.4f, 0.f);
    eve::physics::Body *wallL = world->newBody("static", 30.f, 150.f);
    wallL->newRectangleFixture(40.f, 220.f, 0.f, 0.4f, 0.f);
    eve::physics::Body *wallR = world->newBody("static", 370.f, 150.f);
    wallR->newRectangleFixture(40.f, 220.f, 0.f, 0.4f, 0.f);
    eve::physics::Body *box = world->newBody("dynamic", 200.f, 80.f);
    box->newRectangleFixture(70.f, 70.f, 1.f, 0.3f, 0.1f);
    eve::physics::Body *ball = world->newBody("dynamic", 120.f, 60.f);
    ball->newCircleFixture(28.f, 1.f, 0.2f, 0.4f);
    world->setGravity(0.f, 600.f);
    for (int i = 0; i < 20; ++i) world->update(1.f / 60.f);

    auto presentDebug = [&]() {
        gfx->setScreenReadbackEnabled(true);
        gfx->setBackgroundColorRGBA(0.08f, 0.09f, 0.11f, 1.f);
        gfx->clearScreen();
        std::vector<DrawItem2D> items;
        RenderSystem::collectSprites(items);
        RenderSystem::drawItems(*gfx, items, false);
        world->drawDebug(gfx);
        gfx->present();
    };
    presentDebug();
    auditSwapchain(gfx, "box2d", "debug_draw", bg);
}

TEST_CASE("graphics.imageAudit.imageRotate") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    gfx->setBackgroundColor(Color(0.08f, 0.09f, 0.11f, 1.f));
    [[maybe_unused]] auto *const imageModule = eve::image::Image::create();
    ImageData src(64, 64, "RGBA8");
    auto *px = static_cast<uint8_t *>(src.getData());
    for (int y = 0; y < 64; ++y) {
        for (int x = 0; x < 64; ++x) {
            const bool on = ((x / 8) + (y / 8)) & 1;
            const size_t i = size_t((y * 64 + x) * 4);
            px[i + 0] = on ? 220 : 50;
            px[i + 1] = on ? 90 : 180;
            px[i + 2] = on ? 70 : 210;
            px[i + 3] = 255;
        }
    }

    std::unique_ptr<ImageData> rot90(src.rotate(1.5707963f, "nearest", true));
    REQUIRE(rot90.get() != nullptr);
    Texture *t90 = gfx->newTexture(rot90.get());
    auto *full = makeSprite(t90, 0.f, 0.f, 400.f, 300.f, false);
    auditGpu2D(gfx, "imrotate", "nearest_90", bg);

    std::unique_ptr<ImageData> rotSprite(src.rotate(1.5707963f, "rotsprite", true));
    REQUIRE(rotSprite.get() != nullptr);
    full->sprite()->texture = gfx->newTexture(rotSprite.get());
    auditGpu2D(gfx, "imrotate", "rotsprite_90", bg);

    makeSprite(makeSolid(gfx, 90, 140, 200), 0.f, 0.f, 200.f, 150.f, false);
    makeSprite(makeSolid(gfx, 200, 90, 70), 200.f, 0.f, 200.f, 150.f, false);
    makeSprite(makeSolid(gfx, 70, 180, 110), 0.f, 150.f, 200.f, 150.f, false);
    makeSprite(makeSolid(gfx, 220, 200, 60), 200.f, 150.f, 200.f, 150.f, false);
    full->sprite()->visible = false;
    std::unique_ptr<ImageData> rot45(src.rotate(0.78539816f, "linear", true));
    REQUIRE(rot45.get() != nullptr);
    makeSprite(gfx->newTexture(rot45.get()), 80.f, 50.f, 240.f, 200.f, false);
    auditGpu2D(gfx, "imrotate", "linear_45", bg);

    auto *cam = Camera2D::createCamera();
    cam->setPosition(200.f, 150.f);
    cam->setZoom(1.f);
    Texture *bigTex = gfx->newTexture(&src);
    auto *big = makeSprite(bigTex, 0.f, 0.f, 800.f, 600.f, false);
    big->sprite()->camera = cam;
    big->sprite()->layer = 50;
    auditGpu2D(gfx, "imrotate", "cam_pan_tl", bg);
    cam->setPosition(400.f, 250.f);
    auditGpu2D(gfx, "imrotate", "cam_pan_mid", bg);
}

TEST_CASE("graphics.imageAudit.sceneGraph") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    auto studio = makeStudio3D(gfx);
    makeSprite(makeSolid(gfx, 180, 140, 70), 0.f, 0.f, 400.f, 84.f, false);

    auto hostResult = eve::scene::SceneHost::createHost("audit3d");
    REQUIRE(hostResult.ok());
    eve::scene::SceneHost *host = hostResult.value();
    REQUIRE(host != nullptr);
    host->setTree(eve::scene::node(
        "root", {eve::scene::node("subject").withPosition(0.f, 0.15f, 0.f).withScale(0.55f)}));
    REQUIRE(host->linkRenderable3D("subject", studio.subject));
    eve::scene::TransformSystem::updateHost(host);
    auditGpuFrame(gfx, "scene", "linked_rest", bg);

    host->setTreeReconcile(eve::scene::node(
        "root", {eve::scene::node("subject")
                     .withPosition(0.7f, 0.2f, 0.f)
                     .withRotation(0.8f, 0.15f, 0.f)
                     .withScale(0.6f)}));
    eve::scene::TransformSystem::updateHost(host);
    auditGpuFrame(gfx, "scene", "linked_moved", bg);

    auto *left = Renderable3D::create();
    left->setMesh(studio.sphere);
    left->setTexture(makeSolid(gfx, 210, 90, 80));
    left->setCastShadow(true);
    host->setTree(eve::scene::node("root",
                                   {eve::scene::node("subject").withPosition(0.5f, 0.15f, 0.f).withScale(0.45f),
                                    eve::scene::node("left").withPosition(-1.0f, 0.2f, 0.f).withScale(0.4f)}));
    REQUIRE(host->linkRenderable3D("subject", studio.subject));
    REQUIRE(host->linkRenderable3D("left", left));
    eve::scene::TransformSystem::updateHost(host);
    auditGpuFrame(gfx, "scene", "two_nodes", bg);
}

TEST_CASE("graphics.imageAudit.fovHeightHex") {
    auto *win = eve::window::Window::create();
    auto *gfx = Graphics::create();
    REQUIRE(win != nullptr);
    REQUIRE(gfx != nullptr);
    eve::window::WindowSettings s;
    s.width = 400;
    s.height = 300;
    s.centered = true;
    REQUIRE(win->setWindowSettings(s));
    CloseWin closer{win};
    resetScene3D();

    RenderAuditBg bg{0.08f, 0.09f, 0.11f};
    gfx->setBackgroundColor(Color(0.08f, 0.09f, 0.11f, 1.f));
    auto *map = eve::map::Map::create();
    Texture *tiles = makeAtlasGrid(gfx, 4, 8);
    auto *cam = Camera2D::createCamera();
    cam->setPosition(200.f, 150.f);
    cam->setZoom(1.f);

    auto presentMap = [&]() {
        gfx->setScreenReadbackEnabled(true);
        gfx->setBackgroundColorRGBA(0.08f, 0.09f, 0.11f, 1.f);
        gfx->clearScreen();
        map->render(gfx);
        gfx->present();
    };

    eve::map::TileLayer *ortho = map->newLayer(25, 19, 16.f, 16.f);
    ortho->setTileset(tiles, 1, 4);
    ortho->setTilesetTileSize(8, 8);
    ortho->setCamera(cam);
    for (int y = 0; y < 19; ++y)
        for (int x = 0; x < 25; ++x) ortho->setTile(x, y, 1 + (x + y) % 15);

    std::unique_ptr<eve::map::Fov> fov(map->newFov(ortho));
    REQUIRE(fov.get() != nullptr);
    fov->setMode("heightmap");
    fov->setRadiusMetric("chebyshev");
    fov->setCliffBlock(1.f);
    fov->setEyeOffset(0.f);
    for (int y = 0; y < 19; ++y) fov->setElevation(10, y, 2.f);
    fov->addRevealer(3, 9, 12);
    fov->compute();
    for (int y = 0; y < 19; ++y) {
        for (int x = 0; x < 25; ++x) {
            const bool vis = fov->isVisible(x, y);
            ortho->setTile(x, y, vis ? (1 + (x + y) % 8) : (9 + (x * 3 + y) % 7));
        }
    }
    presentMap();
    auditSwapchain(gfx, "fovmore", "heightmap", bg);
    ortho->setVisible(false);

    eve::map::TileLayer *hex = map->newLayer(18, 16, 32.f, 28.f);
    hex->config()->orientation = eve::map::MapOrientation::Hexagonal;
    hex->config()->hexSideLength = 16.f;
    hex->config()->originX = 16.f;
    hex->config()->originY = 8.f;
    hex->setTileset(tiles, 1, 4);
    hex->setTilesetTileSize(8, 8);
    hex->setCamera(cam);
    for (int y = 0; y < 16; ++y)
        for (int x = 0; x < 18; ++x) hex->setTile(x, y, 1 + (x * 3 + y) % 15);
    fov->bindLayer(hex);
    fov->setMode("grid2d");
    fov->setTopology("hex");
    fov->setAlgorithm("shadowcast");
    fov->clearRevealers();
    fov->addRevealer(4, 6, 8);
    fov->compute();
    for (int y = 0; y < 16; ++y) {
        for (int x = 0; x < 18; ++x) {
            const bool vis = fov->isVisible(x, y);
            hex->setTile(x, y, vis ? (1 + (x + y) % 8) : (9 + (x * 3 + y) % 7));
        }
    }
    makeSprite(makeSolid(gfx, 70, 90, 130), 0.f, 0.f, 400.f, 300.f, false)->sprite()->layer = -1;
    presentMap();
    auditSwapchain(gfx, "fovmore", "hex_topology", bg);
}