1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

#version 450 core
#ifdef COMPUTE_SHADER
#define LOCAL_SIZE 8
#include "include/SkyCommon.glslh"

layout(rgba32f, binding = 0) uniform writeonly image2D transmittanceLut;


layout(local_size_x = LOCAL_SIZE, local_size_y = LOCAL_SIZE, local_size_z = 1) in;
void main()
{
    ivec2 texelCoord = ivec2(gl_GlobalInvocationID.xy);

	AtmosphereParameter Atmosphere;  // TODO: AtmosphereUniform
    Atmosphere.PlanetRadius = 6360000.0;
    Atmosphere.AtmosphereHeight = 60000.0;
    Atmosphere.RayleighScatteringScalarHeight = 8000.0;
    Atmosphere.MieScatteringScalarHeight = 1200.0;
    Atmosphere.OzoneLevelCenterHeight = 25000.0;
    Atmosphere.OzoneLevelWidth = 15000.0;


	float bottomRadius = Atmosphere.PlanetRadius;
	float topRadius = Atmosphere.PlanetRadius + Atmosphere.AtmosphereHeight;


    ivec2 lutSize = imageSize(transmittanceLut);
    float viewHeight;
    float viewZenithCosAngle;
    vec2 uv = vec2(texelCoord) / vec2(lutSize);
	float r = 0.0;

    UvToTransmittanceLutParams(bottomRadius, topRadius, uv, viewZenithCosAngle, r);
	float sin_theta = sqrt(1.0 - viewZenithCosAngle * viewZenithCosAngle);
	vec3 CameraPosition = vec3(0.0, r, 0.0);
	vec3 viewDir = vec3(sin_theta, viewZenithCosAngle, 0);

	float dis = RayIntersectSphere(vec3(0,0,0), topRadius, CameraPosition, viewDir);
	vec3 hitPoint = CameraPosition + viewDir * dis;
	vec3 color = Transmittance(Atmosphere, CameraPosition, hitPoint);
    imageStore(transmittanceLut, texelCoord, vec4(color, 1.0));
}

#endif

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// UV转LUT参数（高度、天顶角的余弦值）
void UvToTransmittanceLutParams(float bottomRadius, float topRadius, vec2 uv, out float mu, out float r)
{
    float x_mu = uv.x;
    float x_r = uv.y;

    float H = sqrt(max(0.0f, topRadius * topRadius - bottomRadius * bottomRadius));
    float rho = H * x_r;
    r = sqrt(max(0.0f, rho * rho + bottomRadius * bottomRadius));

    float d_min = topRadius - r;
    float d_max = rho + H;
    float d = d_min + x_mu * (d_max - d_min);
    mu = d == 0.0f ? 1.0f : (H * H - rho * rho - d * d) / (2.0f * r * d);
    mu = clamp(mu, -1.0f, 1.0f);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

#version 450 core
#ifdef COMPUTE_SHADER
#define LOCAL_SIZE 8
#include "include/SkyCommon.glslh"
// 二维 UV 坐标当作球面坐标 (θ, φ) 映射到单位球方向向量。 一个技巧：用2D球面来存储3D的方向向量了
vec3 UVToViewDir(vec2 uv)
{
    float theta = (1.0 - uv.y) * PI;
    float phi = (uv.x * 2 - 1) * PI;
    
    float x = sin(theta) * cos(phi);
    float z = sin(theta) * sin(phi);
    float y = cos(theta);

    return vec3(x, y, z);
}
layout(rgba32f, binding = 0) uniform writeonly image2D SkyViewLut;
layout(binding = 1) uniform sampler2D u_TransmittanceLut;
layout(binding = 2) uniform sampler2D u_MultiScatteringLut;
layout(std140, set = 0, binding = 3) uniform SceneData
{
	DirectionalLight DirectionalLights;
	float EnvironmentMapIntensity;
} u_Scene;
layout(set = 0,binding = 4) uniform CameraDataUniform {
    mat4 view;
    mat4 proj;
	mat4 viewProj;
	float width;
	float height;
	float Near;
	float Far;
	vec3 CameraPosition;
} u_CameraData;
layout(local_size_x = LOCAL_SIZE, local_size_y = LOCAL_SIZE, local_size_z = 1) in;
void main()
{
    ivec2 texelCoord = ivec2(gl_GlobalInvocationID.xy);

	AtmosphereParameter Atmosphere = BuildAtmosphereParameter();

	ivec2 lutSize = imageSize(SkyViewLut);

	vec2 uv = vec2(texelCoord) / vec2(lutSize);
    vec3 viewDir = UVToViewDir(uv);
	vec3 lightDir = normalize(-u_Scene.DirectionalLights.Direction);
	vec3 cameraPosition = normalize(u_CameraData.CameraPosition);

	float h = cameraPosition.y - Atmosphere.SeaLevel + Atmosphere.PlanetRadius;
	vec3 eyePos = vec3(0, h, 0);

	vec3 color = GetSkyView(Atmosphere, eyePos, viewDir, lightDir, -1.0f,u_TransmittanceLut, u_MultiScatteringLut);

    imageStore(SkyViewLut, texelCoord, vec4(color, 1.0));

}

#endif

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

vec3 GetSkyView(
    in AtmosphereParameter param, vec3 eyePos, vec3 viewDir, vec3 lightDir, float maxDis, 
    sampler2D _transmittanceLut, sampler2D _multiScatteringLut)
{
    const int N_SAMPLE = 32;
    vec3 color = vec3(0, 0, 0);

    // 光线和大气层, 星球求交
    float dis = RayIntersectSphere(vec3(0,0,0), param.PlanetRadius + param.AtmosphereHeight, eyePos, viewDir);
    float d = RayIntersectSphere(vec3(0,0,0), param.PlanetRadius, eyePos, viewDir);
    if(dis < 0) return color; 
    if(d > 0) dis = min(dis, d);
    if(maxDis > 0) dis = min(dis, maxDis);  // 带最长距离 maxDis 限制, 方便 aerial perspective lut 部分复用代码

    float ds = dis / float(N_SAMPLE);
    vec3 p = eyePos + (viewDir * ds) * 0.5;
    vec3 sunLuminance = param.SunLightColor * param.SunLightIntensity;
    vec3 opticalDepth = vec3(0, 0, 0);

    for(int i=0; i<N_SAMPLE; i++)
    {
        // 积累沿途的湮灭系数
        float h = length(p) - param.PlanetRadius;
        vec3 extinction = RayleighCoefficient(param, h) + MieCoefficient(param, h) +  // scattering
                            OzoneAbsorption(param, h) + MieAbsorption(param, h);        // absorption
        opticalDepth += extinction * ds;

        vec3 t1 = TransmittanceToAtmosphere(param, p, lightDir, _transmittanceLut);
        vec3 s  = Scattering(param, p, lightDir, viewDir);
        vec3 t2 = exp(-opticalDepth);
        
        // 单次散射
        vec3 inScattering = t1 * s * t2 * ds * sunLuminance;
        color += inScattering;

        // 多重散射
        vec3 multiScattering = GetMultiScattering(param, p, lightDir, _multiScatteringLut);
        color += multiScattering * t2 * ds * sunLuminance;

        p += viewDir * ds;
    }

    return color;
}