Update fog effect with the new texures (7e6dd4b4) · Commits · e / os / android_frameworks_libs_systemui

weathereffects/graphics/assets/shaders/fog_effect.agsl

+99 −28

Original line number	Diff line number	Diff line
		@@ -16,12 +16,15 @@

		uniform shader foreground;
		uniform shader background;
		uniform shader fog;
		uniform shader clouds;
		uniform half2 fogSize;
		uniform half2 cloudsSize;
		uniform float2 uvOffsetFgd;
		uniform float2 uvScaleFgd;
		uniform float2 uvOffsetBgd;
		uniform float2 uvScaleBgd;
		uniform half timeForeground;
		uniform half timeBackground;
		uniform half4 time;
		uniform half screenAspectRatio;
		uniform half2 screenSize;
		uniform half pixelDensity;
		@@ -31,40 +34,108 @@ uniform half intensity;
		#include "shaders/utils.agsl"
		#include "shaders/simplex2d.agsl"

		const int numOctaves = 2;

		float fbm(vec2 p, half time) {
		float a = 0.5;
		float result = 0.0;
		float rot = 1.2;

		for (int i = 0; i < numOctaves; i++) {
		result += a * simplex2d_flow(p, rot, time);
		rot *= 1.25;
		p *= 2.0152;
		a *= 0.5;
		}

		return result;
		}
		const vec3 fogColor = vec3(1.);

		vec4 main(float2 fragCoord) {
		float2 uv = fragCoord / screenSize;
		uv.y /= screenAspectRatio;

		vec4 colorForeground = foreground.eval(fragCoord * uvScaleFgd + uvOffsetFgd);
		vec4 color = background.eval(fragCoord * uvScaleBgd + uvOffsetBgd);
		vec2 timeForeground = vec2(time.x, time.y);
		vec2 timeBackground = vec2(time.z, time.w);

		/**
		* The shader is composed by two image textures (foreground and background) and four layers of
		* fog. The rendering order (back to front) is the following:
		* - Background
		* - bgdFogFar (layer 1) / bgdFogClose (layer 2)
		* - Foreground
		* - fgdFogFar (layer 1) / fgdFogClose (layer 2)
		*/

		// Load foreground and blend it with constant solid fog color.
		vec4 fgd = foreground.eval(fragCoord * uvScaleFgd + uvOffsetFgd);
		fgd.rgb = mix(fgd.rgb, fogColor, 0.32 * intensity * fgd.a);

		float frontFog = smoothstep(-0.616, 0.552, fbm(uv * 0.8, timeForeground));
		float bgdFog = smoothstep(-0.744, 0.28, fbm(uv * 1.2, timeBackground));
		// Load background and blend it with constant solid fog color.
		vec4 bgd = background.eval(fragCoord * uvScaleBgd + uvOffsetBgd);
		bgd.rgb = mix(bgd.rgb, fogColor, 0.15 * intensity * bgd.a);

		float dither = 1. - triangleNoise(fragCoord * pixelDensity) * 0.161;
		/* Add first layer: background. */
		// set background color as the starting layer.
		vec4 color = bgd;

		color.rgb = normalBlendWithWhiteSrc(color.rgb, 0.8 * dither * bgdFog * intensity);
		/* Prepare fog layers. */
		// Dither to be applied to background noise.
		float bgdDither = triangleNoise((fragCoord + 0.0002 * timeBackground) * pixelDensity) * 0.1;

		// The furthest fog layer in the background.
		vec4 bgdFogFar = fog.eval(
		fogSize * uv +
		// Moves UV based on time.
		vec2(timeBackground * 1.5) +
		// Adds sampling dithering.
		vec2(bgdDither * 7));

		// The furthest fog layer in the background.
		vec4 bgdFogClose = fog.eval(
		0.5 * fogSize * uv +
		// Moves UV based on time.
		vec2(timeBackground * 5.5) +
		// Adds sampling dithering.
		vec2(bgdDither * 22));

		float fgdDither = triangleNoise((fragCoord + 0.003 * timeForeground) * pixelDensity) * 0.07;
		vec4 fgdFogFar = clouds.eval(
		0.5 * cloudsSize * uv +
		// Moves UV based on time.
		vec2(timeForeground * 10.) +
		// Adds distosions based on noise.
		vec2(bgdFogFar.b * 70., bgdFogFar.g * 10) +
		// Adds sampling dithering.
		vec2(fgdDither * 10));
		vec4 fgdFogClose = clouds.eval(
		0.5 * cloudsSize * uv +
		// moves UV based on time.
		vec2(timeForeground * 72.) +
		// Adds distosions based on noise.
		vec2(bgdFogFar.g * 50., bgdFogFar.b * 80) +
		// Adds sampling dithering.
		vec2(fgdDither * 8));

		/* Add second layer: background fog (far or 1, and close or 2). */
		// background, layer 1.
		float bgdFogLayer1 =
		map(bgdFogFar.r, 0.2, 1., fgdFogFar.g, 0.8) *
		bgdFogFar.r *
		(1. - 0.7 * bgdDither);
		// Blend with background.
		color.rgb = normalBlendWithWhiteSrc(color.rgb, bgdFogLayer1 * intensity);

		// background, layer 2.
		float fbmSimplexWorley = bgdFogClose.g * 0.625 + bgdFogClose.b * 0.3755;
		float bgdFogLayer2 =
		0.85 *
		smoothstep(0.88 * fbmSimplexWorley, 1., bgdFogClose.r) *
		(1.- 0.4 * bgdDither);
		// Blend with background.
		color.rgb = normalBlendWithWhiteSrc(color.rgb, bgdFogLayer2 * intensity);

		/* Add third layer: foreground. */
		// Add the foreground. Any effect from here will be in front of the subject.
		color.rgb = normalBlend(color.rgb, colorForeground.rgb, colorForeground.a);
		// foreground fog.
		color.rgb = normalBlendWithWhiteSrc(color.rgb, 0.5 * frontFog * intensity);
		color.rgb = normalBlend(color.rgb, fgd.rgb, fgd.a);

		/* Add fourth layer: foreground fog (far or 1, and close or 2). */
		// foreground fog, layer 1.
		float fgdFogLayer1 =
		fgdFogFar.r *
		0.5 * (1. - fgdDither);
		color.rgb = normalBlendWithWhiteSrc(color.rgb, fgdFogLayer1 * intensity);

		// Foreground fog, layer 2.
		float fgdFogLayer2 =
		fgdFogClose.g *
		0.4 * (1. - fgdDither);
		color.rgb = normalBlendWithWhiteSrc(color.rgb, fgdFogLayer2 * intensity);

		return color;
		}
		No newline at end of file

weathereffects/graphics/src/main/java/com/google/android/wallpaper/weathereffects/graphics/fog/FogEffect.kt

+41 −6

Original line number	Diff line number	Diff line
		@@ -47,14 +47,27 @@ class FogEffect(
		override fun resize(newSurfaceSize: SizeF) = adjustCropping(newSurfaceSize)

		override fun update(deltaMillis: Long, frameTimeNanos: Long) {
		val time = 0.02f * frameTimeNanos.toFloat() * NANOS_TO_SECONDS
		val deltaTime = deltaMillis * MILLIS_TO_SECONDS

		// Variation range [1, 1.5]. We don't want the variation to be 0.
		val variation = (sin(time + sin(3f * time)) * 0.5f + 0.5f) * 1.5f
		elapsedTime += variation * deltaMillis * MILLIS_TO_SECONDS
		val time = frameTimeNanos.toFloat() * NANOS_TO_SECONDS
		// Variation range [0.4, 1]. We don't want the variation to be 0.
		val variation = sin(0.06f * time + sin(0.18f * time)) * 0.3f + 0.7f
		elapsedTime += variation * deltaTime

		fogConfig.shader.setFloatUniform("timeBackground", elapsedTime * 1.5f)
		fogConfig.shader.setFloatUniform("timeForeground", elapsedTime * 2.0f)
		val scaledElapsedTime = elapsedTime * 0.248f

		val variationFgd0 = 0.256f * sin(scaledElapsedTime)
		val variationFgd1 = 0.156f * sin(scaledElapsedTime) * sin(scaledElapsedTime)
		val timeFgd0 = 0.4f * elapsedTime * 5f + variationFgd0
		val timeFgd1 = 0.03f * elapsedTime * 5f + variationFgd1

		val variationBgd0 = 0.156f * sin((scaledElapsedTime + Math.PI.toFloat() / 2.0f))
		val variationBgd1 =
		0.0156f * sin((scaledElapsedTime + Math.PI.toFloat() / 3.0f)) * sin(scaledElapsedTime)
		val timeBgd0 = 0.8f * elapsedTime * 5f + variationBgd0
		val timeBgd1 = 0.2f * elapsedTime * 5f + variationBgd1

		fogConfig.shader.setFloatUniform("time", timeFgd0, timeFgd1, timeBgd0, timeBgd1)

		fogConfig.colorGradingShader.setInputShader("texture", fogConfig.shader)
		}
		@@ -132,6 +145,28 @@ class FogEffect(
		BitmapShader(fogConfig.background, Shader.TileMode.MIRROR, Shader.TileMode.MIRROR)
		)

		fogConfig.shader.setInputBuffer(
		"clouds",
		BitmapShader(fogConfig.cloudsTexture, Shader.TileMode.REPEAT, Shader.TileMode.REPEAT)
		)

		fogConfig.shader.setFloatUniform(
		"cloudsSize",
		fogConfig.cloudsTexture.width.toFloat(),
		fogConfig.cloudsTexture.height.toFloat()
		)

		fogConfig.shader.setInputBuffer(
		"fog",
		BitmapShader(fogConfig.fogTexture, Shader.TileMode.REPEAT, Shader.TileMode.REPEAT)
		)

		fogConfig.shader.setFloatUniform(
		"fogSize",
		fogConfig.fogTexture.width.toFloat(),
		fogConfig.fogTexture.height.toFloat()
		)

		fogConfig.shader.setFloatUniform("pixelDensity", fogConfig.pixelDensity)
		}