X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=resource_pool.h;h=8503b29b6e0020d0111e83c459905a57694e9cd3;hp=b218d7ad18f6bea9666e92a96e79098ebbb2262c;hb=f216b7bef5a968c89f6fc78e83cc26a91e504a8a;hpb=f705cd2a092c0f41603f0d4d619f72dbde476212

diff --git a/resource_pool.h b/resource_pool.h
index b218d7a..8503b29 100644
--- a/resource_pool.h
+++ b/resource_pool.h
@@ -27,8 +27,10 @@
 #include <stddef.h>
 #include <list>
 #include <map>
+#include <stack>
 #include <string>
 #include <utility>
+#include <vector>
 
 namespace movit {
 
@@ -56,9 +58,28 @@ 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 <fragment_shader_outputs> 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<std::string>& frag_shader_outputs);
 	void release_glsl_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
@@ -102,6 +123,12 @@ private:
 	// is no more than <max_length> elements long.
 	void shrink_fbo_freelist(void *context, size_t max_length);
 
+	// 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);
+
 	// Protects all the other elements in the class.
 	pthread_mutex_t lock;
 
@@ -116,7 +143,22 @@ private:
 	std::map<GLuint, int> program_refcount;
 
 	// A mapping from program number to vertex and fragment shaders.
-	std::map<GLuint, std::pair<GLuint, GLuint> > program_shaders;
+	// Contains everything needed to re-link the program.
+	struct ShaderSpec {
+		GLuint vs_obj, fs_obj;
+		std::vector<std::string> fragment_shader_outputs;
+	};
+	std::map<GLuint, ShaderSpec> 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;
+
+	// For each program, the master program that created it
+	// (inverse of program_instances).
+	std::map<GLuint, GLuint> program_masters;
 
 	// A list of programs that are no longer in use, most recently freed first.
 	// Once this reaches <program_freelist_max_length>, the last element
@@ -143,6 +185,7 @@ private:
 
 	static const unsigned num_fbo_attachments = 4;
 	struct FBO {
+		GLuint fbo_num;
 		// GL_INVALID_INDEX means associated to a texture that has since been deleted.
 		// 0 means the output isn't bound.
 		GLuint texture_num[num_fbo_attachments];
@@ -152,11 +195,14 @@ private:
 	// filled if the FBO is given out to a client or on the freelist, but
 	// not if it is deleted from the freelist.
 	std::map<std::pair<void *, GLuint>, FBO> fbo_formats;
+	typedef std::map<std::pair<void *, GLuint>, FBO>::iterator FBOFormatIterator;
 
 	// For each context, a list of all FBOs that are released but not freed
 	// (most recently freed first). Once this reaches <fbo_freelist_max_length>,
 	// the last element will be deleted.
-	std::map<void *, std::list<GLuint> > fbo_freelist;
+	//
+	// We store iterators directly into <fbo_format> for efficiency.
+	std::map<void *, std::list<FBOFormatIterator> > fbo_freelist;
 
 	// See the caveats at the constructor.
 	static size_t estimate_texture_size(const Texture2D &texture_format);