Function RenderCascadeArray

engine/PoseidonGL33/EngineGL33_ShadowDepth.cpp:315–400

Render the casters into each cascade layer of the depth array, once per cascade with that cascade's light-VP: solid triangles with the depth-only program, then the alpha-cutout batches with the texture-alpha-discard program (one bind per caster texture). Depth/clear go through the Core bundles so the GL-state audits stay green; ApplyPipeline re-owns depth/cull/texture on the next draw.

// caster texture). Depth/clear go through the Core bundles so the GL-state audits
// stay green; ApplyPipeline re-owns depth/cull/texture on the next draw.
bool RenderCascadeArray(void* glContext, const float* lightVPs, int numCascades, int res, const float* solidXYZ,
                        int solidVertCount, const float* alphaXYZUV, int alphaVertCount,
                        const ResolvedAlphaBatch* batches, int batchCount)
{
    const bool haveSolid = solidXYZ && solidVertCount >= 3;
    const bool haveAlpha = alphaXYZUV && alphaVertCount >= 3 && batches && batchCount > 0;
    if (!glContext || !lightVPs || res <= 0 || numCascades < 1 || (!haveSolid && !haveAlpha))
        return false;
    if (!EnsureProgram() || !EnsureArrayTarget(res, numCascades) || !EnsureMesh())
        return false;
    if (haveAlpha && (!EnsureAlphaProgram() || !EnsureAlphaMesh()))
        return false;

    GLint prevFBO = 0, prevProg = 0, prevVAO = 0, prevArrayBuf = 0;
    GLint prevVP[4] = {0, 0, 0, 0};
    glGetIntegerv(GL_FRAMEBUFFER_BINDING, &prevFBO);
    glGetIntegerv(GL_CURRENT_PROGRAM, &prevProg);
    glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &prevVAO);
    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &prevArrayBuf);
    glGetIntegerv(GL_VIEWPORT, prevVP);

    glBindFramebuffer(GL_FRAMEBUFFER, s_arrFbo);
    glViewport(0, 0, res, res);
    Poseidon::render::depthstencil::Normal(/*hasStencil*/ false);
    Poseidon::render::cull::None();

    // Upload the (cascade-invariant) geometry once; only the light-VP changes per layer.
    if (haveSolid)
    {
        GL33Bind::Vao(s_vao);
        glBindBuffer(GL_ARRAY_BUFFER, s_vbo);
        glBufferData(GL_ARRAY_BUFFER, static_cast<GLsizeiptr>(solidVertCount) * 3 * sizeof(float), solidXYZ,
                     GL_DYNAMIC_DRAW);
    }
    if (haveAlpha)
    {
        GL33Bind::Vao(s_alphaVao);
        glBindBuffer(GL_ARRAY_BUFFER, s_alphaVbo);
        glBufferData(GL_ARRAY_BUFFER, static_cast<GLsizeiptr>(alphaVertCount) * 5 * sizeof(float), alphaXYZUV,
                     GL_DYNAMIC_DRAW);
    }

    glClearDepth(1.0);
    for (int i = 0; i < numCascades; i++)
    {
        glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, s_arrTex, 0, i);
        Poseidon::render::clear::WithMask(GL_DEPTH_BUFFER_BIT);

        if (haveSolid)
        {
            // Store the BACK faces (cull front): a lit front-facing surface is then
            // strictly nearer the light than the stored depth, so it cannot
            // self-shadow — kills the soldier's self-shadow acne/animation flicker
            // and lets the bias stay tiny (no peter-panning / shadows vanishing up
            // close). ApplyPipeline re-owns cull on the next draw.
            Poseidon::render::cull::Front();
            glUseProgram(s_prog);
            glUniformMatrix4fv(s_locVP, 1, GL_FALSE, lightVPs + i * 16);