Function AUTO_STATIC_ARRAY

engine/PoseidonGL33/TextureGL33_Init.cpp:279–511

    PacLevelMem mip = _mipmaps[level];

    AUTO_STATIC_ARRAY(char, mem, 256 * 256 * 2);
    mem.Realloc(mip._pitch * mip._h);
    mem.Resize(mip._pitch * mip._h);

    _src->GetMipmapData(mem.Data(), mip, level);

    if (_interpolate)
    {
        AUTO_STATIC_ARRAY(char, imem, 256 * 256 * 2);
        PacLevelMem& imip = _interpolate->_mipmaps[level];
        imem.Realloc(imip._pitch * imip._h);
        imem.Resize(imip._pitch * imip._h);
        _interpolate->_src->GetMipmapData(imem.Data(), imip, level);
        icol = imip.GetPixel(imem.Data(), u, v);
    }
    Color col = mip.GetPixel(mem.Data(), u, v);
    if (_interpolate)
    {
        col = col * (1 - _iFactor) + icol * _iFactor;
    }
    return col;
}

// Decode the top (full-resolution) mip once and classify its alpha channel.
// Reads the texture's bytes through the VFS (so it works for PBO-packed textures) and
// decodes via the shared DecodePAABuffer, which handles every PAA/PAC pixel format
// (DXT1/3/5, ARGB8888/4444/1555, AI88, P8) — unlike PacLevelMem::GetPixelInt, which
// only covers a subset and would Fail per texel on the rest. Top mip on purpose: a
// smaller mip blurs a cutout's crisp 0/255 holes into false partial-alpha, which would
// mis-route a pole/fence to the blend pass.
Poseidon::AlphaStats::Kind TextureGL33::ScanTopMipAlphaClass()
{
    LoadHeadersNV();
    if (!_src)
        return Poseidon::AlphaStats::Opaque;

    QIFStream in;
    GFileServer->Open(in, Name());
    const int size = in.fail() ? 0 : in.rest();
    if (size <= 0)
        return Poseidon::AlphaStats::Opaque;

    AUTO_STATIC_ARRAY(char, fileData, 256 * 1024);
    fileData.Realloc(size);
    fileData.Resize(size);
    in.read(fileData.Data(), size);

    const char* name = Name();
    const size_t len = name ? strlen(name) : 0;
    const bool isPaa = len >= 4 && (name[len - 1] == 'a' || name[len - 1] == 'A'); // .paa vs .pac

    const Poseidon::DecodedImage img = Poseidon::DecodePAABuffer(fileData.Data(), static_cast<size_t>(size), isPaa);
    if (!img.valid())
        return Poseidon::AlphaStats::Opaque;

    return Poseidon::ClassifyAlpha(img.rgba.data(), static_cast<size_t>(img.width) * static_cast<size_t>(img.height))
        .kind;
}