gl: Refactor shader type usage

Use Common/GLSLTypes.h program_domain instead of duplicated own internal
type

rpcs3/Emu/RSX/GL/GLCompute.h

@@ -44,7 +44,7 @@ namespace gl
         {
             if (!compiled)
             {
-                m_shader.create(gl::glsl::shader::type::compute, m_src);
+                m_shader.create(::glsl::program_domain::glsl_compute_program, m_src);
                 m_shader.compile();
 
                 m_program.create();

rpcs3/Emu/RSX/GL/GLFragmentProgram.cpp

@@ -366,7 +366,7 @@ void GLFragmentProgram::Decompile(const RSXFragmentProgram& prog)
 		}
 	}
 
-	shader.create(gl::glsl::shader::type::fragment, source);
+	shader.create(::glsl::program_domain::glsl_fragment_program, source);
 }
 
 void GLFragmentProgram::Compile()

rpcs3/Emu/RSX/GL/GLHelpers.h

@@ -11,6 +11,7 @@
 #include "GLExecutionState.h"
 #include "../GCM.h"
 #include "../Common/TextureUtils.h"
+#include "../Common/GLSLTypes.h"
 
 #include "Emu/system_config.h"
 #include "Utilities/geometry.h"
@@ -2406,18 +2407,9 @@ public:
 	{
 		class shader
 		{
-		public:
 			std::string source;
-			enum class type
+			::glsl::program_domain type;
-			{
-				fragment = GL_FRAGMENT_SHADER,
-				vertex = GL_VERTEX_SHADER,
-				compute = GL_COMPUTE_SHADER
-			};
-
-		private:
 			GLuint m_id = GL_NONE;
-			type shader_type = type::vertex;
 
 		public:
 			shader() = default;
@@ -2427,7 +2419,7 @@ public:
 				set_id(id);
 			}
 
-			shader(type type_, const std::string& src)
+			shader(::glsl::program_domain type_, const std::string& src)
 			{
 				create(type_, src);
 			}
@@ -2438,15 +2430,31 @@ public:
 					remove();
 			}
 
-			void create(type type_, const std::string& src)
+			void create(::glsl::program_domain type_, const std::string& src)
 			{
-				shader_type = type_;
+				type = type_;
 				source = src;
 			}
 
 			shader& compile()
 			{
-				m_id = glCreateShader(static_cast<GLenum>(shader_type));
+				GLenum shader_type;
+				switch (type)
+				{
+				case ::glsl::program_domain::glsl_vertex_program:
+					shader_type = GL_VERTEX_SHADER;
+					break;
+				case ::glsl::program_domain::glsl_fragment_program:
+					shader_type = GL_FRAGMENT_SHADER;
+					break;
+				case ::glsl::program_domain::glsl_compute_program:
+					shader_type = GL_COMPUTE_SHADER;
+					break;
+				default:
+					rsx_log.fatal("gl::glsl::shader::compile(): Unhandled shader type");
+				}
+
+				m_id = glCreateShader(shader_type);
 				const char* str = source.c_str();
 				const GLint length = ::narrow<GLint>(source.length());
 
@@ -2455,13 +2463,13 @@ public:
 					std::string base_name;
 					switch (shader_type)
 					{
-					case type::vertex:
+					case ::glsl::program_domain::glsl_vertex_program:
 						base_name = "shaderlog/VertexProgram";
 						break;
-					case type::fragment:
+					case ::glsl::program_domain::glsl_fragment_program:
 						base_name = "shaderlog/FragmentProgram";
 						break;
-					case type::compute:
+					case ::glsl::program_domain::glsl_compute_program:
 						base_name = "shaderlog/ComputeProgram";
 						break;
 					}
@@ -2508,6 +2516,11 @@ public:
 				return m_id;
 			}
 
+			const std::string& get_source() const
+			{
+				return source;
+			}
+
 			void set_id(uint id)
 			{
 				m_id = id;

rpcs3/Emu/RSX/GL/GLOverlays.h

@@ -55,10 +55,10 @@ namespace gl
 		{
 			if (!compiled)
 			{
-				fs.create(gl::glsl::shader::type::fragment, fs_src);
+				fs.create(::glsl::program_domain::glsl_fragment_program, fs_src);
 				fs.compile();
 
-				vs.create(gl::glsl::shader::type::vertex, vs_src);
+				vs.create(::glsl::program_domain::glsl_vertex_program, vs_src);
 				vs.compile();
 
 				program_handle.create();

rpcs3/Emu/RSX/GL/GLProgramBuffer.h

@@ -79,8 +79,8 @@ struct GLTraits
 		rsx_log.notice("*** vp id = %d", vertexProgramData.id);
 		rsx_log.notice("*** fp id = %d", fragmentProgramData.id);
 
-		rsx_log.notice("*** vp shader = \n%s", vertexProgramData.shader.source.c_str());
+		rsx_log.notice("*** vp shader = \n%s", vertexProgramData.shader.get_source().c_str());
-		rsx_log.notice("*** fp shader = \n%s", fragmentProgramData.shader.source.c_str());
+		rsx_log.notice("*** fp shader = \n%s", fragmentProgramData.shader.get_source().c_str());
 
 		return result;
 	}

rpcs3/Emu/RSX/GL/GLShaderInterpreter.cpp

@@ -12,16 +12,16 @@ namespace gl
 
 	namespace interpreter
 	{
-		void texture_pool_allocator::create(shader::type domain)
+		void texture_pool_allocator::create(::glsl::program_domain domain)
 		{
 			GLenum pname;
 			switch (domain)
 			{
 			default:
 				rsx_log.fatal("Unexpected program domain %d", static_cast<int>(domain));
-			case shader::type::vertex:
+			case ::glsl::program_domain::glsl_vertex_program:
 				pname = GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS; break;
-			case shader::type::fragment:
+			case ::glsl::program_domain::glsl_fragment_program:
 				pname = GL_MAX_TEXTURE_IMAGE_UNITS; break;
 			}
 
@@ -150,7 +150,7 @@ namespace gl
 		builder << program_common::interpreter::get_vertex_interpreter();
 		const std::string s = builder.str();
 
-		m_vs.create(glsl::shader::type::vertex, s);
+		m_vs.create(::glsl::program_domain::glsl_vertex_program, s);
 		m_vs.compile();
 	}
 
@@ -160,7 +160,7 @@ namespace gl
 		auto& allocator = prog_data.allocator;
 		if (compiler_options & program_common::interpreter::COMPILER_OPT_ENABLE_TEXTURES)
 		{
-			allocator.create(glsl::shader::type::fragment);
+			allocator.create(::glsl::program_domain::glsl_fragment_program);
 			if (allocator.max_image_units >= 32)
 			{
 				// 16 + 4 + 4 + 4
@@ -302,7 +302,7 @@ namespace gl
 		builder << program_common::interpreter::get_fragment_interpreter();
 		const std::string s = builder.str();
 
-		prog_data.fs.create(glsl::shader::type::fragment, s);
+		prog_data.fs.create(::glsl::program_domain::glsl_fragment_program, s);
 		prog_data.fs.compile();
 	}
 

rpcs3/Emu/RSX/GL/GLShaderInterpreter.h

@@ -1,9 +1,12 @@
 #pragma once
 #include "GLHelpers.h"
 #include "../Common/ProgramStateCache.h"
+#include "../Common/TextureUtils.h"
 
 namespace gl
 {
+	using namespace ::glsl;
+
 	namespace interpreter
 	{
 		using program_metadata = program_hash_util::fragment_program_utils::fragment_program_metadata;
@@ -48,7 +51,7 @@ namespace gl
 			int used = 0;
 			std::vector<texture_pool> pools;
 
-			void create(::gl::glsl::shader::type domain);
+			void create(::glsl::program_domain domain);
 			void allocate(int size);
 		};
 

rpcs3/Emu/RSX/GL/GLTextOut.h

@@ -52,10 +52,10 @@ namespace gl
 				"}\n"
 			};
 
-			m_fs.create(gl::glsl::shader::type::fragment, fs);
+			m_fs.create(::glsl::program_domain::glsl_fragment_program, fs);
 			m_fs.compile();
 
-			m_vs.create(gl::glsl::shader::type::vertex, vs);
+			m_vs.create(::glsl::program_domain::glsl_vertex_program, vs);
 			m_vs.compile();
 
 			m_program.create();

rpcs3/Emu/RSX/GL/GLVertexProgram.cpp

@@ -270,7 +270,7 @@ void GLVertexProgram::Decompile(const RSXVertexProgram& prog)
 	GLVertexDecompilerThread decompiler(prog, source, parr);
 	decompiler.Task();
 
-	shader.create(gl::glsl::shader::type::vertex, source);
+	shader.create(::glsl::program_domain::glsl_vertex_program, source);
 }
 
 void GLVertexProgram::Compile()