summaryrefslogtreecommitdiff
path: root/indra/llrender/llshadermgr.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'indra/llrender/llshadermgr.cpp')
-rw-r--r--indra/llrender/llshadermgr.cpp370
1 files changed, 242 insertions, 128 deletions
diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index 643c368870..bce3720d3b 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -25,22 +25,14 @@
*/
#include "linden_common.h"
-
#include "llshadermgr.h"
-
-#include "llfile.h"
#include "llrender.h"
+#include "llfile.h"
#if LL_DARWIN
#include "OpenGL/OpenGL.h"
#endif
-#ifdef LL_RELEASE_FOR_DOWNLOAD
-#define UNIFORM_ERRS LL_WARNS_ONCE("Shader")
-#else
-#define UNIFORM_ERRS LL_ERRS("Shader")
-#endif
-
// Lots of STL stuff in here, using namespace std to keep things more readable
using std::vector;
using std::pair;
@@ -87,20 +79,20 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
{
if (features->hasWaterFog)
{
- if (!shader->attachObject("windlight/atmosphericsVarsWaterV.glsl"))
+ if (!shader->attachVertexObject("windlight/atmosphericsVarsWaterV.glsl"))
{
return FALSE;
}
}
- else if (!shader->attachObject("windlight/atmosphericsVarsV.glsl"))
+ else if (!shader->attachVertexObject("windlight/atmosphericsVarsV.glsl"))
{
return FALSE;
}
}
- if (features->calculatesLighting || features->atmosphericHelpers)
+ if (features->calculatesLighting || features->calculatesAtmospherics)
{
- if (!shader->attachObject("windlight/atmosphericsHelpersV.glsl"))
+ if (!shader->attachVertexObject("windlight/atmosphericsHelpersV.glsl"))
{
return FALSE;
}
@@ -110,40 +102,40 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
{
if (features->isSpecular)
{
- if (!shader->attachObject("lighting/lightFuncSpecularV.glsl"))
+ if (!shader->attachVertexObject("lighting/lightFuncSpecularV.glsl"))
{
return FALSE;
}
if (!features->isAlphaLighting)
{
- if (!shader->attachObject("lighting/sumLightsSpecularV.glsl"))
+ if (!shader->attachVertexObject("lighting/sumLightsSpecularV.glsl"))
{
return FALSE;
}
}
- if (!shader->attachObject("lighting/lightSpecularV.glsl"))
+ if (!shader->attachVertexObject("lighting/lightSpecularV.glsl"))
{
return FALSE;
}
}
else
{
- if (!shader->attachObject("lighting/lightFuncV.glsl"))
+ if (!shader->attachVertexObject("lighting/lightFuncV.glsl"))
{
return FALSE;
}
if (!features->isAlphaLighting)
{
- if (!shader->attachObject("lighting/sumLightsV.glsl"))
+ if (!shader->attachVertexObject("lighting/sumLightsV.glsl"))
{
return FALSE;
}
}
- if (!shader->attachObject("lighting/lightV.glsl"))
+ if (!shader->attachVertexObject("lighting/lightV.glsl"))
{
return FALSE;
}
@@ -152,8 +144,12 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
// NOTE order of shader object attaching is VERY IMPORTANT!!!
if (features->calculatesAtmospherics)
- {
- if (!shader->attachObject("windlight/atmosphericsV.glsl"))
+ {
+ if (!shader->attachVertexObject("windlight/atmosphericsFuncs.glsl")) {
+ return FALSE;
+ }
+
+ if (!shader->attachVertexObject("windlight/atmosphericsV.glsl"))
{
return FALSE;
}
@@ -161,7 +157,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
if (features->hasSkinning)
{
- if (!shader->attachObject("avatar/avatarSkinV.glsl"))
+ if (!shader->attachVertexObject("avatar/avatarSkinV.glsl"))
{
return FALSE;
}
@@ -169,7 +165,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
if (features->hasObjectSkinning)
{
- if (!shader->attachObject("avatar/objectSkinV.glsl"))
+ if (!shader->attachVertexObject("avatar/objectSkinV.glsl"))
{
return FALSE;
}
@@ -179,33 +175,95 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
// Attach Fragment Shader Features Next
///////////////////////////////////////
+// NOTE order of shader object attaching is VERY IMPORTANT!!!
+
if(features->calculatesAtmospherics)
{
if (features->hasWaterFog)
{
- if (!shader->attachObject("windlight/atmosphericsVarsWaterF.glsl"))
+ if (!shader->attachFragmentObject("windlight/atmosphericsVarsWaterF.glsl"))
{
return FALSE;
}
}
- else if (!shader->attachObject("windlight/atmosphericsVarsF.glsl"))
+ else if (!shader->attachFragmentObject("windlight/atmosphericsVarsF.glsl"))
+ {
+ return FALSE;
+ }
+ }
+
+ if (features->calculatesLighting || features->calculatesAtmospherics)
+ {
+ if (!shader->attachFragmentObject("windlight/atmosphericsHelpersF.glsl"))
+ {
+ return FALSE;
+ }
+ }
+
+ // we want this BEFORE shadows and AO because those facilities use pos/norm access
+ if (features->isDeferred)
+ {
+ if (!shader->attachFragmentObject("deferred/deferredUtil.glsl"))
+ {
+ return FALSE;
+ }
+ }
+
+ if (features->hasShadows)
+ {
+ if (!shader->attachFragmentObject("deferred/shadowUtil.glsl"))
+ {
+ return FALSE;
+ }
+ }
+
+ if (features->hasAmbientOcclusion)
+ {
+ if (!shader->attachFragmentObject("deferred/aoUtil.glsl"))
+ {
+ return FALSE;
+ }
+ }
+
+ if (features->hasIndirect)
+ {
+ if (!shader->attachFragmentObject("deferred/indirect.glsl"))
{
return FALSE;
}
}
- // NOTE order of shader object attaching is VERY IMPORTANT!!!
if (features->hasGamma)
{
- if (!shader->attachObject("windlight/gammaF.glsl"))
+ if (!shader->attachFragmentObject("windlight/gammaF.glsl"))
{
return FALSE;
}
}
-
- if (features->hasAtmospherics)
+
+ if (features->hasSrgb)
+ {
+ if (!shader->attachFragmentObject("environment/srgbF.glsl"))
+ {
+ return FALSE;
+ }
+ }
+
+ if (features->encodesNormal)
{
- if (!shader->attachObject("windlight/atmosphericsF.glsl"))
+ if (!shader->attachFragmentObject("environment/encodeNormF.glsl"))
+ {
+ return FALSE;
+ }
+ }
+
+ if (features->hasAtmospherics)
+ {
+ if (!shader->attachFragmentObject("windlight/atmosphericsFuncs.glsl")) {
+ return FALSE;
+ }
+
+ if (!shader->attachFragmentObject("windlight/atmosphericsF.glsl"))
{
return FALSE;
}
@@ -213,7 +271,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
if (features->hasTransport)
{
- if (!shader->attachObject("windlight/transportF.glsl"))
+ if (!shader->attachFragmentObject("windlight/transportF.glsl"))
{
return FALSE;
}
@@ -225,7 +283,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
// NOTE order of shader object attaching is VERY IMPORTANT!!!
if (features->hasWaterFog)
{
- if (!shader->attachObject("environment/waterFogF.glsl"))
+ if (!shader->attachFragmentObject("environment/waterFogF.glsl"))
{
return FALSE;
}
@@ -239,14 +297,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
{
if (features->hasAlphaMask)
{
- if (!shader->attachObject("lighting/lightWaterAlphaMaskNonIndexedF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightWaterAlphaMaskNonIndexedF.glsl"))
{
return FALSE;
}
}
else
{
- if (!shader->attachObject("lighting/lightWaterNonIndexedF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightWaterNonIndexedF.glsl"))
{
return FALSE;
}
@@ -256,14 +314,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
{
if (features->hasAlphaMask)
{
- if (!shader->attachObject("lighting/lightWaterAlphaMaskF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightWaterAlphaMaskF.glsl"))
{
return FALSE;
}
}
else
{
- if (!shader->attachObject("lighting/lightWaterF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightWaterF.glsl"))
{
return FALSE;
}
@@ -278,14 +336,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
{
if (features->hasAlphaMask)
{
- if (!shader->attachObject("lighting/lightAlphaMaskNonIndexedF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightAlphaMaskNonIndexedF.glsl"))
{
return FALSE;
}
}
else
{
- if (!shader->attachObject("lighting/lightNonIndexedF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightNonIndexedF.glsl"))
{
return FALSE;
}
@@ -295,14 +353,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
{
if (features->hasAlphaMask)
{
- if (!shader->attachObject("lighting/lightAlphaMaskF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightAlphaMaskF.glsl"))
{
return FALSE;
}
}
else
{
- if (!shader->attachObject("lighting/lightF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightF.glsl"))
{
return FALSE;
}
@@ -320,14 +378,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
{
if (features->disableTextureIndex)
{
- if (!shader->attachObject("lighting/lightFullbrightShinyWaterNonIndexedF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightFullbrightShinyWaterNonIndexedF.glsl"))
{
return FALSE;
}
}
else
{
- if (!shader->attachObject("lighting/lightFullbrightShinyWaterF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightFullbrightShinyWaterF.glsl"))
{
return FALSE;
}
@@ -340,12 +398,12 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
{
if (features->hasAlphaMask)
{
- if (!shader->attachObject("lighting/lightFullbrightWaterNonIndexedAlphaMaskF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightFullbrightWaterNonIndexedAlphaMaskF.glsl"))
{
return FALSE;
}
}
- else if (!shader->attachObject("lighting/lightFullbrightWaterNonIndexedF.glsl"))
+ else if (!shader->attachFragmentObject("lighting/lightFullbrightWaterNonIndexedF.glsl"))
{
return FALSE;
}
@@ -354,12 +412,12 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
{
if (features->hasAlphaMask)
{
- if (!shader->attachObject("lighting/lightFullbrightWaterAlphaMaskF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightFullbrightWaterAlphaMaskF.glsl"))
{
return FALSE;
}
}
- else if (!shader->attachObject("lighting/lightFullbrightWaterF.glsl"))
+ else if (!shader->attachFragmentObject("lighting/lightFullbrightWaterF.glsl"))
{
return FALSE;
}
@@ -371,14 +429,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
{
if (features->disableTextureIndex)
{
- if (!shader->attachObject("lighting/lightFullbrightShinyNonIndexedF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightFullbrightShinyNonIndexedF.glsl"))
{
return FALSE;
}
}
else
{
- if (!shader->attachObject("lighting/lightFullbrightShinyF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightFullbrightShinyF.glsl"))
{
return FALSE;
}
@@ -393,14 +451,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
if (features->hasAlphaMask)
{
- if (!shader->attachObject("lighting/lightFullbrightNonIndexedAlphaMaskF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightFullbrightNonIndexedAlphaMaskF.glsl"))
{
return FALSE;
}
}
else
{
- if (!shader->attachObject("lighting/lightFullbrightNonIndexedF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightFullbrightNonIndexedF.glsl"))
{
return FALSE;
}
@@ -410,14 +468,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
{
if (features->hasAlphaMask)
{
- if (!shader->attachObject("lighting/lightFullbrightAlphaMaskF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightFullbrightAlphaMaskF.glsl"))
{
return FALSE;
}
}
else
{
- if (!shader->attachObject("lighting/lightFullbrightF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightFullbrightF.glsl"))
{
return FALSE;
}
@@ -435,14 +493,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
{
if (features->disableTextureIndex)
{
- if (!shader->attachObject("lighting/lightShinyWaterNonIndexedF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightShinyWaterNonIndexedF.glsl"))
{
return FALSE;
}
}
else
{
- if (!shader->attachObject("lighting/lightShinyWaterF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightShinyWaterF.glsl"))
{
return FALSE;
}
@@ -454,14 +512,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
{
if (features->disableTextureIndex)
{
- if (!shader->attachObject("lighting/lightShinyNonIndexedF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightShinyNonIndexedF.glsl"))
{
return FALSE;
}
}
else
{
- if (!shader->attachObject("lighting/lightShinyF.glsl"))
+ if (!shader->attachFragmentObject("lighting/lightShinyF.glsl"))
{
return FALSE;
}
@@ -472,14 +530,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
if (features->mIndexedTextureChannels <= 1)
{
- if (!shader->attachObject("objects/nonindexedTextureV.glsl"))
+ if (!shader->attachVertexObject("objects/nonindexedTextureV.glsl"))
{
return FALSE;
}
}
else
{
- if (!shader->attachObject("objects/indexedTextureV.glsl"))
+ if (!shader->attachVertexObject("objects/indexedTextureV.glsl"))
{
return FALSE;
}
@@ -509,31 +567,50 @@ static std::string get_object_log(GLhandleARB ret)
return res;
}
+//dump shader source for debugging
+void LLShaderMgr::dumpShaderSource(U32 shader_code_count, GLcharARB** shader_code_text)
+{
+ for (GLuint i = 0; i < shader_code_count; i++)
+ {
+ LL_SHADER_LOADING_WARNS() << i << ": " << shader_code_text[i] << LL_ENDL;
+ }
+ LL_SHADER_LOADING_WARNS() << LL_ENDL;
+}
+
void LLShaderMgr::dumpObjectLog(GLhandleARB ret, BOOL warns, const std::string& filename)
{
std::string log = get_object_log(ret);
+ std::string fname = filename;
+ if (filename.empty())
+ {
+ fname = "unknown shader file";
+ }
- if (log.length() > 0 || warns)
+ if (log.length() > 0)
{
- LL_DEBUGS("ShaderLoading") << "Shader loading ";
-
- if (!filename.empty())
- {
- LL_CONT << "From " << filename << ":\n";
- }
- LL_CONT << log << LL_ENDL;
+ LL_SHADER_LOADING_WARNS() << "Shader loading from " << fname << ":\n" << LL_ENDL;
+ LL_SHADER_LOADING_WARNS() << log << LL_ENDL;
}
}
GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_level, GLenum type, boost::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)
+#if LL_DARWIN
+ if (defines)
+ {
+ (*defines)["OLD_SELECT"] = "1";
+ }
+#endif
+
GLenum error = GL_NO_ERROR;
if (gDebugGL)
{
error = glGetError();
if (error != GL_NO_ERROR)
{
- LL_WARNS("ShaderLoading") << "GL ERROR entering loadShaderFile(): " << error << LL_ENDL;
+ LL_SHADER_LOADING_WARNS() << "GL ERROR entering loadShaderFile(): " << error << LL_ENDL;
}
}
@@ -549,6 +626,7 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
S32 try_gpu_class = shader_level;
S32 gpu_class;
+ std::string open_file_name;
//find the most relevant file
for (gpu_class = try_gpu_class; gpu_class > 0; gpu_class--)
{ //search from the current gpu class down to class 1 to find the most relevant shader
@@ -556,18 +634,33 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
fname << getShaderDirPrefix();
fname << gpu_class << "/" << filename;
-
- file = LLFile::fopen(fname.str(), "r"); /* Flawfinder: ignore */
+ open_file_name = fname.str();
+
+ /*
+ Would be awesome, if we didn't have shaders that re-use files
+ with different environments to say, add skinning, etc
+ can't depend on cached version to have evaluate ifdefs identically...
+ if we can define a deterministic hash for the shader based on
+ all the inputs, maybe we can save some time here.
+ if (mShaderObjects.count(filename) > 0)
+ {
+ return mShaderObjects[filename];
+ }
+
+ */
+
+ LL_DEBUGS("ShaderLoading") << "Looking in " << open_file_name << LL_ENDL;
+ file = LLFile::fopen(open_file_name, "r"); /* Flawfinder: ignore */
if (file)
{
- LL_DEBUGS("ShaderLoading") << "Loading file: shaders/class" << gpu_class << "/" << filename << " (Want class " << gpu_class << ")" << LL_ENDL;
+ LL_DEBUGS("ShaderLoading") << "Loading file: " << open_file_name << " (Want class " << gpu_class << ")" << LL_ENDL;
break; // done
}
}
if (file == NULL)
{
- LL_WARNS("ShaderLoading") << "GLSL Shader file not found: " << filename << LL_ENDL;
+ LL_SHADER_LOADING_WARNS() << "GLSL Shader file not found: " << open_file_name << LL_ENDL;
return 0;
}
@@ -612,7 +705,31 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
}
else
{
- if (major_version < 4)
+ if (major_version >= 4)
+ {
+ //set version to 400
+ shader_code_text[shader_code_count++] = strdup("#version 400\n");
+ }
+ else if (major_version == 3)
+ {
+ if (minor_version < 10)
+ {
+ shader_code_text[shader_code_count++] = strdup("#version 300\n");
+ }
+ else if (minor_version <= 19)
+ {
+ shader_code_text[shader_code_count++] = strdup("#version 310\n");
+ }
+ else if (minor_version <= 29)
+ {
+ shader_code_text[shader_code_count++] = strdup("#version 320\n");
+ }
+ else
+ {
+ shader_code_text[shader_code_count++] = strdup("#version 330\n");
+ }
+ }
+ else
{
//set version to 1.30
shader_code_text[shader_code_count++] = strdup("#version 130\n");
@@ -620,10 +737,6 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
extra_code_text[extra_code_count++] = strdup("precision mediump int;\n");
extra_code_text[extra_code_count++] = strdup("precision highp float;\n");
}
- else
- { //set version to 400
- shader_code_text[shader_code_count++] = strdup("#version 400\n");
- }
extra_code_text[extra_code_count++] = strdup("#define DEFINE_GL_FRAGCOLOR 1\n");
extra_code_text[extra_code_count++] = strdup("#define FXAA_GLSL_130 1\n");
@@ -646,7 +759,7 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
extra_code_text[extra_code_count++] = strdup("#define texture2D texture\n");
extra_code_text[extra_code_count++] = strdup("#define textureCube texture\n");
extra_code_text[extra_code_count++] = strdup("#define texture2DLod textureLod\n");
- extra_code_text[extra_code_count++] = strdup("#define shadow2D(a,b) vec2(texture(a,b))\n");
+ extra_code_text[extra_code_count++] = strdup("#define shadow2D(a,b) vec2(texture(a,b))\n");
if (major_version > 1 || minor_version >= 40)
{ //GLSL 1.40 replaces texture2DRect et al with texture
@@ -704,7 +817,7 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
}
*/
- extra_code_text[extra_code_count++] = strdup("#define HAS_DIFFUSE_LOOKUP 1\n");
+ extra_code_text[extra_code_count++] = strdup("#define HAS_DIFFUSE_LOOKUP\n");
//uniform declartion
for (S32 i = 0; i < texture_index_channels; ++i)
@@ -763,11 +876,6 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
LL_ERRS() << "Indexed texture rendering requires GLSL 1.30 or later." << LL_ENDL;
}
}
- else
- {
- extra_code_text[extra_code_count++] = strdup("#define HAS_DIFFUSE_LOOKUP 0\n");
- }
-
//copy file into memory
enum {
@@ -897,38 +1005,8 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
{
//an error occured, print log
LL_WARNS("ShaderLoading") << "GLSL Compilation Error:" << LL_ENDL;
- dumpObjectLog(ret, TRUE, filename);
-#if LL_WINDOWS
- std::stringstream ostr;
- //dump shader source for debugging
- for (GLuint i = 0; i < shader_code_count; i++)
- {
- ostr << i << ": " << shader_code_text[i];
-
- if (i % 128 == 0)
- { //dump every 128 lines
-
- LL_WARNS("ShaderLoading") << "\n" << ostr.str() << LL_ENDL;
- ostr = std::stringstream();
- }
-
- }
-
- LL_WARNS("ShaderLoading") << "\n" << ostr.str() << LL_ENDL;
-#else
- std::string str;
-
- for (GLuint i = 0; i < shader_code_count; i++) {
- str.append(shader_code_text[i]);
-
- if (i % 128 == 0)
- {
- LL_WARNS("ShaderLoading") << str << LL_ENDL;
- str = "";
- }
- }
-#endif
-
+ dumpObjectLog(ret, TRUE, open_file_name);
+ dumpShaderSource(shader_code_count, shader_code_text);
ret = 0;
}
}
@@ -949,7 +1027,12 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
if (ret)
{
// Add shader file to map
- mShaderObjects[filename] = ret;
+ if (type == GL_VERTEX_SHADER_ARB) {
+ mVertexShaderObjects[filename] = ret;
+ }
+ else if (type == GL_FRAGMENT_SHADER_ARB) {
+ mFragmentShaderObjects[filename] = ret;
+ }
shader_level = try_gpu_class;
}
else
@@ -957,7 +1040,7 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
if (shader_level > 1)
{
shader_level--;
- return loadShaderFile(filename,shader_level,type, defines, texture_index_channels);
+ return loadShaderFile(filename, shader_level, type, defines, texture_index_channels);
}
LL_WARNS("ShaderLoading") << "Failed to load " << filename << LL_ENDL;
}
@@ -973,7 +1056,7 @@ BOOL LLShaderMgr::linkProgramObject(GLhandleARB obj, BOOL suppress_errors)
if (!suppress_errors && success == GL_FALSE)
{
//an error occured, print log
- LL_WARNS("ShaderLoading") << "GLSL Linker Error:" << LL_ENDL;
+ LL_SHADER_LOADING_WARNS() << "GLSL Linker Error:" << LL_ENDL;
}
#if LL_DARWIN
@@ -1006,7 +1089,7 @@ BOOL LLShaderMgr::linkProgramObject(GLhandleARB obj, BOOL suppress_errors)
CGLGetParameter(ctx, kCGLCPGPUFragmentProcessing, &fragmentGPUProcessing);
if (!fragmentGPUProcessing || !vertexGPUProcessing)
{
- LL_WARNS("ShaderLoading") << "GLSL Linker: Running in Software:" << LL_ENDL;
+ LL_SHADER_LOADING_WARNS() << "GLSL Linker: Running in Software:" << LL_ENDL;
success = GL_FALSE;
suppress_errors = FALSE;
}
@@ -1017,7 +1100,7 @@ BOOL LLShaderMgr::linkProgramObject(GLhandleARB obj, BOOL suppress_errors)
LLStringUtil::toLower(log);
if (log.find("software") != std::string::npos)
{
- LL_WARNS("ShaderLoading") << "GLSL Linker: Running in Software:" << LL_ENDL;
+ LL_SHADER_LOADING_WARNS() << "GLSL Linker: Running in Software:" << LL_ENDL;
success = GL_FALSE;
suppress_errors = FALSE;
}
@@ -1033,7 +1116,7 @@ BOOL LLShaderMgr::validateProgramObject(GLhandleARB obj)
glGetObjectParameterivARB(obj, GL_OBJECT_VALIDATE_STATUS_ARB, &success);
if (success == GL_FALSE)
{
- LL_WARNS("ShaderLoading") << "GLSL program not valid: " << LL_ENDL;
+ LL_SHADER_LOADING_WARNS() << "GLSL program not valid: " << LL_ENDL;
dumpObjectLog(obj);
}
else
@@ -1067,6 +1150,7 @@ void LLShaderMgr::initAttribsAndUniforms()
mReservedUniforms.push_back("projection_matrix");
mReservedUniforms.push_back("inv_proj");
mReservedUniforms.push_back("modelview_projection_matrix");
+ mReservedUniforms.push_back("inv_modelview");
mReservedUniforms.push_back("normal_matrix");
mReservedUniforms.push_back("texture_matrix0");
mReservedUniforms.push_back("texture_matrix1");
@@ -1109,14 +1193,17 @@ void LLShaderMgr::initAttribsAndUniforms()
mReservedUniforms.push_back("color");
mReservedUniforms.push_back("diffuseMap");
+ mReservedUniforms.push_back("altDiffuseMap");
mReservedUniforms.push_back("specularMap");
mReservedUniforms.push_back("bumpMap");
+ mReservedUniforms.push_back("bumpMap2");
mReservedUniforms.push_back("environmentMap");
- mReservedUniforms.push_back("cloude_noise_texture");
+ mReservedUniforms.push_back("cloud_noise_texture");
+ mReservedUniforms.push_back("cloud_noise_texture_next");
mReservedUniforms.push_back("fullbright");
mReservedUniforms.push_back("lightnorm");
- mReservedUniforms.push_back("sunlight_color_copy");
- mReservedUniforms.push_back("ambient");
+ mReservedUniforms.push_back("sunlight_color");
+ mReservedUniforms.push_back("ambient_color");
mReservedUniforms.push_back("blue_horizon");
mReservedUniforms.push_back("blue_density");
mReservedUniforms.push_back("haze_horizon");
@@ -1175,6 +1262,7 @@ void LLShaderMgr::initAttribsAndUniforms()
mReservedUniforms.push_back("spot_shadow_bias");
mReservedUniforms.push_back("spot_shadow_offset");
mReservedUniforms.push_back("sun_dir");
+ mReservedUniforms.push_back("moon_dir");
mReservedUniforms.push_back("shadow_res");
mReservedUniforms.push_back("proj_shadow_res");
mReservedUniforms.push_back("depth_cutoff");
@@ -1217,8 +1305,6 @@ void LLShaderMgr::initAttribsAndUniforms()
mReservedUniforms.push_back("bloomMap");
mReservedUniforms.push_back("projectionMap");
mReservedUniforms.push_back("norm_mat");
-
- mReservedUniforms.push_back("global_gamma");
mReservedUniforms.push_back("texture_gamma");
mReservedUniforms.push_back("specular_color");
@@ -1232,8 +1318,8 @@ void LLShaderMgr::initAttribsAndUniforms()
mReservedUniforms.push_back("refTex");
mReservedUniforms.push_back("eyeVec");
mReservedUniforms.push_back("time");
- mReservedUniforms.push_back("d1");
- mReservedUniforms.push_back("d2");
+ mReservedUniforms.push_back("waveDir1");
+ mReservedUniforms.push_back("waveDir2");
mReservedUniforms.push_back("lightDir");
mReservedUniforms.push_back("specular");
mReservedUniforms.push_back("lightExp");
@@ -1265,6 +1351,34 @@ void LLShaderMgr::initAttribsAndUniforms()
mReservedUniforms.push_back("origin");
mReservedUniforms.push_back("display_gamma");
+
+ mReservedUniforms.push_back("inscatter");
+ mReservedUniforms.push_back("sun_size");
+ mReservedUniforms.push_back("fog_color");
+
+ mReservedUniforms.push_back("transmittance_texture");
+ mReservedUniforms.push_back("scattering_texture");
+ mReservedUniforms.push_back("single_mie_scattering_texture");
+ mReservedUniforms.push_back("irradiance_texture");
+ mReservedUniforms.push_back("blend_factor");
+ mReservedUniforms.push_back("no_atmo");
+ mReservedUniforms.push_back("moisture_level");
+ mReservedUniforms.push_back("droplet_radius");
+ mReservedUniforms.push_back("ice_level");
+ mReservedUniforms.push_back("rainbow_map");
+ mReservedUniforms.push_back("halo_map");
+ mReservedUniforms.push_back("moon_brightness");
+ mReservedUniforms.push_back("cloud_variance");
+
+ mReservedUniforms.push_back("sh_input_r");
+ mReservedUniforms.push_back("sh_input_g");
+ mReservedUniforms.push_back("sh_input_b");
+
+ mReservedUniforms.push_back("sun_moon_glow_factor");
+ mReservedUniforms.push_back("water_edge");
+ mReservedUniforms.push_back("sun_up_factor");
+ mReservedUniforms.push_back("moonlight_color");
+
llassert(mReservedUniforms.size() == END_RESERVED_UNIFORMS);
std::set<std::string> dupe_check;
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-14 21:00:13 +0000