Merge "Fix NaN and dither in fog effect." into main

    vec3 colorFloor = floor(colorTmp) * SLICE_LAST_IDX_INV;

    ivec2 uvFloor = ivec2(

        int(colorFloor.b * LAST_SLICE_FIRST_IDX + colorFloor.r * SLICE_LAST_IDX),

    int(colorFloor.g * SLICE_LAST_IDX));

        int(colorFloor.g * SLICE_LAST_IDX)

    );

    // Calculate the ceil UVs.

    vec3 colorCeil = ceil(colorTmp) * SLICE_LAST_IDX_INV;

    ivec2 uvCeil = ivec2(

        int(colorCeil.b * LAST_SLICE_FIRST_IDX + colorCeil.r * SLICE_LAST_IDX),

    int(colorCeil.g * SLICE_LAST_IDX));

        int(colorCeil.g * SLICE_LAST_IDX)

    );

    /*

     * Fetch the color from the LUT, and combine both floor and ceiling options based on the

uniform float2 uvScaleFgd;

uniform float2 uvOffsetBgd;

uniform float2 uvScaleBgd;

uniform float2 timeForeground;

uniform float2 timeBackground;

uniform float screenAspectRatio;

uniform float2 screenSize;

uniform half2 timeForeground;

uniform half2 timeBackground;

uniform half screenAspectRatio;

uniform half2 screenSize;

uniform half pixelDensity;

#include "shaders/constants.agsl"

#include "shaders/utils.agsl"

    float frontFog = smoothstep(-0.616, 0.552, fbm(vec3(uv * 0.886, 123.1), timeForeground));

    float bgdFog = smoothstep(-0.744, 0.28, fbm(vec3(uv * 1.2, 231.), timeBackground));

    float dithering =  (1. - idGenerator(uv) * 0.161);

    float dither = 1. - triangleNoise(fragCoord * pixelDensity) * 0.161;

    color.rgb = normalBlendWithWhiteSrc(color.rgb, 0.8 * dithering * bgdFog);

    color.rgb = normalBlendWithWhiteSrc(color.rgb, 0.8 * dither * bgdFog);

    // 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);

    return color;

}

        * sin(wiggleSpeed * time) - 0.5;

}

// Noise range of [-1.0, 1.0[ with triangle distribution.

float triangleNoise(vec2 n) {

    n  = fract(n * vec2(5.3987, 5.4421));

    n += dot(n.yx, n.xy + vec2(21.5351, 14.3137));

    float xy = n.x * n.y;

    // compute in [0..2[ and remap to [-1.0..1.0[

    return fract(xy * 95.4307) + fract(xy * 75.04961) - 1.0;

}

/*

 * This is the normal blend mode in which the foreground is painted on top of the background based

 * on the foreground opacity.

            }

            WallpaperInfoContract.WeatherEffect.FOG -> {

                val fogConfig = FogEffectConfig.create(context.assets, foreground, background)

                val fogConfig = FogEffectConfig.create(

                    context.assets, foreground, background, context.resources.displayMetrics.density

                )

                activeEffect = FogEffect(fogConfig, screenSize.toSizeF())

            }

import com.google.android.wallpaper.weathereffects.WeatherEffect

import com.google.android.wallpaper.weathereffects.utils.ImageCrop

import kotlin.math.sin

import kotlin.math.sqrt

import kotlin.random.Random

/** Defines and generates the fog weather effect animation. */

    override fun update(deltaMillis: Long, frameTimeNanos: Long) {

        val time = 0.02f * frameTimeNanos.toFloat() * NANOS_TO_SECONDS

        val generalVariation: Float = 0.4f + 0.6f * sqrt(sin(time + sin(3f * time)))

        elapsedTime += generalVariation * deltaMillis * MILLIS_TO_SECONDS

        val variation = sin(time + sin(3f * time)) * 0.5f + 0.5f

        elapsedTime += variation * deltaMillis * MILLIS_TO_SECONDS

        val speed = elapsedTime * 0.248f

            "background",

            BitmapShader(fogConfig.background, Shader.TileMode.MIRROR, Shader.TileMode.MIRROR)

        )

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

    }

    private fun prepareColorGrading() {