Introduction to my galaxy engine 7: Volumetric Light Scattering

花了一天时间，给引擎中添加了Volumetric Light Scattering模块.

视频地址：https://vimeo.com/43232452

截屏图如下：

Volumetric Light Scattering又名god light，Crepuscular Rays 等等, 也是一个游戏中比较常见的效果，主要是用post process来实现的。

具体实现步骤如下：

1.渲染发光体和场景，场景不添加材质，只显示成黑色，将结果渲染到render target 1上。

2. 只渲染场景，添加材质和光照，将结果渲染到render target 2上。

3. 对render target 1 做采样处理，计算光照。原理见如下图：

在屏幕上每一点到光源中心点做射线，对射线上点做采样。如果采样点被物体遮住，自然光照亮会减少。具体计算公式见GPU GERM 3相关那一张。最近处理结果如下图所示：

4. 最后一步，将render target 2的贴图附在上图上，就是最后的结果了。

完整代码如下：

SamplerState g_samWrap
{
    Filter = MIN_MAG_MIP_LINEAR;
    AddressU = Wrap;
    AddressV = Wrap;
};

SamplerState g_samClamp
{
    Filter = MIN_MAG_MIP_LINEAR;
    AddressU = Clamp;
    AddressV = Clamp;
};

DepthStencilState DisableDepth
{
    DepthEnable = FALSE;
    DepthWriteMask = ZERO;
};

DepthStencilState EnableDepth
{
    DepthEnable = TRUE;
    DepthWriteMask = ALL;
    DepthFunc = Less_Equal;//set to less equal since texture background is ini as 1.0
};

BlendState NoBlending
{
    AlphaToCoverageEnable = FALSE;
    BlendEnable[0] = FALSE;
};

BlendState AdditiveBlending
{
    AlphaToCoverageEnable = FALSE;
    BlendEnable[0] = TRUE;
    SrcBlend = ONE;
    DestBlend = ONE;
    BlendOp = ADD;
    SrcBlendAlpha = SRC_ALPHA;
    DestBlendAlpha = INV_SRC_ALPHA;
    RenderTargetWriteMask[0] = 0x0F;
};

Texture2D  g_ModelTexture;

Texture2D  g_BlackSceneTexture;
Texture2D  g_NormalSceneTexture;

matrix g_World;
matrix g_View;
matrix g_Projection;

//float4 g_AmbientColor = float4(0.1f, 0.1f, 0.1f, 1.0f);
float4 g_DirLightColor = float4(0.3f, 0.3f, 0.3f, 1.0f);
float3 g_DirLightDir = float3(0.0f, 1.0f, -1.0f);

float4 g_LightPos = float4(0.0f, 1.0f, 0.0f, 1.0f);
uint NUM_SAMPLES = 200;
float g_Density = 1.0f;
float g_Weight = 1.0f;
float g_Decay = 0.98f;
float g_Exposure = 0.05f;

bool g_bLight;

struct VS_MODEL_INPUT
{
    float4 Pos            : POSITION;         
    float2 Tex            : TEXCOORD0;     
    float3 Norm        : NORMAL;       
};

struct PS_MODEL_INPUT
{
    float4 Pos            : SV_POSITION;   
    float2 Tex            : TEXCOORD0;     
    float3 Norm        : NORMAL;    
};

struct PS_MODEL_OUTPUT
{
    float4 blackScene        : SV_Target0;
    float4 normalScene        : SV_Target1;
};
//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
struct VS_QUAD_INPUT
{
    float4 Pos            : POSITION;           
    float2 Tex            : TEXCOORD0;       
};

struct PS_SCENE_INPUT
{
    float4 Pos                        : SV_POSITION;   
    float2 Tex                        : TEXCOORD0;     
    float2 ScreenLightPos        : TEXCOORD1;  
};
//---------------------------------------------------------------------------------------render black scene--------------------------------------------------------------------------------------------------------
PS_MODEL_INPUT VS_SCENE(VS_MODEL_INPUT input)
{
    PS_MODEL_INPUT output = (PS_MODEL_INPUT)0;
    output.Pos = input.Pos;
    output.Pos.w = 1;

    output.Pos = mul( output.Pos, g_World );
    output.Pos = mul( output.Pos, g_View );
    output.Pos = mul( output.Pos, g_Projection );
    output.Pos = output.Pos / output.Pos.w;

    output.Norm = input.Norm;
    output.Tex = input.Tex;
    return output;
}

PS_MODEL_OUTPUT PS_BLACK_SCENE(PS_MODEL_INPUT input)
{
    PS_MODEL_OUTPUT output = (PS_MODEL_OUTPUT)0;

    if(g_bLight)
    {
        output.blackScene = float4(1.0f, 1.0f, 1.0f, 1.0f);
        output.normalScene = float4(0.0f, 0.0f, 0.0f, 0.0f);
    }
    else
    {
        output.blackScene = float4(0.0f, 0.0f, 0.0f, 1.0f);
        output.normalScene = dot(normalize(g_DirLightDir), input.Norm) * g_DirLightColor * g_ModelTexture.Sample( g_samWrap, input.Tex );
        output.normalScene.a = 1;
    }

    return output;
}

PS_SCENE_INPUT VS_VLS(VS_QUAD_INPUT input)
{
    PS_SCENE_INPUT output = (PS_SCENE_INPUT)0;

    float2 Pos = input.Pos.xy;
    output.Pos = float4(Pos.xy, 0, 1);
    
    output.Tex =  0.5 * (1 + Pos);

    float4 ScreenLightPos = g_LightPos;
    ScreenLightPos = mul( ScreenLightPos, g_World );
    ScreenLightPos = mul( ScreenLightPos, g_View );
    ScreenLightPos = mul( ScreenLightPos, g_Projection );
    ScreenLightPos = ScreenLightPos / ScreenLightPos.w;
    ScreenLightPos = (ScreenLightPos + 1.0f) / 2.0f;
    output.ScreenLightPos = ScreenLightPos;

    return output;
}

float4 PS_VLS(PS_SCENE_INPUT input) : SV_Target
{
    float2 texCoord = input.Tex;

    float2 deltaTexCoord = (texCoord - input.ScreenLightPos); 
    deltaTexCoord *= 1.0f / NUM_SAMPLES * g_Density;

    float4 color = g_BlackSceneTexture.Sample(g_samClamp, float2(texCoord.x, 1 - texCoord.y));

    float illuminationDecay = 1.0f;

    for (uint i = 0; i < NUM_SAMPLES; i++)
    {
        texCoord -= deltaTexCoord;
        float4 sampleColor = g_BlackSceneTexture.Sample(g_samClamp, float2(texCoord.x, 1 - texCoord.y));//shift y after operation
        sampleColor *= illuminationDecay * g_Weight;
        color += sampleColor;
        illuminationDecay *= g_Decay;
    }

    color *= g_Exposure;
    color.a = 1;
    return color;
}

float4 PS_Blend(PS_SCENE_INPUT input) : SV_Target
{
    float2 texCoord = input.Tex;
    return g_NormalSceneTexture.Sample(g_samClamp, float2(texCoord.x, 1 - texCoord.y));
}

technique10 RenderBlackScene
{
    pass p0
    {
        SetVertexShader( CompileShader( vs_4_0, VS_SCENE() ) );
        SetGeometryShader( NULL );
        SetPixelShader( CompileShader( ps_4_0, PS_BLACK_SCENE() ) );

        SetBlendState( NoBlending, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
    }  
}
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
technique10 VLS
{
    pass p0
    {
        SetVertexShader( CompileShader( vs_4_0, VS_VLS() ) );
        SetGeometryShader( NULL );
        SetPixelShader( CompileShader( ps_4_0, PS_VLS() ) );

        SetBlendState( NoBlending, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
    }  
}

technique10 BlendScene
{
    pass p0
    {
        SetVertexShader( CompileShader( vs_4_0, VS_VLS() ) );
        SetGeometryShader( NULL );
        SetPixelShader( CompileShader( ps_4_0, PS_Blend() ) );

        SetBlendState( AdditiveBlending, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
        SetDepthStencilState( EnableDepth, 0 );//set depth test to less_equal
    }  
}

References:

[1] http://www.unrealcreations.com/groups/kb/wiki/7d174/Volumetric_Light_Scattering_Implementation.html

[2] http://developer.nvidia.com/node/170

[3] http://fabiensanglard.net/lightScattering/index.php