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.cpp151
1 files changed, 110 insertions, 41 deletions
diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index a8e9f20b40..6dd3634309 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -44,7 +44,6 @@ using std::make_pair;
using std::string;
LLShaderMgr * LLShaderMgr::sInstance = NULL;
-bool LLShaderMgr::sMirrorsEnabled = false;
LLShaderMgr::LLShaderMgr()
{
@@ -80,7 +79,7 @@ bool LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
//////////////////////////////////////
// NOTE order of shader object attaching is VERY IMPORTANT!!!
- if (features->calculatesAtmospherics)
+ if (features->calculatesAtmospherics || features->hasGamma || features->isDeferred)
{
if (!shader->attachVertexObject("windlight/atmosphericsVarsV.glsl"))
{
@@ -224,6 +223,14 @@ bool LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
}
}
+ if (features->hasFullGBuffer)
+ {
+ if (!shader->attachFragmentObject("deferred/gbufferUtil.glsl"))
+ {
+ return false;
+ }
+ }
+
if (features->hasScreenSpaceReflections || features->hasReflectionProbes)
{
if (!shader->attachFragmentObject("deferred/screenSpaceReflUtil.glsl"))
@@ -256,6 +263,7 @@ bool LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
}
}
+ /*
if (features->hasGamma || features->isDeferred)
{
if (!shader->attachFragmentObject("windlight/gammaF.glsl"))
@@ -263,6 +271,7 @@ bool LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
return false;
}
}
+ */
if (features->hasAtmospherics || features->isDeferred)
{
@@ -284,6 +293,14 @@ bool LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
}
}
+ if (features->hasTonemap)
+ {
+ if (!shader->attachFragmentObject("deferred/tonemapUtilF.glsl"))
+ {
+ return false;
+ }
+ }
+
// NOTE order of shader object attaching is VERY IMPORTANT!!!
if (features->hasAtmospherics)
{
@@ -443,7 +460,7 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
// endsure work-around for missing GLSL funcs gets propogated to feature shader files (e.g. srgbF.glsl)
#if LL_DARWIN
- if (defines)
+ if (!gGLManager.mIsApple && defines)
{
(*defines)["OLD_SELECT"] = "1";
}
@@ -459,6 +476,7 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
if (filename.empty())
{
+ LL_WARNS("ShaderLoading") << "tried loading empty filename" << LL_ENDL;
return 0;
}
@@ -555,22 +573,16 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
}
else
{
- shader_code_text[shader_code_count++] = strdup("#version 400\n");
+ shader_code_text[shader_code_count++] = strdup("#version 410\n");
}
}
else if (major_version == 3)
{
- if (minor_version < 10)
+ if (minor_version <= 29)
{
- 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");
+ // OpenGL 3.2 had GLSL version 1.50. anything after that the version numbers match.
+ // https://www.khronos.org/opengl/wiki/Core_Language_(GLSL)#OpenGL_and_GLSL_versions
+ shader_code_text[shader_code_count++] = strdup("#version 150\n");
}
else
{
@@ -579,7 +591,8 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
}
else
{
- if (type == GL_GEOMETRY_SHADER)
+ // OpenGL 3.2 had GLSL version 1.50. anything after that the version numbers match.
+ if (type == GL_GEOMETRY_SHADER || minor_version >= 50)
{
//set version to 1.50
shader_code_text[shader_code_count++] = strdup("#version 150\n");
@@ -596,13 +609,15 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
extra_code_text[extra_code_count++] = strdup("precision highp float;\n");
}
}
-
- extra_code_text[extra_code_count++] = strdup("#define FXAA_GLSL_130 1\n");
}
- if (sMirrorsEnabled)
+ if (type == GL_FRAGMENT_SHADER)
{
- extra_code_text[extra_code_count++] = strdup("#define HERO_PROBES 1\n");
+ extra_code_text[extra_code_count++] = strdup("#define FRAGMENT_SHADER 1\n");
+ }
+ else
+ {
+ extra_code_text[extra_code_count++] = strdup("#define VERTEX_SHADER 1\n");
}
// Use alpha float to store bit flags
@@ -611,7 +626,7 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
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 GBUFFER_FLAG_HAS_HDRI 1.0\n"); // bit 2
- extra_code_text[extra_code_count++] = strdup("#define GET_GBUFFER_FLAG(flag) (abs(norm.w-flag)< 0.1)\n");
+ extra_code_text[extra_code_count++] = strdup("#define GET_GBUFFER_FLAG(data, flag) (abs(data-flag)< 0.1)\n");
if (defines)
{
@@ -722,6 +737,9 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
}
}
+ // Master definition can be found in deferredUtil.glsl
+ extra_code_text[extra_code_count++] = strdup("struct GBufferInfo { vec4 albedo; vec4 specular; vec3 normal; vec4 emissive; float gbufferFlag; float envIntensity; };\n");
+
//copy file into memory
enum {
flag_write_to_out_of_extra_block_area = 0x01
@@ -916,6 +934,8 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
}
LL_WARNS("ShaderLoading") << "Failed to load " << filename << LL_ENDL;
}
+
+ LL_DEBUGS("ShaderLoading") << "loadShaderFile() completed, ret: " << U32(ret) << LL_ENDL;
return ret;
}
@@ -971,16 +991,17 @@ bool LLShaderMgr::validateProgramObject(GLuint obj)
return success;
}
-void LLShaderMgr::initShaderCache(bool enabled, const LLUUID& old_cache_version, const LLUUID& current_cache_version)
+void LLShaderMgr::initShaderCache(bool enabled, const LLUUID& old_cache_version, const LLUUID& current_cache_version, bool second_instance)
{
- LL_INFOS() << "Initializing shader cache" << LL_ENDL;
+ LL_PROFILE_ZONE_SCOPED;
+ LL_INFOS("ShaderMgr") << "Initializing shader cache" << LL_ENDL;
mShaderCacheEnabled = gGLManager.mGLVersion >= 4.09 && enabled;
- if(!mShaderCacheEnabled || mShaderCacheInitialized)
+ if(!mShaderCacheEnabled || mShaderCacheVersion.notNull())
return;
- mShaderCacheInitialized = true;
+ mShaderCacheVersion = current_cache_version;
mShaderCacheDir = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "shader_cache");
LLFile::mkdir(mShaderCacheDir);
@@ -989,29 +1010,36 @@ void LLShaderMgr::initShaderCache(bool enabled, const LLUUID& old_cache_version,
std::string meta_out_path = gDirUtilp->add(mShaderCacheDir, "shaderdata.llsd");
if (gDirUtilp->fileExists(meta_out_path))
{
- LL_INFOS() << "Loading shader cache metadata" << LL_ENDL;
+ LL_PROFILE_ZONE_NAMED("shader_cache");
+ LL_INFOS("ShaderMgr") << "Loading shader cache metadata" << LL_ENDL;
- llifstream instream(meta_out_path);
+ llifstream instream(meta_out_path, std::ifstream::in | std::ifstream::binary);
LLSD in_data;
- LLSDSerialize::fromNotation(in_data, instream, LLSDSerialize::SIZE_UNLIMITED);
+ // todo: this is likely very expensive to parse, should use binary
+ LLSDSerialize::fromBinary(in_data, instream, LLSDSerialize::SIZE_UNLIMITED);
instream.close();
- if (old_cache_version == current_cache_version)
+ if (old_cache_version == current_cache_version
+ && in_data["version"].asUUID() == current_cache_version)
{
- for (const auto& data_pair : llsd::inMap(in_data))
+ for (const auto& data_pair : llsd::inMap(in_data["shaders"]))
{
ProgramBinaryData binary_info = ProgramBinaryData();
binary_info.mBinaryFormat = data_pair.second["binary_format"].asInteger();
binary_info.mBinaryLength = data_pair.second["binary_size"].asInteger();
- binary_info.mLastUsedTime = data_pair.second["last_used"].asReal();
+ binary_info.mLastUsedTime = (F32)data_pair.second["last_used"].asReal();
mShaderBinaryCache.insert_or_assign(LLUUID(data_pair.first), binary_info);
}
}
- else
+ else if (!second_instance)
{
- LL_INFOS() << "Shader cache version mismatch detected. Purging." << LL_ENDL;
+ LL_INFOS("ShaderMgr") << "Shader cache version mismatch detected. Purging." << LL_ENDL;
clearShaderCache();
}
+ else
+ {
+ LL_INFOS("ShaderMgr") << "Shader cache version mismatch detected." << LL_ENDL;
+ }
}
}
}
@@ -1019,7 +1047,7 @@ void LLShaderMgr::initShaderCache(bool enabled, const LLUUID& old_cache_version,
void LLShaderMgr::clearShaderCache()
{
std::string shader_cache = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "shader_cache");
- LL_INFOS() << "Removing shader cache at " << shader_cache << LL_ENDL;
+ LL_INFOS("ShaderMgr") << "Removing shader cache at " << shader_cache << LL_ENDL;
const std::string mask = "*";
gDirUtilp->deleteFilesInDir(shader_cache, mask);
mShaderBinaryCache.clear();
@@ -1028,13 +1056,25 @@ void LLShaderMgr::clearShaderCache()
void LLShaderMgr::persistShaderCacheMetadata()
{
if(!mShaderCacheEnabled) return;
+ if (mShaderCacheVersion.isNull())
+ {
+ LL_WARNS("ShaderMgr") << "Attempted to save shader cache with no version set" << LL_ENDL;
+ return;
+ }
- LL_INFOS() << "Persisting shader cache metadata to disk" << LL_ENDL;
+ LL_INFOS("ShaderMgr") << "Persisting shader cache metadata to disk" << LL_ENDL;
- LLSD out = LLSD::emptyMap();
+ LLSD out;
+ // Settings and shader cache get saved at different time, thus making
+ // RenderShaderCacheVersion unreliable when running multiple viewer
+ // instances, or for cases where viewer crashes before saving settings.
+ // Dupplicate version to the cache itself.
+ out["version"] = mShaderCacheVersion;
+ out["shaders"] = LLSD::emptyMap();
+ LLSD &shaders = out["shaders"];
static const F32 LRU_TIME = (60.f * 60.f) * 24.f * 7.f; // 14 days
- const F32 current_time = LLTimer::getTotalSeconds();
+ const F32 current_time = (F32)LLTimer::getTotalSeconds();
for (auto it = mShaderBinaryCache.begin(); it != mShaderBinaryCache.end();)
{
const ProgramBinaryData& shader_metadata = it->second;
@@ -1050,14 +1090,19 @@ void LLShaderMgr::persistShaderCacheMetadata()
data["binary_format"] = LLSD::Integer(shader_metadata.mBinaryFormat);
data["binary_size"] = LLSD::Integer(shader_metadata.mBinaryLength);
data["last_used"] = LLSD::Real(shader_metadata.mLastUsedTime);
- out[it->first.asString()] = data;
+ shaders[it->first.asString()] = data;
++it;
}
}
std::string meta_out_path = gDirUtilp->add(mShaderCacheDir, "shaderdata.llsd");
- llofstream outstream(meta_out_path);
- LLSDSerialize::toNotation(out, outstream);
+ llofstream outstream(meta_out_path, std::ios_base::out | std::ios_base::binary);
+ if (!outstream.is_open())
+ {
+ LL_WARNS("ShaderMgr") << "Failed to open file. Unable to save shader cache to: " << mShaderCacheDir << LL_ENDL;
+ return;
+ }
+ LLSDSerialize::toBinary(out, outstream);
outstream.close();
}
@@ -1093,7 +1138,7 @@ bool LLShaderMgr::loadCachedProgramBinary(LLGLSLShader* shader)
glGetProgramiv(shader->mProgramObject, GL_LINK_STATUS, &success);
if (error == GL_NO_ERROR && success == GL_TRUE)
{
- binary_iter->second.mLastUsedTime = LLTimer::getTotalSeconds();
+ binary_iter->second.mLastUsedTime = (F32)LLTimer::getTotalSeconds();
LL_INFOS() << "Loaded cached binary for shader: " << shader->mName << LL_ENDL;
return true;
}
@@ -1131,7 +1176,7 @@ bool LLShaderMgr::saveCachedProgramBinary(LLGLSLShader* shader)
fwrite(program_binary.data(), sizeof(U8), program_binary.size(), outfile);
outfile.close();
- binary_info.mLastUsedTime = LLTimer::getTotalSeconds();
+ binary_info.mLastUsedTime = (F32)LLTimer::getTotalSeconds();
mShaderBinaryCache.insert_or_assign(shader->mShaderHash, binary_info);
return true;
@@ -1254,6 +1299,7 @@ void LLShaderMgr::initAttribsAndUniforms()
mReservedUniforms.push_back("sky_hdr_scale");
mReservedUniforms.push_back("sky_sunlight_scale");
mReservedUniforms.push_back("sky_ambient_scale");
+ mReservedUniforms.push_back("classic_mode");
mReservedUniforms.push_back("blue_horizon");
mReservedUniforms.push_back("blue_density");
mReservedUniforms.push_back("haze_horizon");
@@ -1381,6 +1427,7 @@ void LLShaderMgr::initAttribsAndUniforms()
mReservedUniforms.push_back("screenTex");
mReservedUniforms.push_back("screenDepth");
mReservedUniforms.push_back("refTex");
+ mReservedUniforms.push_back("exclusionTex");
mReservedUniforms.push_back("eyeVec");
mReservedUniforms.push_back("time");
mReservedUniforms.push_back("waveDir1");
@@ -1415,6 +1462,7 @@ void LLShaderMgr::initAttribsAndUniforms()
mReservedUniforms.push_back("detail_3");
mReservedUniforms.push_back("alpha_ramp");
+ mReservedUniforms.push_back("paint_map");
mReservedUniforms.push_back("detail_0_base_color");
mReservedUniforms.push_back("detail_1_base_color");
@@ -1439,6 +1487,8 @@ void LLShaderMgr::initAttribsAndUniforms()
mReservedUniforms.push_back("emissiveColors");
mReservedUniforms.push_back("minimum_alphas");
+ mReservedUniforms.push_back("region_scale");
+
mReservedUniforms.push_back("origin");
mReservedUniforms.push_back("display_gamma");
@@ -1473,6 +1523,25 @@ void LLShaderMgr::initAttribsAndUniforms()
mReservedUniforms.push_back("debug_normal_draw_length");
+ mReservedUniforms.push_back("edgesTex");
+ mReservedUniforms.push_back("areaTex");
+ mReservedUniforms.push_back("searchTex");
+ mReservedUniforms.push_back("blendTex");
+
+ mReservedUniforms.push_back("bloomEMap");
+ mReservedUniforms.push_back("bloomBlurredMap");
+ mReservedUniforms.push_back("bloomHorizontal");
+ mReservedUniforms.push_back("bloomBlurRadius");
+ mReservedUniforms.push_back("bloomExtractBrightness");
+ mReservedUniforms.push_back("bloomStrength");
+ mReservedUniforms.push_back("bloomExtractEmissive");
+ mReservedUniforms.push_back("bloomExtractEmissive2");
+ mReservedUniforms.push_back("bloomExtractORM");
+ mReservedUniforms.push_back("bloomExtractMetal");
+ mReservedUniforms.push_back("bloomExtractNonMetal");
+ mReservedUniforms.push_back("bloomClampValue");
+ mReservedUniforms.push_back("mpHDRBoost");
+
llassert(mReservedUniforms.size() == END_RESERVED_UNIFORMS);
std::set<std::string> dupe_check;
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-05 00:17:12 +0000