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

diff --git a/resource_pool.h b/resource_pool.h
index 8503b29..85a5e52 100644
--- a/resource_pool.h
+++ b/resource_pool.h
@@ -27,6 +27,7 @@
 #include <stddef.h>
 #include <list>
 #include <map>
+#include <set>
 #include <stack>
 #include <string>
 #include <utility>
@@ -49,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.
@@ -68,6 +70,11 @@ public:
 	                            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
@@ -104,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<GLint> &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.
 	//
@@ -123,20 +143,38 @@ private:
 	// is no more than <max_length> 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 <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;
 
-	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<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).
@@ -150,11 +188,16 @@ private:
 	};
 	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).
@@ -202,7 +245,17 @@ private:
 	// 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 {
+		GLuint vao_num;
+		std::set<GLint> attribute_indices;
+		GLuint vbo_num;
+	};
+	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;
 
 	// See the caveats at the constructor.
 	static size_t estimate_texture_size(const Texture2D &texture_format);