diff options
Diffstat (limited to 'indra')
23 files changed, 679 insertions, 366 deletions
diff --git a/indra/llrender/llrendertarget.cpp b/indra/llrender/llrendertarget.cpp index b0da054d76..7fcb130ac6 100644 --- a/indra/llrender/llrendertarget.cpp +++ b/indra/llrender/llrendertarget.cpp @@ -623,6 +623,8 @@ void LLRenderTarget::flush(bool fetch_depth) void LLRenderTarget::copyContents(LLRenderTarget& source, S32 srcX0, S32 srcY0, S32 srcX1, S32 srcY1, S32 dstX0, S32 dstY0, S32 dstX1, S32 dstY1, U32 mask, U32 filter) { + LL_PROFILE_GPU_ZONE("LLRenderTarget::copyContents"); + GLboolean write_depth = mask & GL_DEPTH_BUFFER_BIT ? TRUE : FALSE; LLGLDepthTest depth(write_depth, write_depth); diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp index 8807433d80..a363eac59e 100644 --- a/indra/llrender/llshadermgr.cpp +++ b/indra/llrender/llshadermgr.cpp @@ -214,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")) { diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt index 39baa23778..bfc41e3153 100644 --- a/indra/newview/CMakeLists.txt +++ b/indra/newview/CMakeLists.txt @@ -1688,6 +1688,14 @@ set_source_files_properties(${viewer_XUI_FILES} list(APPEND viewer_SOURCE_FILES ${viewer_XUI_FILES}) +file(GLOB_RECURSE viewer_SHADER_FILES LIST_DIRECTORIES TRUE + ${CMAKE_CURRENT_SOURCE_DIR}/app_settings/shaders/*.glsl) +source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR}/app_settings/shaders PREFIX "Shaders" FILES ${viewer_SHADER_FILES}) +set_source_files_properties(${viewer_SHADER_FILES} + PROPERTIES HEADER_FILE_ONLY TRUE) +list(APPEND viewer_SOURCE_FILES ${viewer_SHADER_FILES}) + + set(viewer_APPSETTINGS_FILES app_settings/anim.ini app_settings/cmd_line.xml diff --git a/indra/newview/app_settings/shaders/class1/deferred/deferredUtil.glsl b/indra/newview/app_settings/shaders/class1/deferred/deferredUtil.glsl index bca4771c27..1c2034de69 100644 --- a/indra/newview/app_settings/shaders/class1/deferred/deferredUtil.glsl +++ b/indra/newview/app_settings/shaders/class1/deferred/deferredUtil.glsl @@ -310,16 +310,21 @@ vec4 getPosition(vec2 pos_screen) return pos; } +// get position given a normalized device coordinate +vec3 getPositionWithNDC(vec3 ndc) +{ + vec4 pos = inv_proj * vec4(ndc, 1.0); + return pos.xyz / pos.w; +} + vec4 getPositionWithDepth(vec2 pos_screen, float depth) { vec2 sc = getScreenCoordinate(pos_screen); - vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0); - vec4 pos = inv_proj * ndc; - pos /= pos.w; - pos.w = 1.0; - return pos; + vec3 ndc = vec3(sc.x, sc.y, 2.0*depth-1.0); + return vec4(getPositionWithNDC(ndc), 1.0); } + vec2 getScreenXY(vec4 clip) { vec4 ndc = clip; diff --git a/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl b/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl index 58a444a763..876422f86b 100644 --- a/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl +++ b/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl @@ -22,170 +22,15 @@ * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ - -#extension GL_ARB_texture_rectangle : enable -/*[EXTRA_CODE_HERE]*/ - -#ifdef DEFINE_GL_FRAGCOLOR +// debug stub out vec4 frag_data[4]; -#else -#define frag_data gl_FragData -#endif - -vec3 scaleSoftClip(vec3 inColor); -vec3 atmosTransport(vec3 inColor); - -uniform sampler2D bumpMap; -uniform sampler2D bumpMap2; -uniform float blend_factor; -uniform sampler2D screenTex; -uniform sampler2D refTex; -uniform float sunAngle; -uniform float sunAngle2; -uniform vec3 lightDir; -uniform vec3 specular; -uniform float lightExp; -uniform float refScale; -uniform float kd; -uniform vec2 screenRes; -uniform vec3 normScale; -uniform float fresnelScale; -uniform float fresnelOffset; -uniform float blurMultiplier; -uniform vec2 screen_res; -uniform mat4 norm_mat; //region space to screen space -uniform int water_edge; - -//bigWave is (refCoord.w, view.w); -VARYING vec4 refCoord; -VARYING vec4 littleWave; -VARYING vec4 view; -VARYING vec4 vary_position; - -vec2 encode_normal(vec3 n); -vec3 scaleSoftClip(vec3 l); -vec3 srgb_to_linear(vec3 c); -vec3 linear_to_srgb(vec3 c); -vec3 BlendNormal(vec3 bump1, vec3 bump2) +void main() { - vec3 n = mix(bump1, bump2, blend_factor); - return n; -} - -void main() -{ - vec4 color; - float dist = length(view.xyz); - - //normalize view vector - vec3 viewVec = normalize(view.xyz); - - //get wave normals - vec3 wave1_a = texture2D(bumpMap, vec2(refCoord.w, view.w)).xyz*2.0-1.0; - vec3 wave2_a = texture2D(bumpMap, littleWave.xy).xyz*2.0-1.0; - vec3 wave3_a = texture2D(bumpMap, littleWave.zw).xyz*2.0-1.0; - - - vec3 wave1_b = texture2D(bumpMap2, vec2(refCoord.w, view.w)).xyz*2.0-1.0; - vec3 wave2_b = texture2D(bumpMap2, littleWave.xy).xyz*2.0-1.0; - vec3 wave3_b = texture2D(bumpMap2, littleWave.zw).xyz*2.0-1.0; - - vec3 wave1 = BlendNormal(wave1_a, wave1_b); - vec3 wave2 = BlendNormal(wave2_a, wave2_b); - vec3 wave3 = BlendNormal(wave3_a, wave3_b); - - //get base fresnel components - - vec3 df = vec3( - dot(viewVec, wave1), - dot(viewVec, (wave2 + wave3) * 0.5), - dot(viewVec, wave3) - ) * fresnelScale + fresnelOffset; - df *= df; - - vec2 distort = (refCoord.xy/refCoord.z) * 0.5 + 0.5; - - float dist2 = dist; - dist = max(dist, 5.0); - - float dmod = sqrt(dist); - - vec2 dmod_scale = vec2(dmod*dmod, dmod); - - //get reflected color - vec2 refdistort1 = wave1.xy*normScale.x; - vec2 refvec1 = distort+refdistort1/dmod_scale; - vec4 refcol1 = texture2D(refTex, refvec1); - - vec2 refdistort2 = wave2.xy*normScale.y; - vec2 refvec2 = distort+refdistort2/dmod_scale; - vec4 refcol2 = texture2D(refTex, refvec2); - - vec2 refdistort3 = wave3.xy*normScale.z; - vec2 refvec3 = distort+refdistort3/dmod_scale; - vec4 refcol3 = texture2D(refTex, refvec3); - - vec4 refcol = refcol1 + refcol2 + refcol3; - float df1 = df.x + df.y + df.z; - refcol *= df1 * 0.333; - - vec3 wavef = (wave1 + wave2 * 0.4 + wave3 * 0.6) * 0.5; - wavef.z *= max(-viewVec.z, 0.1); - wavef = normalize(wavef); - - float df2 = dot(viewVec, wavef) * fresnelScale+fresnelOffset; - - vec2 refdistort4 = wavef.xy*0.125; - refdistort4.y -= abs(refdistort4.y); - vec2 refvec4 = distort+refdistort4/dmod; - float dweight = min(dist2*blurMultiplier, 1.0); - vec4 baseCol = texture2D(refTex, refvec4); - - refcol = mix(baseCol*df2, refcol, dweight); - - //get specular component - float spec = clamp(dot(lightDir, (reflect(viewVec,wavef))),0.0,1.0); - - //harden specular - spec = pow(spec, 128.0); - - //figure out distortion vector (ripply) - vec2 distort2 = distort+wavef.xy*refScale/max(dmod*df1, 1.0); - - vec4 fb = texture2D(screenTex, distort2); - - //mix with reflection - // Note we actually want to use just df1, but multiplying by 0.999999 gets around an nvidia compiler bug - color.rgb = mix(fb.rgb, refcol.rgb, df1 * 0.99999f); - - vec4 pos = vary_position; - - //color.rgb += spec * specular; - - //color.rgb = atmosTransport(color.rgb); - //color.rgb = scaleSoftClip(color.rgb); - - //color.rgb = refcol.rgb; - color.rgb = vec3(0.0); - color.a = spec * sunAngle2; - - vec3 screenspacewavef = normalize((norm_mat*vec4(wavef, 1.0)).xyz); - - //frag_data[0] = color; - - // TODO: The non-obvious assignment below is copied from the pre-EEP WL shader code - // Unfortunately, fixing it causes a mismatch for EEP, and so it remains... for now - // SL-12975 (unfix pre-EEP broken alpha) - frag_data[0] = vec4(srgb_to_linear(color.rgb), 0.0); - - frag_data[1] = vec4(1.0, 0.1, 0.0, 0.0); // occlusion, roughness, metalness - frag_data[2] = vec4(encode_normal(screenspacewavef.xyz), 0.0, GBUFFER_FLAG_HAS_PBR);// normalxy, env intens, flags (atmo kill) - frag_data[3] = vec4(srgb_to_linear(refcol.rgb),0); - - - //frag_data[0] = vec4(0.0,0,0,0); - //frag_data[1] = vec4(0, 1.0, 0.0, 0.0); - //frag_data[3] = vec4(0); + // emissive blue PBR material + frag_data[0] = vec4(0, 0, 0, 0); + frag_data[1] = vec4(0, 0, 0, 0); + frag_data[2] = vec4(1, 0, 0, GBUFFER_FLAG_HAS_PBR); + frag_data[3] = vec4(0, 0, 1, 0); } diff --git a/indra/newview/app_settings/shaders/class1/environment/waterF.glsl b/indra/newview/app_settings/shaders/class1/environment/waterF.glsl index d370997123..46a6c2021d 100644 --- a/indra/newview/app_settings/shaders/class1/environment/waterF.glsl +++ b/indra/newview/app_settings/shaders/class1/environment/waterF.glsl @@ -23,146 +23,9 @@ * $/LicenseInfo$ */ -#ifdef DEFINE_GL_FRAGCOLOR out vec4 frag_color; -#else -#define frag_color gl_FragColor -#endif -vec3 scaleSoftClip(vec3 inColor); -vec3 atmosTransport(vec3 inColor); - -uniform sampler2D bumpMap; -uniform sampler2D bumpMap2; -uniform float blend_factor; -uniform sampler2D screenTex; -uniform sampler2D refTex; - -uniform float sunAngle; -uniform float sunAngle2; -uniform vec3 lightDir; -uniform vec3 specular; -uniform float lightExp; -uniform float refScale; -uniform float kd; -uniform vec2 screenRes; -uniform vec3 normScale; -uniform float fresnelScale; -uniform float fresnelOffset; -uniform float blurMultiplier; - - -//bigWave is (refCoord.w, view.w); -VARYING vec4 refCoord; -VARYING vec4 littleWave; -VARYING vec4 view; - -vec3 BlendNormal(vec3 bump1, vec3 bump2) +void main() { - vec3 n = mix(bump1, bump2, blend_factor); - return n; + frag_color = vec4(0, 0, 1, 0); } - - -void main() -{ - vec4 color; - - float dist = length(view.xy); - - //normalize view vector - vec3 viewVec = normalize(view.xyz); - - //get wave normals - vec2 bigwave = vec2(refCoord.w, view.w); - vec3 wave1_a = texture2D(bumpMap, bigwave ).xyz*2.0-1.0; - vec3 wave2_a = texture2D(bumpMap, littleWave.xy).xyz*2.0-1.0; - vec3 wave3_a = texture2D(bumpMap, littleWave.zw).xyz*2.0-1.0; - - - vec3 wave1_b = texture2D(bumpMap2, bigwave ).xyz*2.0-1.0; - vec3 wave2_b = texture2D(bumpMap2, littleWave.xy).xyz*2.0-1.0; - vec3 wave3_b = texture2D(bumpMap2, littleWave.zw).xyz*2.0-1.0; - - vec3 wave1 = BlendNormal(wave1_a, wave1_b); - vec3 wave2 = BlendNormal(wave2_a, wave2_b); - vec3 wave3 = BlendNormal(wave3_a, wave3_b); - - - //get base fresnel components - - vec3 df = vec3( - dot(viewVec, wave1), - dot(viewVec, (wave2 + wave3) * 0.5), - dot(viewVec, wave3) - ) * fresnelScale + fresnelOffset; - df *= df; - - vec2 distort = (refCoord.xy/refCoord.z) * 0.5 + 0.5; - - float dist2 = dist; - dist = max(dist, 5.0); - - float dmod = sqrt(dist); - - vec2 dmod_scale = vec2(dmod*dmod, dmod); - - //get reflected color - vec2 refdistort1 = wave1.xy*normScale.x; - vec2 refvec1 = distort+refdistort1/dmod_scale; - vec4 refcol1 = texture2D(refTex, refvec1); - - vec2 refdistort2 = wave2.xy*normScale.y; - vec2 refvec2 = distort+refdistort2/dmod_scale; - vec4 refcol2 = texture2D(refTex, refvec2); - - vec2 refdistort3 = wave3.xy*normScale.z; - vec2 refvec3 = distort+refdistort3/dmod_scale; - vec4 refcol3 = texture2D(refTex, refvec3); - - vec4 refcol = refcol1 + refcol2 + refcol3; - float df1 = df.x + df.y + df.z; - refcol *= df1 * 0.333; - - vec3 wavef = (wave1 + wave2 * 0.4 + wave3 * 0.6) * 0.5; - - wavef.z *= max(-viewVec.z, 0.1); - wavef = normalize(wavef); - - float df2 = dot(viewVec, wavef) * fresnelScale+fresnelOffset; - - vec2 refdistort4 = wavef.xy*0.125; - refdistort4.y -= abs(refdistort4.y); - vec2 refvec4 = distort+refdistort4/dmod; - float dweight = min(dist2*blurMultiplier, 1.0); - vec4 baseCol = texture2D(refTex, refvec4); - refcol = mix(baseCol*df2, refcol, dweight); - - //get specular component - float spec = clamp(dot(lightDir, (reflect(viewVec,wavef))),0.0,1.0); - - //harden specular - spec = pow(spec, 128.0); - - //figure out distortion vector (ripply) - vec2 distort2 = distort+wavef.xy*refScale/max(dmod*df1, 1.0); - - vec4 fb = texture2D(screenTex, distort2); - - //mix with reflection - // Note we actually want to use just df1, but multiplying by 0.999999 gets around and nvidia compiler bug - color.rgb = mix(fb.rgb, refcol.rgb, df1 * 0.99999); - color.rgb += spec * specular; - - color.rgb = atmosTransport(color.rgb); - color.rgb = scaleSoftClip(color.rgb); - color.a = spec * sunAngle2; - - frag_color = color; - -#if defined(WATER_EDGE) - gl_FragDepth = 0.9999847f; -#endif - -} - diff --git a/indra/newview/app_settings/shaders/class1/environment/waterFogF.glsl b/indra/newview/app_settings/shaders/class1/environment/waterFogF.glsl index df640cba05..7dbba12502 100644 --- a/indra/newview/app_settings/shaders/class1/environment/waterFogF.glsl +++ b/indra/newview/app_settings/shaders/class1/environment/waterFogF.glsl @@ -32,6 +32,8 @@ uniform float waterFogKS; vec3 getPositionEye(); +vec3 srgb_to_linear(vec3 col); + vec4 applyWaterFogView(vec3 pos, vec4 color) { vec3 view = normalize(pos); @@ -71,6 +73,46 @@ vec4 applyWaterFogView(vec3 pos, vec4 color) return color; } +vec4 applyWaterFogViewLinear(vec3 pos, vec4 color) +{ + vec3 view = normalize(pos); + //normalize view vector + float es = -(dot(view, waterPlane.xyz)); + + //find intersection point with water plane and eye vector + + //get eye depth + float e0 = max(-waterPlane.w, 0.0); + + vec3 int_v = waterPlane.w > 0.0 ? view * waterPlane.w / es : vec3(0.0, 0.0, 0.0); + + //get object depth + float depth = length(pos - int_v); + + //get "thickness" of water + float l = max(depth, 0.1); + + float kd = waterFogDensity; + float ks = waterFogKS; + vec4 kc = waterFogColor; + kc.rgb = srgb_to_linear(kc.rgb); // TODO -- pass in waterFogColor linear + + float F = 0.98; + + float t1 = -kd * pow(F, ks * e0); + float t2 = kd + ks * es; + float t3 = pow(F, t2 * l) - 1.0; + + float L = min(t1 / t2 * t3, 1.0); + + float D = pow(0.98, l * kd); + + color.rgb = color.rgb * D + kc.rgb * L; + color.a = kc.a + color.a; + + return color; +} + vec4 applyWaterFog(vec4 color) { //normalize view vector diff --git a/indra/newview/app_settings/shaders/class1/environment/waterV.glsl b/indra/newview/app_settings/shaders/class1/environment/waterV.glsl index cc41e3f740..a0a0e7dfca 100644 --- a/indra/newview/app_settings/shaders/class1/environment/waterV.glsl +++ b/indra/newview/app_settings/shaders/class1/environment/waterV.glsl @@ -24,6 +24,7 @@ */ uniform mat4 modelview_matrix; +uniform mat3 normal_matrix; uniform mat4 modelview_projection_matrix; ATTRIBUTE vec3 position; @@ -36,10 +37,16 @@ uniform vec2 waveDir2; uniform float time; uniform vec3 eyeVec; uniform float waterHeight; +uniform vec3 lightDir; VARYING vec4 refCoord; VARYING vec4 littleWave; VARYING vec4 view; +out vec3 vary_position; +out vec3 vary_light_dir; +out vec3 vary_tangent; +out vec3 vary_normal; +out vec2 vary_fragcoord; float wave(vec2 v, float t, float f, vec2 d, float s) { @@ -52,6 +59,11 @@ void main() vec4 pos = vec4(position.xyz, 1.0); mat4 modelViewProj = modelview_projection_matrix; + vary_position = (modelview_matrix * pos).xyz; + vary_light_dir = normal_matrix * lightDir; + vary_normal = normal_matrix * vec3(0, 0, 1); + vary_tangent = normal_matrix * vec3(1, 0, 0); + vec4 oPosition; //get view vector @@ -63,12 +75,13 @@ void main() pos.xy = eyeVec.xy + oEyeVec.xy/d*ld; view.xyz = oEyeVec; - + d = clamp(ld/1536.0-0.5, 0.0, 1.0); d *= d; oPosition = vec4(position, 1.0); oPosition.z = mix(oPosition.z, max(eyeVec.z*0.75, 0.0), d); + oPosition = modelViewProj * oPosition; refCoord.xyz = oPosition.xyz + vec3(0,0,0.2); @@ -83,8 +96,7 @@ void main() pos = modelview_matrix*pos; calcAtmospherics(pos.xyz); - - + //pass wave parameters to pixel shader vec2 bigWave = (v.xy) * vec2(0.04,0.04) + waveDir1 * time * 0.055; //get two normal map (detail map) texture coordinates diff --git a/indra/newview/app_settings/shaders/class2/deferred/waterF.glsl b/indra/newview/app_settings/shaders/class2/deferred/waterF.glsl new file mode 100644 index 0000000000..96739d91d7 --- /dev/null +++ b/indra/newview/app_settings/shaders/class2/deferred/waterF.glsl @@ -0,0 +1,192 @@ +/** + * @file class1/deferred/waterF.glsl + * + * $LicenseInfo:firstyear=2007&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2007, 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$ + */ + +#extension GL_ARB_texture_rectangle : enable + +/*[EXTRA_CODE_HERE]*/ + +#ifdef DEFINE_GL_FRAGCOLOR +out vec4 frag_data[4]; +#else +#define frag_data gl_FragData +#endif + +vec3 scaleSoftClip(vec3 inColor); +vec3 atmosTransport(vec3 inColor); + +uniform sampler2D bumpMap; +uniform sampler2D bumpMap2; +uniform float blend_factor; +uniform sampler2D screenTex; +uniform sampler2D refTex; +uniform float sunAngle; +uniform float sunAngle2; +uniform vec3 lightDir; +uniform vec3 specular; +uniform float lightExp; +uniform float refScale; +uniform float kd; +uniform vec2 screenRes; +uniform vec3 normScale; +uniform float fresnelScale; +uniform float fresnelOffset; +uniform float blurMultiplier; +uniform vec2 screen_res; +uniform mat4 norm_mat; //region space to screen space +uniform int water_edge; + +//bigWave is (refCoord.w, view.w); +VARYING vec4 refCoord; +VARYING vec4 littleWave; +VARYING vec4 view; +VARYING vec4 vary_position; + +vec2 encode_normal(vec3 n); +vec3 scaleSoftClip(vec3 l); +vec3 srgb_to_linear(vec3 c); +vec3 linear_to_srgb(vec3 c); + +vec3 BlendNormal(vec3 bump1, vec3 bump2) +{ + vec3 n = mix(bump1, bump2, blend_factor); + return n; +} + +void main() +{ + vec4 color; + float dist = length(view.xyz); + + //normalize view vector + vec3 viewVec = normalize(view.xyz); + + //get wave normals + vec3 wave1_a = texture2D(bumpMap, vec2(refCoord.w, view.w)).xyz*2.0-1.0; + vec3 wave2_a = texture2D(bumpMap, littleWave.xy).xyz*2.0-1.0; + vec3 wave3_a = texture2D(bumpMap, littleWave.zw).xyz*2.0-1.0; + + + vec3 wave1_b = texture2D(bumpMap2, vec2(refCoord.w, view.w)).xyz*2.0-1.0; + vec3 wave2_b = texture2D(bumpMap2, littleWave.xy).xyz*2.0-1.0; + vec3 wave3_b = texture2D(bumpMap2, littleWave.zw).xyz*2.0-1.0; + + vec3 wave1 = BlendNormal(wave1_a, wave1_b); + vec3 wave2 = BlendNormal(wave2_a, wave2_b); + vec3 wave3 = BlendNormal(wave3_a, wave3_b); + + //get base fresnel components + + vec3 df = vec3( + dot(viewVec, wave1), + dot(viewVec, (wave2 + wave3) * 0.5), + dot(viewVec, wave3) + ) * fresnelScale + fresnelOffset; + df *= df; + + vec2 distort = (refCoord.xy/refCoord.z) * 0.5 + 0.5; + + float dist2 = dist; + dist = max(dist, 5.0); + + float dmod = sqrt(dist); + + vec2 dmod_scale = vec2(dmod*dmod, dmod); + + //get reflected color + vec2 refdistort1 = wave1.xy*normScale.x; + vec2 refvec1 = distort+refdistort1/dmod_scale; + vec4 refcol1 = texture2D(refTex, refvec1); + + vec2 refdistort2 = wave2.xy*normScale.y; + vec2 refvec2 = distort+refdistort2/dmod_scale; + vec4 refcol2 = texture2D(refTex, refvec2); + + vec2 refdistort3 = wave3.xy*normScale.z; + vec2 refvec3 = distort+refdistort3/dmod_scale; + vec4 refcol3 = texture2D(refTex, refvec3); + + vec4 refcol = refcol1 + refcol2 + refcol3; + float df1 = df.x + df.y + df.z; + refcol *= df1 * 0.333; + + vec3 wavef = (wave1 + wave2 * 0.4 + wave3 * 0.6) * 0.5; + wavef.z *= max(-viewVec.z, 0.1); + wavef = normalize(wavef); + + float df2 = dot(viewVec, wavef) * fresnelScale+fresnelOffset; + + vec2 refdistort4 = wavef.xy*0.125; + refdistort4.y -= abs(refdistort4.y); + vec2 refvec4 = distort+refdistort4/dmod; + float dweight = min(dist2*blurMultiplier, 1.0); + vec4 baseCol = texture2D(refTex, refvec4); + + refcol = mix(baseCol*df2, refcol, dweight); + + //get specular component + float spec = clamp(dot(lightDir, (reflect(viewVec,wavef))),0.0,1.0); + + //harden specular + spec = pow(spec, 128.0); + + //figure out distortion vector (ripply) + vec2 distort2 = distort+wavef.xy*refScale/max(dmod*df1, 1.0); + + vec4 fb = texture2D(screenTex, distort2); + + //mix with reflection + // Note we actually want to use just df1, but multiplying by 0.999999 gets around an nvidia compiler bug + color.rgb = mix(fb.rgb, refcol.rgb, df1 * 0.99999f); + + vec4 pos = vary_position; + + //color.rgb += spec * specular; + + //color.rgb = atmosTransport(color.rgb); + //color.rgb = scaleSoftClip(color.rgb); + + //color.rgb = refcol.rgb; + color.rgb = vec3(0.0); + color.a = spec * sunAngle2; + + vec3 screenspacewavef = normalize((norm_mat*vec4(wavef, 1.0)).xyz); + + //frag_data[0] = color; + + // TODO: The non-obvious assignment below is copied from the pre-EEP WL shader code + // Unfortunately, fixing it causes a mismatch for EEP, and so it remains... for now + // SL-12975 (unfix pre-EEP broken alpha) + frag_data[0] = vec4(srgb_to_linear(color.rgb), 0.0); + + frag_data[1] = vec4(1.0, 0.1, 0.0, 0.0); // occlusion, roughness, metalness + frag_data[2] = vec4(encode_normal(screenspacewavef.xyz), 0.0, GBUFFER_FLAG_HAS_PBR);// normalxy, env intens, flags (atmo kill) + //frag_data[3] = vec4(srgb_to_linear(refcol.rgb),0); + frag_data[3] = vec4(0, 0, 0, 0); + + + //frag_data[0] = vec4(0.0,0,0,0); + //frag_data[1] = vec4(0, 1.0, 0.0, 0.0); + //frag_data[3] = vec4(0); +} diff --git a/indra/newview/app_settings/shaders/class2/environment/waterF.glsl b/indra/newview/app_settings/shaders/class2/environment/waterF.glsl new file mode 100644 index 0000000000..59e7e64fbb --- /dev/null +++ b/indra/newview/app_settings/shaders/class2/environment/waterF.glsl @@ -0,0 +1,249 @@ +/** + * @file waterF.glsl + * + * $LicenseInfo:firstyear=2007&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2007, 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 DEFINE_GL_FRAGCOLOR +out vec4 frag_color; +#else +#define frag_color gl_FragColor +#endif + +vec3 scaleSoftClipFragLinear(vec3 l); +vec3 atmosFragLightingLinear(vec3 light, vec3 additive, vec3 atten); +void calcAtmosphericVarsLinear(vec3 inPositionEye, vec3 norm, vec3 light_dir, out vec3 sunlit, out vec3 amblit, out vec3 atten, out vec3 additive); +vec4 applyWaterFogViewLinear(vec3 pos, vec4 color); + +// PBR interface +vec3 pbrIbl(vec3 diffuseColor, + vec3 specularColor, + vec3 radiance, // radiance map sample + vec3 irradiance, // irradiance map sample + float ao, // ambient occlusion factor + float nv, // normal dot view vector + float perceptualRoughness); + +vec3 pbrPunctual(vec3 diffuseColor, vec3 specularColor, + float perceptualRoughness, + float metallic, + vec3 n, // normal + vec3 v, // surface point to camera + vec3 l); //surface point to light + +uniform sampler2D bumpMap; +uniform sampler2D bumpMap2; +uniform float blend_factor; +uniform sampler2D screenTex; +uniform sampler2D screenDepth; + +uniform sampler2D refTex; + +uniform float sunAngle; +uniform float sunAngle2; +uniform vec3 lightDir; +uniform vec3 specular; +uniform float lightExp; +uniform float refScale; +uniform float kd; +uniform vec2 screenRes; +uniform vec3 normScale; +uniform float fresnelScale; +uniform float fresnelOffset; +uniform float blurMultiplier; +uniform vec4 waterFogColor; + + +//bigWave is (refCoord.w, view.w); +VARYING vec4 refCoord; +VARYING vec4 littleWave; +VARYING vec4 view; +in vec3 vary_position; +in vec3 vary_normal; +in vec3 vary_tangent; +in vec3 vary_light_dir; + +vec3 BlendNormal(vec3 bump1, vec3 bump2) +{ + vec3 n = mix(bump1, bump2, blend_factor); + return n; +} + +vec3 srgb_to_linear(vec3 col); + +void sampleReflectionProbesLegacy(inout vec3 ambenv, inout vec3 glossenv, inout vec3 legacyenv, + vec3 pos, vec3 norm, float glossiness, float envIntensity); + +vec3 vN, vT, vB; + +vec3 transform_normal(vec3 vNt) +{ + return normalize(vNt.x * vT + vNt.y * vB + vNt.z * vN); +} + +void sampleReflectionProbes(inout vec3 ambenv, inout vec3 glossenv, + vec3 pos, vec3 norm, float glossiness); + +vec3 getPositionWithNDC(vec3 ndc); + +void main() +{ + vec4 color; + + vN = vary_normal; + vT = vary_tangent; + vB = cross(vN, vT); + + vec3 pos = vary_position.xyz; + + float dist = length(pos.xyz); + + //normalize view vector + vec3 viewVec = normalize(pos.xyz); + + //get wave normals + vec2 bigwave = vec2(refCoord.w, view.w); + vec3 wave1_a = texture2D(bumpMap, bigwave ).xyz*2.0-1.0; + vec3 wave2_a = texture2D(bumpMap, littleWave.xy).xyz*2.0-1.0; + vec3 wave3_a = texture2D(bumpMap, littleWave.zw).xyz*2.0-1.0; + + vec3 wave1_b = texture2D(bumpMap2, bigwave ).xyz*2.0-1.0; + vec3 wave2_b = texture2D(bumpMap2, littleWave.xy).xyz*2.0-1.0; + vec3 wave3_b = texture2D(bumpMap2, littleWave.zw).xyz*2.0-1.0; + + vec3 wave1 = BlendNormal(wave1_a, wave1_b); + vec3 wave2 = BlendNormal(wave2_a, wave2_b); + vec3 wave3 = BlendNormal(wave3_a, wave3_b); + + wave1 = transform_normal(wave1); + wave2 = transform_normal(wave2); + wave3 = transform_normal(wave3); + + vec3 wavef = (wave1 + wave2 * 0.4 + wave3 * 0.6) * 0.5; + + wavef.z *= max(-viewVec.z, 0.1); + + wavef = normalize(wavef); + + //get base fresnel components + + vec3 df = vec3( + dot(viewVec, wave1), + dot(viewVec, (wave2 + wave3) * 0.5), + dot(viewVec, wave3) + ) * fresnelScale + fresnelOffset; + + vec2 distort = (refCoord.xy/refCoord.z) * 0.5 + 0.5; + + float dist2 = dist; + dist = max(dist, 5.0); + + float dmod = sqrt(dist); + + vec2 dmod_scale = vec2(dmod*dmod, dmod); + + float df1 = df.x + df.y + df.z; + + wavef = normalize(wavef + vary_normal); + //wavef = vary_normal; + + vec3 waver = reflect(viewVec, -wavef)*3; + + //figure out distortion vector (ripply) + vec2 distort2 = distort + waver.xy * refScale / max(dmod * df1, 1.0); + distort2 = clamp(distort2, vec2(0), vec2(0.99)); + + vec4 fb = texture2D(screenTex, distort2); + float depth = texture2D(screenDepth, distort2).r; + vec3 refPos = getPositionWithNDC(vec3(distort2*2.0-vec2(1.0), depth*2.0-1.0)); + +#if 1 + if (refPos.z > pos.z-0.05) + { + //we sampled an above water sample, don't distort + distort2 = distort; + fb = texture2D(screenTex, distort2); + depth = texture2D(screenDepth, distort2).r; + refPos = getPositionWithNDC(vec3(distort2 * 2.0 - vec2(1.0), depth * 2.0 - 1.0)); + } +#endif + + fb = applyWaterFogViewLinear(refPos, fb); + + vec3 sunlit; + vec3 amblit; + vec3 additive; + vec3 atten; + + calcAtmosphericVarsLinear(pos.xyz, wavef, lightDir, sunlit, amblit, additive, atten); + + vec3 v = -viewVec; + float NdotV = clamp(abs(dot(wavef.xyz, v)), 0.001, 1.0); + + float metallic = fresnelOffset * 0.1; // fudge -- use fresnelOffset as metalness + float roughness = 0.08; + float gloss = 1.0 - roughness; + + vec3 baseColor = vec3(0.25); + vec3 f0 = vec3(0.04); + vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0); + diffuseColor *= gloss; + + vec3 specularColor = mix(f0, baseColor.rgb, metallic); + + //vec3 refnorm = normalize(wavef + vary_normal); + vec3 refnorm = wavef; + + + vec3 irradiance = vec3(0); + vec3 radiance = vec3(0); + sampleReflectionProbes(irradiance, radiance, pos, refnorm, gloss); + radiance *= 0.5; + irradiance = fb.rgb; + + color.rgb = pbrIbl(diffuseColor, specularColor, radiance, irradiance, gloss, NdotV, 0.0); + + + // fudge -- for punctual lighting, pretend water is metallic + diffuseColor = vec3(0); + specularColor = vec3(1); + roughness = 0.1; + float scol = 1.0; // TODO -- incorporate shadow map + + //color.rgb += pbrPunctual(diffuseColor, specularColor, roughness, metallic, wavef, v, vary_light_dir) * sunlit * 2.75 * scol; + color.rgb = atmosFragLightingLinear(color.rgb, additive, atten); + color.rgb = scaleSoftClipFragLinear(color.rgb); + + color.a = 0.f; + //color.rgb = fb.rgb; + //color.rgb = vec3(depth*depth*depth*depth); + //color.rgb = srgb_to_linear(normalize(refPos) * 0.5 + 0.5); + //color.rgb = srgb_to_linear(normalize(pos) * 0.5 + 0.5); + //color.rgb = srgb_to_linear(wavef * 0.5 + 0.5); + frag_color = color; + +#if defined(WATER_EDGE) + gl_FragDepth = 0.9999847f; +#endif + +} + diff --git a/indra/newview/lldrawpool.cpp b/indra/newview/lldrawpool.cpp index 7c4c2e4b7e..074d223b59 100644 --- a/indra/newview/lldrawpool.cpp +++ b/indra/newview/lldrawpool.cpp @@ -211,15 +211,6 @@ void LLDrawPool::renderPostDeferred(S32 pass) //virtual void LLDrawPool::endRenderPass( S32 pass ) { - /*for (U32 i = 0; i < gGLManager.mNumTextureImageUnits; i++) - { //dummy cleanup of any currently bound textures - if (gGL.getTexUnit(i)->getCurrType() != LLTexUnit::TT_NONE) - { - gGL.getTexUnit(i)->unbind(gGL.getTexUnit(i)->getCurrType()); - gGL.getTexUnit(i)->disable(); - } - }*/ - //make sure channel 0 is active channel gGL.getTexUnit(0)->activate(); } diff --git a/indra/newview/lldrawpool.h b/indra/newview/lldrawpool.h index e8fde70ed0..2b7ace7ae5 100644 --- a/indra/newview/lldrawpool.h +++ b/indra/newview/lldrawpool.h @@ -48,6 +48,9 @@ public: enum { // Correspond to LLPipeline render type + // Also controls render order, so passes that don't use alpha masking/blending should come before + // other passes and occlusion culling should happen just before rendering alpha masked passes + // in order to take advantage of hierarchical Z // NOTE: Keep in sync with gPoolNames POOL_SIMPLE = 1, POOL_GROUND, diff --git a/indra/newview/lldrawpoolwater.cpp b/indra/newview/lldrawpoolwater.cpp index 576024ead3..0b9bca06db 100644 --- a/indra/newview/lldrawpoolwater.cpp +++ b/indra/newview/lldrawpoolwater.cpp @@ -117,16 +117,33 @@ S32 LLDrawPoolWater::getNumPasses() return 0; } +S32 LLDrawPoolWater::getNumPostDeferredPasses() +{ + return 1; +} + void LLDrawPoolWater::beginPostDeferredPass(S32 pass) { - beginRenderPass(pass); - deferred_render = TRUE; + // copy framebuffer contents so far to a texture to be used for + // reflections and refractions + LLRenderTarget& src = gPipeline.mRT->screen; + LLRenderTarget& dst = gPipeline.mWaterDis; + dst.copyContents(src, + 0, 0, src.getWidth(), src.getHeight(), + 0, 0, dst.getWidth(), dst.getHeight(), + GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, + GL_NEAREST); } -void LLDrawPoolWater::endPostDeferredPass(S32 pass) +void LLDrawPoolWater::renderPostDeferred(S32 pass) { - endRenderPass(pass); - deferred_render = FALSE; + renderWater(); +} + + +S32 LLDrawPoolWater::getNumDeferredPasses() +{ + return 0; } //=============================== @@ -152,6 +169,7 @@ void LLDrawPoolWater::renderDeferred(S32 pass) void LLDrawPoolWater::render(S32 pass) { +#if 0 LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_WATER); if (mDrawFace.empty() || LLDrawable::getCurrentFrame() <= 1) { @@ -323,11 +341,13 @@ void LLDrawPoolWater::render(S32 pass) glStencilFunc(GL_NOTEQUAL, 0, 0xFFFFFFFF); renderReflection(refl_face); } +#endif } // for low end hardware void LLDrawPoolWater::renderOpaqueLegacyWater() { +#if 0 LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; LLVOSky *voskyp = gSky.mVOSkyp; @@ -432,11 +452,13 @@ void LLDrawPoolWater::renderOpaqueLegacyWater() } gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE); +#endif } void LLDrawPoolWater::renderReflection(LLFace* face) { +#if 0 LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; LLVOSky *voskyp = gSky.mVOSkyp; @@ -462,6 +484,7 @@ void LLDrawPoolWater::renderReflection(LLFace* face) LLOverrideFaceColor override(this, LLColor4(face->getFaceColor().mV)); face->renderIndexed(); +#endif } void LLDrawPoolWater::renderWater() @@ -535,7 +558,8 @@ void LLDrawPoolWater::renderWater() shader = deferred_render ? &gDeferredWaterProgram : &gWaterProgram; } } - shader->bind(); + + gPipeline.bindDeferredShader(*shader); // bind textures for water rendering S32 reftex = shader->enableTexture(LLShaderMgr::WATER_REFTEX); @@ -576,6 +600,8 @@ void LLDrawPoolWater::renderWater() // bind reflection texture from RenderTarget S32 screentex = shader->enableTexture(LLShaderMgr::WATER_SCREENTEX); + S32 screenDepth = shader->enableTexture(LLShaderMgr::WATER_SCREENDEPTH); + F32 screenRes[] = {1.f / gGLViewport[2], 1.f / gGLViewport[3]}; S32 diffTex = shader->enableTexture(LLShaderMgr::DIFFUSE_MAP); @@ -602,6 +628,11 @@ void LLDrawPoolWater::renderWater() gGL.getTexUnit(screentex)->bind(&gPipeline.mWaterDis); } + if (screenDepth > -1) + { + gGL.getTexUnit(screenDepth)->bind(&gPipeline.mWaterDis, true); + } + if (mShaderLevel == 1) { fog_color.mV[VW] = log(fog_density) / log(2); @@ -683,7 +714,8 @@ void LLDrawPoolWater::renderWater() shader->disableTexture(LLShaderMgr::WATER_SCREENDEPTH); // clean up - shader->unbind(); + gPipeline.unbindDeferredShader(*shader); + gGL.getTexUnit(bumpTex)->unbind(LLTexUnit::TT_TEXTURE); gGL.getTexUnit(bumpTex2)->unbind(LLTexUnit::TT_TEXTURE); } diff --git a/indra/newview/lldrawpoolwater.h b/indra/newview/lldrawpoolwater.h index 6f2fc3271d..418430d68a 100644 --- a/indra/newview/lldrawpoolwater.h +++ b/indra/newview/lldrawpoolwater.h @@ -35,7 +35,7 @@ class LLHeavenBody; class LLWaterSurface; class LLGLSLShader; -class LLDrawPoolWater: public LLFacePool +class LLDrawPoolWater final: public LLFacePool { protected: LLPointer<LLViewerTexture> mWaterImagep[2]; @@ -56,26 +56,26 @@ public: LLVertexBuffer::MAP_TEXCOORD0 }; - virtual U32 getVertexDataMask() { return VERTEX_DATA_MASK; } + virtual U32 getVertexDataMask() override { return VERTEX_DATA_MASK; } LLDrawPoolWater(); /*virtual*/ ~LLDrawPoolWater(); static void restoreGL(); - /*virtual*/ S32 getNumPostDeferredPasses() { return 0; } //getNumPasses(); } - /*virtual*/ void beginPostDeferredPass(S32 pass); - /*virtual*/ void endPostDeferredPass(S32 pass); - /*virtual*/ void renderPostDeferred(S32 pass) { render(pass); } - /*virtual*/ S32 getNumDeferredPasses() { return 1; } - /*virtual*/ void renderDeferred(S32 pass = 0); - - /*virtual*/ S32 getNumPasses(); - /*virtual*/ void render(S32 pass = 0); - /*virtual*/ void prerender(); - - /*virtual*/ LLViewerTexture *getDebugTexture(); - /*virtual*/ LLColor3 getDebugColor() const; // For AGP debug display + + S32 getNumPostDeferredPasses() override; + void beginPostDeferredPass(S32 pass) override; + void renderPostDeferred(S32 pass) override; + S32 getNumDeferredPasses() override; + void renderDeferred(S32 pass = 0) override; + + S32 getNumPasses() override; + void render(S32 pass = 0) override; + void prerender() override; + + LLViewerTexture *getDebugTexture() override; + LLColor3 getDebugColor() const; // For AGP debug display void renderReflection(LLFace* face); void renderWater(); diff --git a/indra/newview/llreflectionmapmanager.cpp b/indra/newview/llreflectionmapmanager.cpp index 4b2a2a382a..cbefb93ca9 100644 --- a/indra/newview/llreflectionmapmanager.cpp +++ b/indra/newview/llreflectionmapmanager.cpp @@ -34,6 +34,7 @@ #include "llviewershadermgr.h" #include "llviewercontrol.h" #include "llenvironment.h" +#include "llstartup.h" extern BOOL gCubeSnapshot; extern BOOL gTeleportDisplay; @@ -63,7 +64,7 @@ struct CompareProbeDistance // helper class to seed octree with probes void LLReflectionMapManager::update() { - if (!LLPipeline::sReflectionProbesEnabled || gTeleportDisplay) + if (!LLPipeline::sReflectionProbesEnabled || gTeleportDisplay || LLStartUp::getStartupState() < STATE_PRECACHE) { return; } @@ -212,7 +213,11 @@ LLReflectionMap* LLReflectionMapManager::addProbe(LLSpatialGroup* group) { LLReflectionMap* probe = new LLReflectionMap(); probe->mGroup = group; - probe->mOrigin = group->getOctreeNode()->getCenter(); + + if (group) + { + probe->mOrigin = group->getOctreeNode()->getCenter(); + } if (gCubeSnapshot) { //snapshot is in progress, mProbes is being iterated over, defer insertion until next update @@ -272,7 +277,9 @@ LLReflectionMap* LLReflectionMapManager::registerSpatialGroup(LLSpatialGroup* gr return addProbe(group); } } - +#endif + +#if 0 if (group->getSpatialPartition()->mPartitionType == LLViewerRegion::PARTITION_TERRAIN) { OctreeNode* node = group->getOctreeNode(); diff --git a/indra/newview/llreflectionmapmanager.h b/indra/newview/llreflectionmapmanager.h index 493f53efb8..4dcd822677 100644 --- a/indra/newview/llreflectionmapmanager.h +++ b/indra/newview/llreflectionmapmanager.h @@ -62,7 +62,7 @@ public: void update(); // add a probe for the given spatial group - LLReflectionMap* addProbe(LLSpatialGroup* group); + LLReflectionMap* addProbe(LLSpatialGroup* group = nullptr); // Populate "maps" with the N most relevant Reflection Maps where N is no more than maps.size() // If less than maps.size() ReflectionMaps are available, will assign trailing elements to nullptr. diff --git a/indra/newview/llsurface.cpp b/indra/newview/llsurface.cpp index ea36e1d7be..1418499f8b 100644 --- a/indra/newview/llsurface.cpp +++ b/indra/newview/llsurface.cpp @@ -681,6 +681,13 @@ BOOL LLSurface::idleUpdate(F32 max_update_time) } } } + + if (did_update) + { + // some patches changed, update region reflection probes + mRegionp->updateReflectionProbes(); + } + return did_update; } diff --git a/indra/newview/llviewerdisplay.cpp b/indra/newview/llviewerdisplay.cpp index 7e1f8db9a8..118dbb833e 100644 --- a/indra/newview/llviewerdisplay.cpp +++ b/indra/newview/llviewerdisplay.cpp @@ -1007,7 +1007,7 @@ void display(BOOL rebuild, F32 zoom_factor, int subfield, BOOL for_snapshot) if (LLPipeline::sRenderDeferred) { - gPipeline.renderDeferredLighting(&gPipeline.mRT->screen); + gPipeline.renderDeferredLighting(); } LLPipeline::sUnderWaterRender = FALSE; @@ -1062,11 +1062,9 @@ void display_cube_face() llassert(!gSnapshot); llassert(!gTeleportDisplay); - llassert(LLPipeline::sRenderDeferred); llassert(LLStartUp::getStartupState() >= STATE_PRECACHE); llassert(!LLAppViewer::instance()->logoutRequestSent()); llassert(!gRestoreGL); - llassert(!gUseWireframe); bool rebuild = false; @@ -1148,7 +1146,7 @@ void display_cube_face() gPipeline.mRT->deferredScreen.flush(); - gPipeline.renderDeferredLighting(&gPipeline.mRT->screen); + gPipeline.renderDeferredLighting(); LLPipeline::sUnderWaterRender = FALSE; diff --git a/indra/newview/llviewerregion.cpp b/indra/newview/llviewerregion.cpp index 8f56f6110f..628d0ecc6a 100644 --- a/indra/newview/llviewerregion.cpp +++ b/indra/newview/llviewerregion.cpp @@ -1233,6 +1233,45 @@ U32 LLViewerRegion::getNumOfVisibleGroups() const return mImpl ? mImpl->mVisibleGroups.size() : 0; } +void LLViewerRegion::updateReflectionProbes() +{ + const F32 probe_spacing = 32.f; + const F32 probe_radius = sqrtf((probe_spacing * 0.5f) * (probe_spacing * 0.5f) * 3.f); + const F32 hover_height = 2.f; + + F32 start = probe_spacing * 0.5f; + + U32 grid_width = REGION_WIDTH_METERS / probe_spacing; + + mReflectionMaps.resize(grid_width * grid_width); + + F32 water_height = getWaterHeight(); + LLVector3 origin = getOriginAgent(); + + for (U32 i = 0; i < grid_width; ++i) + { + F32 x = i * probe_spacing + start; + for (U32 j = 0; j < grid_width; ++j) + { + F32 y = j * probe_spacing + start; + + U32 idx = i * grid_width + j; + + if (mReflectionMaps[idx].isNull()) + { + mReflectionMaps[idx] = gPipeline.mReflectionMapManager.addProbe(); + } + + LLVector3 probe_origin = LLVector3(x,y, llmax(water_height, mImpl->mLandp->resolveHeightRegion(x,y))); + probe_origin.mV[2] += hover_height; + probe_origin += origin; + + mReflectionMaps[idx]->mOrigin.load3(probe_origin.mV); + mReflectionMaps[idx]->mRadius = probe_radius; + } + } +} + void LLViewerRegion::addToVOCacheTree(LLVOCacheEntry* entry) { if(!sVOCacheCullingEnabled) diff --git a/indra/newview/llviewerregion.h b/indra/newview/llviewerregion.h index d0fa9fea01..250e0236e4 100644 --- a/indra/newview/llviewerregion.h +++ b/indra/newview/llviewerregion.h @@ -41,6 +41,7 @@ #include "llcapabilityprovider.h" #include "m4math.h" // LLMatrix4 #include "llframetimer.h" +#include "llreflectionmap.h" // Surface id's #define LAND 1 @@ -399,6 +400,9 @@ public: static BOOL isNewObjectCreationThrottleDisabled() {return sNewObjectCreationThrottle < 0;} + // rebuild reflection probe list + void updateReflectionProbes(); + private: void addToVOCacheTree(LLVOCacheEntry* entry); LLViewerObject* addNewObject(LLVOCacheEntry* entry); @@ -572,6 +576,10 @@ private: LLFrameTimer mMaterialsCapThrottleTimer; LLFrameTimer mRenderInfoRequestTimer; LLFrameTimer mRenderInfoReportTimer; + + // list of reflection maps being managed by this llviewer region + std::vector<LLPointer<LLReflectionMap> > mReflectionMaps; + }; inline BOOL LLViewerRegion::getRegionProtocol(U64 protocol) const diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp index 6783875161..46abd83449 100644 --- a/indra/newview/llviewershadermgr.cpp +++ b/indra/newview/llviewershadermgr.cpp @@ -1020,9 +1020,12 @@ BOOL LLViewerShaderMgr::loadShadersWater() // load water shader gWaterProgram.mName = "Water Shader"; gWaterProgram.mFeatures.calculatesAtmospherics = true; + gWaterProgram.mFeatures.hasAtmospherics = true; + gWaterProgram.mFeatures.hasWaterFog = true; gWaterProgram.mFeatures.hasGamma = true; gWaterProgram.mFeatures.hasTransport = true; gWaterProgram.mFeatures.hasSrgb = true; + gWaterProgram.mFeatures.hasReflectionProbes = true; gWaterProgram.mShaderFiles.clear(); gWaterProgram.mShaderFiles.push_back(make_pair("environment/waterV.glsl", GL_VERTEX_SHADER)); gWaterProgram.mShaderFiles.push_back(make_pair("environment/waterF.glsl", GL_FRAGMENT_SHADER)); @@ -1037,9 +1040,12 @@ BOOL LLViewerShaderMgr::loadShadersWater() // load water shader gWaterEdgeProgram.mName = "Water Edge Shader"; gWaterEdgeProgram.mFeatures.calculatesAtmospherics = true; + gWaterEdgeProgram.mFeatures.hasAtmospherics = true; + gWaterEdgeProgram.mFeatures.hasWaterFog = true; gWaterEdgeProgram.mFeatures.hasGamma = true; gWaterEdgeProgram.mFeatures.hasTransport = true; gWaterEdgeProgram.mFeatures.hasSrgb = true; + gWaterEdgeProgram.mFeatures.hasReflectionProbes = true; gWaterEdgeProgram.mShaderFiles.clear(); gWaterEdgeProgram.mShaderFiles.push_back(make_pair("environment/waterV.glsl", GL_VERTEX_SHADER)); gWaterEdgeProgram.mShaderFiles.push_back(make_pair("environment/waterF.glsl", GL_FRAGMENT_SHADER)); diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp index 92cca190fd..08c99266f8 100644 --- a/indra/newview/pipeline.cpp +++ b/indra/newview/pipeline.cpp @@ -1032,7 +1032,6 @@ void LLPipeline::updateRenderBump() // static void LLPipeline::updateRenderDeferred() { - sRenderDeferred = !gUseWireframe; sRenderPBR = sRenderDeferred; static LLCachedControl<S32> sProbeDetail(gSavedSettings, "RenderReflectionProbeDetail", -1); sReflectionProbesEnabled = sProbeDetail >= 0 && gGLManager.mGLVersion > 3.99f; @@ -4326,6 +4325,7 @@ U32 LLPipeline::sCurRenderPoolType = 0 ; void LLPipeline::renderGeom(LLCamera& camera, bool forceVBOUpdate) { +#if 0 LL_PROFILE_ZONE_SCOPED_CATEGORY_PIPELINE; //LL_RECORD_BLOCK_TIME(FTM_RENDER_GEOMETRY); LL_PROFILE_GPU_ZONE("renderGeom"); assertInitialized(); @@ -4575,6 +4575,7 @@ void LLPipeline::renderGeom(LLCamera& camera, bool forceVBOUpdate) LLGLState::checkStates(); // LLGLState::checkTextureChannels(); // LLGLState::checkClientArrays(); +#endif } void LLPipeline::renderGeomDeferred(LLCamera& camera) @@ -4774,6 +4775,16 @@ void LLPipeline::renderGeomPostDeferred(LLCamera& camera, bool do_occlusion) gGL.matrixMode(LLRender::MM_MODELVIEW); gGL.loadMatrix(gGLModelView); } + + if (!gCubeSnapshot) + { + // debug displays + renderHighlights(); + mHighlightFaces.clear(); + + renderDebug(); + } + } void LLPipeline::renderGeomShadow(LLCamera& camera) @@ -8431,7 +8442,7 @@ LLVector4 pow4fsrgb(LLVector4 v, F32 f) return v; } -void LLPipeline::renderDeferredLighting(LLRenderTarget *screen_target) +void LLPipeline::renderDeferredLighting() { LL_PROFILE_ZONE_SCOPED_CATEGORY_PIPELINE; LL_PROFILE_GPU_ZONE("renderDeferredLighting"); @@ -8440,6 +8451,7 @@ void LLPipeline::renderDeferredLighting(LLRenderTarget *screen_target) return; } + LLRenderTarget *screen_target = &mRT->screen; LLRenderTarget *deferred_target = &mRT->deferredScreen; LLRenderTarget *deferred_depth_target = &mRT->deferredDepth; LLRenderTarget *deferred_light_target = &mRT->deferredLight; @@ -8692,6 +8704,7 @@ void LLPipeline::renderDeferredLighting(LLRenderTarget *screen_target) unbindDeferredShader(LLPipeline::sUnderWaterRender ? gDeferredSoftenWaterProgram : gDeferredSoftenProgram); } +#if 0 { // render non-deferred geometry (fullbright, alpha, etc) LLGLDisable blend(GL_BLEND); LLGLDisable stencil(GL_STENCIL_TEST); @@ -8707,6 +8720,7 @@ void LLPipeline::renderDeferredLighting(LLRenderTarget *screen_target) renderGeomPostDeferred(*LLViewerCamera::getInstance(), false); gPipeline.popRenderTypeMask(); } +#endif bool render_local = RenderLocalLights; // && !gCubeSnapshot; @@ -8970,10 +8984,6 @@ void LLPipeline::renderDeferredLighting(LLRenderTarget *screen_target) gGL.setColorMask(true, true); } - screen_target->flush(); - - screen_target->bindTarget(); - { // render non-deferred geometry (alpha, fullbright, glow) LLGLDisable blend(GL_BLEND); LLGLDisable stencil(GL_STENCIL_TEST); @@ -9001,6 +9011,7 @@ void LLPipeline::renderDeferredLighting(LLRenderTarget *screen_target) LLPipeline::RENDER_TYPE_CONTROL_AV, LLPipeline::RENDER_TYPE_ALPHA_MASK, LLPipeline::RENDER_TYPE_FULLBRIGHT_ALPHA_MASK, + LLPipeline::RENDER_TYPE_WATER, END_RENDER_TYPES); renderGeomPostDeferred(*LLViewerCamera::getInstance()); @@ -9065,16 +9076,7 @@ void LLPipeline::renderDeferredLighting(LLRenderTarget *screen_target) gGL.popMatrix(); gGL.matrixMode(LLRender::MM_MODELVIEW); gGL.popMatrix(); - } - - if (!gCubeSnapshot) - { - // render highlights, etc. - renderHighlights(); - mHighlightFaces.clear(); - - renderDebug(); - + LLVertexBuffer::unbind(); if (gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_UI)) @@ -9346,6 +9348,7 @@ inline float sgn(float a) void LLPipeline::generateWaterReflection(LLCamera& camera_in) { +#if 0 LL_PROFILE_ZONE_SCOPED_CATEGORY_PIPELINE; LL_PROFILE_GPU_ZONE("generateWaterReflection"); @@ -9684,6 +9687,7 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in) gPipeline.popRenderTypeMask(); } } +#endif } glh::matrix4f look(const LLVector3 pos, const LLVector3 dir, const LLVector3 up) diff --git a/indra/newview/pipeline.h b/indra/newview/pipeline.h index 0b6b7d91ae..a31df9c16f 100644 --- a/indra/newview/pipeline.h +++ b/indra/newview/pipeline.h @@ -306,7 +306,7 @@ public: - void renderDeferredLighting(LLRenderTarget* light_target); + void renderDeferredLighting(); void postDeferredGammaCorrect(LLRenderTarget* screen_target); void generateWaterReflection(LLCamera& camera); |