path: root/video/out/opengl/shader_cache.c

#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <assert.h>

#include <libavutil/sha.h>
#include <libavutil/intreadwrite.h>
#include <libavutil/mem.h>

#include "osdep/io.h"

#include "common/common.h"
#include "options/path.h"
#include "stream/stream.h"
#include "shader_cache.h"
#include "formats.h"
#include "ra_gl.h"
#include "gl_utils.h"

// Force cache flush if more than this number of shaders is created.
#define SC_MAX_ENTRIES 48

enum uniform_type {
    UT_invalid,
    UT_i,
    UT_f,
    UT_m,
};

union uniform_val {
    GLfloat f[9];
    GLint i[4];
};

struct sc_uniform {
    char *name;
    enum uniform_type type;
    const char *glsl_type;
    int size;
    GLint loc;
    union uniform_val v;
    // Set for sampler uniforms.
    GLenum tex_target;
    GLuint tex_handle;
    // Set for image uniforms
    GLuint img_handle;
    GLenum img_access;
    GLenum img_iformat;
};

struct sc_buffer {
    char *name;
    char *format;
    GLuint binding;
    GLuint ssbo;
};

struct sc_cached_uniform {
    GLint loc;
    union uniform_val v;
};

struct sc_entry {
    GLuint gl_shader;
    struct sc_cached_uniform *uniforms;
    int num_uniforms;
    bstr frag;
    bstr vert;
    bstr comp;
    struct gl_timer *timer;
    struct gl_vao vao;
};

struct gl_shader_cache {
    GL *gl;
    struct mp_log *log;

    // permanent
    char **exts;
    int num_exts;

    // this is modified during use (gl_sc_add() etc.) and reset for each shader
    bstr prelude_text;
    bstr header_text;
    bstr text;
    int next_texture_unit;
    int next_image_unit;
    int next_buffer_binding;
    struct gl_vao *vao; // deprecated

    struct sc_entry *entries;
    int num_entries;

    struct sc_entry *current_shader; // set by gl_sc_generate()

    struct sc_uniform *uniforms;
    int num_uniforms;
    struct sc_buffer *buffers;
    int num_buffers;

    const struct gl_vao_entry *vertex_entries;
    size_t vertex_size;

    // For checking that the user is calling gl_sc_reset() properly.
    bool needs_reset;

    bool error_state; // true if an error occurred

    // temporary buffers (avoids frequent reallocations)
    bstr tmp[5];

    // For the disk-cache.
    char *cache_dir;
    struct mpv_global *global; // can be NULL
};

struct gl_shader_cache *gl_sc_create(GL *gl, struct mp_log *log)
{
    struct gl_shader_cache *sc = talloc_ptrtype(NULL, sc);
    *sc = (struct gl_shader_cache){
        .gl = gl,
        .log = log,
    };
    gl_sc_reset(sc);
    return sc;
}

// Reset the previous pass. This must be called after
// Unbind all GL state managed by sc - the current program and texture units.
void gl_sc_reset(struct gl_shader_cache *sc)
{
    GL *gl = sc->gl;

    if (sc->needs_reset) {
        gl_timer_stop(gl);
        gl->UseProgram(0);

        for (int n = 0; n < sc->num_uniforms; n++) {
            struct sc_uniform *u = &sc->uniforms[n];
            if (u->type == UT_i && u->tex_target) {
                gl->ActiveTexture(GL_TEXTURE0 + u->v.i[0]);
                gl->BindTexture(u->tex_target, 0);
            }
            if (u->type == UT_i && u->img_access) {
                gl->BindImageTexture(u->v.i[0], 0, 0, GL_FALSE, 0,
                                     u->img_access, u->img_iformat);
            }
        }
        gl->ActiveTexture(GL_TEXTURE0);

        for (int n = 0; n < sc->num_buffers; n++) {
            struct sc_buffer *b = &sc->buffers[n];
            gl->BindBufferBase(GL_SHADER_STORAGE_BUFFER, b->binding, 0);
        }
    }

    sc->prelude_text.len = 0;
    sc->header_text.len = 0;
    sc->text.len = 0;
    for (int n = 0; n < sc->num_uniforms; n++)
        talloc_free(sc->uniforms[n].name);
    sc->num_uniforms = 0;
    for (int n = 0; n < sc->num_buffers; n++) {
        talloc_free(sc->buffers[n].name);
        talloc_free(sc->buffers[n].format);
    }
    sc->num_buffers = 0;
    sc->next_texture_unit = 1; // not 0, as 0 is "free for use"
    sc->next_image_unit = 1;
    sc->next_buffer_binding = 1;
    sc->vertex_entries = NULL;
    sc->vertex_size = 0;
    sc->current_shader = NULL;
    sc->needs_reset = false;
}

static void sc_flush_cache(struct gl_shader_cache *sc)
{
    MP_VERBOSE(sc, "flushing shader cache\n");

    for (int n = 0; n < sc->num_entries; n++) {
        struct sc_entry *e = &sc->entries[n];
        sc->gl->DeleteProgram(e->gl_shader);
        talloc_free(e->vert.start);
        talloc_free(e->frag.start);
        talloc_free(e->comp.start);
        talloc_free(e->uniforms);
        gl_timer_free(e->timer);
        gl_vao_uninit(&e->vao);
    }
    sc->num_entries = 0;
}

void gl_sc_destroy(struct gl_shader_cache *sc)
{
    if (!sc)
        return;
    gl_sc_reset(sc);
    sc_flush_cache(sc);
    talloc_free(sc);
}

bool gl_sc_error_state(struct gl_shader_cache *sc)
{
    return sc->error_state;
}

void gl_sc_reset_error(struct gl_shader_cache *sc)
{
    sc->error_state = false;
}

void gl_sc_enable_extension(struct gl_shader_cache *sc, char *name)
{
    for (int n = 0; n < sc->num_exts; n++) {
        if (strcmp(sc->exts[n], name) == 0)
            return;
    }
    MP_TARRAY_APPEND(sc, sc->exts, sc->num_exts, talloc_strdup(sc, name));
}

#define bstr_xappend0(sc, b, s) bstr_xappend(sc, b, bstr0(s))

void gl_sc_add(struct gl_shader_cache *sc, const char *text)
{
    bstr_xappend0(sc, &sc->text, text);
}

void gl_sc_addf(struct gl_shader_cache *sc, const char *textf, ...)
{
    va_list ap;
    va_start(ap, textf);
    bstr_xappend_vasprintf(sc, &sc->text, textf, ap);
    va_end(ap);
}

void gl_sc_hadd(struct gl_shader_cache *sc, const char *text)
{
    bstr_xappend0(sc, &sc->header_text, text);
}

void gl_sc_haddf(struct gl_shader_cache *sc, const char *textf, ...)
{
    va_list ap;
    va_start(ap, textf);
    bstr_xappend_vasprintf(sc, &sc->header_text, textf, ap);
    va_end(ap);
}

void gl_sc_hadd_bstr(struct gl_shader_cache *sc, struct bstr text)
{
    bstr_xappend(sc, &sc->header_text, text);
}

void gl_sc_paddf(struct gl_shader_cache *sc, const char *textf, ...)
{
    va_list ap;
    va_start(ap, textf);
    bstr_xappend_vasprintf(sc, &sc->prelude_text, textf, ap);
    va_end(ap);
}

static struct sc_uniform *find_uniform(struct gl_shader_cache *sc,
                                       const char *name)
{
    for (int n = 0; n < sc->num_uniforms; n++) {
        if (strcmp(sc->uniforms[n].name, name) == 0)
            return &sc->uniforms[n];
    }
    // not found -> add it
    struct sc_uniform new = {
        .loc = -1,
        .name = talloc_strdup(NULL, name),
    };
    MP_TARRAY_APPEND(sc, sc->uniforms, sc->num_uniforms, new);
    return &sc->uniforms[sc->num_uniforms - 1];
}

static struct sc_buffer *find_buffer(struct gl_shader_cache *sc,
                                     const char *name)
{
    for (int n = 0; n < sc->num_buffers; n++) {
        if (strcmp(sc->buffers[n].name, name) == 0)
            return &sc->buffers[n];
    }
    // not found -> add it
    struct sc_buffer new = {
        .name = talloc_strdup(NULL, name),
    };
    MP_TARRAY_APPEND(sc, sc->buffers, sc->num_buffers, new);
    return &sc->buffers[sc->num_buffers - 1];
}

const char *mp_sampler_type(GLenum texture_target)
{
    switch (texture_target) {
    case GL_TEXTURE_1D:         return "sampler1D";
    case GL_TEXTURE_2D:         return "sampler2D";
    case GL_TEXTURE_RECTANGLE:  return "sampler2DRect";
    case GL_TEXTURE_EXTERNAL_OES: return "samplerExternalOES";
    case GL_TEXTURE_3D:         return "sampler3D";
    default: abort();
    }
}

void gl_sc_uniform_tex(struct gl_shader_cache *sc, char *name, GLenum target,
                       GLuint texture)
{
    struct sc_uniform *u = find_uniform(sc, name);
    u->type = UT_i;
    u->size = 1;
    u->glsl_type = mp_sampler_type(target);
    u->v.i[0] = sc->next_texture_unit++;
    u->tex_target = target;
    u->tex_handle = texture;
}

void gl_sc_uniform_tex_ui(struct gl_shader_cache *sc, char *name, GLuint texture)
{
    struct sc_uniform *u = find_uniform(sc, name);
    u->type = UT_i;
    u->size = 1;
    u->glsl_type = sc->gl->es ? "highp usampler2D" : "usampler2D";
    u->v.i[0] = sc->next_texture_unit++;
    u->tex_target = GL_TEXTURE_2D;
    u->tex_handle = texture;
}

void gl_sc_uniform_texture(struct gl_shader_cache *sc, char *name,
                           struct ra_tex *tex)
{
    struct ra_tex_gl *tex_gl = tex->priv;
    if (tex->params.format->ctype == RA_CTYPE_UINT) {
        gl_sc_uniform_tex_ui(sc, name, tex_gl->texture);
    } else {
        gl_sc_uniform_tex(sc, name, tex_gl->target, tex_gl->texture);
    }
}

static const char *mp_image2D_type(GLenum access)
{
    switch (access) {
    case GL_WRITE_ONLY: return "writeonly image2D";
    case GL_READ_ONLY:  return "readonly image2D";
    case GL_READ_WRITE: return "image2D";
    default: abort();
    }
}

void gl_sc_uniform_image2D(struct gl_shader_cache *sc, const char *name,
                           GLuint texture, GLuint iformat, GLenum access)
{
    gl_sc_enable_extension(sc, "GL_ARB_shader_image_load_store");

    struct sc_uniform *u = find_uniform(sc, name);
    u->type = UT_i;
    u->size = 1;
    u->glsl_type = mp_image2D_type(access);
    u->v.i[0] = sc->next_image_unit++;
    u->img_handle = texture;
    u->img_access = access;
    u->img_iformat = iformat;
}

void gl_sc_ssbo(struct gl_shader_cache *sc, char *name, GLuint ssbo,
                char *format, ...)
{
    gl_sc_enable_extension(sc, "GL_ARB_shader_storage_buffer_object");

    struct sc_buffer *b = find_buffer(sc, name);
    b->binding = sc->next_buffer_binding++;
    b->ssbo = ssbo;
    b->format = format;

    va_list ap;
    va_start(ap, format);
    b->format = ta_vasprintf(sc, format, ap);
    va_end(ap);
}

void gl_sc_uniform_f(struct gl_shader_cache *sc, char *name, GLfloat f)
{
    struct sc_uniform *u = find_uniform(sc, name);
    u->type = UT_f;
    u->size = 1;
    u->glsl_type = "float";
    u->v.f[0] = f;
}

void gl_sc_uniform_i(struct gl_shader_cache *sc, char *name, GLint i)
{
    struct sc_uniform *u = find_uniform(sc, name);
    u->type = UT_i;
    u->size = 1;
    u->glsl_type = "int";
    u->v.i[0] = i;
}

void gl_sc_uniform_vec2(struct gl_shader_cache *sc, char *name, GLfloat f[2])
{
    struct sc_uniform *u = find_uniform(sc, name);
    u->type = UT_f;
    u->size = 2;
    u->glsl_type = "vec2";
    u->v.f[0] = f[0];
    u->v.f[1] = f[1];
}

void gl_sc_uniform_vec3(struct gl_shader_cache *sc, char *name, GLfloat f[3])
{
    struct sc_uniform *u = find_uniform(sc, name);
    u->type = UT_f;
    u->size = 3;
    u->glsl_type = "vec3";
    u->v.f[0] = f[0];
    u->v.f[1] = f[1];
    u->v.f[2] = f[2];
}

static void transpose2x2(float r[2 * 2])
{
    MPSWAP(float, r[0+2*1], r[1+2*0]);
}

void gl_sc_uniform_mat2(struct gl_shader_cache *sc, char *name,
                        bool transpose, GLfloat *v)
{
    struct sc_uniform *u = find_uniform(sc, name);
    u->type = UT_m;
    u->size = 2;
    u->glsl_type = "mat2";
    for (int n = 0; n < 4; n++)
        u->v.f[n] = v[n];
    if (transpose)
        transpose2x2(&u->v.f[0]);
}

static void transpose3x3(float r[3 * 3])
{
    MPSWAP(float, r[0+3*1], r[1+3*0]);
    MPSWAP(float, r[0+3*2], r[2+3*0]);
    MPSWAP(float, r[1+3*2], r[2+3*1]);
}

void gl_sc_uniform_mat3(struct gl_shader_cache *sc, char *name,
                        bool transpose, GLfloat *v)
{
    struct sc_uniform *u = find_uniform(sc, name);
    u->type = UT_m;
    u->size = 3;
    u->glsl_type = "mat3";
    for (int n = 0; n < 9; n++)
        u->v.f[n] = v[n];
    if (transpose)
        transpose3x3(&u->v.f[0]);
}

// Tell the shader generator (and later gl_sc_draw_data()) about the vertex
// data layout and attribute names. The entries array is terminated with a {0}
// entry. The array memory must remain valid indefinitely (for now).
void gl_sc_set_vertex_format(struct gl_shader_cache *sc,
                             const struct gl_vao_entry *entries,
                             size_t vertex_size)
{
    sc->vertex_entries = entries;
    sc->vertex_size = vertex_size;
}

static const char *vao_glsl_type(const struct gl_vao_entry *e)
{
    // pretty dumb... too dumb, but works for us
    switch (e->num_elems) {
    case 1: return "float";
    case 2: return "vec2";
    case 3: return "vec3";
    case 4: return "vec4";
    default: abort();
    }
}

// Assumes program is current (gl->UseProgram(program)).
static void update_uniform(GL *gl, struct sc_entry *e, struct sc_uniform *u, int n)
{
    struct sc_cached_uniform *un = &e->uniforms[n];
    GLint loc = un->loc;
    if (loc < 0)
        return;
    switch (u->type) {
    case UT_i:
        assert(u->size == 1);
        if (memcmp(un->v.i, u->v.i, sizeof(u->v.i)) != 0) {
            memcpy(un->v.i, u->v.i, sizeof(u->v.i));
            gl->Uniform1i(loc, u->v.i[0]);
        }
        // For samplers: set the actual texture.
        if (u->tex_target) {
            gl->ActiveTexture(GL_TEXTURE0 + u->v.i[0]);
            gl->BindTexture(u->tex_target, u->tex_handle);
        }
        if (u->img_handle) {
            gl->BindImageTexture(u->v.i[0], u->img_handle, 0, GL_FALSE, 0,
                                 u->img_access, u->img_iformat);
        }
        break;
    case UT_f:
        if (memcmp(un->v.f, u->v.f, sizeof(u->v.f)) != 0) {
            memcpy(un->v.f, u->v.f, sizeof(u->v.f));
            switch (u->size) {
            case 1: gl->Uniform1f(loc, u->v.f[0]); break;
            case 2: gl->Uniform2f(loc, u->v.f[0], u->v.f[1]); break;
            case 3: gl->Uniform3f(loc, u->v.f[0], u->v.f[1], u->v.f[2]); break;
            case 4: gl->Uniform4f(loc, u->v.f[0], u->v.f[1], u->v.f[2],
                                  u->v.f[3]); break;
            default: abort();
            }
        }
        break;
    case UT_m:
        if (memcmp(un->v.f, u->v.f, sizeof(u->v.f)) != 0) {
            memcpy(un->v.f, u->v.f, sizeof(u->v.f));
            switch (u->size) {
            case 2: gl->UniformMatrix2fv(loc, 1, GL_FALSE, &u->v.f[0]); break;
            case 3: gl->UniformMatrix3fv(loc, 1, GL_FALSE, &u->v.f[0]); break;
            default: abort();
            }
        }
        break;
    default:
        abort();
    }
}

void gl_sc_set_cache_dir(struct gl_shader_cache *sc, struct mpv_global *global,
                         const char *dir)
{
    talloc_free(sc->cache_dir);
    sc->cache_dir = talloc_strdup(sc, dir);
    sc->global = global;
}

static const char *shader_typestr(GLenum type)
{
    switch (type) {
    case GL_VERTEX_SHADER:   return "vertex";
    case GL_FRAGMENT_SHADER: return "fragment";
    case GL_COMPUTE_SHADER:  return "compute";
    default: abort();
    }
}

static void compile_attach_shader(struct gl_shader_cache *sc, GLuint program,
                                  GLenum type, const char *source)
{
    GL *gl = sc->gl;

    GLuint shader = gl->CreateShader(type);
    gl->ShaderSource(shader, 1, &source, NULL);
    gl->CompileShader(shader);
    GLint status = 0;
    gl->GetShaderiv(shader, GL_COMPILE_STATUS, &status);
    GLint log_length = 0;
    gl->GetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);

    int pri = status ? (log_length > 1 ? MSGL_V : MSGL_DEBUG) : MSGL_ERR;
    const char *typestr = shader_typestr(type);
    if (mp_msg_test(sc->log, pri)) {
        MP_MSG(sc, pri, "%s shader source:\n", typestr);
        mp_log_source(sc->log, pri, source);
    }
    if (log_length > 1) {
        GLchar *logstr = talloc_zero_size(NULL, log_length + 1);
        gl->GetShaderInfoLog(shader, log_length, NULL, logstr);
        MP_MSG(sc, pri, "%s shader compile log (status=%d):\n%s\n",
               typestr, status, logstr);
        talloc_free(logstr);
    }
    if (gl->GetTranslatedShaderSourceANGLE && mp_msg_test(sc->log, MSGL_DEBUG)) {
        GLint len = 0;
        gl->GetShaderiv(shader, GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE, &len);
        if (len > 0) {
            GLchar *sstr = talloc_zero_size(NULL, len + 1);
            gl->GetTranslatedShaderSourceANGLE(shader, len, NULL, sstr);
            MP_DBG(sc, "Translated shader:\n");
            mp_log_source(sc->log, MSGL_DEBUG, sstr);
        }
    }

    gl->AttachShader(program, shader);
    gl->DeleteShader(shader);

    if (!status)
        sc->error_state = true;
}

static void link_shader(struct gl_shader_cache *sc, GLuint program)
{
    GL *gl = sc->gl;
    gl->LinkProgram(program);
    GLint status = 0;
    gl->GetProgramiv(program, GL_LINK_STATUS, &status);
    GLint log_length = 0;
    gl->GetProgramiv(program, GL_INFO_LOG_LENGTH, &log_length);

    int pri = status ? (log_length > 1 ? MSGL_V : MSGL_DEBUG) : MSGL_ERR;
    if (mp_msg_test(sc->log, pri)) {
        GLchar *logstr = talloc_zero_size(NULL, log_length + 1);
        gl->GetProgramInfoLog(program, log_length, NULL, logstr);
        MP_MSG(sc, pri, "shader link log (status=%d): %s\n", status, logstr);
        talloc_free(logstr);
    }

    if (!status)
        sc->error_state = true;
}

// either 'compute' or both 'vertex' and 'frag' are needed
static GLuint compile_program(struct gl_shader_cache *sc, struct bstr *vertex,
                              struct bstr *frag, struct bstr *compute)
{
    GL *gl = sc->gl;
    GLuint prog = gl->CreateProgram();
    if (compute)
        compile_attach_shader(sc, prog, GL_COMPUTE_SHADER, compute->start);
    if (vertex && frag) {
        compile_attach_shader(sc, prog, GL_VERTEX_SHADER, vertex->start);
        compile_attach_shader(sc, prog, GL_FRAGMENT_SHADER, frag->start);
        for (int n = 0; sc->vertex_entries[n].name; n++) {
            char *vname = mp_tprintf(80, "vertex_%s", sc->vertex_entries[n].name);
            gl->BindAttribLocation(prog, n, vname);
        }
    }
    link_shader(sc, prog);
    return prog;
}

static GLuint load_program(struct gl_shader_cache *sc, struct bstr *vertex,
                           struct bstr *frag, struct bstr *compute)
{
    GL *gl = sc->gl;

    MP_VERBOSE(sc, "new shader program:\n");
    if (sc->header_text.len) {
        MP_VERBOSE(sc, "header:\n");
        mp_log_source(sc->log, MSGL_V, sc->header_text.start);
        MP_VERBOSE(sc, "body:\n");
    }
    if (sc->text.len)
        mp_log_source(sc->log, MSGL_V, sc->text.start);

    if (!sc->cache_dir || !sc->cache_dir[0] || !gl->ProgramBinary)
        return compile_program(sc, vertex, frag, compute);

    // Try to load it from a disk cache, or compiling + saving it.

    GLuint prog = 0;
    void *tmp = talloc_new(NULL);
    char *dir = mp_get_user_path(tmp, sc->global, sc->cache_dir);

    struct AVSHA *sha = av_sha_alloc();
    if (!sha)
        abort();
    av_sha_init(sha, 256);

    if (vertex)
        av_sha_update(sha, vertex->start, vertex->len + 1);
    if (frag)
        av_sha_update(sha, frag->start, frag->len + 1);
    if (compute)
        av_sha_update(sha, compute->start, compute->len + 1);

    // In theory, the array could change order, breaking old binaries.
    for (int n = 0; sc->vertex_entries[n].name; n++) {
        av_sha_update(sha, sc->vertex_entries[n].name,
                      strlen(sc->vertex_entries[n].name) + 1);
    }

    uint8_t hash[256 / 8];
    av_sha_final(sha, hash);
    av_free(sha);

    char hashstr[256 / 8 * 2 + 1];
    for (int n = 0; n < 256 / 8; n++)
        snprintf(hashstr + n * 2, sizeof(hashstr) - n * 2, "%02X", hash[n]);

    const char *header = "mpv shader cache v1\n";
    size_t header_size = strlen(header) + 4;

    char *filename = mp_path_join(tmp, dir, hashstr);
    if (stat(filename, &(struct stat){0}) == 0) {
        MP_VERBOSE(sc, "Trying to load shader from disk...\n");
        struct bstr cachedata = stream_read_file(filename, tmp, sc->global,
                                                 1000000000); // 1 GB
        if (cachedata.len > header_size) {
            GLenum format = AV_RL32(cachedata.start + header_size - 4);
            prog = gl->CreateProgram();
            gl_check_error(gl, sc->log, "before loading program");
            gl->ProgramBinary(prog, format, cachedata.start + header_size,
                                            cachedata.len - header_size);
            gl->GetError(); // discard potential useless error
            GLint status = 0;
            gl->GetProgramiv(prog, GL_LINK_STATUS, &status);
            if (!status) {
                gl->DeleteProgram(prog);
                prog = 0;
            }
        }
        MP_VERBOSE(sc, "Loading cached shader %s.\n", prog ? "ok" : "failed");
    }

    if (!prog) {
        prog = compile_program(sc, vertex, frag, compute);

        GLint size = 0;
        gl->GetProgramiv(prog, GL_PROGRAM_BINARY_LENGTH, &size);
        uint8_t *buffer = talloc_size(tmp, size + header_size);
        GLsizei actual_size = 0;
        GLenum binary_format = 0;
        gl->GetProgramBinary(prog, size, &actual_size, &binary_format,
                             buffer + header_size);
        memcpy(buffer, header, header_size - 4);
        AV_WL32(buffer + header_size - 4, binary_format);

        if (actual_size) {
            mp_mkdirp(dir);

            MP_VERBOSE(sc, "Writing shader cache file: %s\n", filename);
            FILE *out = fopen(filename, "wb");
            if (out) {
                fwrite(buffer, header_size + actual_size, 1, out);
                fclose(out);
            }
        }
    }

    talloc_free(tmp);
    return prog;
}

#define ADD(x, ...) bstr_xappend_asprintf(sc, (x), __VA_ARGS__)
#define ADD_BSTR(x, s) bstr_xappend(sc, (x), (s))

// 1. Generate vertex and fragment shaders from the fragment shader text added
//    with gl_sc_add(). The generated shader program is cached (based on the
//    text), so actual compilation happens only the first time.
// 2. Update the uniforms and textures set with gl_sc_uniform_*.
// 3. Make the new shader program current (glUseProgram()).
// After that, you render, and then you call gc_sc_reset(), which does:
// 1. Unbind the program and all textures.
// 2. Reset the sc state and prepare for a new shader program. (All uniforms
//    and fragment operations needed for the next program have to be re-added.)
// The return value is a mp_pass_perf containing performance metrics for the
// execution of the generated shader. (Note: execution is measured up until
// the corresponding gl_sc_reset call)
// 'type' can be either GL_FRAGMENT_SHADER or GL_COMPUTE_SHADER
struct mp_pass_perf gl_sc_generate(struct gl_shader_cache *sc, GLenum type)
{
    GL *gl = sc->gl;

    // gl_sc_reset() must be called after ending the previous render process,
    // and before starting a new one.
    assert(!sc->needs_reset);

    // gl_sc_set_vertex_format() must always be called
    assert(sc->vertex_entries);

    for (int n = 0; n < MP_ARRAY_SIZE(sc->tmp); n++)
        sc->tmp[n].len = 0;

    // set up shader text (header + uniforms + body)
    bstr *header = &sc->tmp[0];
    ADD(header, "#version %d%s\n", gl->glsl_version, gl->es >= 300 ? " es" : "");
    if (type == GL_COMPUTE_SHADER) {
        // This extension cannot be enabled in fragment shader. Enable it as
        // an exception for compute shader.
        ADD(header, "#extension GL_ARB_compute_shader : enable\n");
    }
    for (int n = 0; n < sc->num_exts; n++)
        ADD(header, "#extension %s : enable\n", sc->exts[n]);
    if (gl->es) {
        ADD(header, "precision mediump float;\n");
        ADD(header, "precision mediump sampler2D;\n");
        if (gl->mpgl_caps & MPGL_CAP_3D_TEX)
            ADD(header, "precision mediump sampler3D;\n");
    }

    if (gl->glsl_version >= 130) {
        ADD(header, "#define texture1D texture\n");
        ADD(header, "#define texture3D texture\n");
    } else {
        ADD(header, "#define texture texture2D\n");
    }

    // Additional helpers.
    ADD(header, "#define LUT_POS(x, lut_size)"
                " mix(0.5 / (lut_size), 1.0 - 0.5 / (lut_size), (x))\n");

    char *vert_in = gl->glsl_version >= 130 ? "in" : "attribute";
    char *vert_out = gl->glsl_version >= 130 ? "out" : "varying";
    char *frag_in = gl->glsl_version >= 130 ? "in" : "varying";

    struct bstr *vert = NULL, *frag = NULL, *comp = NULL;

    if (type == GL_FRAGMENT_SHADER) {
        // vertex shader: we don't use the vertex shader, so just setup a
        // dummy, which passes through the vertex array attributes.
        bstr *vert_head = &sc->tmp[1];
        ADD_BSTR(vert_head, *header);
        bstr *vert_body = &sc->tmp[2];
        ADD(vert_body, "void main() {\n");
        bstr *frag_vaos = &sc->tmp[3];
        for (int n = 0; sc->vertex_entries[n].name; n++) {
            const struct gl_vao_entry *e = &sc->vertex_entries[n];
            const char *glsl_type = vao_glsl_type(e);
            if (strcmp(e->name, "position") == 0) {
                // setting raster pos. requires setting gl_Position magic variable
                assert(e->num_elems == 2 && e->type == GL_FLOAT);
                ADD(vert_head, "%s vec2 vertex_position;\n", vert_in);
                ADD(vert_body, "gl_Position = vec4(vertex_position, 1.0, 1.0);\n");
            } else {
                ADD(vert_head, "%s %s vertex_%s;\n", vert_in, glsl_type, e->name);
                ADD(vert_head, "%s %s %s;\n", vert_out, glsl_type, e->name);
                ADD(vert_body, "%s = vertex_%s;\n", e->name, e->name);
                ADD(frag_vaos, "%s %s %s;\n", frag_in, glsl_type, e->name);
            }
        }
        ADD(vert_body, "}\n");
        vert = vert_head;
        ADD_BSTR(vert, *vert_body);

        // fragment shader; still requires adding used uniforms and VAO elements
        frag = &sc->tmp[4];
        ADD_BSTR(frag, *header);
        if (gl->glsl_version >= 130)
            ADD(frag, "out vec4 out_color;\n");
        ADD_BSTR(frag, *frag_vaos);
        for (int n = 0; n < sc->num_uniforms; n++) {
            struct sc_uniform *u = &sc->uniforms[n];
            ADD(frag, "uniform %s %s;\n", u->glsl_type, u->name);
        }

        ADD_BSTR(frag, sc->prelude_text);
        ADD_BSTR(frag, sc->header_text);

        ADD(frag, "void main() {\n");
        // we require _all_ frag shaders to write to a "vec4 color"
        ADD(frag, "vec4 color = vec4(0.0, 0.0, 0.0, 1.0);\n");
        ADD_BSTR(frag, sc->text);
        if (gl->glsl_version >= 130) {
            ADD(frag, "out_color = color;\n");
        } else {
            ADD(frag, "gl_FragColor = color;\n");
        }
        ADD(frag, "}\n");
    }

    if (type == GL_COMPUTE_SHADER) {
        comp = &sc->tmp[4];
        ADD_BSTR(comp, *header);

        for (int n = 0; n < sc->num_uniforms; n++) {
            struct sc_uniform *u = &sc->uniforms[n];
            ADD(comp, "uniform %s %s;\n", u->glsl_type, u->name);
        }

        for (int n = 0; n < sc->num_buffers; n++) {