Introduction to my galaxy engine 2: Depth of field

参考shaderx2 中DOF via Simulation of Circle of Confusion 算法 or http://amdstaging.wpengine.com/wordpress/media/2012/10/Scheuermann_DepthOfField.pdf，引擎中增加了depth of field 功能模块。基本原理就是根据物体与聚焦平面的距离来设定模糊kernel的大小，对远离聚焦平面的物体做模糊处理。

视频地址：http://my.ku6.com/watch?v=c-wjiz_TdM2S7MkC_MNwpw..#

1.首先将场景中物体的颜色渲染到一个render target上，颜色计算公式可以自己定，以下是我用的方法：

output.Color = saturate( dot(input.Norm, normalize(SunLightDir)) * vLightColor + diffuse + vAmbiantColor );

2.再将场景深度，模糊值blur分别存到另一个render target的R值和G值

深度模糊值计算方法如下：

float blur = saturate(abs(input.Depth - focalDist) / focalRange);

input.Depth为物体深度，focalDist为聚焦平面的值，focalRange为聚焦范围，blue这样计算的话就在0-1范围内。

output.Depth = float4(depth, blur, 0, 1);

下面的话就是按照以上两个信息做模糊处理

首先建立一个屏幕大小的平面，有四个顶点，作为画布传入vertex shader

从第一个贴图中获取物体颜色

float4 colorSum = g_SceneTexture.Sample( g_samClamp, input.Tex );

然后从另一张贴图去除深度值和模糊值

float2 centerDepthBlur = g_DepthTexture.Sample( g_samClamp,  input.Tex );

依据模糊值确定kernel大小

float sizeCoC = centerDepthBlur.y * g_MaxCoC;

下面是关键：

for (int i = 0; i < 12; i++)//kernel中原先有的12个采样点
{
// Compute tap coordinates
float2 tapCoord = input.Tex + g_FilterTaps[i] * sizeCoC;计算采样点的纹理坐标

// Fetch tap sample
float4 tapColor = g_SceneTexture.Sample(g_samClamp, tapCoord); 采样点所在位置的颜色值
float2 tapDepthBlur = g_DepthTexture.Sample(g_samClamp, tapCoord);采样点所在位置的深度和模糊因素

// Compute tap contribution
float tapContribution = (tapDepthBlur.x > centerDepthBlur.x) ? 1.0f : tapDepthBlur.y;防止聚焦平面后面的物体采样到聚焦平面的物体的颜色值

// Accumulate color and contribution
colorSum += tapColor * tapContribution;
totalContribution += tapContribution;
}

// Normalize to get proper luminance
finalColor = colorSum / totalContribution;

以下是截图，分别是没有DOF效果图，深度图，模糊因素图和有DOF的效果图

以下是所有shader代码

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

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

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

BlendState AlphaBlendingOn
{
    BlendEnable[0] = TRUE;
    SrcBlend = SRC_ALPHA;
    DestBlend = INV_SRC_ALPHA;
};

matrix World;
matrix View;
matrix Projection;
matrix LightView;
float3  SunLightDir;

float4 vLightColor = float4(0.3f, 0.3f, 0.3f, 1.0f);
float4 vAmbiantColor = float4(0.1f, 0.1f, 0.1f, 1.0f);

float focalDist = 1.0;
float focalRange = 1.0;

Texture2D g_SceneTexture;
Texture2D g_DepthTexture;
Texture2D g_ModelTexture;

float2 g_FilterTaps[12];

float g_MaxCoC = 3;

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        : TEXCOORD1;    
    float   Depth        : TEXCOORD2;   
};

struct PS_MODEL_OUTPUT
{
    float4 Color    : SV_Target1;
    float4 Depth    : SV_Target0;
};

struct VS_DOF_INPUT
{
    float4 Pos            : POSITION;         
    float2 Tex            : TEXCOORD0;       
};

struct PS_DOF_INPUT
{
    float4 Pos            :SV_POSITION;   
    float2 Tex            : TEXCOORD0;     
};

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, World );
    output.Pos = mul( output.Pos, View );
    output.Pos = mul( output.Pos, Projection );
    output.Depth = output.Pos.z;
    output.Pos = output.Pos / output.Pos.w;

    output.Norm = mul( input.Norm, World );
    output.Norm = normalize( output.Norm );

    output.Tex = input.Tex;

    return output;
}

PS_MODEL_OUTPUT PS_SCENE( PS_MODEL_INPUT input ) : SV_Target
{
    PS_MODEL_OUTPUT output = (PS_MODEL_OUTPUT)0;

    float4 diffuse = g_ModelTexture.Sample( g_samClamp, input.Tex );
    output.Color = saturate( dot(input.Norm, normalize(SunLightDir)) * vLightColor + diffuse + vAmbiantColor );

    float blur = saturate(abs(input.Depth - focalDist) / focalRange);
    float depth = input.Pos.z;
    output.Depth = float4(depth, blur, 0, 1);

    return output;
}

PS_DOF_INPUT VS_DOF(VS_DOF_INPUT input)
{
    PS_DOF_INPUT output = (PS_DOF_INPUT)0;
    output.Pos = input.Pos;

    output.Tex = float2( input.Tex.x,  1 - input.Tex.y );

    return output;
}

float4 PS_DOF(PS_DOF_INPUT input) : SV_Target
{
    float4 finalColor = 0;

     float4 colorSum = g_SceneTexture.Sample( g_samClamp, input.Tex );

    float2 centerDepthBlur = g_DepthTexture.Sample( g_samClamp,  input.Tex );

    //return centerDepthBlur.y;

    float sizeCoC = centerDepthBlur.y * g_MaxCoC;//blur * maxCoC

    //return sizeCoC;
    float totalContribution = 1.0f;

    for (int i = 0; i < 12; i++)
    {
        // Compute tap coordinates
        float2 tapCoord = input.Tex + g_FilterTaps[i] * sizeCoC;
        
        // Fetch tap sample
        float4 tapColor = g_SceneTexture.Sample(g_samClamp, tapCoord); 
        float2 tapDepthBlur = g_DepthTexture.Sample(g_samClamp, tapCoord);

        // Compute tap contribution
        //for obj in front, use tapDepthBlur.y, and if obj is in focus, tapDepthBlur.y is 0, so no leak of front obj color; for back obj, use 1.0f
        float tapContribution = (tapDepthBlur.x > centerDepthBlur.x) ? 1.0f : tapDepthBlur.y;

        // Accumulate color and contribution
        colorSum += tapColor * tapContribution;
        totalContribution += tapContribution;
    }

    // Normalize to get proper luminance
    finalColor = colorSum / totalContribution;

    return finalColor;
}

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

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

   pass p1
    {
        SetVertexShader( CompileShader( vs_4_0, VS_DOF() ) );
        SetGeometryShader( NULL );
        SetPixelShader( CompileShader( ps_4_0, PS_DOF() ) );

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