https://docs.unity3d.com/2023.2/Documentation/Manual/SL-ShaderPrograms.html

In Unity, you use the HLSL programming language to write shader programs.
(Unity에서는 HLSL 프로그래밍 언어를 사용하여 셰이더를 작성합니다.)

This section of the manual includes information on using HLSL in a Unity-specific way.
(이 메뉴얼의 섹션은 HLSL을 Unity-specific 방식으로 사용하는 방법이 포함되어있습니다.
* Unity-specific => Unity 엔진에서 HLSL을 사용하는 특수한 규칙이나 패턴을 의미,
Unity는 기본적인 HLSL 문법과 개념을 사용하지만, Shader를 작성할 때 ShaderLab 시스템과 통합하여 사용하는 방식을 채택하고 있음.
렌더링 파이프라인과 호환되도록 설계된 특정 구조와 방법)

For general information on writing HLSL, see Microsoft’s HLSL documentation.
(HLSL 작성에 대한 일반적인 정보는 Microsoft의 HLSL 문서를 참조하세요.)

Note: Unity originally used the Cg language, hence the name of some of Unity’s keywords (CGPROGRAM) and file extensions (.cginc).
(참고: Unity는 원래 Cg 언어를 사용했기 때문에 Unity의 일부 키워드(CGPROGRAM)와 파일 확장자(.cginc)의 이름을 사용했습니다.)

Unity no longer uses Cg, but these names are still in use.
(유니티는 더 이상 Cg를 사용하지 않지만 이러한 이름은 여전히 사용되고 있습니다.)

Adding HLSL code to your ShaderLab code
(ShaderLab code에 HLSL 코드 추가)

You place your HLSL code inside code blocks in your ShaderLab code.
ShaderLab code 블록 안에 HLSL code를 넣습니다.

They usually look like this:
보통 아래와 같이 보입니다.

  Pass {
      // ... the usual pass state setup ...
      
      HLSLPROGRAM
      // compilation directives for this snippet, e.g.:
      #pragma vertex vert
      #pragma fragment frag
      
      // the shader program itself
      
      ENDHLSL

      // ... the rest of pass ...
  }

For more information on shader code blocks, see ShaderLab: adding shader programs.
(shader code blocks에 대한 자세한 내용은 ShaderLab: shader 프로그램 추가를 참조하세요.)

HLSL syntax (HLSL 구문)

HLSL has two syntaxes: a legacy DirectX 9-style syntax, and a more modern DirectX 10+ style syntax.
(HLSL에는 기존 DirectX 9 스타일 syntax와 최신 DirectX 10+ 스타일 syntax의 두 가지 syntax가 있습니다.)

The difference is mostly in how texture sampling functions work:
(차이점은 대부분 텍스처 샘플링 기능의 작동 방식에 있습니다:)

• – The legacy syntax uses sampler2D, tex2D() and similar functions. This syntax works on all platforms.
  (기존 구문은 sampler2D, tex2D() 및 유사한 기능을 사용합니다. 이 syntax는 모든 플랫폼에서 작동합니다.)
• – The DX10+ syntax uses Texture2D, SamplerState and .Sample() functions.
  (DX10+ 구문은 Texture2D, SamplerState 및 .Sample() 함수를 사용합니다.)
  Some forms of this syntax do not work on OpenGL platforms, because textures and samplers are not different objects in OpenGL.
  (textures와 samplers 는 OpenGL에서 서로 다른 개체가 아니기 때문에 이 syntax의 일부 형태는 OpenGL 플랫폼에서 작동하지 않습니다.)

Unity provides shader libraries that contain preprocessor macros to help you manage these differences.
(Unity는 이러한 차이점을 관리하는 데 도움이 되는 전처리 매크로(preprocessor macros)가 포함된 shader libraries를 제공합니다.)

For more information, see Built-in shader macros.
자세한 내용은 Built-in shader macros를 참조하세요.

// Comment out the following line to disable shader debugging
// (다음 줄의 주석 처리('#')를 제거하면 hader debugging이 비활성화됩니다)
#pragma enable_d3d11_debug_symbols

// Example pragma directives
#pragma target 4.0 // Shader가 DirectX 11의 Shader 모델 4.0을 대상으로 한다는 것을 지정
#pragma vertex vert // vert라는 이름의 버텍스 Shader 함수를 사용하겠다고 선언
#pragma fragment frag // frag라는 이름의 프래그먼트 Shader 함수를 사용하겠다고 선언

// Replace path-to-include-file with the path to the include file 
// (지정된 경로의 포함 파일을 포함하며, 이 파일에 있는 #pragma 지시어도 함께 적용)
// (경로 "path-to-include-file"는 실제 포함 파일의 경로로 대체해야 합니다.)
#include_with_pragmas "path-to-include-file"

// The rest of the HLSL code goes here
------------------------------
#include_with_pragmas "path-to-include-file" 지시어를 사용하면, 
해당 경로에 있는 파일(path-to-include-file) 내부의 #pragma 지시어들을 여러 shader 파일에서 공유
여러 shader에서 공통으로 사용하는 #pragma 지시어를 한 곳에서 관리할 수 있게 됩니다.

#pragma target 3.0 // Shader가 DirectX 9의 Shader 모델 3.0을 대상으로 한다는 것을 지정
#pragma exclude_renderers vulkan // 특정 렌더링 API에서 Shader를 제외 / Vulkan 렌더링 API를 사용할 때는 컴파일되거나 실행되지 않음
#pragma vertex vert // vert라는 이름의 버텍스 Shader 함수를 사용하겠다고 선언
#pragma fragment frag // frag라는 이름의 프래그먼트 Shader 함수를 사용하겠다고 선언

// The rest of your HLSL code goes here
// 나머지 HLSL 코드는 여기에 작성합니다

#pragma require integers mrt8

// integers: Shader에서 정수 연산을 지원하는 GPU를 요구
// 이는 정수 기반의 계산이나 비트 연산을 수행하는 Shader에서 필수

// mrt8: 최대 8개의 Multiple Render Targets (MRTs)을 지원하는 GPU를 요구
// mrt는 Shader가 한 번의 렌더 패스에서 여러 개의 렌더 타겟에 출력할 수 있도록 하는 기능

#pragma require integers mrt8 : EXAMPLE_KEYWORD OTHER_EXAMPLE_KEYWORD

#pragma require integers
#pragma require integers mrt8 : EXAMPLE_KEYWORD

#pragma target 4.0

#pragma target 4.0 EXAMPLE_KEYWORD OTHER_EXAMPLE_KEYWORD

#pragma only_renderers metal vulkan

#pragma exclude_renderers metal vulkan

#pragma hardware_tier_variants metal

#pragma shader_feature REFLECTION_TYPE1 REFLECTION_TYPE2 REFLECTION_TYPE3

#pragma shader_feature REFLECTION_TYPE1 REFLECTION_TYPE2 REFLECTION_TYPE3

#pragma shader_feature REFLECTION_TYPE1 REFLECTION_TYPE2 REFLECTION_TYPE3
#pragma shader_feature RED GREEN BLUE WHITE

#pragma multi_compile QUALITY_LOW QUALITY_MED QUALITY_HIGH

if (QUALITY_LOW)
{
    // code for low quality setting
    // 저품질 설정에 대한 코드
}

#pragma shader_feature_local QUALITY_LOW QUALITY_MED QUALITY_HIGH

#pragma shader_feature EXAMPLE_ON

#pragma multi_compile _ EXAMPLE_ON
#pragma shader_feature _ RED GREEN BLUE WHITE

#pragma multi_compile_shadowcaster

#pragma multi_compile_fwdadd
#pragma skip_variants POINT POINT_COOKIE

Shader semantics (쉐이더 의미론)

When writing HLSL shader programs, input and output variables need to have their “intent” indicated via semantics.
(HLSL shader programs을 작성할 때, 입력 및 출력 변수는 그 “의도”를 의미론을 통해 나타내야 합니다)

This is a standard concept in HLSL shader language; see the Semantics documentation on MSDN for more details.
(이는 HLSL 쉐이더 언어의 표준 개념으로, 자세한 내용은 MSDN의 의미론 문서를 참조하십시오.)

Vertex shader input semantics (정점 쉐이더 입력 의미론)

The main vertex shader function (indicated by the #pragma vertex directive) needs to have semantics on all the input parameters.
(주요 정점 쉐이더 함수( #pragma vertex 지시어로 표시됨)에는 모든 입력 매개변수에 대한 의미론이 필요합니다.)

These correspond to individual Mesh data elements, like vertex position, normal mesh, and texture coordinates.
(이러한 의미론은 정점 위치, 정점 법선, 텍스처 좌표와 같은 개별 메시 데이터 요소에 해당합니다.)

See vertex program inputs for more details.
(더 자세한 내용은 정점 프로그램 입력을 참조하십시오.)

Here’s an example of a simple vertex shader that takes vertex position and a texture coordinate as an input.
(다음은 정점 위치와 텍스처 좌표를 입력으로 받는 간단한 정점 shader의 예입니다.)

The pixel shader visualizes the texture coordinate as a color.
(픽셀 shader는 텍스처 좌표를 색상으로 시각화합니다.)

Shader "Unlit/Show UVs"
{
    SubShader
    {
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            struct v2f {
                float2 uv : TEXCOORD0;
                float4 pos : SV_POSITION;
            };

            v2f vert (
                float4 vertex : POSITION, // vertex position input
                float2 uv : TEXCOORD0 // first texture coordinate input
                )
            {
                v2f o;
                o.pos = UnityObjectToClipPos(vertex);
                o.uv = uv;
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                return fixed4(i.uv, 0, 0);
            }
            ENDCG
        }
    }
}

Instead of spelling out all individual inputs one by one, it’s also possible to declare a structure of them, and indicate semantics on each individual member variable of the struct.
(개별 입력을 하나씩 나열하는 대신, 입력들을 구조체로 선언하고 구조체의 각 멤버 변수에 의미론을 지정할 수도 있습니다.)

Fragment shader output semantics (프래그먼트(픽셀) 쉐이더 출력 의미론)

Most often a fragment (pixel) shader outputs a color, and has an SV_Target semantic. The fragment shader in the example above does exactly that:
(대부분의 경우, 프래그먼트(픽셀) 쉐이더는 색상을 출력하며, SV_Target 의미론을 가집니다. 위의 예제에서 프래그먼트 쉐이더는 정확히 이 작업을 수행합니다.)

struct fragOutput {
    fixed4 color : SV_Target;
};
fragOutput frag (v2f i)
{
    fragOutput o;
    o.color = fixed4(i.uv, 0, 0);
    return o;
}

Returning structures from the fragment shader is mostly useful for shaders that don’t just return a single color.
(fragment shader에서 구조체를 반환하는 것은 단일 색상 외에 여러 값을 반환해야 하는 shader에 유용합니다.)

Additional semantics supported by the fragment shader outputs are as follows.
(fragment shader 출력에서 지원하는 추가 의미론은 다음과 같습니다.)

SV_TargetN: Multiple render targets

SV_Target1, SV_Target2, etc.: These are additional colors written by the shader.
(SV_Target1, SV_Target2 등은 쉐이더가 추가로 작성하는 색상 값입니다.)

This is used when rendering into more than one render target at once (known as the Multiple Render Targets rendering technique, or MRT). SV_Target0 is the same as SV_Target.
(이는 한 번에 여러 렌더 타겟에 렌더링할 때 사용됩니다(MRT, Multiple Render Targets 렌더링 기술). SV_Target0은 SV_Target과 동일합니다.)

SV_Depth: Pixel shader depth output

Usually the fragment shader doesn’t override the Z buffer value, and a default value is used from the regular triangle rasterization
.
(일반적으로 프래그먼트 shader는 Z 버퍼 값을 덮어쓰지 않으며, 기본 값은 일반적인 삼각형 래스터화에서 사용됩니다.)

However, for some effects it’s useful to output custom Z buffer depth values per pixel.
(그러나 일부 효과에서는 픽셀별로 사용자 정의 Z 버퍼 깊이 값을 출력하는 것이 유용할 수 있습니다.)

Note that on many GPUs this turns off some depth buffer optimizations, so don’t override Z buffer value without a good reason.
많은 GPU에서 이 작업을 수행하면 depth buffer 최적화가 비활성화될 수 있으므로, 특별한 이유 없이 Z 버퍼 값을 덮어쓰지 않는 것이 좋습니다.

The cost incurred by SV_Depth varies depending on the GPU architecture, but overall it’s fairly similar to the cost of alpha testing (using the built-in clip() function in HLSL).
(SV_Depth로 인한 비용은 GPU 아키텍처에 따라 다르지만, 대체로 알파 테스트(내장된 clip() 함수 사용)와 비슷한 비용을 가집니다.)

Render shaders that modify depth after all regular opaque shaders (for example, by using the AlphaTest rendering queue.
(모든 일반 불투명 쉐이더 후에 깊이를 수정하는 렌더 쉐이더(예: AlphaTest 렌더링 큐를 사용하는 경우)에서 사용됩니다.)

The depth output value needs to be a single float.
(깊이 출력 값은 단일 float 값이어야 합니다.)

Vertex shader outputs and fragment shader inputs
(Vertex shader 출력과 fragment shader 입력)

A vertex shader needs to output the final clip space position of a vertex, so that the GPU knows where on the screen to rasterize it, and at what depth.
(vertex shader는 꼭지점의 최종 클립 공간 위치를 출력해야 하며, 그래야 GPU가 화면 어디에 그리며 어느 깊이에서 rasterize해야 할지 알 수 있습니다.)

This output needs to have the SV_POSITION semantic, and be of a float4 type.
(이 출력 값은 SV_POSITION 의미론을 가져야 하며, float4 타입이어야 합니다.)

Any other outputs (“interpolators” or “varyings”) produced by the vertex shader are whatever your particular shader needs.
(vertex shader 생성되는 다른 출력들(“보간자” 또는 “변화값”)은 shader에서 필요한 값들입니다. )

The values output from the vertex shader will be interpolated across the face of the rendered triangles, and the values at each pixel will be passed as inputs to the fragment shader.
(vertex shader에서 출력된 값들은 렌더링된 삼각형 면 전체에 걸쳐 보간되며, 각 픽셀의 값들은 fragment shader로 입력됩니다.)

Many modern GPUs don’t really care what semantics these variables have; however some old systems (most notably, shader model 2 GPUs) did have special rules about the semantics:
(대부분의 최신 GPU는 이 변수들이 어떤 의미론을 가지는지 신경 쓰지 않습니다. 그러나 일부 구형 시스템(특히 shader 모델 2 GPU)은 의미론에 대한 특별한 규칙이 있었습니다.)

• – TEXCOORD0, TEXCOORD1 etc are used to indicate arbitrary high precision data such as texture coordinates and positions.
  (TEXCOORD0, TEXCOORD1 등은 텍스처 좌표나 위치와 같은 임의의 고정밀 데이터를 나타내는 데 사용됩니다.)
• – COLOR0 and COLOR1 semantics on vertex outputs and fragment inputs are for low-precision, 0–1 range data (like simple color values).
  (vertex 출력과 fragment 입력에서 COLOR0과 COLOR1 의미론은 저정밀도, 0–1 범위의 데이터를 나타내며, 간단한 색상 값과 같은 데이터를 다룹니다.)

For best cross platform support, label vertex outputs and fragment inputs as TEXCOORDn semantics.
(최적의 플랫폼 호환성을 위해 버텍스 출력과 프래그먼트 입력은 TEXCOORDn 의미론으로 지정하는 것이 좋습니다.)

Interpolator count limits (보간자 개수 제한)

There are limits to how many interpolator variables can be used in total to pass the information from the vertex into the fragment shader.
(vertex에서 fragment shader로 정보를 전달하는 데 사용할 수 있는 보간자 변수의 총 개수에는 제한이 있습니다.)

The limit depends on the platform and GPU, and the general guidelines are:
(이 제한은 플랫폼과 GPU에 따라 다르며, 일반적인 가이드는 다음과 같습니다.)

• – Up to 8 interpolators:
  (최대 8개의 보간자: )
  Direct3D 11 9.x level (Windows Phone) . Since the interpolator count is limited, but each interpolator can be a 4-component vector, some shaders pack things together to stay within limits. For example, you can pass two texture coordinates in one float4 variable (.xy for one coordinate, .zw for the second coordinate).
  (Direct3D 11 9.x 수준 (Windows Phone). 보간자 개수가 제한되어 있지만, 각 보간자는 4개의 구성 요소로 이루어진 벡터일 수 있기 때문에, 일부 쉐이더는 제한 내에서 값을 패킹합니다. 예를 들어, 두 개의 텍스처 좌표를 하나의 float4 변수(.xy는 첫 번째 좌표, .zw는 두 번째 좌표)로 전달할 수 있습니다.)
• – Up to 10 interpolators: Shader model 3.0 (#pragma target 3.0).
  (최대 10개의 보간자: 쉐이더 모델 3.0 (#pragma target 3.0).)
• – Up to 16 interpolators: OpenGL ES 3.0 (Android), Metal (iOS).
  (최대 16개의 보간자: OpenGL ES 3.0 (Android), Metal (iOS).)
• – Up to 32 interpolators: Direct3D 10 shader model 4.0 (#pragma target 4.0).
  (최대 32개의 보간자: Direct3D 10 쉐이더 모델 4.0 (#pragma target 4.0).)

Regardless of your particular target hardware, it’s generally a good idea to use as few interpolators as possible for performance reasons.
(목표 하드웨어와 관계없이 성능을 위해 보간자를 가능한 적게 사용하는 것이 좋습니다.)

Other special semantics (기타 특수 의미론)

Screen space pixel position: VPOS
(스크린 공간 픽셀 위치: VPOS)

A fragment shader can receive position of the pixel being rendered as a special VPOS semantic.
(fragment 쉐이더는 렌더링 중인 픽셀의 위치를 VPOS라는 특별한 의미론으로 받을 수 있습니다.)

This feature only exists starting with shader model 3.0, so the shader needs to have the #pragma target 3.0 compilation directive.
(이 기능은 shader 모델 3.0부터 존재하므로, shader 는 #pragma target 3.0 컴파일 지시어가 필요합니다.)

On different platforms the underlying type of the screen space position input varies, so for maximum portability use the UNITY_VPOS_TYPE type for it, which is float4 on most platforms.
(다른 플랫폼에서는 스크린 공간 위치 입력의 기본 타입이 다를 수 있으므로, 최대 호환성을 위해 대부분의 플랫폼에서 float4 타입인 UNITY_VPOS_TYPE을 사용하는 것이 좋습니다.)

Additionally, using the pixel position semantic makes it hard to have both the clip space position (SV_POSITION) and VPOS in the same vertex-to-fragment structure.
(또한 픽셀 위치 의미론을 사용하면 클립 공간 위치(SV_POSITION)와 VPOS를 동일한 vertex-to-fragmen 구조에서 함께 사용하는 것이 어려워집니다.)

Therefore, the vertex shader should output the clip space position as a separate “out” variable. See the example shader below:
(따라서 vertex shader는 클립 공간 위치를 별도의 “출력” 변수로 출력해야 합니다. 아래의 예제 쉐이더를 참조하십시오.)

Shader "Unlit/Screen Position"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma target 3.0

            // note: no SV_POSITION in this struct
            struct v2f {
                float2 uv : TEXCOORD0;
            };

            v2f vert (
                float4 vertex : POSITION, // vertex position input
                float2 uv : TEXCOORD0, // texture coordinate input
                out float4 outpos : SV_POSITION // clip space position output
                )
            {
                v2f o;
                o.uv = uv;
                outpos = UnityObjectToClipPos(vertex);
                return o;
            }

            sampler2D _MainTex;

            fixed4 frag (v2f i, UNITY_VPOS_TYPE screenPos : VPOS) : SV_Target
            {
                // screenPos.xy will contain pixel integer coordinates.
                // use them to implement a checkerboard pattern that skips rendering
                // 4x4 blocks of pixels

                // checker value will be negative for 4x4 blocks of pixels
                // in a checkerboard pattern
                screenPos.xy = floor(screenPos.xy * 0.25) * 0.5;
                float checker = -frac(screenPos.r + screenPos.g);

                // clip HLSL instruction stops rendering a pixel if value is negative
                clip(checker);

                // for pixels that were kept, read the texture and output it
                fixed4 c = tex2D (_MainTex, i.uv);
                return c;
            }
            ENDCG
        }
    }
}

Face orientation: VFACE (면 방향: VFACE)

A fragment shader can receive a variable that indicates whether the rendered surface is facing the camera, or facing away from the camera.
(fragment shader는 렌더링된 표면이 카메라를 향하고 있는지, 아니면 카메라에서 멀어지고 있는지를 나타내는 변수를 받을 수 있습니다.)

This is useful when rendering geometry that should be visible from both sides – often used on leaves and similar thin objects.
(이는 잎사귀와 같은 얇은 객체에서 양면이 모두 보이게 렌더링해야 할 때 유용합니다.)

The VFACE semantic input variable will contain a positive value for front-facing triangles, and a negative value for back-facing ones.
(VFACE 의미론 입력 변수는 앞면을 향하는 삼각형에는 양의 값을, 뒷면을 향하는 삼각형에는 음의 값을 포함합니다.)

This feature only exists from shader model 3.0 onwards, so the shader needs to have the #pragma target 3.0 compilation directive.
(이 기능은 쉐이더 모델 3.0부터 존재하므로, 쉐이더는 #pragma target 3.0 컴파일 지시어가 필요합니다.)

Shader "Unlit/Face Orientation"
{
    Properties
    {
        _ColorFront ("Front Color", Color) = (1,0.7,0.7,1)
        _ColorBack ("Back Color", Color) = (0.7,1,0.7,1)
    }
    SubShader
    {
        Pass
        {
            Cull Off // turn off backface culling

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma target 3.0

            float4 vert (float4 vertex : POSITION) : SV_POSITION
            {
                return UnityObjectToClipPos(vertex);
            }

            fixed4 _ColorFront;
            fixed4 _ColorBack;

            fixed4 frag (fixed facing : VFACE) : SV_Target
            {
                // VFACE input positive for frontbaces,
                // negative for backfaces. Output one
                // of the two colors depending on that.
                return facing > 0 ? _ColorFront : _ColorBack;
            }
            ENDCG
        }
    }
}

The shader above uses the Cull state to disable back-face culling (by default back-facing triangles aren’t rendered at all).
(위의 shader 는 Cull 상태를 사용하여 후면 컬링을 비활성화합니다. 기본적으로 후면 삼각형은 전혀 렌더링되지 않습니다.)

Here is the shader applied to a bunch of Quad meshes, rotated at different orientations:
(다양한 방향으로 회전된 여러 개의 쿼드 메시들에 적용된 쉐이더는 다음과 같습니다:)

Vertex ID: SV_VertexID (Vertex ID: SV_VertexID)

A vertex shader can receive a variable that has the “vertex number” as an unsigned integer.
(정점 쉐이더는 ‘정점 번호’를 부호 없는 정수로 받을 수 있습니다.)

This is mostly useful when you want to fetch additional per-vertex data from textures or ComputeBuffers.
(이는 주로 텍스처나 ComputeBuffers에서 추가적인 per-vertex data를 가져올 때 유용합니다.)

This feature only exists from DX10 (shader model 4.0) and GLCore / OpenGL ES 3, so the shader needs to have the #pragma target 3.5 compilation directive.
(이 기능은 DX10(쉐이더 모델 4.0)과 GLCore/OpenGL ES 3부터 존재하므로, 쉐이더는 #pragma target 3.5 컴파일 지시어를 포함해야 합니다.)

Shader "Unlit/VertexID"
{
    SubShader
    {
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma target 3.5

            struct v2f {
                fixed4 color : TEXCOORD0;
                float4 pos : SV_POSITION;
            };

            v2f vert (
                float4 vertex : POSITION, // vertex position input
                uint vid : SV_VertexID // vertex ID, needs to be uint
                )
            {
                v2f o;
                o.pos = UnityObjectToClipPos(vertex);
                // output funky colors based on vertex ID
                float f = (float)vid;
                o.color = half4(sin(f/10),sin(f/100),sin(f/1000),0) * 0.5 + 0.5;
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                return i.color;
            }
            ENDCG
        }
    }
}

Accessing shader properties in Cg/HLSL
(Cg/HLSL에서 셰이더 속성 접근)

Shader declares Material properties in a Properties block.
(Shader는 Properties 블록에서 머티리얼 속성을 선언합니다. )

If you want to access some of those properties in a shader program, you need to declare a Cg/HLSL variable with the same name and a matching type.|
(shader program에서 해당 속성 중 일부에 접근하려면, 동일한 이름과 일치하는 타입을 가진 Cg/HLSL 변수를 선언해야 합니다. )

For example these shader properties:
(예를 들어, 이러한 shader 속성들 : )

_MyColor ("Some Color", Color) = (1,1,1,1) 
_MyVector ("Some Vector", Vector) = (0,0,0,0) 
_MyFloat ("My float", Float) = 0.5 
_MyTexture ("Texture", 2D) = "white" {} 
_MyCubemap ("Cubemap", CUBE) = "" {} 

would be declared for access in Cg/HLSL code as:
(Cg/HLSL 코드에서 다음과 같이 선언됩니다: )

fixed4 _MyColor; // low precision type is usually enough for colors (색상에는 일반적으로 낮은 정밀도의 타입이 충분)
float4 _MyVector;
float _MyFloat; 
sampler2D _MyTexture;
samplerCUBE _MyCubemap;

Cg/HLSL can also accept uniform keyword, but it is not necessary:
(Cg/HLSL에서는 uniform 키워드를 사용할 수 있지만, 반드시 필요한 것은 아닙니다: )

uniform float4 _MyColor;

Property types in ShaderLab map to Cg/HLSL variable types this way:

• – Color and Vector properties map to float4, half4 or fixed4 variables.
  (Color와 Vector 속성은 float4, half4 또는 fixed4 변수에 매핑됩니다. )
• – Range and Float properties map to float, half or fixed variables.
  (Range와 Float 속성은 float, half 또는 fixed 변수에 매핑됩니다.)
• – Texture properties map to sampler2D variables for regular (2D) textures; Cubemaps map to samplerCUBE; and 3D textures map to sampler3D.
  (텍스처 속성은 일반 (2D) textures의 경우 sampler2D 변수에, Cubemaps의 경우 samplerCUBE, 3D 텍스처는 sampler3D에 매핑됩니다. )

How property values are provided to shaders (속성 값이 shader에 제공되는 방법)

Shader property values are found and provided to shaders from these places:
(셰이더 속성 값은 다음과 같은 경로로 셰이더에 전달됩니다: )

• – Per-Renderer values set in MaterialPropertyBlock. This is typically “per-instance” data (e.g. customized tint color for a lot of objects that all share the same material).
  MaterialPropertyBlock에 설정된 렌더러별 값. 이는 일반적으로 “인스턴스별” 데이터입니다 (예: 동일한 머티리얼을 공유하는 여러 객체에 대한 맞춤형 색상).
• – Values set in the Material that’s used on the rendered object.
  (렌더링된 객체에 사용된 머티리얼에 설정된 값. )
• – Global shader properties, set either by Unity rendering code itself (see built-in shader variables), or from your own scripts (e.g. Shader.SetGlobalTexture).
  전역 셰이더 속성은 Unity의 렌더링 코드에서 설정되거나(내장 셰이더 변수 참조), 스크립트에서 직접 설정됩니다(예: Shader.SetGlobalTexture).

The order of precedence is like above: per-instance data overrides everything; then Material data is used; and finally if shader property does not exist in these two places then global property value is used.
(우선순위는 위와 같습니다: 인스턴스별 데이터가 모든 것을 덮어쓰며, 그다음으로 머티리얼 데이터가 사용됩니다. 이 두 곳에 shader 속성이 없으면 전역 속성 값이 사용됩니다.)

Finally, if there’s no shader property value defined anywhere, then “default” (zero for floats, black for colors, empty white texture for textures) value will be provided.
(마지막으로, 어느 곳에도 shader 속성이 정의되어 있지 않으면 “기본값”(float의 경우 0, 색상의 경우 검정, 텍스처의 경우 빈 흰색 텍스처)이 제공됩니다. )

Serialized and Runtime Material properties
(직렬화된 머티리얼 속성과 런타임 머티리얼 속성)

Materials can contain both serialized and runtime-set property values.
(Materials은 직렬화된 값과 런타임에서 설정된 속성 값을 모두 포함할 수 있습니다. )

Serialized data is all the properties defined in shader’s Properties block.
(직렬화된 데이터는 셰이더의 Properties 블록에 정의된 모든 Properties입니다.)

Typically these are values that need to be stored in the material, and are tweakable by the user in Material Inspector.
(일반적으로 이러한 값들은 material에 저장되어야 하며, Material Inspector에서 사용자가 조정할 수 있습니다.)

A material can also have some properties that are used by the shader, but not declared in shader’s Properties block.
material 에는 shader에서 사용되지만 shader의 Properties 블록에 선언되지 않은 속성도 있을 수 있습니다.

Typically this is for properties that are set from script code at runtime, e.g. via Material.SetColor.
(이러한 속성은 일반적으로 런타임에서 스크립트 코드로 설정됩니다(예:  Material.SetColor를 통해).)

Note that matrices and arrays can only exist as non-serialized runtime properties (since there’s no way to define them in Properties block).
(행렬과 배열은 Properties 블록에서 정의할 수 없기 때문에 직렬화되지 않은 런타임 속성으로만 존재할 수 있다는 점에 유의해야 합니다.)

Special Texture properties (특수 텍스처 속성)

For each texture that is setup as a shader/material property, Unity also sets up some extra information in additional vector properties.
(shader/material 속성으로 설정된 각 텍스처에 대해 Unity는 추가 벡터 속성에 추가 정보를 설정합니다.)

Texture tiling & offset (텍스처 타일링 및 오프셋)

Materials often have Tiling and Offset fields for their texture properties.
(Materials은 종종 텍스처 속성에 대해 타일링 및 오프셋 필드를 가집니다.)

This information is passed into shaders in a float4 {TextureName}_ST property:
(이 정보는 float4 {TextureName}_ST 속성으로 shaders에 전달됩니다.)

• – x contains X tiling value (x는 X 타일링 값을 포함합니다)
• – y contains Y tiling value (y는 Y 타일링 값을 포함합니다)
• – z contains X offset value (z는 X 오프셋 값을 포함합니다)
• – w contains Y offset value (w는 Y 오프셋 값을 포함합니다)

For example, if a shader contains texture named _MainTex, the tiling information will be in a _MainTex_ST vector.
(예를 들어, shader에 _MainTex라는 텍스처가 있을 경우, 타일링 정보는 _MainTex_ST 벡터에 포함됩니다.)

Texture size (텍스처 크기)

{TextureName}_TexelSize – a float4 property contains texture size information:
({TextureName}_TexelSize – float4 속성은 텍스처 크기 정보를 포함합니다 : )

• – x contains 1.0/width (x는 1.0/너비 값을 포함합니다)
• – y contains 1.0/height (y는 1.0/높이 값을 포함합니다)
• – z contains width (z는 너비를 포함합니다)
• – w contains height (w는 높이를 포함합니다)

Texture HDR parameters (Texture HDR 매개변수)

{TextureName}_HDR – a float4 property with information on how to decode a potentially HDR (e.g. RGBM-encoded) texture depending on the color space used.
({TextureName}_HDR – 사용된 색 공간에 따라 HDR (예: RGBM 인코딩된) 텍스처를 디코딩하는 방법에 대한 정보를 포함하는 float4 속성입니다.)

See DecodeHDR function in UnityCG.cginc shader include file.
(자세한 내용은UnityCG.cginc shader 포함 파일의 DecodeHDR 함수를 참조하세요.)

Color spaces and color/vector shader data (색 공간 및 색상/벡터 shader 데이터)

When using Linear color space, all material color properties are supplied as sRGB colors, but are converted into linear values when passed into shaders.
( Linear color space을 사용할 때, 모든 Material 색상 속성은 sRGB 색상으로 제공되며, shader로 전달될 때 선형 값으로 변환됩니다.)

For example, if your Properties shader block contains a Color property called “MyColor“, then the corresponding ”MyColor” HLSL variable will get the linear color value.
(예를 들어, Properties 셰이더 블록에 “MyColor”라는 Color 속성이 있으면, 해당 “MyColor” HLSL 변수는 선형 색상 값을 받게 됩니다.)

For properties that are marked as Float or Vector type, no color space conversions are done by default; it is assumed that they contain non-color data.
(Float 또는 Vector 타입으로 표시된 속성의 경우 기본적으로 색 공간 변환이 수행되지 않으며, 이들은 색상 데이터가 아닌 것으로 간주됩니다.)

It is possible to add [Gamma] attribute for float/vector properties to indicate that they are specified in sRGB space, just like colors (see Properties).
(색상과 마찬가지로 float/vector 속성이 sRGB 공간에서 지정된다는 것을 나타내기 위해 [Gamma] 속성을 추가할 수 있습니다 (Properties 참조).)

See Also (참고)

• ShaderLab Properties block. (ShaderLab Properties 블록.)
• Writing Shader Programs. (셰이더 프로그램 작성하기.)

Providing vertex data to vertex programs (버텍스 프로그램에 버텍스 데이터 제공)

https://docs.unity3d.com/2023.2/Documentation/Manual/SL-VertexProgramInputs.html

For Cg/HLSL vertex programs, the Mesh vertex data is passed as inputs to the vertex shader function.
Cg/HLSL vertex programs에서는 Mesh 버텍스 데이터가 vertex shader 함수의 입력으로 전달됩니다.

Each input needs to have a semantic specified for it: for example, POSITION input is the vertex position, and NORMAL is the vertex normal.
(각 입력에는 의미(semantic)가 지정되어야 합니다. 예를 들어, POSITION 입력은 vertex 위치이고, NORMAL은 vertex 노멀입니다.)

Often, vertex data inputs are declared in a structure, instead of listing them one by one.
(종종 vertex 데이터 입력은 하나씩 나열하는 대신 구조체로 선언됩니다.)

Several commonly used vertex structures are defined in UnityCG.cginc include file, and in most cases it’s enough just to use those. The structures are:
(UnityCG.cginc include file에 여러 가지 일반적으로 사용되는 버텍스 구조체가 정의되어 있으며, 대부분의 경우 이를 사용하는 것 만으로충분합니다. 이 구조체들은 다음과 같습니다 : )

• – appdata_base: position, normal and one texture coordinate. (위치, 노멀 및 하나의 텍스처 좌표.)
• – appdata_tan: position, tangent, normal and one texture coordinate. (위치, 탄젠트, 노멀 및 하나의 텍스처 좌표.)
• – appdata_full: position, tangent, normal, four texture coordinates and color. (위치, 탄젠트, 노멀, 네 개의 텍스처 좌표 및 색상.)

Example: This shader colors the mesh based on its normals, and uses appdata_base as vertex program input:
(예시: 이 shader는 노멀에 기반하여 메시에 색상을 입히며, appdata_base를 버텍스 프로그램 입력으로 사용합니다 : )

Shader "VertexInputSimple" {
    SubShader {
        Pass {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"
         
            struct v2f {
                float4 pos : SV_POSITION;
                fixed4 color : COLOR;
            };
            
            v2f vert (appdata_base v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.color.xyz = v.normal * 0.5 + 0.5;
                o.color.w = 1.0;
                return o;
            }

            fixed4 frag (v2f i) : SV_Target { return i.color; }
            ENDCG
        }
    } 
}

To access different vertex data, you need to declare the vertex structure yourself, or add input parameters to the vertex shader.
(다른 버텍스 데이터에 접근하려면, 직접 버텍스 구조체를 선언하거나 버텍스 shader에 입력 파라미터를 추가해야 합니다.)

Vertex data is identified by Cg/HLSL semantics, and must be from the following list:
(버텍스 데이터는 Cg/HLSL 의미(semantics)에 의해 식별되며, 다음 목록 중 하나여야 합니다 : )

• – POSITION is the vertex position, typically a float3 or float4. (POSITION은 버텍스 위치로, 일반적으로 float3 또는 float4입니다.)
• – NORMAL is the vertex normal, typically a float3. (NORMAL은 버텍스 노멀로, 일반적으로 float3입니다.)
• – TEXCOORD0 is the first UV coordinate, typically float2, float3 or float4. (TEXCOORD0은 첫 번째 UV 좌표로, 일반적으로 float2, float3 또는 float4입니다.)
• – TEXCOORD1, TEXCOORD2 and TEXCOORD3 are the 2nd, 3rd and 4th UV coordinates, respectively. (TEXCOORD1, TEXCOORD2 및 TEXCOORD3는 각각 두 번째, 세 번째, 네 번째 UV 좌표입니다.)
• – TANGENT is the tangent vector (used for normal mapping), typically a float4. (TANGENT는 탄젠트 벡터(노멀 맵핑에 사용되며), 일반적으로 float4입니다.)
• – COLOR is the per-vertex color, typically a float4. (COLOR는 버텍스당 색상으로, 일반적으로 float4입니다.)

When the mesh data contains fewer components than are needed by the vertex shader input, the rest are filled with zeroes, except for the .w component which defaults to 1.
(메시 데이터가 vertex shader 입력에서 요구하는 구성 요소보다 적은 경우, 나머지는 0으로 채워지며, .w 구성 요소는 기본적으로 1이 됩니다.)

For example, mesh texture coordinates are often 2D vectors with just x and y components.
(예를 들어, 메시의 텍스처 좌표는 종종 x와 y 구성 요소만 있는 2D 벡터입니다.)

If a vertex shader declares a float4 input with TEXCOORD0 semantic, the value received by the vertex shader will contain (x,y,0,1).
(만약 vertex shader가 TEXCOORD0 의미로 float4 입력을 선언하면, vertex shader가 받는 값은 (x, y, 0, 1)이 됩니다.)

For examples of using these techniques to visualize vertex data in the Built-in Render Pipeline, see Visualizing vertex data.
(이 기술을 사용하여 기본 렌더 파이프라인에서 버텍스 데이터를 시각화하는 예시는 Visualizing vertex data“를 참조하십시오.)

Built-in shader include files

https://docs.unity3d.com/2023.2/Documentation/Manual/SL-BuiltinIncludes.html

Unity contains several files that can be used by your shader programs to bring in predefined variables and helper functions.
(Unity에는 미리 정의된 변수와 헬퍼 함수들을 shader programs에서 사용할 수 있도록 하는 여러 파일이 포함되어 있습니다.)

This is done by the standard #include directive, e.g.:
(이는 표준 #include 지시어를 사용하여 실행됩니다. 예를 들어 : )

CGPROGRAM
// ...
#include "UnityCG.cginc"
// ...
ENDCG

Shader include files in Unity are with .cginc extension, and the built-in ones are:
(Unity의 셰이더 인클루드 파일은 .cginc 확장자를 가지며, 내장된 파일들은 다음과 같습니다:)

• – HLSLSupport.cginc – (automatically included) Helper macros and definitions for cross-platform shader compilation.
  (자동으로 포함) 크로스 플랫폼 shader 컴파일을 위한 헬퍼 매크로 및 정의.)
• – UnityShaderVariables.cginc – (automatically included) Commonly used global variables.
  ((자동으로 포함) 일반적으로 사용되는 전역 변수.)
• – UnityCG.cginc – commonly used helper functions.
  (일반적으로 사용되는 helper functions.)
• – AutoLight.cginc – lighting & shadowing functionality, e.g. surface shaders use this file internally.
  (조명 및 그림자 기능, 예를 들어 surface shaders는 이 파일을 내부적으로 사용합니다.)
• – Lighting.cginc – standard surface shader lighting models; automatically included when you’re writing surface shaders.
  (표준 서피스 셰이더 조명 모델; surface shader를 작성할 때 자동으로 포함됩니다.)
• – TerrainEngine.cginc – helper functions for Terrain & Vegetation shaders.
  (지형 및 식물 shader 헬퍼 함수.)

These files are found inside Unity application ({unity install path}/Data/CGIncludes/UnityCG.cginc on Windows, /Applications/Unity/Unity.app/Contents/CGIncludes/UnityCG.cginc on Mac), if you want to take a look at what exactly is done in any of the helper code.
(이 파일들은 Unity 애플리케이션 내부에서 찾을 수 있습니다 ({유니티 설치 경로}/Data/CGIncludes/UnityCG.cginc, Windows의 경우 /Applications/Unity/Unity.app/Contents/CGIncludes/UnityCG.cginc, Mac의 경우). 필요한 경우 헬퍼 코드에서 실제로 수행되는 작업을 확인할 수 있습니다.)

HLSLSupport.cginc

This file is automatically included when compiling CGPROGRAM shaders (but not included for HLSLPROGRAM ones).
(이 파일은 CGPROGRAM 셰이더를 컴파일할 때 자동으로 포함되며, HLSLPROGRAM에는 포함되지 않습니다.)

It declares various preprocessor macros to aid in multi-platform shader development.
(멀티 플랫폼 shader 개발을 돕기 위한 여러 preprocessor macros을 선언합니다.)

UnityShaderVariables.cginc

This file is automatically included when compiling CGPROGRAM shaders (but not included for HLSLPROGRAM ones).
(이 파일은 CGPROGRAM shader를 컴파일할 때 자동으로 포함되며, HLSLPROGRAM에는 포함되지 않습니다.)

It declares various built-in global variables that are commonly used in shaders.
(shader에서 일반적으로 사용되는 다양한 내장 전역 변수를 선언합니다.)

UnityCG.cginc

This file is often included in Shader objects.
(이 파일은 Shader objects에 자주 포함됩니다.)

It declares many built-in helper functions and data structures.
(많은 built-in helper functions와 데이터 구조를 선언합니다.)

Data structures in UnityCG.cginc (UnityCG.cginc의 데이터 구조)

• struct appdata_base: vertex shader input with position, normal, one texture coordinate. (위치, 법선, 하나의 텍스처 좌표를 가진 버텍스 셰이더 입력..)
• struct appdata_tan: vertex shader input with position, normal, tangent, one texture coordinate. (위치, 법선, 탄젠트, 하나의 텍스처 좌표를 가진 버텍스 셰이더 입력.)
• struct appdata_full: vertex shader input with position, normal, tangent, vertex color and two texture coordinates. (위치, 법선, 탄젠트, 버텍스 색상 및 두 개의 텍스처 좌표를 가진 버텍스 셰이더 입력.)
• struct appdata_img: vertex shader input with position and one texture coordinate. (위치와 하나의 텍스처 좌표를 가진 버텍스 셰이더 입력.)

The post Write HLSL Shader in Unity (URP) appeared first on 어제와 내일의 나 그 사이의 이야기.

빛의 성질

---

빛은 여러가지 성질을 가지고 있다.

가장 대표적인 성질은 직진하는 성질이다.

매질이 없는 진공 또는 투명한 매질을 통과할 경우 직진한다.

빛이 다른 무언가와 부딪치면

• 반사(Reflection) : 빛이 표면과 부딪혔을 때, 표면에서 특정 각도로 반사되는 현상
• 굴절(Refraction) : 빛이 한 매질에서 다른 매질로 옮겨갈 때, 빛의 속도가 달라지면서 방향이 바뀌는 현상
• 투과(Transmission) : 빛이 투명한 매체를 통과하며 진행하는 현상으로, 투과된 빛은 매체를 통과한 후 계속 이동
• 산란(Scattering) : 빛이 표면이나 매질의 불순물과 상호 작용하여 여러 방향으로 흩어지는 현상
• 흡수(Absorption) : 빛이 물질에 흡수되어 일부 또는 전체적으로 에너지로 전환되는 현상
• 간섭(Interference): 두 개 이상의 빛 파동이 만나서 서로 상호 작용할 때 나타나는 현상으로, 파동의 합이 강화되거나 약화되는 현상
• 회절(Refraction): 빛이 물체의 경계면을 통과할 때 파동의 속도가 변함에 따라 방향이 바뀌는 현상

정반사(Specular Reflection) / 난반사(Diffuse Reflection) – 반사(Reflection)

• 정반사(Regular Reflection)
  정반사는 표면이 매우 매끄럽고 평평한 경우 발생
  이 때, 빛은 표면과 수직인 방향으로 반사됩니다.
  거울이나 유리와 같이 매우 매끄러운 표면에서 주로 나타납니다.

• 난반사(Diffuse Reflection)
  난반사는 표면이 거친 경우나 불규칙한 표면에서 발생합니다.
  이 때, 반사된 빛은 여러 방향으로 흩어집니다.
  벽, 종이, 나무 등의 표면에서 주로 나타납니다.

굴절(Refraction)과 투과(Transmission)

굴절(Refraction)

물체를 통과하는 빛은 일반적으로 직선으로 이동하는 것이 아니라, 물체의 경계면을 통과할 때 굴절(Refraction) 현상이 일어납니다.

위와 같은 현상은 빛이 한 매질에서 다른 매질로 옮겨갈 때 빛의 속도가 달라지면서 발생합니다.

빛의 속도가 다른 매질로 옮겨갈 때, 빛은 특정 각도로 바뀌어 이동합니다.

이때 빛의 파장은 그대로 유지되지만, 진행 방향이 바뀌게 됩니다.

예를 들어, 빛이 물체에서 공기로 옮겨갈 때는 경계면을 통과할 때 빛의 속도가 증가하게 되어 굴절각이 작아지게 됩니다.

반대로, 빛이 공기에서 유리 등의 밀도가 높은 매질로 옮겨갈 때는 굴절각이 커지게 됩니다.

빛은 파동과 입자의 성질을 동시에 가지고 있는데 굴절은 파동의 특성에 의해서 발생합니다.

https://www.microscopyu.com/tutorials/refraction

투과(Transmission)

빛이 투명한 매체를 통과하여 이동하는 현상을 의미합니다.

즉, 빛이 매질을 통과한 후 계속 진행되는 것을 말합니다.

투과된 빛은 매체를 통과한 후에도 에너지를 가지고 있어 이동을 계속합니다.

예를 들어, 유리, 공기, 물 등의 투명한 매체를 통과하는 빛은 투과된 빛입니다.

이는 투과된 빛이 매질의 내부에서 계속 이동하고 있음을 나타냅니다.

산란(Scattering)과 흡수(Absorption)

산란(Scattering)

산란(Scattering)은 빛이 표면이나 매질의 불순물과 상호 작용하여 여러 방향으로 흩어지는 현상을 의미합니다.

이는 불순물의 크기가 빛의 파장과 비슷한 크기일 때 특히 뚜렷하게 나타납니다.

산란은 물체를 통과할 때 발생할 수 있으며, 특정 방향으로 진행하는 빛이 여러 방향으로 흩어지기 때문에 빛의 진행 경로가 무작위로 바뀝니다.

대기 중의 먼지나 연기와 같은 입자들에 의해 발생하는 태양빛의 산란은 하늘의 푸른 색상을 만들어내는데 중요한 역할을 합니다.

따뜻한 색은 파장이 길어서 적게 산란되어 지표면에 쉽게 도달하는 반면, 대기의 공기 분자는 파장이 짧은 빛(높은 주파수)인 푸른색을 더 많이 산란시킵니다.

이러한 이유로 정오의 하늘이 파란색으로 보입니다.

노을이나 일몰 시에는 태양이 지평선 아래로 가려지면서 더 긴 파장의 빛이 더 쉽게 통과합니다.

태양 광선이 지평선을 통과하는 동안 지표면을 통과하는 거리가 늘어나면서, 대기를 통과하는 빛은 더 많은 산란을 겪게 됩니다.

이에 따라 주로 긴 파장의 색상인 주황색과 붉은색이 우세해져서 노을이 붉게 보입니다.

공기 중의 미세먼지, 구름, 연기, 물 속의 부유물과 같은 입자들의 산란은 빛의 파장과 무관하게 주로 흰색으로 산란됩니다.

이는 입자들의 크기가 빛의 파장보다 훨씬 크기 때문에 발생하며, 결과적으로 모든 색상의 빛이 균일하게 흩어지게 됩니다.

이러한 현상은 주로 하얀색 빛을 만들어냅니다.

The post 빛의 성질 – 요약 appeared first on 어제와 내일의 나 그 사이의 이야기.

12 – 03 홀로그램(Hologram) 만들기 (Unity Shader)

Rim 라이트를 구현할 수 있게 되었으니 알파를 사용하여 홀로그램을 만들 수 있습니다.

처음은 Lambert 기본형에서 시작합니다.

Shader "Custom/Holo"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf Lambert noambient

        #pragma target 3.0
        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            o.Albedo = c.rgb;
            o.Alpha = c.a;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

다음은 Fresnel 기본 연산을 구현합니다.

잠시 Albedo 는 끄고 Emission 으로 결과를 확인하겠습니다. 

이제 반투명으로 구현하겠습니다.

홀로그램의 핵심원리는 ” Rim 라이트 연산을 알파 채널에 넣는다 “ 입니다.

반투명 구현은 앞 부분의 불을 만들 때 사용한 방식입니다.

마지막으로 Emission에 원하는 색상을 넣어주면 됩니다.

다음은 두께를 조절하게 해줍니다.

입안이 이상하게 구현된 것은 캐릭터가 입안까지 모델링이 되었기 때문입니다.

반투명이 되면서 반대편의 오브젝트나 안쪽의 오브젝트가 비쳐 보이는 것은 나중에 Z버퍼를 이용한 2pass 쉐이더를 사용하여 해결합니다.

전체 코드

Shader "Custom/Holo"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _RimColor("RimColor", Color) = (1,1,1,1)
        _RimPower("RimPower", Range(1,10)) = 3
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent" }
        LOD 200

        CGPROGRAM
        #pragma surface surf Lambert noambient alpha:fade

        #pragma target 3.0
        sampler2D _MainTex;
        float4 _RimColor;
        float _RimPower;

        struct Input
        {
            float2 uv_MainTex;
            float3 viewDir;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {
            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            float rim = saturate(dot(o.Normal, IN.viewDir));
            rim = pow(1 - rim, _RimPower);
            o.Emission = _RimColor.rgb;
            o.Alpha = rim;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

기본형은 만들었지만 이것만으로는 부족합니다.

다양한 효과를 넣어 봅시다.

첫번째로 이 홀로그램을 깜빡이게 표현합니다.

Sin(_Time.y) 를 이용합니다.

깜빡임 속도 증가

그런데, 이러면 깜빡일 떄 안보이는 시간이 너무 길게 나타납니다.

이것은 sin 또는 cos 곡선에서 일어나는 당연한 결과 입니다.

이 곡선들이 -1 ~ 1을 반복하다 보니 그림처럼 0 이하로 내려가는 부분이 절반이기 때문입니다.

saturate 해주는 것은 0 이나 – 1 이나 우리눈에 안보이는 것은 같기 때문에 의미가 없습니다.

첫번째로  * 0.5 + 0.5 를 사용하는 방법이 있습니다.

하프 램버트에서 사용했던 공식을 이용하면 -1 ~ 1을 0 ~ 1로 변화시켜주므로 부드럽게 지속적으로 반짝이는 곡선을 구할 수 있게 됩니다.

sin(_Time.y) * 0.5 + 0.5;

또 다른 방법으로는 abs () 함수를 사용하여 모든 음수를 양수로 변화시킬 수 있습니다.

abs(sin(_Time.y));

Shader "Custom/Holo"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _RimColor("RimColor", Color) = (1,1,1,1)
        _RimPower("RimPower", Range(1,10)) = 3
        _HoloTwinkling("HoloTwinkling",Range(1,5)) = 1
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent" }
        LOD 200

        CGPROGRAM
        #pragma surface surf Lambert noambient alpha:fade

        #pragma target 3.0
        sampler2D _MainTex;
        float4 _RimColor;
        float _RimPower;
        float _HoloTwinkling;

        struct Input
        {
            float2 uv_MainTex;
            float3 viewDir;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            float rim = saturate(dot(o.Normal, IN.viewDir));
            rim = pow(1 - rim, _RimPower);
            o.Emission = _RimColor.rgb;

            //o.Alpha = rim * sin(_Time.y * _HoloTwinkling);
            //o.Alpha = rim * sin(_Time.y * _HoloTwinkling) *0.5 + 0.5;
            o.Alpha = rim * abs(sin(_Time.y * _HoloTwinkling));
        }
        ENDCG
    }
    FallBack "Diffuse"
}

다음은 홀로그램의 줄무늬가 올라가는 효과를 만들겠습니다.

버텍스 컬러를 이용하여 아래에서 위로 밝아지게 칠할 수도 있고, 두번째 UV를 펴는 방법도 있습니다.

여기서는 Input 구조체에서 다른 값을 이용하겠습니다.

https://docs.unity3d.com/Manual/SL-SurfaceShaders.html <- 영문

https://docs.unity3d.com/kr/2021.3/Manual/SL-SurfaceShaders.html <-한글

표면 셰이더 입력 구조

입력 구조 Input에는 일반적으로 셰이더가 필요로 하는 텍스처 좌표가 있습니다. 텍스처 좌표의 이름은 텍스처 이름 앞에 “uv”가 붙는 형식으로 지어야 합니다(또는 두 번째 텍스처 좌표 세트를 사용하려면 “uv2”로 시작해야 합니다).

다음 값을 입력 구조에 추가할 수 있습니다.

float3 viewDir – 뷰 방향을 포함합니다. 패럴랙스 이펙트, 림 조명 등의 컴퓨팅에 사용합니다.

float4와 COLOR 시맨틱 – 보간된 버텍스당 컬러를 포함합니다.

float4 screenPos – 반사 또는 스크린 공간 효과를 위한 스크린 공간 포지션을 포함합니다. GrabPass에는 적합하지 않습니다. ComputeGrabScreenPos 함수를 사용하여 커스텀 UV를 직접 계산해야 합니다.

float3 worldPos – 월드 공간 포지션을 포함합니다.

float3 worldRefl – 표면 셰이더가 o.Normal에 기록하지 않는 경우 월드 반사 벡터를 포함합니다. 예를 들어 리플렉트-디퓨즈(Reflect-Diffuse) 셰이더가 있습니다.

float3 worldNormal – 표면 셰이더가 o.Normal에 기록하지 않는 경우 월드 노멀 벡터를 포함합니다.

float3 worldRefl; INTERNAL_DATA – 표면 셰이더가 o.Normal에 기록하는 경우 월드 반사 벡터를 포함합니다. 픽셀당 노멀 맵을 기반으로 반사 벡터를 얻으려면 WorldReflectionVector (IN, o.Normal)를 사용해야 합니다. 예를 들어 리플렉트-범프드(Reflect-Bumped) 셰이더가 있습니다.

float3 worldNormal; INTERNAL_DATA – 표면 셰이더가 o.Normal에 기록하는 경우 월드 노멀 벡터를 포함합니다. 픽셀당 노멀 맵에 기반한 노멀 벡터를 얻으려면 WorldNormalVector (IN, o.Normal)를 사용해야 합니다.

이번에는 float3 worldPos를 사용합니다.

해당 변수의 기능을 확인하기 위해서 코드를 변경합니다.

해당 x, y, z 가 각각 r, g, b 에 대입하여 나타납니다.

우리는 상/하의 값인 Y만 필요하기 때문에 g (y)만 출력합니다.

위의 코드로는  위로 올라가면 1이 넘는 값이 될 것이고 아래로 내려가면 -1의 아래 값으로 변하게 됩니다.

이러한 상황에서 유용한 내장 함수는 frac ( ) 입니다.

frac ( ) 은 안에 들어온 숫자의 “소수점 부분” 만 리턴해 줍니다.

즉, 1.1 은 0.1을 리턴하고 1.9는 0.9를 리턴합니다.

이제 흰 부분을 줄여 주겠습니다.

그라디에이션에서 검정 부분을 확장시키고 흰 부분을 줄이는 것은 이전에  fresnel 을 배울 때 pow ( ) 함수를 이용하여 해결했습니다.

추가로 시간에 따라 위로 흘러가게 해줍니다.

NormalMap 적용 후 변경이 가능하게 프로퍼티로 설정

Shader "Custom/Holo"
{
    Properties
    {
        _BumpMap("Normal Map", 2D) = "white" {}
        _RimColor ("RimColor", Color) = (1,1,1,1)
        _RimPower ("RimPower", Range(1,10)) = 3
        _HoloTwinkling ("HoloTwinkling",Range(1,5)) = 1
        _HoloSpeed ("HoloSpeed",Range(1,5)) = 1
        _HoloInterval ("HoloInterval",Range(1,5)) = 5
        
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent" }
        LOD 200

        CGPROGRAM
        #pragma surface surf Lambert noambient alpha:fade

        #pragma target 3.0
        sampler2D _BumpMap;
        float4 _RimColor;
        float _RimPower;
        float _HoloTwinkling;
        float _HoloSpeed;
        float _HoloInterval;

        struct Input
        {
            float2 uv_BumpMap;
            float3 viewDir;
            float3 worldPos;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

            float3 d = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
            o.Normal = d;
            float rim = saturate(dot(o.Normal, IN.viewDir));
            rim = pow(1 - rim, _RimPower);
            o.Emission = pow (frac(IN.worldPos.g * _HoloInterval - _Time.y * _HoloSpeed), 5) + _RimColor.rgb;
            o.Alpha = rim * abs(sin(_Time.y * _HoloTwinkling));
        }
        ENDCG
    }
    FallBack "Transparent/Diffuse"
}

Transparent/Diffuse 는 그림자를 생성하지 않게 하도록 넣는 코드입니다.

원래 FallBack은 그래픽 카드에서 이 쉐이더 연산을 실패 했을 때의 대체 쉐이더를 적는 란이지만

이 책의 저자분은 그림자 연산할 때 이 FallBack에 씌여진 쉐이더가 영향을 끼치게 된다는 것을 발견했다고 합니다.

이 쉐이더는 마치 이펙트와 같은 쉐이더이기 때문에 그림자가 필요없으므로 해당 코드를 넣습니다.

홀로그램 2Pass

Shader "Custom/Holo"
{
    Properties
    {
        _BumpMap("Normal Map", 2D) = "white" {}
        _RimColor ("RimColor", Color) = (1,1,1,1)
        _RimPower ("RimPower", Range(1,10)) = 3
        _HoloTwinkling ("HoloTwinkling",Range(1,5)) = 1
        _HoloSpeed ("HoloSpeed",Range(1,5)) = 1
        _HoloInterval ("HoloInterval",Range(1,5)) = 5
        
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent" }

        ZWrite On
        ColorMask 0

        LOD 200

        CGPROGRAM
        #pragma surface surf _NoLight
        #pragma target 3.0

        struct Input
        {
            float4 color:COLOR;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {
        }

        float4 Lighting_NoLight(SurfaceOutput s, float3 lightDir, float atten) {
            return 0;
        }
        ENDCG

        ZWrite Off

        CGPROGRAM
        #pragma surface surf Lambert noambient alpha:fade

        #pragma target 3.0
        sampler2D _BumpMap;
        float4 _RimColor;
        float _RimPower;
        float _HoloTwinkling;
        float _HoloSpeed;
        float _HoloInterval;

        struct Input
        {
            float2 uv_BumpMap;
            float3 viewDir;
            float3 worldPos;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {
            float3 d = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
            o.Normal = d;
            float rim = saturate(dot(o.Normal, IN.viewDir));
            rim = pow(1 - rim, _RimPower);
            o.Emission = pow (frac(IN.worldPos.g * _HoloInterval - _Time.y * _HoloSpeed), 30) + _RimColor.rgb;
            o.Alpha = rim * abs(sin(_Time.y * _HoloTwinkling));
        }
        ENDCG
    }
    FallBack "Transparent/Diffuse"
}

The post 12 – 03 홀로그램(Hologram) 만들기 (Unity Shader) appeared first on 어제와 내일의 나 그 사이의 이야기.

12 – 01 ~ 02 Rim 라이트의 기초 (Unity Shader)

주변을 자세히 보면 모든 물체는 기울어 질수록 반사가 심해집니다.

실제로 모든 물체는 기울어 질수록 심하게 반사가 되며 그 반사율은 재질에 따라 다르게 나타납니다.

만약 역광이 있을 떄, 털이나 반투명의 재질을 가진 물체들은 이 현상이 매우 강렬하게 나타날 수 있고

재질에 따라 때로는 잘 보이지 않게 나타날 수도 있습니다.

사진 분야에서는 이것을 Rim Light ( 림 라이트 ) 라고 부릅니다.

우리가 사용하는 Standard Shader와 같은 물리 기반의 쉐이더는 이러한 재질의 특성에 따른 반사율이

BRDF(Bidirectional Reflectance Distribution Function – 양방향 반사 분포 함수) 를 이용하여 구현되어 있습니다.

이러한 반사 공식을 fresnel (프레넬) 이라 부릅니다.

이번에 설명할 fresnel 공식은 그보다는 간단하게, 빛의 방향과는 전혀 상관이 없게 만드는 효과입니다.

기본적으로 배경과 캐릭터의 분리나 강조를 위해, 혹은 선택되었을때나 특정 상태를 표현하기 위한 특수한 효과를 위해 사용합니다.

직접 확인해보기 위해서 아래 에셋을 사용했습니다. (무료)

https://assetstore.unity.com/packages/3d/characters/humanoids/barbarian-warrior-75519 <- TestAsset

fresnel 공식 구현

텍스쳐를 한장만 받는 기본형으로 쉐이더를 변경합니다.

Shader "Custom/RimLight"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        
        #pragma surface surf Lambert noambient
        #pragma target 3.0

        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {
            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            o.Albedo = c.rgb;
            o.Alpha = c.a;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

o.Albedo 를 0 으로 만들어서 검게 만들고 시작하는 것이 좋습니다. 

이전에 배운 Lambert 공식은 노멀 벡터와 조명 벡터를 dot 연산한 공식입니다.

이 공식을 간단하게 정의하면 두 벡터, 즉 노멀벡터와 조명 벡터의 각도가 같으면 밝고, 90도가 되면 어두워져서 검정색이 된다는 것입니다.

그렇다면 여기에서 input 구조체에서 다른 값을 받아 봅시다.

https://docs.unity3d.com/Manual/SL-SurfaceShaders.html <- 영문

https://docs.unity3d.com/kr/2021.3/Manual/SL-SurfaceShaders.html <- 한글

표면 셰이더 입력 구조

입력 구조 Input에는 일반적으로 셰이더가 필요로 하는 텍스처 좌표가 있습니다. 텍스처 좌표의 이름은 텍스처 이름 앞에 “uv”가 붙는 형식으로 지어야 합니다(또는 두 번째 텍스처 좌표 세트를 사용하려면 “uv2”로 시작해야 합니다.)

다음 값을 입력 구조에 추가할 수 있습니다.

float3 viewDir – 뷰 방향을 포함합니다. 패럴랙스 이펙트, 림 조명 등의 컴퓨팅에 사용합니다.

float4와 COLOR 시맨틱 – 보간된 버텍스당 컬러를 포함합니다.

float4 screenPos – 반사 또는 스크린 공간 효과를 위한 스크린 공간 포지션을 포함합니다. GrabPass에는 적합하지 않습니다. ComputeGrabScreenPos 함수를 사용하여 커스텀 UV를 직접 계산해야 합니다.

float3 worldPos – 월드 공간 포지션을 포함합니다.

float3 worldRefl – 표면 셰이더가 o.Normal에 기록하지 않는 경우 월드 반사 벡터를 포함합니다. 예를 들어 리플렉트-디퓨즈(Reflect-Diffuse) 셰이더가 있습니다.

float3 worldNormal – 표면 셰이더가 o.Normal에 기록하지 않는 경우 월드 노멀 벡터를 포함합니다.

float3 worldRefl; INTERNAL_DATA – 표면 셰이더가 o.Normal에 기록하는 경우 월드 반사 벡터를 포함합니다. 픽셀당 노멀 맵을 기반으로 반사 벡터를 얻으려면 WorldReflectionVector (IN, o.Normal)를 사용해야 합니다. 예를 들어 리플렉트-범프드(Reflect-Bumped) 셰이더가 있습니다.

float3 worldNormal; INTERNAL_DATA – 표면 셰이더가 o.Normal에 기록하는 경우 월드 노멀 벡터를 포함합니다. 픽셀당 노멀 맵에 기반한 노멀 벡터를 얻으려면 WorldNormalVector (IN, o.Normal)를 사용해야 합니다.

우리가 사용할 값은 float3 viewDir 입니다.

float3 는 3차원 벡터 Input 구조체 안에 있는 것으로 봐서 엔진에서 받을 수 있는 데이터입니다.

float3 lightDir가 버텍스에서 바라보는 조명의 방향을 나타내는 길이가 1인 벡터라면

float3 viewDir 은 버텍스에서 바라보는 카메라의 방향을 나타냅니다.

그럼 Normal dot lightDir  대신  Normal dot viewDir 을 하면

카메라가 마치 조명처럼 인식되어 내가 바라보는 방향이 계속 밝아진다는 것입니다. 

반전

Shader "Custom/RimLight"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        
        #pragma surface surf Lambert noambient
        #pragma target 3.0

        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
            float3 viewDir;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {
            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            float rim = dot(o.Normal, IN.viewDir);
            o.Emission = 1 - rim; // 결과 뒤집기
            o.Alpha = c.a;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

위에서 조심할 내용은 dot 연산은 -1 까지 내려가서 나중에 결과가 이상해 질 수 가 있습니다.   saturate() 를 잊지마세요

보는 각도를 바꿔도 언제나 외각이 밝아 보이면서 이제 Rim 라이트처럼 보이기 시작합니다.

그런데 Rim라이트가 너무 두꺼워서 Rim 라이트 느낌이 살아나지 않습니다.

흰테두리를 더 얇게 만들어줄 필요가 있습니다.

검정부터 흰색까지 변하는 음영을 표로 보면 아래와 같습니다.

가로축은 1 – dot(o.Normal, IN.viewDir) 이고 세로축은 색상 (흑백)을 의미합니다. 두 벡터의 각도 차이가 벌어질수록, 색상도 흰색이 됩니다. 

pow 를 이용하면 지수함수와 같은 그래프로 어두운 부분이 한참동안 존재하다가 갑자기 밝아지는 모양이 됩니다.

이 그래프를 이용하여 흰 테두리를 얇게 만듭니다.

이제 rim 라이트에 색상을 추가합니다.

두께 조절 프로퍼티도 만들어줍니다.

NormalMap 추가

Rim 연산에서 o.Normal을 사용하기 때문에 반드시 Rim라이트 연산 이전에 NormalMap 을 적용시켜줘야 합니다.

이제 dot 연산에서 -1로 넘어가는 부분을 막아주고 noambient 까지 지워서 완성합니다.

이것이 Rim 라이트라고 부르는 Fresnel 이 적용된 결과 입니다.

게임에서 캐릭터가 데미지를 입었을 때나 선택할 때, 혹은 단순히 배경과 분리된 느낌을 원할 때 자주 사용되는 방식이지만

실제 존재하는 Rim 라이트를 구현했다고 부르기에는 약간 부족합니다.

우리가 만든 Rim 라이트는 조명의 방향과 전혀 연관이 없습니다.

이상적인 Rim 라이트는 역광일 때 주로 나타나고 직광일 때는 보이지 않습니다. (나중에 커스텀 라이트를 만들 때 가능합니다.)

The post 12 – 01 ~ 02 Rim 라이트의 기초 (Unity Shader) appeared first on 어제와 내일의 나 그 사이의 이야기.

11 – 03 ~ 04 Half-Lambert(하프 램버트) 연산 및 완성 (Unity Shader)

Lambert 라이트는 꽤 가벼운 조명 공식이지만, cos 그래프 연산의 특성상 밝다가 너무 갑자기 검게 음영이 떨어지는 단점이 있습니다. 

그래서 이 단점을 해결하고자 만든 것이 Half-Lambert (하프 램버트) 공식입니다.

물리적으로는 옳지 않지만, 매우 가벼우며 보기 좋은 장점이 있습니다.

저번에 글에서 사용한 코드에서 시작하겠습니다. 

Shader "Custom/CustomLight"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _BumpMap("Normal Map", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf _MyLight noambient  
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _BumpMap;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_BumpMap;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            float3 d = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
            o.Normal = d;
            o.Albedo = c.rgb;
            o.Alpha = c.a;
        }

        
        float4 Lighting_MyLight(SurfaceOutput s, float3 lightDir, float atten)
        {
            float ndotl = saturate(dot(s.Normal, lightDir));
            return ndotl;
        }

        ENDCG
    }
    FallBack "Diffuse"
}

직접 확인해보기 위해서 아래 에셋을 사용했습니다. (무료)

https://assetstore.unity.com/packages/3d/characters/humanoids/barbarian-warrior-75519 <- TestAsset

위의 이미지는 saturate() 함수로 인하여 0 이하의 값은 전부 0 이 되었습니다.

saturate() 를 다시 제거해서 다시 -1 ~ 1까지의 범위를 출력하도록 만들어 줍니다.

변경 전

그리고 라이팅의 결과물에  Half- Lamber ( 하프 람버트 ) 공식인  * 0.5 + 0.5  를 적용해줍니다.

Half- Lamber ( 하프 람버트 공식) 적용 후

* 0.5 + 0.5  의 식은 -1 에서부터 1까지의 숫자를 0 에서 부터 1까지의 범위로 만들어 줍니다.

아래의 푸른 cos 이 붉은 라인으로 끌어 올라오게 됩니다.

이로 인하여 매우 부드러운 결과 값이 나오게 됩니다.

실제 사용할 때에는 빛의 영향을 좀 줄이고자 제곱을 해서 사용합니다.  

Shader "Custom/CustomLight"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _BumpMap("Normal Map", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf _MyLight noambient  
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _BumpMap;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_BumpMap;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            float3 d = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
            o.Normal = d;
            o.Albedo = c.rgb;
            o.Alpha = c.a;
        }

        
        float4 Lighting_MyLight(SurfaceOutput s, float3 lightDir, float atten)
        {
            float ndotl = dot(s.Normal, lightDir) * 0.5 + 0.5;
            return pow(ndotl, 3); // pow는 제곱
        }

        ENDCG
    }
    FallBack "Diffuse"
}

pow   제곱 적용 후

Lambert 라이트 완성하기

위의 상황은 빛 방향에 따른 밝기만 구현되었을 뿐, 조명의 색상과 강고 / 빛 감쇄 Albedo 텍스쳐 는 전혀 적용되지 않았습니다.

아래에서 나머지 내용을 추가하겠습니다. 

pow와 dot 계산식을 하나로 병합합니다.

제 텍스쳐와 조명색상, 감쇠를 연산해서 조명을 완성해줍니다.

전체 코드

Shader "Custom/CustomLight"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _BumpMap("Normal Map", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf _MyLight noambient  
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _BumpMap;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_BumpMap;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            float3 d = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
            o.Normal = d;
            o.Albedo = c.rgb;
            o.Alpha = c.a;
        }

        
        float4 Lighting_MyLight(SurfaceOutput s, float3 lightDir, float atten)
        {
            float ndotl = pow ( dot(s.Normal, lightDir) * 0.5 + 0.5 , 3 );
            float4 final;
            final.rgb = ndotl * s.Albedo * _LightColor0.rgb * atten;
            final.a = s.Alpha;
            return final; 
        }

        ENDCG
    }
    FallBack "Diffuse"
}

비어있던 MainTex도 넣어줍니다.

s.Albedo 

Albedo 로 입력받은 텍스쳐 입니다.

SurfaceOutput이 s 로 들어왔으니 s.Albedo 가 됩니다.

여기서 들어온 Albedo 텍스쳐가 Lambert 라이트와 연산이 되어서 Diffuse (확산) 됩니다. 

_LightColor0.rgb

이전에 연산했던 Ndotl 연산은 조명과 노멀의 각도를 표현한 것 뿐입니다.

조명의 색상이나 강도는 이 내장 변수를 이용해서 조명의 색상이나 강도를 가져옵니다.

이 변수를 곱한 후 조명의 생상과 강도를 변화시키면 그대로 반영됩니다. 

atten

빛의 감쇠 현상을 시뮬레이트합니다.

빛의 감쇠가 일어나는 경우는 아래와 같습니다. (atten를 계산하지 않으면 다음 일이 일어나지 않습니다.)

1. self shadow가 생기지 않습니다.

자신의 그림자를 자신이 받지 않습니다.

2. receive shadow가 동작하지 않습니다.

다른 물체가 그림자를 드리우지 못합니다.

3. 조명의 감쇠 현상이 일어나지 않습니다.

Directional 라이트에서는 확인이 불가능하고  point 라이트에서 확인이 가능합니다.

point 라이트가 멀어질수록 어두워지는데 이것이 atten가 하는 일입니다. 

atten 미적용

atten 적용

//  noambient  제거

Shader "Custom/CustomLight"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _BumpMap("Normal Map", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf _MyLight //noambient  
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _BumpMap;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_BumpMap;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            float3 d = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
            o.Normal = d;
            o.Albedo = c.rgb;
            o.Alpha = c.a;
        }

        
        float4 Lighting_MyLight(SurfaceOutput s, float3 lightDir, float atten)
        {
            float ndotl = pow ( dot(s.Normal, lightDir) * 0.5 + 0.5 , 3 );
            float4 final;
            final.rgb = ndotl * s.Albedo * _LightColor0.rgb * atten;
            final.a = s.Alpha;
            return final; 
        }

        ENDCG
    }
    FallBack "Diffuse"
}

이렇게 적용하면 얼굴이 밝아지면서 atten으로 생기는 얼굴의 그림자가 두드러지게 보이는 단점이 생길 것 입니다.

정답은 없고 atten를 제거해도 좋고 pow 함수를 이용하여 적절하게 숨기는 것도 하나의 방법입니다.

이제 완전한 Lambert 가 완성되었습니다.

이것은 유니티4까지 사용되었던 Bump Diffuse와 완전히 같은 쉐이더이며

유니티5에서도 Legacy Shaders / Bumped Diffuse와도 완전히 같은 쉐이더입니다.

The post 11 – 03 ~ 04 Half-Lambert(하프 램버트) 연산 및 완성 (Unity Shader) appeared first on 어제와 내일의 나 그 사이의 이야기.

11 – 01 ~ 02 커스텀 라이트 기본형 / Lambert 라이트 연산 (Unity Shader)

텍스처 한 장만 받는 기본형 쉐이더를 만듭니다.

직접 확인해보기 위해서 아래 에셋을 사용했습니다. (무료)

https://assetstore.unity.com/packages/3d/characters/humanoids/barbarian-warrior-75519 <- TestAsset

Shader "Custom/CustomLight"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf Lambert noambient  
        // noambient - 주변광 또는 라이트 프로브를 적용하지 않습니다.
        #pragma target 3.0
        
        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            o.Albedo = c.rgb;
            o.Alpha = c.a;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

Lambert 라이트를 삭제하고 자신만의 라이트 이름을 지어서 커스텀 라이트를 구동시켜 보겠습니다.

바뀌거나 추가된 내용을 하나씩 보겠습니다.

Lambert 대신에 _MyLight로 바뀌었습니다.

여기는 이름을 마음대로 지어도 상관없습니다.

우리가 만든 커스텀 함수의 모습입니다.

이전까지는 void surf 사용했습니다.

이 함수는 float4로 시작합니다. 함수가 float4 를 반환 하므로 return float4  출력값을 가지고 있습니다. 

이어서 나오는 이름도 Lighting + “커스텀 라이트 이름” 을 추가해 주어야 합니다.

SurfaceOutput 구조체를 통째로 받아옵니다.

float3 lightDir 은 이전 파트에서 배웠던 조명 방향의 벡터 입니다.

단, 조명 계산을 편하게 사용하기 위해서 뒤집혀지고 길이가 1인 단위 벡터의 상태입니다.

float atten

atten ( attenuation ) 감쇠

그림자를 받거나 거리가 멀어지면서 점점 조명이 흐려지는 라이트의 거리별 감쇠 현상을 나타냅니다.

내가 빛을 받는 것을 없앨 때 사용하는 부분입니다.

Lambert 라이트 연산

우리가 만든 커스텀 라이트에서 변경합니다.

Shader "Custom/CustomLight"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf _MyLight noambient  
        // noambient - 주변광 또는 라이트 프로브를 적용하지 않습니다.
        #pragma target 3.0

        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            o.Albedo = c.rgb;
            o.Alpha = c.a;
        }

        
        float4 Lighting_MyLight(SurfaceOutput s, float3 lightDir, float atten)
        {
            float ndotl = dot(s.Normal, lightDir);
            // dot 노멀 백터와 라이트 벡터를 내적 연산
            // surf 에서 Normal 값을 받지 않아도 버텍스에서 노말값을 평범하게 받음

            return ndotl;
        }

        ENDCG
    }
    FallBack "Diffuse"
}

lightDir은 버텍스에서 바라보는 조명의 방향인 뒤집힌 방향 이기 때문에 두 벤터를 단순하게 내적해주면 cos 값이 나오게 됩니다.

위와 같은 코드는 가장 밝은 곳이 1 / 어두워 지는 경계선은 0 / 가장 어두운 곳은 -1 값으로 되어서

나중에 추가 라이트를 비추거나 할 때 문제가 됩니다. 

이 현상을 방지하기 위해서  saturate (값) 함수를 사용합니다.

max 함수도 사용하지만 최대 값이 없습니다.

max(0, dot(s.Normal, lightDir));

float ndotl = max(0, dot(s.Normal, lightDir));

Shader "Custom/CustomLight"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf _MyLight noambient  
        // noambient - 주변광 또는 라이트 프로브를 적용하지 않습니다.
        #pragma target 3.0

        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            o.Albedo = c.rgb;
            o.Alpha = c.a;
        }

        
        float4 Lighting_MyLight(SurfaceOutput s, float3 lightDir, float atten)
        {
            float ndotl = saturate(dot(s.Normal, lightDir));

            // dot 노멀 백터와 라이트 벡터를 내적 연산
            // surf 에서 Normal 값을 받지 않아도 버텍스에서 노말값을 평범하게 받음
            // saturate 0 이하 값을 0으로 만들어줌
            
            // float ndotl = max(0, dot(s.Normal, lightDir));
            // max 함수도 있지만 최대 값이 없습니다.

            return ndotl;
        }

        ENDCG
    }
    FallBack "Diffuse"
}

NormalMap 적용

Shader "Custom/CustomLight"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _BumpMap("Normal Map", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf _MyLight noambient  
        // noambient - 주변광 또는 라이트 프로브를 적용하지 않습니다.
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _BumpMap;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_BumpMap;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            float3 d = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
            o.Normal = d;
            o.Albedo = c.rgb;
            o.Alpha = c.a;
        }

        
        float4 Lighting_MyLight(SurfaceOutput s, float3 lightDir, float atten)
        {
            float ndotl = saturate(dot(s.Normal, lightDir));

            // dot 노멀 백터와 라이트 벡터를 내적 연산
            // surf 에서 Normal 값을 받지 않아도 버텍스에서 노말값을 평범하게 받음
            // saturate 0 이하 값을 0으로 만들어줌
            
            // float ndotl = max(0, dot(s.Normal, lightDir));
            // max 함수도 있지만 최대 값이 없습니다.

            return ndotl;
        }

        ENDCG
    }
    FallBack "Diffuse"
}

환경광 제거

The post 11 – 01 ~ 02 커스텀 라이트 기본형 / Lambert 라이트 연산 (Unity Shader) appeared first on 어제와 내일의 나 그 사이의 이야기.

9 – 02 ~ 03 Lambert (램버트) / Blinn-Phong(블린-퐁) (Unity Shader)

유니티4 이전 시절에 존재하던 가벼운 라이팅 방식인 Lambert 라이팅

램버트 라이팅 초기 구조

Shader "Custom/Lambert"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf Lambert
        #pragma target 3.0

        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {
            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            o.Albedo = c.rgb;
            o.Alpha = c.a;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

둔탁한 느낌의 이미지가 Lambert 라이트의 특징입니다.

o.Specular / o.Gloss 는 사용하지 않으므로 값을 넣어도 나타나지 않습니다.

겉으로는 크게 바뀐 것 같지 않지만 내장된 기본 라이팅 구조 중에서 가장 가벼운 라이트입니다. (저사양 기기에서도 잘 구동됩니다.)

간단한 Blinn Phong 라이트 구현 

Shader "Custom/BlinnPhong"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf BlinnPhong
        #pragma target 3.0

        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };


        void surf (Input IN, inout SurfaceOutput o)
        {
            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            o.Albedo = c.rgb;
            o.Alpha = c.a;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

BlinnPhong 공식이 가동 되었지만 Specular는 보이지 않습니다.

Specular를 보기위해 추가로 데이터를 입력합니다.

Shader "Custom/BlinnPhong"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _SpecColor("SpecColor", color) = (1,1,1,1)
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf BlinnPhong
        #pragma target 3.0

        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };


        void surf (Input IN, inout SurfaceOutput o)
        {
            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            o.Albedo = c.rgb;
            o.Specular = 0.5;
            o.Gloss = 1;
            o.Alpha = c.a;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

위의 코드에서 어디에서도 _SpecColor 를 받는 부분이 없습니다.

_SpecColor 는 절대로 코드에서 받으면 안 되고, 단지  Properties 에서만 만들어야 한다는 것 입니다.

그리고 _SpecColor 라는 이름 외에 다른 이름을 써서도 안됩니다.

BlinnPong 내부의 코드를 열어보면 _SpecColor 이름이 예약어이며 절대로 코드 내부에서 받으면 안된다는 특이한 예외 사항이 존재합니다.

o.Gloss 는 0~ 1 사이의 값을 넣어야 하며 Specular 의 강도를 의미합니다.

0이면 둔탁한 재질 / 1이면 매끄러운 재질을 의미합니다.

o.Specular는 0~ 1 사이의 값을 넣어야 하며 Specular 의 크기를 의미합니다.

0이면 크기가 커지고  / 1이면 크기가 작아집니다.

확인용 코드

Shader "Custom/BlinnPhong"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _SpecColor("SpecColor", color) = (1,1,1,1)
        _SpecAmount("SpecAmount",Range(0,1)) = 0.5
        _GlossAmount("_GlossAmount",Range(0,1)) = 1
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf BlinnPhong
        #pragma target 3.0

        sampler2D _MainTex;
        float _SpecAmount;
        float _GlossAmount;

        struct Input
        {
            float2 uv_MainTex;
        };


        void surf (Input IN, inout SurfaceOutput o)
        {
            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            o.Albedo = c.rgb;
            o.Specular = _SpecAmount;
            o.Gloss = _GlossAmount;
            o.Alpha = c.a;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

The post 9 – 02 ~ 03 Lambert (램버트) / Blinn-Phong(블린-퐁) (Unity Shader) appeared first on 어제와 내일의 나 그 사이의 이야기.

9 – 01 유니티에 내장된 라이팅 구조 (Unity Shader)

쉐이더를 처음 만들면 자동으로 생성되는 Standard Shader 는 유니티 5부터 기본적으로 적용된 쉐이더 형태입니다.

Standard Shader의 라이팅은 좋은 라이팅이지만 물리기반의 쉐이더 라이트이기 때문에

모바일과 같은 저 사양 기기에서 구동하기에는 다소 무겁습니다.

그래서 유니티 내부적으로는 유니티4버전 이전부터 사용하던 라이트 구조도 그대로 구현되어 있습니다.

이 라이팅은 물리 기반의 쉐이더보다 품질을 떨어질 수 있지만 상대적으로 가볍기 때문에 물리 기반의 쉐이더를 사용할 필요 없이

가볍게 처리해야 하는 모바일 프로젝트에 적합한 쉐이더 구조라고 할 수 있습니다.

우리가 지금까지 사용한 물리기반 쉐이더의 구조체

또는

물리 기반 쉐이더 이전의 쉐이더 구조인 램버트 / 블린퐁 라이트에서 사용하는 구조체 

즉 유니티에 내장되어 있는 라이팅은 총 3가지라고 할 수 있습니다. 

1. Lambert 램버트

Specular 의 공식이 없고 단지 빛에 의한 밝고 어두움이 구현된 가벼운 라이트 구조  / SurfaceOutput 구조체 사용

2. Blinn Phong 블린퐁

램버트 공식에 가벼운 Specular 공식인 블린퐁 공식이 더해진 라이트 구조,

Specular 공식은 보는 각도와 조명 각도에 따라 계산된 특정 색의 하이라이트 동그라미로 표현된다. / SurfaceOutput 구조체 사용

3.  Standard 스탠다드

일명 PBS ( 물리 기반 쉐이더 : Physically Based Shader)

주변 환경을 반사하서 Specular 를 구현하며, Diffuse 와 Specular 가 에너지 보존 법칙에 의해 서로 보완관계를 자동적으로 가지며

Specular dml 칼라가 메탈릭 속성에 따라 자동적으로 결정되는 라이트 구조

SurfaceOutputStandard 또는 SurfaceOutputStandardSpecular 구조체 사용

The post 9 – 01 유니티에 내장된 라이팅 구조 (Unity Shader) appeared first on 어제와 내일의 나 그 사이의 이야기.

8 – 04 Occlusion (오클루젼) (Unity Shader)

Occlusion (오클루젼)은 Ambient Occlusion (엠비언트 오클루젼) 이라고 부르며, 구석진 부분의 추가적인 음영을 표현하는 기능입니다.

일반적으로 세상에서 그림자가 드리워진 부분도 사방에서 오는 환경광 정도를 받고 있는 것이 일반적입니다.

하지만, 매우 구석져 있거나 복잡한 물체들로 가려져서 환경광도 닫지 못하는 부분은 더욱 더 어두워지는 데  

이 부분은 Ambient Occlusion (엠비언트 오클루젼) 환경차폐라고 부릅니다.

https://docs.unity3d.com/Manual/SL-SurfaceShaders.html

직접 확인해보기 위해서 아래 에셋을 사용했습니다. (무료)

https://assetstore.unity.com/packages/3d/characters/humanoids/barbarian-warrior-75519 <- TestAsset

사용했던 바바리안 몸체는 잠시 비활성화 하고 도끼를 활성화 했습니다.

쉐이더 코드는 바바리안 바디에 적용했던 코드를 사용했습니다.

Shader "Custom/AxeOC"
{
    Properties
    {
        _MainTex("Albedo (RGB)", 2D) = "white" {}
        _BumpMap("Normal Map", 2D) = "white" {} // NormalMap
        _Test("TestFloat",Range(0.5, 3)) = 1
    }
        SubShader
        {
            Tags { "RenderType" = "Opaque" }
            LOD 200

            CGPROGRAM
            #pragma surface surf Standard
            #pragma target 3.0

            sampler2D _MainTex;
            sampler2D _BumpMap; // NormalMap
            float _Test;

            struct Input
            {
                float2 uv_MainTex;
                float2 uv_BumpMap; // NormalMap
            };

            void surf(Input IN, inout SurfaceOutputStandard o)
            {
                float4 c = tex2D(_MainTex, IN.uv_MainTex);

                float3 d = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
                o.Normal = float3(d.x * _Test, d.y * _Test, d.z);
                // _Test에 따라서 수치 변화  2  2배  0.5  0.5배 
                o.Albedo = c.rgb;
                o.Alpha = c.a;
            }
            ENDCG
        }
            FallBack "Diffuse"
}

Occlusion 추가

Shader "Custom/AxeOC"
{
    Properties
    {
        _MainTex("Albedo (RGB)", 2D) = "white" {}
        _BumpMap("Normal Map", 2D) = "white" {}
        _Test("TestFloat",Range(0.5, 3)) = 1
        _Occlusion("Occlusion", 2D) = "white" {} // Occlusion
    }
        SubShader
    {
        Tags { "RenderType" = "Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf Standard
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _BumpMap;
        sampler2D _Occlusion;

        float _Test;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_BumpMap;
            // 주의 uv_Occlusion 포함 X

        };

        void surf(Input IN, inout SurfaceOutputStandard o)
        {
            float4 c = tex2D(_MainTex, IN.uv_MainTex);
            o.Occlusion = tex2D(_Occlusion, IN.uv_MainTex); // Occlusion
            // _MainTex와 동일한 UV 값을 받습니다.

            float3 d = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
            o.Normal = float3(d.x * _Test, d.y * _Test, d.z);
            o.Albedo = c.rgb;
            o.Alpha = c.a;
        }
        ENDCG
    }
        FallBack "Diffuse"
}

Occlusion 적용 전

Occlusion 적용 후

Normal Map 의 강도를 조절하면 더 확실하게 알 수 있습니다.

지금 사용한 코드에서는 Occlusion은 half (SurfaceOutput -float4)를 받습니다. (r 채널만 사용합니다.)

Occlusion 기능을 위해서 rgb 채널을 사용하는 텍스쳐를 사용하는 것은 낭비입니다.

_MainTex의 a 채널에 Occlusion 맵을 넣고 사용한다면 텍스쳐를 절약 할 수 있습니다.

The post 8 – 04 Occlusion (오클루젼) (Unity Shader) appeared first on 어제와 내일의 나 그 사이의 이야기.

08 – 01 Standard Shader

https://docs.unity3d.com/kr/2020.3/Manual/UpgradeGuide5.html

유니티 5.0이 되면서 다른 많은 그래픽 툴이나 엔진처럼 최신의 쉐이더 시스템인

‘물리 기반 쉐이더’ 시스템을 도입하게 되었습니다.

기존의 쉐이더 시스템과는 다르게, 주변 환경에 따른 재질 변화를 물리 법칙에 기반하여

실시간으로 재질을 구현해주는 사실적인 쉐이더 표현 기법입니다.

유니티에 있는 기본 Standard Shader 가 대표적인 물리 기반 쉐이더입니다.

https://docs.unity3d.com/kr/2021.3/Manual/SL-SurfaceShaders.html

우리가 사용한  o.Emission과 o.Albedo 같은 변수들은 바로 이 구조체 안에 정의되어 있는 것을 사용한 것이고

우리는 여기에 알맞은 값을 넣어 주면 알아서 결과가 나오게 되는 것입니다. 

이제 다른 구조체들을 사용해 보겠습니다.

08 – 02 Metallic, Smoothness

새로운 쉐이더와 메테리얼을 만들어서 Sphere에 적용 시켜줍니다.

Shader "Custom/Metallic"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf Standard
        #pragma target 3.0

        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            o.Albedo = c.rgb;
            o.Alpha = c.a;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

기존 쉐이더에 이미 Metallic, Smoothness 가 생성되어 있습니다.

공부를 위해서 만들어 봅시다.

이제 Properties에 Metallic, Smoothness를

Shader "Custom/Metallic"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _Metallic ("Metallic", Range(0, 1)) = 0 
        _Smoothness("Smoothness", Range(0, 1)) = 0
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf Standard
        #pragma target 3.0

        sampler2D _MainTex;
        float _Smoothness;
        float _Metallic;

        struct Input
        {
            float2 uv_MainTex;
        };

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            o.Albedo = c.rgb;
            o.Alpha = c.a;
            o.Metallic = _Metallic;
            o.Smoothness = _Smoothness;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

이제 적당한 텍스쳐를 넣고 결과를 확인합니다.

Smoothness는 이 재질이 매끄러운지 거친 지를 결정하는 부분입니다.

0이면 완벽히 거칠어서 난반사(Diffise)만 일어나고 1이면 완벽히 매끄러워서 정반사(Specular)만 일어나게 됩니다.

유니티에서 Standard Shader라는 물리기반렌더링의 기본 개념은

나가는 빛의 양은 들오는 빛의 양을 넘길 수 없다라는 에너지 보존법칙 개념입니다.

재질의 거칠기에 따라서 난반사와 정반사의 비율이 결정되므로 정반사가 높아지면 그만큼 난반사의 비율이 적어집니다.

물리 기반 쉐이더에서 Metallic 이 0이면 스페큘러 컬러가 흑백이 되며 1이면 Albedo에 넣은 색이 됩니다.

금속은 고유의 스펙큘러 컬러를 가지고 있기 때문입니다.

가급적 0과 1외의 값은 쓰지 않는 것이 정확한 물리 기반 쉐이더를 다루는 방법입니다. 

https://docs.unity3d.com/Manual/StandardShaderMaterialCharts.html

유니티에서는 이러한 재질의 올바른 사용법을 위해서 아래와 같은 차트를 제공합니다.

노멀맵 추가 후 확인해보면 진짜 금속같이 보이네요

Shader "Custom/Metallic"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _Metallic ("Metallic", Range(0, 1)) = 0 
        _Smoothness("Smoothness", Range(0, 1)) = 0
        _BumpMap("NormalMAp", 2D) = "bump" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf Standard
        #pragma target 3.0

        sampler2D _MainTex;
        float _Smoothness;
        float _Metallic;
        sampler2D _BumpMap;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_BumpMap;
        };

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            float3 d = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
            o.Normal = d;
            o.Albedo = c.rgb;
            o.Alpha = c.a;
            o.Metallic = _Metallic;
            o.Smoothness = _Smoothness;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

The post 8 – 01 ~ 02 Standard Shader / Metallic, Smoothness (Unity Shader) appeared first on 어제와 내일의 나 그 사이의 이야기.