Outline

Sobel Mask Filter

(Post Processing - Render Feature)

이미지 처리에서, 한 픽셀에 대해 주변 9가지 픽셀을 검사하여,

변위를 크기화 하여 외곽선을 찾아낼 수 있습니다.

즉 마스킹을 해서 처리하는 방식이라 볼 수 있는데, 그에 따른 마스크는 다음과 같습니다.

어느방향에 대한 경계선 성분을 검사할 것 인지에 대해 설정하는데,

저렇게 만들어진 필터를 사용해, 처리합니다.

어떤 점에 대해, 주변 픽셀의 광량을 모두 합산해 저장합니다.

(색상의 강도 혹은 원하는 변조된 값도 넣을 수 있겠죠. depth라던지)

그런데 한쪽 방향의 데이터와, 반대쪽 데이터의 부호가 반대이므로,

양 방향의 차이가 크다면 명확하게 큰 값(부호는 다를 수 있음)을 저장하게 됩니다.

이때 이제 구해진 부호있는 값의 부호를 삭제하기 위해 자기자신으로 내적한 후 제곱근 연산하여 크기를 반환합니다.

코드가 한국어보다 쉽습니다.

만약 어떤 성분에 대해 극단적으로 찾고싶다면,

필터를 이렇게 걸어도 됩니다.

BRDF(양방향반사도분포함수)

Cook-Torrance Light Model

Cook - Torrance 라이트 모델은 오브젝트의 표면이

매우 많은 미세면에 의해 구성되어있다고 가정합니다.

이 미세면이 각자 개별적으로 들어오는 빛을 반사할 때, 거칠기에 따라 반사패턴이 달라지죠.

$$I = ambient + \sum_l(n \cdot l)\times (k+(1-k)\times I_{spec})$$

k는 확산비율, NoL은 난반사, I(spec)은 Microfacet BRDF, 극소면 BRDF라고 합니다.

그 중 specular에 해당하는 항은 다음과 같이 구성되는데,

$$I_{spec} = \frac{F \times D \times G} {\pi \cdot (N \cdot L ) \cdot (N \cdot V )}$$

추후 여기적힌 π는 4로 나누는게 에너지 보존법칙에 더 적합하다며 4로 대체됩니다.

https://www.cs.cornell.edu/~srm/publications/EGSR07-btdf.pdf

F(fresnel) 프레넬,

G(geometrix Attenuation Factor), 기하학 감쇠요소 (거칠기에 따른 입사광차단, 자체 그림자)

혹은 V라는 약칭으로 불립니다.

D(NDF, Normal Distribution Fuction), 정규 분포 함수

입니다.

그중 살펴볼 것은 Diffuse 과 Specular(사진의 Glossy)입니다.

어떻게 빛을 확산하는지 알아봅시다.

Diffuse BRDF: Lambert Light model

램버트는 Diffuse만 처리하는 간단한 라이트 모델입니다.

노멀과 빛의 내적(N dot L)을 통해 음영을 표기합니다.

Shader "Hidden/Lambert"
{
    Properties
    {
        _BaseColor ("Base Color", Color) = (1, 1, 1, 1)
    }

    HLSLINCLUDE
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"

        struct Attributes
        {
            float4 positionOS   : POSITION; 
            float3 normal : NORMAL;                
        };

        struct Varyings
        {
            float4 positionHCS  : SV_POSITION;
            float3 normal : NORMAL;
        };            

        Varyings vert(Attributes IN)
        {
            Varyings OUT;
            OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
            OUT.normal = TransformObjectToWorldNormal(IN.normal);
            return OUT;
        }

    ENDHLSL

    SubShader
    {
        Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalRenderPipeline" }

        HLSLINCLUDE
            #pragma multi_compile _MAIN_LIGHT_SHADOWS
            #pragma multi_compile _MAIN_LIGHT_SHADOWS_CASCADE
            #pragma multi_compile _SHADOWS_SOFT

            CBUFFER_START(UnityPerMaterial)
                float4 _BaseColor;
            CBUFFER_END
        ENDHLSL

        Pass
        {
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            
            half4 frag(Varyings IN) : SV_Target
            {
                Light light = GetMainLight();
                float lambertian = saturate(dot(IN.normal, light.direction));
                return _BaseColor * lambertian;
            }

            ENDHLSL
        }
    }
}

Diffuse BRDF: Half Lambert

하지만 램버트는 어두운면이 너무 어두워, 디테일이 모두 날라간다는 점이 있습니다.

그래서 절반을 곱하고 절반을 더한, 하프라이프 시절 만들어진 방식이 Half Lambert입니다.

Pass
{
    HLSLPROGRAM
    #pragma vertex vert
    #pragma fragment frag
    
    half4 frag(Varyings IN) : SV_Target
    {
        Light light = GetMainLight();
        float lambertian = saturate(dot(IN.normal, light.direction));

        lambertian = lambertian * 0.5f + 0.5f;
        
        return _BaseColor * lambertian;
    }

    ENDHLSL
}

Specular BRDF: Phong Light Model(Phong Reflection Model)

퐁 라이트 모델의 연산방법은 다음과 같습니다.

일단 노멀과 빛의 반사 빛 벡터를 구합니다.

이후 반사 빛 벡터를 시선벡터의 역과 내적하여 빛이 눈에 도달하는 정도를 구합니다.

빛의 방향은 표면으로 들어오는 방향,

반사되는 방향은 표면에서 나가는 방향, 시선벡터는 들어오는 방향이므로

시선벡터의 역을 반사벡터와 내적하거나 , 혹은 반사벡터의 역을 시선벡터와 내적해야 합니다.

같은 나가거나-들어오는 방향을 이룰 수 있게 말이죠.

Pass
{
    HLSLPROGRAM
    #pragma vertex vert
    #pragma fragment frag
    
    half4 frag(Varyings IN) : SV_Target
    {
        IN.normal = normalize(IN.normal);

        //Half lambert
        Light light = GetMainLight();
        float lambertian = saturate(dot(IN.normal, light.direction));
        lambertian = lambertian * 0.5f + 0.5f;

        //Phong
        float3 view = GetWorldSpaceNormalizeViewDir(IN.PositionWS);
        float3 reflectDirection = reflect(light.direction, IN.normal);
        half spec = saturate(dot(reflectDirection, -view));
        spec = pow(spec,5);
        return _BaseColor * lambertian + spec;
    }

    ENDHLSL
}

Specular BRDF: Blinn - Phong Light Model

Bline - Phong 라이트 모델은 위 방법을 좀 더 계산에 최적화 했습니다.

표면 기준, 빛으로 나가는 방향과 시야로 나가는 방향을 더해, 하프벡터를 만듭니다.

이 하프 벡터의 방향과 표면의 방향을 내적한 값이 1에 가까울 때, 시야와 반사벡터가 같다는 뜻이죠.

Pass
{
    HLSLPROGRAM
    #pragma vertex vert
    #pragma fragment frag
    
    half4 frag(Varyings IN) : SV_Target
    {
        IN.normal = normalize(IN.normal);

        //lambert
        Light light = GetMainLight();
        float lambertian = saturate(dot(IN.normal, light.direction));
        lambertian = lambertian * 0.5f + 0.5f;

        //BPhong
        float3 view = GetWorldSpaceNormalizeViewDir(IN.PositionWS);    //ShaderVariablesFunctions.hlsl
        float3 halfDirection = SafeNormalize(view + light.direction);  //common.hlsl
        
        half spec = saturate(dot(halfDirection, IN.normal));
        spec = pow(spec,5);
        return _BaseColor * lambertian + spec;
    }

    ENDHLSL
}

Specular BRDF: Minimalist Cook-Torrance BRDF

아까 위에서 확인했던

$$I_{spec} = \frac{F \times D \times G} {\pi \cdot (N \cdot L ) \cdot (N \cdot V )}$$

이 식을 근사합니다.

이때, 두 부분으로 분리하는데, D 와 G x F 입니다.

$$D = \frac{ roughness^2}{((N \cdot H)^2 \cdot (roughness^2 - 1) + 1 )^2}$$ $$V \times F = \frac{1-(L\cdot H)^5} {(L\cdot H)^2 \cdot (1-roughness^2) + roughness^2}$$

이렇게 나온 그래프는

이런 형태를 띄는데,

이를 이제 근사합니다.

$$V \times F_{approx} = \frac{1.0 }{ ( (L\cdot H)^2 \cdot (roughness + 0.5) )}$$

최종적으로 이를 합쳐 처리합니다.

$$I_{spec} = \frac{roughness^4}{4 \cdot \pi \cdot ((N \cdot H)^2 \cdot (roughness^4-1)+1)^2 \cdot (L \cdot H)^2 \cdot (roughness+0.5)}$$

Pass
{
    HLSLPROGRAM
    #pragma vertex vert
    #pragma fragment frag
    
    half4 frag(Varyings IN) : SV_Target
    {
        IN.normal = normalize(IN.normal);

        //lambert
        Light light = GetMainLight();
        float lambertian = saturate(dot(IN.normal, light.direction));
        lambertian = lambertian * 0.5f + 0.5f;

        //BPhong
        float3 view = GetWorldSpaceNormalizeViewDir(IN.PositionWS);    //ShaderVariablesFunctions.hlsl
        float3 halfDirection = SafeNormalize(view + light.direction);  //common.hlsl
        
        float NoH = saturate(dot(halfDirection, IN.normal));
        half LoH = half(saturate(dot(light.direction, halfDirection)));
				
				//approx GGX
        float roughness2 = _Roughness * _Roughness; //Property

        float d = NoH * NoH * (roughness2 - 1) + 1.00001f;
        half d2 = half(d * d);

        half LoH2 = LoH * LoH;
        half specularTerm = roughness2 / (d2 * max(half(0.1), LoH2) * (roughness * 4.0 + 2.0));

        return _BaseColor * lambertian + specularTerm;
    }

    ENDHLSL
}

Image Based Lighting

큐브맵 샘플링입니다.

https://learnopengl.com/Advanced-OpenGL/Cubemaps

사실 개념자체는 간단합니다. 큐브의 전개도를 펼쳐 각 이미지를 작성한 다음,

아까 Phong 모델에서 사용하던것과 같이 반사벡터를 구해

해당 반사벡터가 가르키는 큐브의 색상을 가져오면 됩니다.

Spherical Harmonics (SH, 구면조화)

라이트프로브 혹은 스카이박스로 부터 가져오는 방법입니다.

보통 L에 대해 **대역(Band)**이라고 말하며,

각 대역은 해당차수의 다항식과 동일(0대역 = 0차 = 상수)하며,

주어진 대역에는 2L+1개의 함수가 존재합니다.

라이트 정보는 L2 구형 고조파라고도 하는 3차 다항식을 이용해,

각 색상채널에 대해 9개, 총 27개의 부동소숫점값을 사용하여 저장합니다.

이를 큐브맵 시각화(붉은색 - 양수, 녹색 - 0, 파란색 - 음수)하면 다음과 같습니다.

유니티에서 사용하는 정보는 Vector4를 7개 사용합니다.

마지막 값을 제외한 27개 맞습니다.

해당데이터는

다음과 같이 샘플링되어 사용됩니다.

여기서 각 대역에 대해

와 같이 계산해서 던지고 있습니다.

대충 찾아봅시다.

SHA에는 각 R,G,B에 대한 x,y,z 기저 및 강도(w)를 설정하고 있습니다.

SH를 직접 가져와서 넣어봤습니다.

public void SetSH()
{
    LightProbes.GetInterpolatedProbe(target.transform.position, target, out sh);
    
    for (var i = 0; i < 3; i++)
        SHA[i] = new Vector4(sh[i, 3], sh[i, 1], sh[i, 2], sh[i, 0] - sh[i, 6]);

    for (var i = 0; i < 3; i++)
        SHB[i] = new Vector4(sh[i, 4], sh[i, 5], sh[i, 6] * 3.0f, sh[i, 7]);

    SHC = new Vector4(sh[0, 8], sh[1, 8], sh[2, 8], 1);

    mat.SetVector("_SHAr", SHA[0]);
    mat.SetVector("_SHAg", SHA[1]);
    mat.SetVector("_SHAb", SHA[2]);
    mat.SetVector("_SHBr", SHB[0]);
    mat.SetVector("_SHBg", SHB[1]);
    mat.SetVector("_SHBb", SHB[2]);
    mat.SetVector("_SHC", SHC);
}

half4 frag(Varyings IN) : SV_Target
{
    IN.normal = normalize(IN.normal);

    //lambert
    Light light = GetMainLight();
    float lambertian = saturate(dot(IN.normal, light.direction));
    lambertian = lambertian * 0.5f + 0.5f;

    //BPhong
    float3 view = GetWorldSpaceNormalizeViewDir(IN.PositionWS);    //ShaderVariablesFunctions.hlsl
    float3 halfDirection = SafeNormalize(view + light.direction);  //common.hlsl
    
    float NoH = saturate(dot(halfDirection, IN.normal));
    half LoH = half(saturate(dot(light.direction, halfDirection)));

    //GGX
    float roughness2 = _Roughness * _Roughness;

    float d = NoH * NoH * (roughness2 - 1) + 1.00001f;
    half d2 = half(d * d);

    half LoH2 = LoH * LoH;
    half specularTerm = roughness2 / (d2 * max(half(0.1), LoH2) * (_Roughness * 4.0 + 2.0));
    
    //SH
    
    real4 SHCoefficients[7];
    SHCoefficients[0] = _SHAr;
    SHCoefficients[1] = _SHAg;
    SHCoefficients[2] = _SHAb;
    SHCoefficients[3] = _SHBr;
    SHCoefficients[4] = _SHBg;
    SHCoefficients[5] = _SHBb;
    SHCoefficients[6] = _SHC;

    half4 ambient = float4(SampleSH9(SHCoefficients, IN.normal), 1);
    return _BaseColor * lambertian + specularTerm + ambient;
}

이제 더 알고싶다면 GDC 2008에 소개된 Stupid SH Tricks를 읽으면 됩니다.

참조

https://learnopengl.com/Lighting/Basic-Lighting

https://jcgt.org/published/0007/04/01/paper.pdf

https://pharr.org/matt/blog/images/average-irregularity-representation-of-a-rough-surface-for-ray-reflection.pdf

http://www.cs.cornell.edu/~srm/publications/EGSR07-btdf.pdf

• 해당 문서에는 일부 오류 수정사항이 적용되지 않았습니다.

아래 원본 문서를 확인해주세요

https://www.graphics.cornell.edu/~bjw/microfacetbsdf.pdf

http://www.ppsloan.org/publications/StupidSH36.pdf