squad-proto/src/render/lighting.cpp

#include "render/lighting.h"
#include "engine/projection.h"

namespace
{

inline float Smooth01(float t)
{
    if (t <= 0.0f) return 0.0f;
    if (t >= 1.0f) return 1.0f;
    return t * t * (3.0f - 2.0f * t);
}

// Плавное падение с 1 до 0 на отрезке [lo, hi].
inline float FadeOut(float x, float lo, float hi)
{
    if (hi <= lo) return x <= lo ? 1.0f : 0.0f;
    return 1.0f - Smooth01((x - lo) / (hi - lo));
}

}   // namespace

void Lighting::Reset()
{
    for (int i = 0; i < MAP_W * MAP_H; ++i)
    {
        vis[i] = 0.0f;
        mem[i] = 0.0f;
        dyn[i] = 0.0f;
        tile[i] = 0.0f;
    }
    for (int i = 0; i < (MAP_W + 1) * (MAP_H + 1); ++i) corner[i] = 0.0f;
    flashCount = 0;
    eventCursor = 0;
}

void Lighting::Ingest(const CombatEventLog& log, const Agent* agents, int agentCount)
{
    // Кольцо: если за кадр событий больше ёмкости, старые честно потеряны.
    uint32_t from = eventCursor;
    if (log.head > from + COMBAT_EVENT_CAP) from = log.head - COMBAT_EVENT_CAP;

    for (uint32_t i = from; i < log.head; ++i)
    {
        const CombatEvent& e = log.buf[i % COMBAT_EVENT_CAP];

        // Параметры вспышки берутся с оружия стрелявшего, если оно известно.
        const bool ownerKnown = (e.owner >= 0 && e.owner < agentCount);
        const float ownPower = ownerKnown ? agents[e.owner].gun.def.flashPower : g_tune.flashPower;
        const float ownRadius = ownerKnown ? agents[e.owner].gun.def.flashRadius : g_tune.flashRadius;

        float power = 0.0f;
        switch (e.kind)
        {
            case CombatEventKind::SHOT:       power = ownPower; break;
            case CombatEventKind::HIT_WALL:   power = g_tune.flashPower * 0.45f; break;
            case CombatEventKind::HIT_TARGET: power = g_tune.flashPower * 0.35f; break;
            case CombatEventKind::HIT_KILL:   power = g_tune.flashPower * 0.9f; break;
            // Клинок не даёт дульной вспышки, но искры от удара в упор освещают
            // не хуже — иначе весь ближний бой идёт в кромешной темноте.
            case CombatEventKind::MELEE_SWING: power = g_tune.flashPower * 0.22f; break;
            case CombatEventKind::MELEE_HIT:   power = g_tune.flashPower * 0.75f; break;
            default: break;
        }
        if (power <= 0.0f) continue;

        if (flashCount < LIGHT_FLASH_MAX)
            flashes[flashCount++] = LightFlash{e.pos, power, g_tune.flashTime,
                                               (e.kind == CombatEventKind::SHOT)
                                                   ? ownRadius : g_tune.flashRadius};
    }
    eventCursor = log.head;
}

void Lighting::Update(const Agent* agents, int count, const Tilemap& map, float dt)
{
    static float visRaw[MAP_W * MAP_H];

    if (!enabled)
    {
        // Аварийный тумблер: всё видно, память полная, вспышек нет.
        for (int i = 0; i < MAP_W * MAP_H; ++i) { vis[i] = 1.0f; mem[i] = 1.0f; dyn[i] = 0.0f; }
        for (int i = 0; i < MAP_W * MAP_H; ++i) tile[i] = 1.0f;
        for (int cy = 0; cy <= MAP_H; ++cy)
            for (int cx = 0; cx <= MAP_W; ++cx) corner[cy * (MAP_W + 1) + cx] = 1.0f;
        return;
    }

    for (int i = 0; i < MAP_W * MAP_H; ++i) visRaw[i] = 0.0f;

    // --- 1. видимость пола от каждого агента ---------------------------------
    const float coneHalf = g_tune.sightConeDeg * 0.5f * DEG2RAD_F;
    const float coneSoft = g_tune.sightConeSoftDeg * DEG2RAD_F;

    for (int a = 0; a < count; ++a)
    {
        const Agent& ag = agents[a];
        if (!ag.alive) continue;   // павший больше не смотрит по сторонам

        // Радиус обзора СВОЙ у каждого бойца: фонарь в кармане светит дальше,
        // саван — ближе (sim/items.h). Без этого экран отряда показывал бы
        // «SIGHT 135%», за которым ничего не стоит.
        // Глубина сжимает обзор ВСЕМ одинаково, поверх личного множителя:
        // фонарь на двадцатом этаже по-прежнему лучше савана, просто оба
        // светят хуже, чем на первом.
        const float mul = ag.sightMul * sightScale;
        const float rFull = g_tune.sightFullRadius * mul;
        const float rMax  = std::max(rFull + 0.01f, g_tune.sightRadius * mul);
        const float personal = g_tune.sightPersonalRadius * mul;

        const int x0 = std::max(0, int(std::floor(ag.pos.x - rMax)));
        const int x1 = std::min(MAP_W - 1, int(std::floor(ag.pos.x + rMax)));
        const int y0 = std::max(0, int(std::floor(ag.pos.y - rMax)));
        const int y1 = std::min(MAP_H - 1, int(std::floor(ag.pos.y + rMax)));

        for (int ty = y0; ty <= y1; ++ty)
        {
            for (int tx = x0; tx <= x1; ++tx)
            {
                if (map.IsWall(tx, ty)) continue;   // стены освещаются отдельно

                const Vec2 c{tx + 0.5f, ty + 0.5f};
                const Vec2 d = c - ag.pos;
                const float dist = Length(d);
                if (dist > rMax) continue;

                const float fd = FadeOut(dist, rFull, rMax);
                if (fd <= 0.0f) continue;

                // Конус по направлению взгляда + круговой «личный» ореол рядом.
                // max, а не сумма: ореол дырявит конус вблизи, но не удваивает свет.
                const float ang = std::fabs(AngleDiff(ag.facing, AngleOf(d)));
                const float fc = FadeOut(ang, coneHalf, coneHalf + coneSoft);
                const float fp = FadeOut(dist, personal * 0.6f, personal);
                const float v = fd * std::max(fc, fp);
                if (v <= 0.0f) continue;

                const int idx = ty * MAP_W + tx;
                if (v <= visRaw[idx]) continue;              // уже ярче — рейкаст не нужен
                if (map.RaycastBlocked(ag.pos, c)) continue; // стена перекрыла обзор
                visRaw[idx] = v;
            }
        }
    }

    // --- 2. свет протекает в стены ------------------------------------------
    // Стену нельзя проверить лучом до её центра: DDA считает попадание в саму
    // стену перекрытием. Поэтому стена берёт максимум от соседей.
    for (int pass = 0; pass < WALL_LIGHT_PASSES; ++pass)
    {
        for (int ty = 0; ty < MAP_H; ++ty)
        {
            for (int tx = 0; tx < MAP_W; ++tx)
            {
                if (!map.IsWall(tx, ty)) continue;
                float best = 0.0f;
                for (int oy = -1; oy <= 1; ++oy)
                    for (int ox = -1; ox <= 1; ++ox)
                    {
                        if (ox == 0 && oy == 0) continue;
                        const int nx = tx + ox, ny = ty + oy;
                        if (!Tilemap::InBounds(nx, ny)) continue;
                        best = std::max(best, visRaw[ny * MAP_W + nx]);
                    }
                const int idx = ty * MAP_W + tx;
                visRaw[idx] = std::max(visRaw[idx], best * g_tune.fogWallBleed);
            }
        }
    }

    // --- 3. временное сглаживание, чтобы свет не щёлкал ----------------------
    const float k = 1.0f - std::exp(-g_tune.fogFadeRate * dt);
    for (int i = 0; i < MAP_W * MAP_H; ++i)
        vis[i] += (visRaw[i] - vis[i]) * k;

    // --- 4. динамический свет от вспышек -------------------------------------
    for (int i = 0; i < MAP_W * MAP_H; ++i) dyn[i] = 0.0f;

    for (int i = 0; i < flashCount;)
    {
        LightFlash& f = flashes[i];
        f.life -= dt;
        if (f.life <= 0.0f)
        {
            flashes[i] = flashes[--flashCount];
            continue;
        }

        const float t = Clampf(f.life / std::max(0.001f, g_tune.flashTime), 0.0f, 1.0f);
        const float amp = f.power * t * t;   // резкий спад, вспышка короткая
        const float rad = f.radius;

        const int x0 = std::max(0, int(std::floor(f.pos.x - rad)));
        const int x1 = std::min(MAP_W - 1, int(std::floor(f.pos.x + rad)));
        const int y0 = std::max(0, int(std::floor(f.pos.y - rad)));
        const int y1 = std::min(MAP_H - 1, int(std::floor(f.pos.y + rad)));

        for (int ty = y0; ty <= y1; ++ty)
            for (int tx = x0; tx <= x1; ++tx)
            {
                const Vec2 c{tx + 0.5f, ty + 0.5f};
                const float dist = Distance(f.pos, c);
                if (dist > rad) continue;
                const float fall = FadeOut(dist, rad * 0.15f, rad);
                if (fall <= 0.0f) continue;
                // Вспышка не светит сквозь стены (сама стена подсвечивается).
                if (!map.IsWall(tx, ty) && map.RaycastBlocked(f.pos, c)) continue;
                const int idx = ty * MAP_W + tx;
                dyn[idx] = std::max(dyn[idx], amp * fall);
            }
        ++i;
    }

    // --- 5. память карты и сборка итогового уровня ---------------------------
    for (int i = 0; i < MAP_W * MAP_H; ++i)
    {
        const float seen = vis[i];
        if (seen > 0.02f) mem[i] = std::max(mem[i], g_tune.fogMemoryLevel);

        float lvl = std::max(mem[i], seen * g_tune.sightBrightness) + dyn[i];
        tile[i] = Clampf(lvl, 0.0f, 1.0f);
    }

    // --- 6. узловая сетка: узел = среднее смежных тайлов ----------------------
    for (int cy = 0; cy <= MAP_H; ++cy)
    {
        for (int cx = 0; cx <= MAP_W; ++cx)
        {
            float sum = 0.0f;
            int n = 0;
            for (int oy = -1; oy <= 0; ++oy)
                for (int ox = -1; ox <= 0; ++ox)
                {
                    const int tx = cx + ox, ty = cy + oy;
                    if (!Tilemap::InBounds(tx, ty)) continue;
                    sum += tile[ty * MAP_W + tx];
                    ++n;
                }
            corner[cy * (MAP_W + 1) + cx] = (n > 0) ? (sum / float(n)) : 0.0f;
        }
    }
}

float Lighting::LightAt(Vec2 world) const
{
    const float fx = Clampf(world.x, 0.0f, float(MAP_W) - 0.001f);
    const float fy = Clampf(world.y, 0.0f, float(MAP_H) - 0.001f);
    const int cx = int(fx);
    const int cy = int(fy);
    const float u = fx - float(cx);
    const float v = fy - float(cy);

    const int stride = MAP_W + 1;
    const float c00 = corner[cy * stride + cx];
    const float c10 = corner[cy * stride + cx + 1];
    const float c01 = corner[(cy + 1) * stride + cx];
    const float c11 = corner[(cy + 1) * stride + cx + 1];

    return c00 * (1 - u) * (1 - v) + c10 * u * (1 - v) + c01 * (1 - u) * v + c11 * u * v;
}

float Lighting::MaxCornerOf(int tx, int ty) const
{
    if (!Tilemap::InBounds(tx, ty)) return 0.0f;
    const int stride = MAP_W + 1;
    const float c00 = corner[ty * stride + tx];
    const float c10 = corner[ty * stride + tx + 1];
    const float c01 = corner[(ty + 1) * stride + tx];
    const float c11 = corner[(ty + 1) * stride + tx + 1];
    return std::max(std::max(c00, c10), std::max(c01, c11));
}

ShadeQuad Lighting::QuadFor(int tx, int ty, int clampRow) const
{
    const int stride = MAP_W + 1;
    const float c00 = corner[ty * stride + tx];                 // верх ромба,   спрайт (16,0)
    const float c10 = corner[ty * stride + tx + 1];             // право,        спрайт (32,8)
    const float c01 = corner[(ty + 1) * stride + tx];           // лево,         спрайт (0,8)
    const float c11 = corner[(ty + 1) * stride + tx + 1];       // низ,          спрайт (16,16)

    const float Bu = c10 - c00;
    const float Bv = c01 - c00;
    const float K  = c00 - c10 - c01 + c11;

    const float tw = float(g_proj.tileW);
    const float th = float(g_proj.tileH);

    ShadeQuad q;
    q.clampRow = clampRow;

    if (g_proj.mode == ViewMode::TOP_DOWN)
    {
        // Плита — квадрат, углы лежат по сторонам света: c00 в (0,0), c10 в
        // (tw,0), c01 в (0,th). Косой член K тут остался бы честным слагаемым
        // u*v, а ShadeQuad такого не умеет — у неё только px, py, px^2, py^2.
        // Поэтому он отбрасывается: на тайле в 32 пикселя это доли ступени
        // рампы, а размен на лишний член в горячем блите того не стоит.
        q.a = c00;
        q.b = Bu / tw;
        q.c = Bv / th;
        return q;
    }

    // Изометрия: те же четыре угла попадают в вершины ромба, и билинейка,
    // записанная в координатах спрайта, честно раскладывается по этим членам —
    // поэтому на общем ребре соседних тайлов значения совпадают и швов нет.
    q.a = c00 - (Bu - Bv) * 0.5f - K * 0.25f;
    q.b = (Bu - Bv + K) / tw;
    q.c = (Bu + Bv) / th;
    q.e = -K / (tw * tw);
    q.f =  K / (th * th);
    return q;
}