X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=resource_pool.h;h=85a5e52cd0de92a040bbd4f79f8e5e305aef5bf0;hp=8881958d27b0b1c4d2a082bbb649dcecc2304347;hb=e09662ec1b11f72746c7691fef56e14241d32d1c;hpb=831150846e1e79b53b02b07fbf12ec7cae289a3a diff --git a/resource_pool.h b/resource_pool.h index 8881958..85a5e52 100644 --- a/resource_pool.h +++ b/resource_pool.h @@ -27,8 +27,11 @@ #include #include #include +#include +#include #include #include +#include namespace movit { @@ -47,7 +50,8 @@ public: // twice this estimate or more. ResourcePool(size_t program_freelist_max_length = 100, size_t texture_freelist_max_bytes = 100 << 20, // 100 MB. - size_t fbo_freelist_max_length = 100); // Per context. + size_t fbo_freelist_max_length = 100, // Per context. + size_t vao_freelist_max_length = 100); // Per context. ~ResourcePool(); // All remaining functions are intended for calls from EffectChain only. @@ -56,9 +60,33 @@ public: // compiled program from the cache if possible. Keeps ownership of the // program; you must call release_glsl_program() instead of deleting it // when you no longer want it. - GLuint compile_glsl_program(const std::string& vertex_shader, const std::string& fragment_shader); + // + // If contains more than one value, the given + // outputs will be bound to fragment shader output colors in the order + // they appear in the vector. Otherwise, output order is undefined and + // determined by the OpenGL driver. + GLuint compile_glsl_program(const std::string& vertex_shader, + const std::string& fragment_shader, + const std::vector& 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 + // (usually because two EffectChains share them via caching), + // we will need to make a clone. use_glsl_program() makes such + // a clone if needed, calls glUseProgram(), and returns the real + // program number that was used; this must be given to + // unuse_glsl_program() to release it. unuse_glsl_program() does not + // actually change any OpenGL state, though. + GLuint use_glsl_program(GLuint glsl_program_num); + void unuse_glsl_program(GLuint instance_program_num); + // Allocate a 2D texture of the given internal format and dimensions, // or fetch a previous used if possible. Unbinds GL_TEXTURE_2D afterwards. // Keeps ownership of the texture; you must call release_2d_texture() instead @@ -83,6 +111,19 @@ public: GLuint texture3_num = 0); void release_fbo(GLuint fbo_num); + // Create a VAO of a very specific form: All the given attribute indices + // are bound to start of the given VBO and contain two-component floats. + // Keeps ownership of the VAO; you must call release_vec2_vao() of deleting + // it when you no longer want it. VAOs are not sharable across contexts. + // + // These are not cached primarily for performance, but rather to work + // around an NVIDIA driver bug where glVertexAttribPointer() is thread-hostile + // (ie., simultaneous GL work in unrelated contexts can cause the driver + // to free() memory that was never malloc()-ed). + GLuint create_vec2_vao(const std::set &attribute_indices, + GLuint vbo_num); + void release_vec2_vao(const GLuint vao_num); + // Informs the ResourcePool that the current context is going away soon, // and that any resources held for it in the freelist should be deleted. // @@ -102,21 +143,65 @@ private: // is no more than elements long. void shrink_fbo_freelist(void *context, size_t max_length); + // 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 . + static GLuint link_program(GLuint vs_obj, + GLuint fs_obj, + const std::vector& fragment_shader_outputs); + + static GLuint link_compute_program(GLuint cs_obj); + // Protects all the other elements in the class. pthread_mutex_t lock; - size_t program_freelist_max_length, texture_freelist_max_bytes, fbo_freelist_max_length; + size_t program_freelist_max_length, texture_freelist_max_bytes, fbo_freelist_max_length, vao_freelist_max_length; // A mapping from vertex/fragment shader source strings to compiled program number. std::map, GLuint> programs; + // A mapping from compute shader source string to compiled program number. + std::map 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 program_refcount; // A mapping from program number to vertex and fragment shaders. - std::map > program_shaders; + // Contains everything needed to re-link the program. + struct ShaderSpec { + GLuint vs_obj, fs_obj; + std::vector fragment_shader_outputs; + }; + std::map program_shaders; + + struct ComputeShaderSpec { + GLuint cs_obj; + }; + std::map 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> program_instances; + + // For each program, the master program that created it + // (inverse of program_instances). + std::map program_masters; // A list of programs that are no longer in use, most recently freed first. // Once this reaches , the last element @@ -160,7 +245,17 @@ private: // the last element will be deleted. // // We store iterators directly into for efficiency. - std::map > fbo_freelist; + std::map> fbo_freelist; + + // Very similar, for VAOs. + struct VAO { + GLuint vao_num; + std::set attribute_indices; + GLuint vbo_num; + }; + std::map, VAO> vao_formats; + typedef std::map, VAO>::iterator VAOFormatIterator; + std::map> vao_freelist; // See the caveats at the constructor. static size_t estimate_texture_size(const Texture2D &texture_format);