const std::vector<std::string>& frag_shader_outputs);
void release_glsl_program(GLuint glsl_program_num);
+ // Same as the previous, but for compile shaders instead. There is currently
+ // no support for binding multiple outputs.
+ GLuint compile_glsl_compute_program(const std::string& compile_shader);
+ void release_glsl_compute_program(GLuint glsl_program_num);
+
// Since uniforms belong to the program and not to the context,
// a given GLSL program number can't be used by more than one thread
// at a time. Thus, if two threads want to use the same program
// Same, for VAOs.
void shrink_vao_freelist(void *context, size_t max_length);
+ // Increment the refcount, or take it off the freelist if it's zero.
+ void increment_program_refcount(GLuint program_num);
+
+ // If debugging is on, output shader to a temporary file, for easier debugging.
+ void output_debug_shader(const std::string &shader_src, const std::string &suffix);
+
+ // For a new program that's not a clone of anything, insert it into the right
+ // structures: Give it a refcount, and set up the program_masters / program_instances lists.
+ void add_master_program(GLuint program_num);
+
// Link the given vertex and fragment shaders into a full GLSL program.
// See compile_glsl_program() for explanation of <fragment_shader_outputs>.
static GLuint link_program(GLuint vs_obj,
GLuint fs_obj,
const std::vector<std::string>& fragment_shader_outputs);
+ static GLuint link_compute_program(GLuint cs_obj);
+
// Protects all the other elements in the class.
pthread_mutex_t lock;
// A mapping from vertex/fragment shader source strings to compiled program number.
std::map<std::pair<std::string, std::string>, GLuint> programs;
+ // A mapping from compute shader source string to compiled program number.
+ std::map<std::string, GLuint> compute_programs;
+
// A mapping from compiled program number to number of current users.
// Once this reaches zero, the program is taken out of this map and instead
// put on the freelist (after which it may be deleted).
};
std::map<GLuint, ShaderSpec> program_shaders;
+ struct ComputeShaderSpec {
+ GLuint cs_obj;
+ };
+ std::map<GLuint, ComputeShaderSpec> compute_program_shaders;
+
// For each program, a list of other programs that are exactly like it.
// By default, will only contain the program itself, but due to cloning
// (see use_glsl_program()), may grow. Programs are taken off this list
// while they are in use (by use_glsl_program()).
- std::map<GLuint, std::stack<GLuint> > program_instances;
+ std::map<GLuint, std::stack<GLuint>> program_instances;
// For each program, the master program that created it
// (inverse of program_instances).
struct Texture2D {
GLint internal_format;
GLsizei width, height;
+ GLsync no_reuse_before = nullptr;
};
// A mapping from texture number to format details. This is filled if the
// the last element will be deleted.
//
// We store iterators directly into <fbo_format> for efficiency.
- std::map<void *, std::list<FBOFormatIterator> > fbo_freelist;
+ std::map<void *, std::list<FBOFormatIterator>> fbo_freelist;
// Very similar, for VAOs.
struct VAO {
};
std::map<std::pair<void *, GLuint>, VAO> vao_formats;
typedef std::map<std::pair<void *, GLuint>, VAO>::iterator VAOFormatIterator;
- std::map<void *, std::list<VAOFormatIterator> > vao_freelist;
+ std::map<void *, std::list<VAOFormatIterator>> vao_freelist;
// See the caveats at the constructor.
static size_t estimate_texture_size(const Texture2D &texture_format);