1 files changed, 141 insertions, 47 deletions

diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index c64f46f38a..b189e5452c 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -145,6 +145,11 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 	// NOTE order of shader object attaching is VERY IMPORTANT!!!
 	if (features->calculatesAtmospherics)
     {
+        if (!shader->attachVertexObject("environment/srgbF.glsl")) // NOTE -- "F" suffix is superfluous here, there is nothing fragment specific in srgbF
+        {
+            return FALSE;
+        }
+
         if (!shader->attachVertexObject("windlight/atmosphericsFuncs.glsl")) {
             return FALSE;
         }
@@ -177,6 +182,13 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 	///////////////////////////////////////
 
 // NOTE order of shader object attaching is VERY IMPORTANT!!!
+    if (features->hasSrgb || features->hasAtmospherics || features->calculatesAtmospherics)
+    {
+        if (!shader->attachFragmentObject("environment/srgbF.glsl"))
+        {
+            return FALSE;
+        }
+    }
 
 	if(features->calculatesAtmospherics)
 	{
@@ -202,7 +214,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 	}
 
     // we want this BEFORE shadows and AO because those facilities use pos/norm access
-    if (features->isDeferred)
+    if (features->isDeferred || features->hasReflectionProbes)
 	{
         if (!shader->attachFragmentObject("deferred/deferredUtil.glsl"))
 		{
@@ -210,6 +222,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 		}
 	}
 
+	if (features->hasScreenSpaceReflections)
+	{
+        if (!shader->attachFragmentObject("deferred/screenSpaceReflUtil.glsl"))
+        {
+            return FALSE;
+        }
+	}
+
     if (features->hasShadows)
 	{
         if (!shader->attachFragmentObject("deferred/shadowUtil.glsl"))
@@ -218,6 +238,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 		}
 	}
 
+    if (features->hasReflectionProbes)
+    {
+        if (!shader->attachFragmentObject("deferred/reflectionProbeF.glsl"))
+        {
+            return FALSE;
+        }
+    }
+
     if (features->hasAmbientOcclusion)
 	{
         if (!shader->attachFragmentObject("deferred/aoUtil.glsl"))
@@ -242,14 +270,6 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 		}
 	}
 
-	if (features->hasSrgb)
-	{
-        if (!shader->attachFragmentObject("environment/srgbF.glsl"))
-		{
-			return FALSE;
-		}
-	}
-
     if (features->encodesNormal)
 	{
         if (!shader->attachFragmentObject("environment/encodeNormF.glsl"))
@@ -550,26 +570,59 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 //============================================================================
 // Load Shader
 
-static std::string get_object_log(GLhandleARB ret)
+static std::string get_shader_log(GLuint ret)
 {
 	std::string res;
 	
 	//get log length 
 	GLint length;
-	glGetObjectParameterivARB(ret, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
+    glGetShaderiv(ret, GL_INFO_LOG_LENGTH, &length);
 	if (length > 0)
 	{
 		//the log could be any size, so allocate appropriately
-		GLcharARB* log = new GLcharARB[length];
-		glGetInfoLogARB(ret, length, &length, log);
+		GLchar* log = new GLchar[length];
+        glGetShaderInfoLog(ret, length, &length, log);
 		res = std::string((char *)log);
 		delete[] log;
 	}
 	return res;
 }
 
+static std::string get_program_log(GLuint ret)
+{
+    std::string res;
+
+    //get log length 
+    GLint length;
+    glGetProgramiv(ret, GL_INFO_LOG_LENGTH, &length);
+    if (length > 0)
+    {
+        //the log could be any size, so allocate appropriately
+        GLchar* log = new GLchar[length];
+        glGetProgramInfoLog(ret, length, &length, log);
+        res = std::string((char*)log);
+        delete[] log;
+    }
+    return res;
+}
+
+// get the info log for the given object, be it a shader or program object
+// NOTE: ret MUST be a shader OR a program object
+static std::string get_object_log(GLuint ret)
+{
+    if (glIsProgram(ret))
+    {
+        return get_program_log(ret);
+    }
+    else
+    {
+        llassert(glIsShader(ret));
+        return get_shader_log(ret);
+    }
+}
+
 //dump shader source for debugging
-void LLShaderMgr::dumpShaderSource(U32 shader_code_count, GLcharARB** shader_code_text)
+void LLShaderMgr::dumpShaderSource(U32 shader_code_count, GLchar** shader_code_text)
 {
 	char num_str[16]; // U32 = max 10 digits
 
@@ -584,9 +637,10 @@ void LLShaderMgr::dumpShaderSource(U32 shader_code_count, GLcharARB** shader_cod
     LL_CONT << LL_ENDL;
 }
 
-void LLShaderMgr::dumpObjectLog(GLhandleARB ret, BOOL warns, const std::string& filename) 
+void LLShaderMgr::dumpObjectLog(GLuint ret, BOOL warns, const std::string& filename)
 {
-	std::string log = get_object_log(ret);
+    std::string log;
+    log = get_object_log(ret);
     std::string fname = filename;
     if (filename.empty())
     {
@@ -600,7 +654,7 @@ void LLShaderMgr::dumpObjectLog(GLhandleARB ret, BOOL warns, const std::string&
 	}
  }
 
-GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_level, GLenum type, std::unordered_map<std::string, std::string>* defines, S32 texture_index_channels)
+GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_level, GLenum type, std::unordered_map<std::string, std::string>* defines, S32 texture_index_channels)
 {
 
 // endsure work-around for missing GLSL funcs gets propogated to feature shader files (e.g. srgbF.glsl)
@@ -671,9 +725,9 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 
 	//we can't have any lines longer than 1024 characters 
 	//or any shaders longer than 4096 lines... deal - DaveP
-    GLcharARB buff[1024];
-    GLcharARB *extra_code_text[1024];
-    GLcharARB *shader_code_text[4096 + LL_ARRAY_SIZE(extra_code_text)] = { NULL };
+    GLchar buff[1024];
+    GLchar *extra_code_text[1024];
+    GLchar *shader_code_text[4096 + LL_ARRAY_SIZE(extra_code_text)] = { NULL };
     GLuint extra_code_count = 0, shader_code_count = 0;
     BOOST_STATIC_ASSERT(LL_ARRAY_SIZE(extra_code_text) < LL_ARRAY_SIZE(shader_code_text));
     
@@ -712,8 +766,15 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 	{  
         if (major_version >= 4)
         {
-            //set version to 400
-			shader_code_text[shader_code_count++] = strdup("#version 400\n");
+            //set version to 400 or 420
+            if (minor_version >= 20)
+            {
+                shader_code_text[shader_code_count++] = strdup("#version 420\n");
+            }
+            else
+            {
+                shader_code_text[shader_code_count++] = strdup("#version 400\n");
+            }
         }
         else if (major_version == 3)
         {
@@ -748,7 +809,7 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 
 		extra_code_text[extra_code_count++] = strdup("#define ATTRIBUTE in\n");
 
-		if (type == GL_VERTEX_SHADER_ARB)
+		if (type == GL_VERTEX_SHADER)
 		{ //"varying" state is "out" in a vertex program, "in" in a fragment program 
 			// ("varying" is deprecated after version 1.20)
 			extra_code_text[extra_code_count++] = strdup("#define VARYING out\n");
@@ -772,13 +833,20 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 			extra_code_text[extra_code_count++] = strdup("#define shadow2DRect(a,b) vec2(texture(a,b))\n");
 		}
 	}
-	
+
+    // Use alpha float to store bit flags
+    // See: C++: addDeferredAttachment(), shader: frag_data[2]
+    extra_code_text[extra_code_count++] = strdup("#define GBUFFER_FLAG_SKIP_ATMOS   0.0 \n"); // atmo kill
+    extra_code_text[extra_code_count++] = strdup("#define GBUFFER_FLAG_HAS_ATMOS    0.34\n"); // bit 0
+    extra_code_text[extra_code_count++] = strdup("#define GBUFFER_FLAG_HAS_PBR      0.67\n"); // bit 1
+    extra_code_text[extra_code_count++] = strdup("#define GET_GBUFFER_FLAG(flag)    (abs(norm.w-flag)< 0.1)\n");
+
 	if (defines)
 	{
 		for (std::unordered_map<std::string,std::string>::iterator iter = defines->begin(); iter != defines->end(); ++iter)
 		{
 			std::string define = "#define " + iter->first + " " + iter->second + "\n";
-			extra_code_text[extra_code_count++] = (GLcharARB *) strdup(define.c_str());
+			extra_code_text[extra_code_count++] = (GLchar *) strdup(define.c_str());
 		}
 	}
 
@@ -787,7 +855,7 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 		extra_code_text[extra_code_count++] = strdup( "#define IS_AMD_CARD 1\n" );
 	}
 	
-	if (texture_index_channels > 0 && type == GL_FRAGMENT_SHADER_ARB)
+	if (texture_index_channels > 0 && type == GL_FRAGMENT_SHADER)
 	{
 		//use specified number of texture channels for indexed texture rendering
 
@@ -927,7 +995,7 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 		}
         else
         {
-            shader_code_text[shader_code_count] = (GLcharARB *)strdup((char *)buff);
+            shader_code_text[shader_code_count] = (GLchar *)strdup((char *)buff);
 		
             if(flag_write_to_out_of_extra_block_area & flags)
             {
@@ -964,40 +1032,40 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 	fclose(file);
 
 	//create shader object
-	GLhandleARB ret = glCreateShaderObjectARB(type);
+    GLuint ret = glCreateShader(type);
 
 	error = glGetError();
 	if (error != GL_NO_ERROR)
 	{
-		LL_WARNS("ShaderLoading") << "GL ERROR in glCreateShaderObjectARB: " << error << " for file: " << open_file_name << LL_ENDL;
+		LL_WARNS("ShaderLoading") << "GL ERROR in glCreateShader: " << error << " for file: " << open_file_name << LL_ENDL;
 	}
 
 	//load source
-	glShaderSourceARB(ret, shader_code_count, (const GLcharARB**) shader_code_text, NULL);
+	glShaderSource(ret, shader_code_count, (const GLchar**) shader_code_text, NULL);
 
 	error = glGetError();
 	if (error != GL_NO_ERROR)
 	{
-		LL_WARNS("ShaderLoading") << "GL ERROR in glShaderSourceARB: " << error << " for file: " << open_file_name << LL_ENDL;
+		LL_WARNS("ShaderLoading") << "GL ERROR in glShaderSource: " << error << " for file: " << open_file_name << LL_ENDL;
 	}
 
 	//compile source
-	glCompileShaderARB(ret);
+	glCompileShader(ret);
 
 	error = glGetError();
 	if (error != GL_NO_ERROR)
 	{
-		LL_WARNS("ShaderLoading") << "GL ERROR in glCompileShaderARB: " << error << " for file: " << open_file_name << LL_ENDL;
+		LL_WARNS("ShaderLoading") << "GL ERROR in glCompileShader: " << error << " for file: " << open_file_name << LL_ENDL;
 	}
 
 	if (error == GL_NO_ERROR)
 	{
 		//check for errors
 		GLint success = GL_TRUE;
-		glGetObjectParameterivARB(ret, GL_OBJECT_COMPILE_STATUS_ARB, &success);
+        glGetShaderiv(ret, GL_COMPILE_STATUS, &success);
 
 		error = glGetError();
-		if (error != GL_NO_ERROR || success == GL_FALSE) 
+		if (error != GL_NO_ERROR || success == GL_FALSE)
 		{
 			//an error occured, print log
 			LL_WARNS("ShaderLoading") << "GLSL Compilation Error:" << LL_ENDL;
@@ -1022,10 +1090,10 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 	if (ret)
 	{
 		// Add shader file to map
-        if (type == GL_VERTEX_SHADER_ARB) {
+        if (type == GL_VERTEX_SHADER) {
             mVertexShaderObjects[filename] = ret;
         }
-        else if (type == GL_FRAGMENT_SHADER_ARB) {
+        else if (type == GL_FRAGMENT_SHADER) {
             mFragmentShaderObjects[filename] = ret;
         }
 		shader_level = try_gpu_class;
@@ -1042,19 +1110,21 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 	return ret;
 }
 
-BOOL LLShaderMgr::linkProgramObject(GLhandleARB obj, BOOL suppress_errors) 
+BOOL LLShaderMgr::linkProgramObject(GLuint obj, BOOL suppress_errors)
 {
 	//check for errors
-	glLinkProgramARB(obj);
+	glLinkProgram(obj);
 	GLint success = GL_TRUE;
-	glGetObjectParameterivARB(obj, GL_OBJECT_LINK_STATUS_ARB, &success);
+    glGetProgramiv(obj, GL_LINK_STATUS, &success);
 	if (!suppress_errors && success == GL_FALSE) 
 	{
 		//an error occured, print log
 		LL_SHADER_LOADING_WARNS() << "GLSL Linker Error:" << LL_ENDL;
+        dumpObjectLog(obj, TRUE, "linker");
+        return success;
 	}
 
-	std::string log = get_object_log(obj);
+	std::string log = get_program_log(obj);
 	LLStringUtil::toLower(log);
 	if (log.find("software") != std::string::npos)
 	{
@@ -1065,12 +1135,12 @@ BOOL LLShaderMgr::linkProgramObject(GLhandleARB obj, BOOL suppress_errors)
 	return success;
 }
 
-BOOL LLShaderMgr::validateProgramObject(GLhandleARB obj)
+BOOL LLShaderMgr::validateProgramObject(GLuint obj)
 {
 	//check program validity against current GL
-	glValidateProgramARB(obj);
+	glValidateProgram(obj);
 	GLint success = GL_TRUE;
-	glGetObjectParameterivARB(obj, GL_OBJECT_VALIDATE_STATUS_ARB, &success);
+    glGetProgramiv(obj, GL_LINK_STATUS, &success);
 	if (success == GL_FALSE)
 	{
 		LL_SHADER_LOADING_WARNS() << "GLSL program not valid: " << LL_ENDL;
@@ -1108,6 +1178,7 @@ void LLShaderMgr::initAttribsAndUniforms()
 	mReservedUniforms.push_back("inv_proj");
 	mReservedUniforms.push_back("modelview_projection_matrix");
     mReservedUniforms.push_back("inv_modelview");
+    mReservedUniforms.push_back("identity_matrix");
 	mReservedUniforms.push_back("normal_matrix");
 	mReservedUniforms.push_back("texture_matrix0");
 	mReservedUniforms.push_back("texture_matrix1");
@@ -1115,13 +1186,18 @@ void LLShaderMgr::initAttribsAndUniforms()
 	mReservedUniforms.push_back("texture_matrix3");
 	mReservedUniforms.push_back("object_plane_s");
 	mReservedUniforms.push_back("object_plane_t");
-	llassert(mReservedUniforms.size() == LLShaderMgr::OBJECT_PLANE_T+1);
+    mReservedUniforms.push_back("texture_basecolor_matrix"); // GLTF
+    mReservedUniforms.push_back("texture_normal_matrix"); // GLTF
+    mReservedUniforms.push_back("texture_metallic_roughness_matrix"); // GLTF
+    mReservedUniforms.push_back("texture_emissive_matrix"); // GLTF
+    llassert(mReservedUniforms.size() == LLShaderMgr::TEXTURE_EMISSIVE_MATRIX+1);
 
 	mReservedUniforms.push_back("viewport");
 
 	mReservedUniforms.push_back("light_position");
 	mReservedUniforms.push_back("light_direction");
 	mReservedUniforms.push_back("light_attenuation");
+    mReservedUniforms.push_back("light_deferred_attenuation");
 	mReservedUniforms.push_back("light_diffuse");
 	mReservedUniforms.push_back("light_ambient");
 	mReservedUniforms.push_back("light_count");
@@ -1148,13 +1224,19 @@ void LLShaderMgr::initAttribsAndUniforms()
 	llassert(mReservedUniforms.size() == LLShaderMgr::PROJECTOR_AMBIENT_LOD+1);
 
 	mReservedUniforms.push_back("color");
-		
+    mReservedUniforms.push_back("emissiveColor");
+    mReservedUniforms.push_back("metallicFactor");
+    mReservedUniforms.push_back("roughnessFactor");
+
 	mReservedUniforms.push_back("diffuseMap");
     mReservedUniforms.push_back("altDiffuseMap");
 	mReservedUniforms.push_back("specularMap");
+    mReservedUniforms.push_back("emissiveMap");
 	mReservedUniforms.push_back("bumpMap");
     mReservedUniforms.push_back("bumpMap2");
 	mReservedUniforms.push_back("environmentMap");
+    mReservedUniforms.push_back("reflectionProbes");
+    mReservedUniforms.push_back("irradianceProbes");
 	mReservedUniforms.push_back("cloud_noise_texture");
     mReservedUniforms.push_back("cloud_noise_texture_next");
 	mReservedUniforms.push_back("fullbright");
@@ -1162,9 +1244,12 @@ void LLShaderMgr::initAttribsAndUniforms()
 	mReservedUniforms.push_back("sunlight_color");
 	mReservedUniforms.push_back("ambient_color");
 	mReservedUniforms.push_back("blue_horizon");
+    mReservedUniforms.push_back("blue_horizon_linear");
 	mReservedUniforms.push_back("blue_density");
+    mReservedUniforms.push_back("blue_density_linear");
 	mReservedUniforms.push_back("haze_horizon");
 	mReservedUniforms.push_back("haze_density");
+    mReservedUniforms.push_back("haze_density_linear");
 	mReservedUniforms.push_back("cloud_shadow");
 	mReservedUniforms.push_back("density_multiplier");
 	mReservedUniforms.push_back("distance_multiplier");
@@ -1201,6 +1286,7 @@ void LLShaderMgr::initAttribsAndUniforms()
 	mReservedUniforms.push_back("minimum_alpha");
 	mReservedUniforms.push_back("emissive_brightness");
 
+    // Deferred
 	mReservedUniforms.push_back("shadow_matrix");
 	mReservedUniforms.push_back("env_mat");
 	mReservedUniforms.push_back("shadow_clip");
@@ -1225,8 +1311,9 @@ void LLShaderMgr::initAttribsAndUniforms()
 	mReservedUniforms.push_back("depth_cutoff");
 	mReservedUniforms.push_back("norm_cutoff");
 	mReservedUniforms.push_back("shadow_target_width");
+    mReservedUniforms.push_back("view_dir"); // DEFERRED_VIEW_DIR
 	
-	llassert(mReservedUniforms.size() == LLShaderMgr::DEFERRED_SHADOW_TARGET_WIDTH+1);
+	llassert(mReservedUniforms.size() == LLShaderMgr::DEFERRED_VIEW_DIR+1);
 
 	mReservedUniforms.push_back("tc_scale");
 	mReservedUniforms.push_back("rcp_screen_res");
@@ -1256,6 +1343,8 @@ void LLShaderMgr::initAttribsAndUniforms()
 	mReservedUniforms.push_back("positionMap");
 	mReservedUniforms.push_back("diffuseRect");
 	mReservedUniforms.push_back("specularRect");
+    mReservedUniforms.push_back("emissiveRect");
+    mReservedUniforms.push_back("brdfLut");
 	mReservedUniforms.push_back("noiseMap");
 	mReservedUniforms.push_back("lightFunc");
 	mReservedUniforms.push_back("lightMap");
@@ -1281,6 +1370,7 @@ void LLShaderMgr::initAttribsAndUniforms()
 	mReservedUniforms.push_back("specular");
 	mReservedUniforms.push_back("lightExp");
 	mReservedUniforms.push_back("waterFogColor");
+    mReservedUniforms.push_back("waterFogColorLinear");
 	mReservedUniforms.push_back("waterFogDensity");
 	mReservedUniforms.push_back("waterFogKS");
 	mReservedUniforms.push_back("refScale");
@@ -1326,6 +1416,7 @@ void LLShaderMgr::initAttribsAndUniforms()
     mReservedUniforms.push_back("halo_map");
     mReservedUniforms.push_back("moon_brightness");
     mReservedUniforms.push_back("cloud_variance");
+    mReservedUniforms.push_back("reflection_probe_ambiance");
 
     mReservedUniforms.push_back("sh_input_r");
     mReservedUniforms.push_back("sh_input_g");
@@ -1335,6 +1426,9 @@ void LLShaderMgr::initAttribsAndUniforms()
     mReservedUniforms.push_back("water_edge");
     mReservedUniforms.push_back("sun_up_factor");
     mReservedUniforms.push_back("moonlight_color");
+    mReservedUniforms.push_back("moonlight_linear");
+    mReservedUniforms.push_back("sunlight_linear");
+    mReservedUniforms.push_back("ambient_linear");
 
 	llassert(mReservedUniforms.size() == END_RESERVED_UNIFORMS);