Introduction to my galaxy engine 4: Test on local light model

今天按照shadow volumn阴影的检查方法对spot light和point light的灯光范围模型做了个测试。

测试图片如下：（蓝色为场景中的物体，黄色表示场景中受灯光影响的部分，绿色为灯光模型）

depth fail test 和 stencil test 是在GPU中执行的，首先渲染蓝色的盒子RenderScene，再渲染灯光模型CalRadium（disable write to depth buffer），最后再将模板值为1的部分添加上另一个颜色来突出受光照部分LitScene，代码如下：

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 AlphaBlendingOn
{
    BlendEnable[0] = TRUE;
    SrcBlend = SRC_ALPHA;
    DestBlend = INV_SRC_ALPHA;
};

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

RasterizerState DisableCulling
{
    //FillMode = WIREFRAME;
    CullMode = NONE;
};

RasterizerState EnableCulling
{
    //FillMode = WIREFRAME;
    CullMode = BACK;
};

RasterizerState FrontCulling
{
    //FillMode = WIREFRAME;
    CullMode = FRONT;
};

BlendState DisableFrameBuffer
{
    BlendEnable[0] = FALSE;
    RenderTargetWriteMask[0] = 0x0;
};

BlendState EnableFrameBuffer
{
    BlendEnable[0] = FALSE;
    RenderTargetWriteMask[0] = 0x0F;
};

DepthStencilState TwoSidedStencil
{
    DepthEnable = true;
    DepthWriteMask = ZERO;//Turn off writes to the depth-stencil buffer.
    DepthFunc = Less;
    
    // Setup stencil states
    StencilEnable = true;
    StencilReadMask = 0xFFFFFFFF;
    StencilWriteMask = 0xFFFFFFFF;
    
    BackFaceStencilFunc = Always;// how stencil data is compared against existing stencil data.Always pass the comparison.
    BackFaceStencilDepthFail = Incr;// describes the stencil operation to perform when stencil testing passes and depth testing fails. 
    BackFaceStencilPass = Keep;// describes the stencil operation to perform when stencil testing and depth testing both pass. 
    BackFaceStencilFail = Keep;//describes the stencil operation to perform when stencil testing fails. 
    
    FrontFaceStencilFunc = Always;
    FrontFaceStencilDepthFail = Decr;
    FrontFaceStencilPass = Keep;
    FrontFaceStencilFail = Keep;
};

DepthStencilState RenderNonShadows
{
    DepthEnable = true;
    DepthWriteMask = ZERO;
    DepthFunc = Less_Equal;
    
    StencilEnable = true;
    StencilReadMask = 0xFFFFFFFF;//read stencil buffer to check if lit or not
    StencilWriteMask = 0x0;
    
    FrontFaceStencilFunc = Less_Equal;//If the source data is greater (multipay light)or equal to the destination data, the comparison passes.
    FrontFaceStencilPass = Keep;//Keep the existing stencil data.
    FrontFaceStencilFail = Zero;//Set the stencil data to 0.
    
    BackFaceStencilFunc = Never;//Never pass the comparison.
    BackFaceStencilPass = Zero;
    BackFaceStencilFail = Zero;
};

Texture2D  g_ModelTexture;

Texture2D  g_NormDepthTexture;
Texture2D  g_DiffuseTexture;

matrix World;
matrix View;
matrix 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_LocalLightColor;
//---------------------------------------------------------------------------------------------------------------------------------
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;    
};

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

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

struct PS_SCENE_OUTPUT
{
    float4 Color        :SV_Target;   
    float     Depth        : SV_Depth;
};
//-----------------------------------------------------------render scene to gbuffer-----------------------------------------------
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.Pos = output.Pos / output.Pos.w;

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

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

    float4 NormDepth = 0;
    NormDepth.rgb = input.Norm;//normal
    NormDepth.a = input.Pos.z;//depth

    output.NormDepth = NormDepth;
    output.DiffuseColor = g_ModelTexture.Sample( g_samWrap, input.Tex );

    return output;
}
//----------------------------------------------add ambient light to scene------------------------------------------------
PS_SCENE_INPUT VS_Ambient(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.x = 0.5 * (1 + Pos.x);
    output.Tex.y = 0.5 * (1 - Pos.y);

    return output;
}

PS_SCENE_OUTPUT PS_Ambient(PS_SCENE_INPUT input)
{
    PS_SCENE_OUTPUT output = (PS_SCENE_OUTPUT)0;

    float4 DiffuseColor = g_DiffuseTexture.Sample( g_samClamp, input.Tex );
    float4 NormalDepth = g_NormDepthTexture.Sample( g_samClamp, input.Tex );
    float3 Normal = NormalDepth.rgb;
    float Depth = NormalDepth.a;
    float4 Pos = input.Pos;

    clip(Depth - 0.0001);

    output.Color = (g_AmbientColor + dot(normalize(g_DirLightDir), Normal) * g_DirLightColor) * DiffuseColor;
    output.Color.a = 1;
    output.Depth = Depth;
    
    return output;
}
//------------------------------calcuate depth test and set stencil value-------------------------------------------------------
float4 PS_CalRadium(PS_MODEL_INPUT input) : SV_Target
{   
    return float4(0.0, 1.0, 0.0, 0.3);//green light volumn
}
//-------------------------------------------------------------------------------------lit the area where stencil value is 1----------------------------------------------------------------------------------------
float4 PS_LitScene(PS_SCENE_INPUT input) : SV_Target
{
    return g_LocalLightColor;
}
//---------------------------------------------------------------------------------------------------------
technique10 RenderScene
{
    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 );
        SetDepthStencilState( EnableDepth, 0 );
        SetRasterizerState( EnableCulling );

        //SetRasterizerState( FrontCulling );
    }  
}

technique10 AmbientLighting
{
    pass p0
    {
        SetVertexShader( CompileShader( vs_4_0, VS_Ambient() ) );
        SetGeometryShader( NULL );
        SetPixelShader( CompileShader( ps_4_0, PS_Ambient() ) );

        SetBlendState( NoBlending, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
        SetDepthStencilState( EnableDepth, 0 );//render all model on texture, no depth test is needed
        SetRasterizerState( EnableCulling );
    }  
}

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

        SetBlendState( AlphaBlendingOn, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
        //SetBlendState( DisableFrameBuffer, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );//don't render color to render target
        SetDepthStencilState( TwoSidedStencil, 1 ); //do depth fail test, write to stencil buffer
        SetRasterizerState( DisableCulling );//no culling, so both front and back face could be tested
    }  
}

technique10 LitScene
{
    pass p0
    {
        SetVertexShader( CompileShader( vs_4_0, VS_Ambient() ) );
        SetGeometryShader( NULL );
        SetPixelShader( CompileShader( ps_4_0, PS_LitScene() ) );

        SetBlendState( AdditiveBlending, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
        SetDepthStencilState( RenderNonShadows, 1); //when stencil value is 0, stencil fun pass and lit that pixel
        SetRasterizerState( EnableCulling );
    }  
}