livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

SL-19181 Modulate "glow" by PBR emissive.

meow-7.2.2
Dave Parks 2023-02-09 17:00:36 -06:00
parent 95de63eaa3
commit 577f6a46f0
12 changed files with 290 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
indra/newview/app_settings/shaders/class1/deferred/pbrglowF.glsl Normal file
View File

@ -0,0 +1,67 @@
/**
* @file pbrglowF.glsl
*
* $LicenseInfo:firstyear=2023&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2023, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
/*[EXTRA_CODE_HERE]*/
// forward fullbright implementation for HUDs
uniform sampler2D diffuseMap; //always in sRGB space
uniform vec3 emissiveColor;
uniform sampler2D emissiveMap;
out vec4 frag_color;
in vec3 vary_position;
in vec4 vertex_emissive;
in vec2 basecolor_texcoord;
in vec2 emissive_texcoord;
uniform float minimum_alpha; // PBR alphaMode: MASK, See: mAlphaCutoff, setAlphaCutoff()
vec3 linear_to_srgb(vec3 c);
vec3 srgb_to_linear(vec3 c);
void main()
{
vec4 basecolor = texture2D(diffuseMap, basecolor_texcoord.xy).rgba;
if (basecolor.a < minimum_alpha)
{
discard;
}
vec3 emissive = emissiveColor;
emissive *= srgb_to_linear(texture2D(emissiveMap, emissive_texcoord.xy).rgb);
float lum = max(max(emissive.r, emissive.g), emissive.b);
lum *= vertex_emissive.a;
// HUDs are rendered after gamma correction, output in sRGB space
frag_color.rgb = vec3(0);
frag_color.a = lum;
}

70
indra/newview/app_settings/shaders/class1/deferred/pbrglowV.glsl Normal file
View File

@ -0,0 +1,70 @@
/**
* @file pbgglowV.glsl
*
* $LicenseInfo:firstyear=2023&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2023, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
#ifdef HAS_SKIN
uniform mat4 modelview_matrix;
uniform mat4 projection_matrix;
mat4 getObjectSkinnedTransform();
#else
uniform mat4 modelview_projection_matrix;
#endif
uniform mat4 texture_matrix0;
uniform mat3 texture_basecolor_matrix;
uniform mat3 texture_emissive_matrix;
in vec3 position;
in vec4 emissive;
in vec2 texcoord0;
out vec2 basecolor_texcoord;
out vec2 emissive_texcoord;
out vec4 vertex_emissive;
void main()
{
#ifdef HAS_SKIN
mat4 mat = getObjectSkinnedTransform();
mat = modelview_matrix * mat;
vec3 pos = (mat*vec4(position.xyz,1.0)).xyz;
gl_Position = projection_matrix*vec4(pos,1.0);
#else
//transform vertex
gl_Position = modelview_projection_matrix * vec4(position.xyz, 1.0);
#endif
basecolor_texcoord = (texture_matrix0 * vec4(texture_basecolor_matrix * vec3(texcoord0,1), 1)).xy;
emissive_texcoord = (texture_matrix0 * vec4(texture_emissive_matrix * vec3(texcoord0,1), 1)).xy;
vertex_emissive = emissive;
}

2
indra/newview/lldrawpool.h
View File

@ -184,6 +184,8 @@ public:
PASS_NORMSPEC_EMISSIVE_RIGGED,
PASS_GLOW,
PASS_GLOW_RIGGED,
PASS_GLTF_GLOW,
PASS_GLTF_GLOW_RIGGED,
PASS_ALPHA,
PASS_ALPHA_RIGGED,
PASS_ALPHA_MASK,

97
indra/newview/lldrawpoolalpha.cpp
View File

@ -175,9 +175,12 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
llassert(LLPipeline::sRenderDeferred);
emissive_shader = &gDeferredEmissiveProgram;
prepare_alpha_shader(emissive_shader, true, false, water_sign);
pbr_emissive_shader = &gPBRGlowProgram;
prepare_alpha_shader(pbr_emissive_shader, true, false, water_sign);
fullbright_shader =
(LLPipeline::sImpostorRender) ? &gDeferredFullbrightAlphaMaskProgram :
(LLPipeline::sUnderWaterRender) ? &gDeferredFullbrightWaterAlphaProgram :
@ -482,7 +485,7 @@ void LLDrawPoolAlpha::RestoreTexSetup(bool tex_setup)
}
}
void LLDrawPoolAlpha::drawEmissive(U32 mask, LLDrawInfo* draw)
void LLDrawPoolAlpha::drawEmissive(LLDrawInfo* draw)
{
LLGLSLShader::sCurBoundShaderPtr->uniform1f(LLShaderMgr::EMISSIVE_BRIGHTNESS, 1.f);
draw->mVertexBuffer->setBuffer();
@ -490,7 +493,7 @@ void LLDrawPoolAlpha::drawEmissive(U32 mask, LLDrawInfo* draw)
}
void LLDrawPoolAlpha::renderEmissives(U32 mask, std::vector<LLDrawInfo*>& emissives)
void LLDrawPoolAlpha::renderEmissives(std::vector<LLDrawInfo*>& emissives)
{
emissive_shader->bind();
emissive_shader->uniform1f(LLShaderMgr::EMISSIVE_BRIGHTNESS, 1.f);
@ -498,12 +501,25 @@ void LLDrawPoolAlpha::renderEmissives(U32 mask, std::vector<LLDrawInfo*>& emissi
for (LLDrawInfo* draw : emissives)
{
bool tex_setup = TexSetup(draw, false);
drawEmissive(mask, draw);
drawEmissive(draw);
RestoreTexSetup(tex_setup);
}
}
void LLDrawPoolAlpha::renderRiggedEmissives(U32 mask, std::vector<LLDrawInfo*>& emissives)
void LLDrawPoolAlpha::renderPbrEmissives(std::vector<LLDrawInfo*>& emissives)
{
pbr_emissive_shader->bind();
for (LLDrawInfo* draw : emissives)
{
llassert(draw->mGLTFMaterial);
draw->mGLTFMaterial->bind(draw->mTexture);
draw->mVertexBuffer->setBuffer();
draw->mVertexBuffer->drawRange(LLRender::TRIANGLES, draw->mStart, draw->mEnd, draw->mCount, draw->mOffset);
}
}
void LLDrawPoolAlpha::renderRiggedEmissives(std::vector<LLDrawInfo*>& emissives)
{
LLGLDepthTest depth(GL_TRUE, GL_FALSE); //disable depth writes since "emissive" is additive so sorting doesn't matter
LLGLSLShader* shader = emissive_shader->mRiggedVariant;
@ -513,8 +529,6 @@ void LLDrawPoolAlpha::renderRiggedEmissives(U32 mask, std::vector<LLDrawInfo*>&
LLVOAvatar* lastAvatar = nullptr;
U64 lastMeshId = 0;
mask |= LLVertexBuffer::MAP_WEIGHT4;
for (LLDrawInfo* draw : emissives)
{
bool tex_setup = TexSetup(draw, false);
@ -527,11 +541,37 @@ void LLDrawPoolAlpha::renderRiggedEmissives(U32 mask, std::vector<LLDrawInfo*>&
lastAvatar = draw->mAvatar;
lastMeshId = draw->mSkinInfo->mHash;
}
drawEmissive(mask, draw);
drawEmissive(draw);
RestoreTexSetup(tex_setup);
}
}
void LLDrawPoolAlpha::renderRiggedPbrEmissives(std::vector<LLDrawInfo*>& emissives)
{
LLGLDepthTest depth(GL_TRUE, GL_FALSE); //disable depth writes since "emissive" is additive so sorting doesn't matter
pbr_emissive_shader->bind(true);
LLVOAvatar* lastAvatar = nullptr;
U64 lastMeshId = 0;
for (LLDrawInfo* draw : emissives)
{
if (lastAvatar != draw->mAvatar || lastMeshId != draw->mSkinInfo->mHash)
{
if (!uploadMatrixPalette(*draw))
{ // failed to upload matrix palette, skip rendering
continue;
}
lastAvatar = draw->mAvatar;
lastMeshId = draw->mSkinInfo->mHash;
}
draw->mGLTFMaterial->bind(draw->mTexture);
draw->mVertexBuffer->setBuffer();
draw->mVertexBuffer->drawRange(LLRender::TRIANGLES, draw->mStart, draw->mEnd, draw->mCount, draw->mOffset);
}
}
void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL;
@ -600,8 +640,13 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
static std::vector<LLDrawInfo*> emissives;
static std::vector<LLDrawInfo*> rigged_emissives;
static std::vector<LLDrawInfo*> pbr_emissives;
static std::vector<LLDrawInfo*> pbr_rigged_emissives;
emissives.resize(0);
rigged_emissives.resize(0);
pbr_emissives.resize(0);
pbr_rigged_emissives.resize(0);
bool is_particle_or_hud_particle = group->getSpatialPartition()->mPartitionType == LLViewerRegion::PARTITION_PARTICLE
|| group->getSpatialPartition()->mPartitionType == LLViewerRegion::PARTITION_HUD_PARTICLE;
@ -787,11 +832,25 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
{
if (params.mAvatar != nullptr)
{
rigged_emissives.push_back(&params);
if (params.mGLTFMaterial.isNull())
{
rigged_emissives.push_back(&params);
}
else
{
pbr_rigged_emissives.push_back(&params);
}
}
else
{
emissives.push_back(&params);
if (params.mGLTFMaterial.isNull())
{
emissives.push_back(&params);
}
else
{
pbr_emissives.push_back(&params);
}
}
}
@ -818,14 +877,28 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
if (!emissives.empty())
{
light_enabled = true;
renderEmissives(mask, emissives);
renderEmissives(emissives);
rebind = true;
}
if (!pbr_emissives.empty())
{
light_enabled = true;
renderPbrEmissives(pbr_emissives);
rebind = true;
}
if (!rigged_emissives.empty())
{
light_enabled = true;
renderRiggedEmissives(mask, rigged_emissives);
renderRiggedEmissives(rigged_emissives);
rebind = true;
}
if (!pbr_rigged_emissives.empty())
{
light_enabled = true;
renderRiggedPbrEmissives(pbr_rigged_emissives);
rebind = true;
}

9
indra/newview/lldrawpoolalpha.h
View File

@ -77,11 +77,14 @@ private:
LLGLSLShader* simple_shader = nullptr;
LLGLSLShader* fullbright_shader = nullptr;
LLGLSLShader* emissive_shader = nullptr;
LLGLSLShader* pbr_emissive_shader = nullptr;
LLGLSLShader* pbr_shader = nullptr;
void drawEmissive(U32 mask, LLDrawInfo* draw);
void renderEmissives(U32 mask, std::vector<LLDrawInfo*>& emissives);
void renderRiggedEmissives(U32 mask, std::vector<LLDrawInfo*>& emissives);
void drawEmissive(LLDrawInfo* draw);
void renderEmissives(std::vector<LLDrawInfo*>& emissives);
void renderRiggedEmissives(std::vector<LLDrawInfo*>& emissives);
void renderPbrEmissives(std::vector<LLDrawInfo*>& emissives);
void renderRiggedPbrEmissives(std::vector<LLDrawInfo*>& emissives);
bool TexSetup(LLDrawInfo* draw, bool use_material);
void RestoreTexSetup(bool tex_setup);

25
indra/newview/lldrawpoolpbropaque.cpp
View File

@ -59,18 +59,29 @@ void LLDrawPoolGLTFPBR::renderDeferred(S32 pass)
S32 LLDrawPoolGLTFPBR::getNumPostDeferredPasses()
{
return LLPipeline::sRenderingHUDs ? 1 : 0;
return 1;
}
void LLDrawPoolGLTFPBR::renderPostDeferred(S32 pass)
{
// only HUD rendering should execute this pass
llassert(LLPipeline::sRenderingHUDs);
gHUDPBROpaqueProgram.bind();
for (U32 type : gltf_render_types)
if (LLPipeline::sRenderingHUDs)
{
pushGLTFBatches(type);
gHUDPBROpaqueProgram.bind();
for (U32 type : gltf_render_types)
{
pushGLTFBatches(type);
}
}
else
{
gGL.setColorMask(false, true);
gPBRGlowProgram.bind();
pushGLTFBatches(LLRenderPass::PASS_GLTF_GLOW);
gPBRGlowProgram.bind(true);
pushRiggedGLTFBatches(LLRenderPass::PASS_GLTF_GLOW_RIGGED);
gGL.setColorMask(true, false);
}
}

4
indra/newview/llfetchedgltfmaterial.cpp
View File

@ -60,7 +60,9 @@ void LLFetchedGLTFMaterial::bind(LLViewerTexture* media_tex)
if (mAlphaMode == LLGLTFMaterial::ALPHA_MODE_MASK)
{
min_alpha = mAlphaCutoff;
// dividing the alpha cutoff by transparency here allows the shader to compare against
// the alpha value of the texture without needing the transparency value
min_alpha = mAlphaCutoff/mBaseColor.mV[3];
}
shader->uniform1f(LLShaderMgr::MINIMUM_ALPHA, min_alpha);

22
indra/newview/llviewershadermgr.cpp
View File

@ -206,6 +206,8 @@ LLGLSLShader gDeferredGenBrdfLutProgram;
LLGLSLShader gDeferredMaterialProgram[LLMaterial::SHADER_COUNT*2];
LLGLSLShader gDeferredMaterialWaterProgram[LLMaterial::SHADER_COUNT*2];
LLGLSLShader gHUDPBROpaqueProgram;
LLGLSLShader gPBRGlowProgram;
LLGLSLShader gPBRGlowSkinnedProgram;
LLGLSLShader gDeferredPBROpaqueProgram;
LLGLSLShader gDeferredSkinnedPBROpaqueProgram;
LLGLSLShader gHUDPBRAlphaProgram;
@ -1016,6 +1018,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
}
gHUDPBROpaqueProgram.unload();
gPBRGlowProgram.unload();
gDeferredPBROpaqueProgram.unload();
gDeferredSkinnedPBROpaqueProgram.unload();
gDeferredPBRAlphaProgram.unload();
@ -1325,6 +1328,23 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
llassert(success);
}
if (success)
{
gPBRGlowProgram.mName = " PBR Glow Shader";
gPBRGlowProgram.mFeatures.hasSrgb = true;
gPBRGlowProgram.mShaderFiles.clear();
gPBRGlowProgram.mShaderFiles.push_back(make_pair("deferred/pbrglowV.glsl", GL_VERTEX_SHADER));
gPBRGlowProgram.mShaderFiles.push_back(make_pair("deferred/pbrglowF.glsl", GL_FRAGMENT_SHADER));
gPBRGlowProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
success = make_rigged_variant(gPBRGlowProgram, gPBRGlowSkinnedProgram);
if (success)
{
success = gPBRGlowProgram.createShader(NULL, NULL);
}
llassert(success);
}
if (success)
{
gHUDPBROpaqueProgram.mName = "HUD PBR Opaque Shader";
@ -1341,6 +1361,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
llassert(success);
}
if (success)
{
LLGLSLShader* shader = &gDeferredPBRAlphaProgram;

1
indra/newview/llviewershadermgr.h
View File

@ -268,6 +268,7 @@ extern LLGLSLShader gDeferredMaterialProgram[LLMaterial::SHADER_COUNT*2];
extern LLGLSLShader gDeferredMaterialWaterProgram[LLMaterial::SHADER_COUNT*2];
extern LLGLSLShader gHUDPBROpaqueProgram;
extern LLGLSLShader gPBRGlowProgram;
extern LLGLSLShader gDeferredPBROpaqueProgram;
extern LLGLSLShader gDeferredPBRAlphaProgram;
extern LLGLSLShader gHUDPBRAlphaProgram;

14
indra/newview/llvovolume.cpp
View File

@ -5201,8 +5201,11 @@ void LLVolumeGeometryManager::registerFace(LLSpatialGroup* group, LLFace* facep,
(type == LLRenderPass::PASS_ALPHA && facep->isState(LLFace::FULLBRIGHT)) ||
(facep->getTextureEntry()->getFullbright());
if (!fullbright && type != LLRenderPass::PASS_GLOW && !facep->getVertexBuffer()->hasDataType(LLVertexBuffer::TYPE_NORMAL))
if (!fullbright &&
type != LLRenderPass::PASS_GLOW &&
!facep->getVertexBuffer()->hasDataType(LLVertexBuffer::TYPE_NORMAL))
{
llassert(false);
LL_WARNS() << "Non fullbright face has no normals!" << LL_ENDL;
return;
}
@ -6798,7 +6801,14 @@ U32 LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, LLFace
if (!is_alpha && LLPipeline::sRenderGlow && te->getGlow() > 0.f)
{
registerFace(group, facep, LLRenderPass::PASS_GLOW);
if (gltf_mat)
{
registerFace(group, facep, LLRenderPass::PASS_GLTF_GLOW);
}
else
{
registerFace(group, facep, LLRenderPass::PASS_GLOW);
}
}
++face_iter;

2
indra/newview/pipeline.cpp
View File

@ -8443,6 +8443,7 @@ void LLPipeline::renderDeferredLighting()
LLPipeline::RENDER_TYPE_VOLUME,
LLPipeline::RENDER_TYPE_GLOW,
LLPipeline::RENDER_TYPE_BUMP,
LLPipeline::RENDER_TYPE_GLTF_PBR,
LLPipeline::RENDER_TYPE_PASS_SIMPLE,
LLPipeline::RENDER_TYPE_PASS_ALPHA,
LLPipeline::RENDER_TYPE_PASS_ALPHA_MASK,
@ -8452,6 +8453,7 @@ void LLPipeline::renderDeferredLighting()
LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT_ALPHA_MASK,
LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT_SHINY,
LLPipeline::RENDER_TYPE_PASS_GLOW,
LLPipeline::RENDER_TYPE_PASS_GLTF_GLOW,
LLPipeline::RENDER_TYPE_PASS_GRASS,
LLPipeline::RENDER_TYPE_PASS_SHINY,
LLPipeline::RENDER_TYPE_PASS_INVISIBLE,

2
indra/newview/pipeline.h
View File

@ -492,6 +492,8 @@ public:
RENDER_TYPE_PASS_POST_BUMP_RIGGED = LLRenderPass::PASS_POST_BUMP_RIGGED,
RENDER_TYPE_PASS_GLOW = LLRenderPass::PASS_GLOW,
RENDER_TYPE_PASS_GLOW_RIGGED = LLRenderPass::PASS_GLOW_RIGGED,
RENDER_TYPE_PASS_GLTF_GLOW = LLRenderPass::PASS_GLTF_GLOW,
RENDER_TYPE_PASS_GLTF_GLOW_RIGGED = LLRenderPass::PASS_GLTF_GLOW_RIGGED,
RENDER_TYPE_PASS_ALPHA = LLRenderPass::PASS_ALPHA,
RENDER_TYPE_PASS_ALPHA_MASK = LLRenderPass::PASS_ALPHA_MASK,
RENDER_TYPE_PASS_ALPHA_MASK_RIGGED = LLRenderPass::PASS_ALPHA_MASK_RIGGED,