Universal RP 17.0.3

include “Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl” 내부에 input이 포함됨
include “Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl”

Input.hlsl

#ifndef UNIVERSAL_INPUT_INCLUDED
#define UNIVERSAL_INPUT_INCLUDED
// URP package specific shader input variables and defines.
// Unity Engine specific built-in shader input variables are defined in .universal/ShaderLibrary/UnityInput.hlsl

#include "Packages/com.unity.render-pipelines.universal-config/Runtime/ShaderConfig.cs.hlsl"

#define MAX_VISIBLE_LIGHTS_UBO  32
#define MAX_VISIBLE_LIGHTS_SSBO 256

// Keep in sync with RenderingUtils.useStructuredBuffer
#define USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA 0

#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderTypes.cs.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Deprecated.hlsl"

// Must match: UniversalRenderPipeline.maxVisibleAdditionalLights
#if defined(SHADER_API_MOBILE) && defined(SHADER_API_GLES30)
    #define MAX_VISIBLE_LIGHTS MAX_VISIBLE_LIGHT_COUNT_LOW_END_MOBILE
// WebGPU's minimal limits are based on mobile rather than desktop, so it will need to assume mobile.
#elif defined(SHADER_API_MOBILE) || (defined(SHADER_API_GLCORE) && !defined(SHADER_API_SWITCH)) || defined(SHADER_API_GLES3) || defined(SHADER_API_WEBGPU) // Workaround because SHADER_API_GLCORE is also defined when SHADER_API_SWITCH is
    #define MAX_VISIBLE_LIGHTS MAX_VISIBLE_LIGHT_COUNT_MOBILE
#else
    #define MAX_VISIBLE_LIGHTS MAX_VISIBLE_LIGHT_COUNT_DESKTOP
#endif

// Match with values in UniversalRenderPipeline.cs
#define MAX_ZBIN_VEC4S 1024
#if MAX_VISIBLE_LIGHTS <= 16
    #define MAX_LIGHTS_PER_TILE 32
    #define MAX_TILE_VEC4S 1024
    #define MAX_REFLECTION_PROBES 16
#elif MAX_VISIBLE_LIGHTS <= 32
    #define MAX_LIGHTS_PER_TILE 32
    #define MAX_TILE_VEC4S 1024
    #define MAX_REFLECTION_PROBES 32
#else
    #define MAX_LIGHTS_PER_TILE MAX_VISIBLE_LIGHTS
    #define MAX_TILE_VEC4S 4096
    #define MAX_REFLECTION_PROBES 64
#endif

struct InputData
{
    float3  positionWS;
    float4  positionCS;
    float3  normalWS;
    half3   viewDirectionWS;
    float4  shadowCoord;
    half    fogCoord;
    half3   vertexLighting;
    half3   bakedGI;
    float2  normalizedScreenSpaceUV;
    half4   shadowMask;
    half3x3 tangentToWorld;

    #if defined(DEBUG_DISPLAY)
    half2   dynamicLightmapUV;
    half2   staticLightmapUV;
    float3  vertexSH;

    half3 brdfDiffuse;
    half3 brdfSpecular;

    // Mipmap Streaming Debug
    float2 uv;
    uint mipCount;

    // texelSize :
    // x = 1 / width
    // y = 1 / height
    // z = width
    // w = height
    float4 texelSize;

    // mipInfo :
    // x = quality settings minStreamingMipLevel
    // y = original mip count for texture
    // z = desired on screen mip level
    // w = loaded mip level
    float4 mipInfo;

    // streamInfo :
    // x = streaming priority
    // y = time stamp of the latest texture upload
    // z = streaming status
    // w = 0
    float4 streamInfo;

    float3 originalColor;
    #endif
};

///////////////////////////////////////////////////////////////////////////////
//                      Constant Buffers                                     //
///////////////////////////////////////////////////////////////////////////////

half4 _GlossyEnvironmentColor;
half4 _SubtractiveShadowColor;

half4 _GlossyEnvironmentCubeMap_HDR;
TEXTURECUBE(_GlossyEnvironmentCubeMap);
SAMPLER(sampler_GlossyEnvironmentCubeMap);

#define _InvCameraViewProj unity_MatrixInvVP
float4 _ScaledScreenParams;

// x = Mip Bias
// y = 2.0 ^ [Mip Bias]
float2 _GlobalMipBias;

// 1.0 if it's possible for AlphaToMask to be enabled for this draw and 0.0 otherwise
float _AlphaToMaskAvailable;

float4 _MainLightPosition;
// In Forward+, .a stores whether the main light is using subtractive mixed mode.
half4 _MainLightColor;
half4 _MainLightOcclusionProbes;
uint _MainLightLayerMask;

// x: SSAO Enabled/Disabled (Needed for situations when OFF keyword is stripped out but feature disabled in runtime)
// yz are currently unused
// w: directLightStrength
half4 _AmbientOcclusionParam;

half4 _AdditionalLightsCount;

uint _RenderingLayerMaxInt;
float _RenderingLayerRcpMaxInt;

// Screen coord override.
float4 _ScreenCoordScaleBias;
float4 _ScreenSizeOverride;

uint _EnableProbeVolumes;

#if USE_FORWARD_PLUS
float4 _FPParams0;
float4 _FPParams1;
float4 _FPParams2;

#define URP_FP_ZBIN_SCALE (_FPParams0.x)
#define URP_FP_ZBIN_OFFSET (_FPParams0.y)
#define URP_FP_PROBES_BEGIN ((uint)_FPParams0.z)
// Directional lights would be in all clusters, so they don't go into the cluster structure.
// Instead, they are stored first in the light buffer.
#define URP_FP_DIRECTIONAL_LIGHTS_COUNT ((uint)_FPParams0.w)

// Scale from screen-space UV [0, 1] to tile coordinates [0, tile resolution].
#define URP_FP_TILE_SCALE ((float2)_FPParams1.xy)
#define URP_FP_TILE_COUNT_X ((uint)_FPParams1.z)
#define URP_FP_WORDS_PER_TILE ((uint)_FPParams1.w)

#define URP_FP_ZBIN_COUNT ((uint)_FPParams2.x)
#define URP_FP_TILE_COUNT ((uint)_FPParams2.y)

#endif

#if USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA
StructuredBuffer<LightData> _AdditionalLightsBuffer;
StructuredBuffer<int> _AdditionalLightsIndices;
#else
// GLES3 causes a performance regression in some devices when using CBUFFER.
#ifndef SHADER_API_GLES3
CBUFFER_START(AdditionalLights)
#endif
float4 _AdditionalLightsPosition[MAX_VISIBLE_LIGHTS];
// In Forward+, .a stores whether the light is using subtractive mixed mode.
half4 _AdditionalLightsColor[MAX_VISIBLE_LIGHTS];
half4 _AdditionalLightsAttenuation[MAX_VISIBLE_LIGHTS];
half4 _AdditionalLightsSpotDir[MAX_VISIBLE_LIGHTS];
half4 _AdditionalLightsOcclusionProbes[MAX_VISIBLE_LIGHTS];
float _AdditionalLightsLayerMasks[MAX_VISIBLE_LIGHTS]; // we want uint[] but Unity api does not support it.
#ifndef SHADER_API_GLES3
CBUFFER_END
#endif
#endif

#if USE_FORWARD_PLUS

CBUFFER_START(urp_ZBinBuffer)
        float4 urp_ZBins[MAX_ZBIN_VEC4S];
CBUFFER_END
CBUFFER_START(urp_TileBuffer)
        float4 urp_Tiles[MAX_TILE_VEC4S];
CBUFFER_END

TEXTURE2D(urp_ReflProbes_Atlas);
float urp_ReflProbes_Count;

// 2023.3 Deprecated. This is for backwards compatibility. Remove in the future.
#define samplerurp_ReflProbes_Atlas sampler_LinearClamp

#ifndef SHADER_API_GLES3
CBUFFER_START(urp_ReflectionProbeBuffer)
#endif
float4 urp_ReflProbes_BoxMax[MAX_REFLECTION_PROBES];          // w contains the blend distance
float4 urp_ReflProbes_BoxMin[MAX_REFLECTION_PROBES];          // w contains the importance
float4 urp_ReflProbes_ProbePosition[MAX_REFLECTION_PROBES];   // w is positive for box projection, |w| is max mip level
float4 urp_ReflProbes_MipScaleOffset[MAX_REFLECTION_PROBES * 7];
#ifndef SHADER_API_GLES3
CBUFFER_END
#endif

#endif

#define UNITY_MATRIX_M     unity_ObjectToWorld
#define UNITY_MATRIX_I_M   unity_WorldToObject
#define UNITY_MATRIX_V     unity_MatrixV
#define UNITY_MATRIX_I_V   unity_MatrixInvV
#define UNITY_MATRIX_P     OptimizeProjectionMatrix(glstate_matrix_projection)
#define UNITY_MATRIX_I_P   unity_MatrixInvP
#define UNITY_MATRIX_VP    unity_MatrixVP
#define UNITY_MATRIX_I_VP  unity_MatrixInvVP
#define UNITY_MATRIX_MV    mul(UNITY_MATRIX_V, UNITY_MATRIX_M)
#define UNITY_MATRIX_T_MV  transpose(UNITY_MATRIX_MV)
#define UNITY_MATRIX_IT_MV transpose(mul(UNITY_MATRIX_I_M, UNITY_MATRIX_I_V))
#define UNITY_MATRIX_MVP   mul(UNITY_MATRIX_VP, UNITY_MATRIX_M)
#define UNITY_PREV_MATRIX_M   unity_MatrixPreviousM
#define UNITY_PREV_MATRIX_I_M unity_MatrixPreviousMI

// Note: #include order is important here.
// UnityInput.hlsl must be included before UnityInstancing.hlsl, so constant buffer
// declarations don't fail because of instancing macros.
// UniversalDOTSInstancing.hlsl must be included after UnityInstancing.hlsl
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/UnityInput.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/UnityInstancing.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/UniversalDOTSInstancing.hlsl"

// VFX may also redefine UNITY_MATRIX_M / UNITY_MATRIX_I_M as static per-particle global matrices.
#ifdef HAVE_VFX_MODIFICATION
#include "Packages/com.unity.visualeffectgraph/Shaders/VFXMatricesOverride.hlsl"
#endif

#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/SpaceTransforms.hlsl"

#endif

1. 헤더 정의 및 보호구문

#ifndef UNIVERSAL_INPUT_INCLUDED
#define UNIVERSAL_INPUT_INCLUDED

헤더 파일을 여러 번 포함하는 것을 방지

UNIVERSAL_INPUT_INCLUDED가 정의되지 않은 경우에만 코드가 실행되도록 합니다.

2. 패키지 및 설정 파일 포함

#include "Packages/com.unity.render-pipelines.universal-config/Runtime/ShaderConfig.cs.hlsl"

URP의 설정 및 구성을 정의하는 파일을 포함

이 파일에는 URP에서 사용하는 여러 가지 상수 값과 설정이 정의되어 있습니다.

3. 최대 조명 및 타일링 설정

#define MAX_VISIBLE_LIGHTS_UBO  32
#define MAX_VISIBLE_LIGHTS_SSBO 256

UBO(Uniform Buffer Object)와 SSBO(Shader Storage Buffer Object)에 사용할 수 있는 최대 조명 개수를 정의

MAX_VISIBLE_LIGHTS_UBO: UBO 방식으로 사용할 수 있는 최대 조명 수 (32).

MAX_VISIBLE_LIGHTS_SSBO: SSBO 방식으로 사용할 수 있는 최대 조명 수 (256).

4. 조명 데이터 저장 방법 결정

#define USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA 0

0으로 설정되어 있으며, 이는 Structured Buffer가 아닌 Constant Buffer를 사용하여 조명 데이터를 저장함을 의미합니다.

5. 플랫폼에 따른 최대 조명 설정

// Must match: UniversalRenderPipeline.maxVisibleAdditionalLights
#if defined(SHADER_API_MOBILE) && defined(SHADER_API_GLES30)
    #define MAX_VISIBLE_LIGHTS MAX_VISIBLE_LIGHT_COUNT_LOW_END_MOBILE
// WebGPU's minimal limits are based on mobile rather than desktop, so it will need to assume mobile.
#elif defined(SHADER_API_MOBILE) || (defined(SHADER_API_GLCORE) && !defined(SHADER_API_SWITCH)) || defined(SHADER_API_GLES3) || defined(SHADER_API_WEBGPU) // Workaround because SHADER_API_GLCORE is also defined when SHADER_API_SWITCH is
    #define MAX_VISIBLE_LIGHTS MAX_VISIBLE_LIGHT_COUNT_MOBILE
#else
    #define MAX_VISIBLE_LIGHTS MAX_VISIBLE_LIGHT_COUNT_DESKTOP
#endif

플랫폼에 따라 최대 조명 수를 다르게 설정합니다.

모바일 플랫폼에서는 자원을 덜 사용하도록 제한을 두며, 데스크탑에서는 더 많은 조명을 허용합니다.

6. 입력 데이터 구조체 (InputData)

struct InputData
{
    float3  positionWS;
    float4  positionCS;
    float3  normalWS;
    half3   viewDirectionWS;
    float4  shadowCoord;
    half    fogCoord;
    half3   vertexLighting;
    half3   bakedGI;
    float2  normalizedScreenSpaceUV;
    half4   shadowMask;
    half3x3 tangentToWorld;
};

InputData 구조체는 Shader에서 필요한 여러 데이터를 모아둔 것입니다.

• positionWS: 월드 좌표계에서의 정점 위치.
• positionCS: 클립 좌표계에서의 정점 위치.
• normalWS: 월드 좌표계에서의 법선 벡터.
• viewDirectionWS: 월드 좌표계에서의 시선 방향.
• shadowCoord: 그림자 좌표.
• vertexLighting: 정점 기반의 조명.
• bakedGI: 프리컴퓨티드 전역 조명.
• normalizedScreenSpaceUV: 화면 공간 UV 좌표.
• shadowMask: 그림자 마스크.
• tangentToWorld: 탄젠트 공간에서 월드 공간으로 변환하는 행렬.

7. 그 외 입력 구조체 (DEBUG_DISPLAY 포함)

DEBUG_DISPLAY가 정의되어 있는 경우 추가적인 디버그용 데이터를 받습니다.

• 동적, 정적 라이트맵 UV 좌표, 텍스처 스트리밍 관련 정보 등을 포함합니다.

8. 상수 버퍼 및 조명 데이터

half4 _GlossyEnvironmentColor;
half4 _SubtractiveShadowColor;
half4 _GlossyEnvironmentCubeMap_HDR;
TEXTURECUBE(_GlossyEnvironmentCubeMap);
SAMPLER(sampler_GlossyEnvironmentCubeMap);

환경 반사, 그림자 색상, 큐브맵 반사 등과 관련된 상수 값들이 정의됩니다.

텍스처와 샘플러도 정의됩니다.

9. 주 조명 및 추가 조명 데이터

float4 _MainLightPosition;
half4 _MainLightColor;
float4 _AdditionalLightsPosition[MAX_VISIBLE_LIGHTS];
half4 _AdditionalLightsColor[MAX_VISIBLE_LIGHTS];

주 조명과 추가 조명에 대한 데이터를 저장합니다.

각 조명에 대해 위치, 색상, 감쇠(Attenuation), 스포트라이트 방향 등이 포함됩니다.

10. 타일 기반 및 반사 프로브 처리 (Forward Plus)

CBUFFER_START(urp_TileBuffer)
    float4 urp_Tiles[MAX_TILE_VEC4S];
CBUFFER_END

타일 기반 조명 처리 및 반사 프로브에 대한 데이터를 정의합니다.

이는 Forward Plus 렌더링에서 사용됩니다.타일당 조명 수, 타일 크기, 반사 프로브의 위치 등을 정의합니다.

11. 매트릭스 정의

#define UNITY_MATRIX_M     unity_ObjectToWorld
#define UNITY_MATRIX_I_M   unity_WorldToObject

객체에서 월드로 변환하는 매트릭스와 반대로 월드에서 객체로 변환하는 매트릭스 등 다양한 매트릭스가 정의됩니다.

12. 기타 패키지 포함

#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/UnityInput.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/UnityInstancing.hlsl"

Unity의 인스턴싱 및 DOTS 관련 쉐이더 라이브러리를 포함하여 인스턴싱 처리 및 VFX 처리 관련 기능을 지원합니다.

이 코드는 Universal Render Pipeline에서 사용하는 다양한 조명, 타일 기반 조명 처리, 반사 처리 및 그림자 처리를 위한 입력 데이터를 처리하는 방법을 정의합니다.

The post Unity URP Input.hlsl appeared first on 어제와 내일의 나 그 사이의 이야기.

Shader "Unlit/lycos/Grayscale_URP_Unlit"
{
    Properties
    {
        [MainTexture] _BaseMap("Texture", 2D) = "white" {}
        _GrayscaleIntensity("Grayscale Intensity", Range(0, 1)) = 1.0 // 흑백 효과 강도 (0: 원본 색상, 1: 완전 흑백)
    }
    SubShader
    {
        Tags { "RenderType" = "Opaque" "Queue" = "Geometry" "RenderPipeline" = "UniversalPipeline" }

        Pass
        {
            Name  "Grayscale_URP_Unlit"
            Tags {"LightMode" = "SRPDefaultUnlit"} // 이 Pass는 Unlit(조명이 없는) 모드로 작동함을 선언

            HLSLPROGRAM
            #pragma target 4.5 // Shader 모델 4.5를 대상
            #pragma vertex vert // vertex shader 선언 (vert 함수)
            #pragma fragment frag // fragment shader 선언 (frag 함수)
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            // Constant Buffer 
            // Unity의 각 Material 상수를 정의
            CBUFFER_START(UnityPerMaterial) 
                float4 _BaseMap_ST; // TEXTURE UV 좌표 변환에 사용되는 정보 (offset, tiling)
                float _GrayscaleIntensity; // 흑백 효과 강도
            CBUFFER_END
            TEXTURE2D(_BaseMap);  // TEXTURE2D 선언
            SAMPLER(sampler_BaseMap); // SAMPLER 선언
            // vertex shader의 입력 구조체 
            struct Attributes
            {
                float4 positionOS : POSITION;  // 모델 공간에서의 정점 위치 (float3, float4)
                float2 uv : TEXCOORD0;   // 첫 번째 UV 텍스처 좌표 (float2, float3, float4)
                float4 color : COLOR;  // 정점 별 색상  (float4)
            };
            // Varyings 구조체 정의
            // 출력 구조체로, fragment Shader에서 사용할 데이터(예: 변환된 위치, UV 좌표 등)를 포함
            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };
            // vertex shader가 Attributes를 사용
            Varyings vert(Attributes input)
            {
                // 출력 변수를 정의
                Varyings output = (Varyings)0; // Varyings 초기화, 모든 필드에 기본값을 할당
                float4 positionOS = input.positionOS; // 모델 공간에서의 정점 위치를 float4 형태로 저장
                float3 positionWS = TransformObjectToWorld(positionOS.xyz); // 모델 공간에서 월드 공간으로의 변환을 수행
                float4 positionCS = TransformWorldToHClip(positionWS); // 월드 공간에서 클립 공간으로의 변환을 수행
                output.positionCS = positionCS; // 변환된 클립 공간 위치를 출력 구조체 output에 저장
                output.uv = input.uv; // 입력으로 받은 UV 좌표를 출력 구조체 output에 저장
                output.color = input.color;
                return output;
            }
            // 프래그먼트 셰이더(fragment shader) 
            // 픽셀 단위로 호출되며, 각 픽셀의 최종 색상을 계산해 화면에 출력
            // 기본적으로 입력된 UV 좌표를 이용해 텍스처 색상을 샘플링하고, 
            // 최종적으로 머티리얼의 색상과 결합하여 픽셀의 색상을 반환하는 역할
            float4 frag(Varyings input) : SV_Target
            {
                // UV 좌표 변환을 위한 계산
                float2 baseMapUV = input.uv.xy * _BaseMap_ST.xy + _BaseMap_ST.zw;
                // SAMPLE_TEXTURE2D 함수를 사용하여 텍스처를 샘플링합니다.
                float4 texColor = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, baseMapUV);
                // Grayscale 변환
                float gray = dot(texColor.rgb, float3(0.299, 0.587, 0.114));
                // 흑백 효과의 강도를 적용
                // lerp 함수를 사용하여 texColor와 변환된 흑백 색상 사이에서 _GrayscaleIntensity 값을 기반으로 색상을 보간합니다.
                float4 finalColor = lerp(texColor, float4(gray, gray, gray, texColor.a), _GrayscaleIntensity);

                // 최종 계산된 색상을 출력합니다. SV_Target은 이 값이 픽셀 셰이더의 출력으로 화면에 렌더링된다는 것을 의미합니다.
                return finalColor;
            }
            ENDHLSL
        }
    }
}

Grayscale 변환 원리 :

주어진 코드에서 색상을 흑백으로 변환하는 원리는 색상의 밝기(휘도, Luminance)를 계산하는 것에 기반합니다.

인간의 눈은 색상마다 민감도가 다르기 때문에, 각 RGB 채널에 가중치를 부여하여 밝기를 계산합니다.

// Grayscale 변환
float gray = dot(texColor.rgb, float3(0.299, 0.587, 0.114));

RGB를 Grayscale로 변환하는 원리

인간의 눈은 각각의 색상 성분(R, G, B)에 대해 감도가 다르다.

일반적으로 녹색(G) 성분에 가장 민감하고, 빨간색(R) 성분에 중간 정도로 민감하며, 파란색(B) 성분에 가장 덜 민감하다.

따라서, 각 색상 성분에 적절한 가중치를 부여하여 이를 반영한 값을 계산해야 더 자연스러운 Grayscale 변환이 된다.

그래서 RGB 값에서 Grayscale 값을 구하는 공식은 각 성분의 가중치를 적용한 합으로 나타낸다.

이 가중치는 인간의 시각적 감도를 반영한 표준 가중치라고 할 수 있다.

내적(Dot Product) 사용 이유

내적은 두 벡터 간의 대응되는 성분을 곱한 후 더하는 연산입니다.

RGB 값을 각각의 가중치와 곱한 후 더하는 이 과정을 내적을 통해 쉽게 계산할 수 있습니다.

float gray = dot(texColor.rgb, float3(0.299, 0.587, 0.114));

이 공식을 내적 연산을 사용하여 간결하게 표현한 것입니다.

HueAdjustment_URP_Unlit.shader

Shader "Unlit/lycos/HueAdjustment_URP_Unlit"
{
    Properties
    {
        [MainTexture] _BaseMap("Texture", 2D) = "white" {} // 기본 텍스처
        _HueAdjustment("Hue Adjustment", Range(-1, 1)) = 0.0 // 색조 조정 값 (-1: -180도, 1: 180도)
    }
    SubShader
    {
        Tags { "RenderType" = "Opaque" "Queue" = "Geometry" "RenderPipeline" = "UniversalPipeline" }

        Pass
        {
            Name  "HueAdjustment_URP_Unlit"
            Tags {"LightMode" = "SRPDefaultUnlit"} // 이 Pass는 Unlit(조명이 없는) 모드로 작동함을 선언

            HLSLPROGRAM
            #pragma target 4.5 // Shader 모델 4.5를 대상으로 함
            #pragma vertex vert // vertex shader 선언
            #pragma fragment frag // fragment shader 선언
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            // Constant Buffer
            // Unity의 각 Material 상수를 정의
            CBUFFER_START(UnityPerMaterial) 
                float4 _BaseMap_ST; // 텍스처의 UV 좌표 변환 정보 (offset, tiling)
                float _HueAdjustment; // 색조 조정 값
            CBUFFER_END

            TEXTURE2D(_BaseMap);  // 텍스처 선언
            SAMPLER(sampler_BaseMap); // 샘플러 선언

            // Vertex Shader의 입력 구조체
            struct Attributes
            {
                float4 positionOS : POSITION;  // 모델 공간에서의 정점 위치
                float2 uv : TEXCOORD0;   // UV 텍스처 좌표
                float4 color : COLOR;  // 정점 색상
            };

            // Varyings 구조체 정의
            // Fragment Shader에서 사용할 데이터(예: 변환된 위치, UV 좌표 등)를 포함
            struct Varyings
            {
                float4 positionCS : SV_POSITION; // 클립 공간에서의 정점 위치
                float2 uv : TEXCOORD0; // UV 좌표
                float4 color : COLOR; // 색상
            };

            // Vertex Shader
            Varyings vert(Attributes input)
            {
                Varyings output = (Varyings)0; // Varyings 초기화
                float4 positionOS = input.positionOS; // 모델 공간에서의 정점 위치 저장
                float3 positionWS = TransformObjectToWorld(positionOS.xyz); // 모델 공간에서 월드 공간으로 변환
                float4 positionCS = TransformWorldToHClip(positionWS); // 월드 공간에서 클립 공간으로 변환
                output.positionCS = positionCS; // 변환된 클립 공간 위치 저장
                output.uv = input.uv; // UV 좌표 저장
                output.color = input.color; // 색상 저장
                return output;
            }

            float3 ApplyHue(float3 col, float hueAdjust)
            {
                // RGB 색상을 HSV 색상 공간으로 변환
                float4 K = float4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
                float4 P = lerp(float4(col.bg, K.wz), float4(col.gb, K.xy), step(col.b, col.g));
                float4 Q = lerp(float4(P.xyw, col.r), float4(col.r, P.yzx), step(P.x, col.r));
                float D = Q.x - min(Q.w, Q.y);
                float E = 1e-10; // 작은 값 추가
                float3 hsv = float3(abs(Q.z + (Q.w - Q.y)/(6.0 * D + E)), D / (Q.x + E), Q.x);

                // 색조 조정
                float hue = hsv.x + hueAdjust;
                hsv.x = (hue < 0)
                        ? hue + 1
                        : (hue > 1)
                            ? hue - 1
                            : hue;

                // HSV 색상을 RGB 색상으로 변환
                float4 K2 = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
                float3 P2 = abs(frac(hsv.xxx + K2.xyz) * 6.0 - K2.www);
                float3 result = hsv.z * lerp(K2.xxx, saturate(P2 - K2.xxx), hsv.y);
                return result;
            }

            // Fragment Shader
            float4 frag(Varyings input) : SV_Target
            {
                // UV 좌표 변환
                float2 baseMapUV = input.uv.xy * _BaseMap_ST.xy + _BaseMap_ST.zw;
                // 텍스처 샘플링
                float4 texColor = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, baseMapUV);
                // 색조 조정
                float3 hueAdjustedColor = ApplyHue(texColor.rgb, _HueAdjustment);
                // 최종 색상 반환
                float4 finalColor = float4(hueAdjustedColor, texColor.a);

                // 최종 계산된 색상을 출력
                return finalColor;
            }
            ENDHLSL
        }
    }
}

1. RGB to HSV 변환 (RGB 색상을 HSV 색상 공간으로 변환)

float4 K = float4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
float4 P = lerp(float4(col.bg, K.wz), float4(col.gb, K.xy), step(col.b, col.g));
float4 Q = lerp(float4(P.xyw, col.r), float4(col.r, P.yzx), step(P.x, col.r));
float D = Q.x - min(Q.w, Q.y);
float E = 1e-10; // 작은 값 추가
float3 hsv = float3(abs(Q.z + (Q.w - Q.y) / (6.0 * D + E)), D / (Q.x + E), Q.x);

입력 변수: col은 RGB 색상을 나타내는 float3 값입니다. 이 색상을 HSV로 변환하는 과정입니다.

K: 색상 변환에 필요한 상수 값입니다. 다양한 색상 조합을 비교할 때 사용됩니다.

P, Q: lerp(선형 보간) 함수와 step 함수를 사용하여 색상 성분을 비교하고 보간합니다. 이를 통해 RGB에서 가장 큰 값과 작은 값을 찾고, 색상 성분을 적절히 섞어 색상 차이 D와 관련된 값을 계산합니다.

D: RGB 색상의 최댓값과 최솟값의 차이를 나타내며, 이것은 채도(Saturation)를 결정하는 값입니다.

hsv.x: 색상(Hue)을 계산하기 위한 값입니다. RGB에서 Hue는 특정 범위의 계산을 통해 구해지며, 이 값은 색상 톤을 나타냅니다.

hsv.y: 채도(Saturation)를 계산한 값입니다.

D를 RGB에서의 최댓값과 나누어 채도를 구합니다.

hsv.z: 명도(Value)로, RGB 색상에서의 최댓값이 됩니다.

2. 색조 조정 (Hue Shift)

float hue = hsv.x + hueAdjust;
hsv.x = (hue < 0) ? hue + 1 : (hue > 1) ? hue - 1 : hue;

hueAdjust: 함수의 인자로 전달된 색조 변경 값입니다.

hsv.x + hueAdjust: 기존의 색조에 새로운 색조 조정 값을 더해 색조를 변경합니다.

hsv.x: Hue는 0에서 1 사이의 값으로 표현되므로, hue 값이 0보다 작으면 1을 더하고, 1보다 크면 1을 빼서 순환시킵니다. 이는 색조의 값을 항상 0~1 범위 내에 유지시키기 위한 작업입니다.

3. HSV to RGB 변환 (HSV를 다시 RGB로 변환)

float4 K2 = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
float3 P2 = abs(frac(hsv.xxx + K2.xyz) * 6.0 - K2.www);
float3 result = hsv.z * lerp(K2.xxx, saturate(P2 - K2.xxx), hsv.y);

K2: HSV에서 RGB로 변환할 때 사용되는 상수 값입니다.

frac(hsv.xxx + K2.xyz): 이 계산을 통해 hsv.x에 기반한 색상 조합을 생성합니다.

P2: 색상을 변환할 때 필요한 중간 계산으로, 색조(Hue) 정보를 바탕으로 RGB로 변환하는데 필요한 보간을 수행합니다.

lerp: 보간을 사용하여 최종 RGB 값에 대한 보정을 수행합니다. hsv.y는 채도, hsv.z는 명도에 해당하는 값을 적용하여 최종적인 색상 값을 구합니다.

result: 변환된 최종 RGB 값입니다.

The post URP_Unlit_Grayscale / Hue Shader – HLSL appeared first on 어제와 내일의 나 그 사이의 이야기.

Shader "URP/Unlit/URP_UnlitBase"
{
    Properties
    {
        [MainTexture] _BaseMap("Texture", 2D) = "white" {}
        [MainColor] _BaseColor("Color", Color) = (1, 1, 1, 1)
    }

        SubShader
        {
            Tags { "RenderType" = "Opaque" "Queue" = "Geometry" "RenderPipeline" = "UniversalPipeline" }
            LOD 100

            Pass
            {
                Name  "URP_UnlitBase"
                Tags {"LightMode" = "SRPDefaultUnlit"} // 이 Pass는 Unlit(조명이 없는) 모드로 작동함을 선언

                HLSLPROGRAM
                #pragma target 4.5 // Shader 모델 4.5를 대상

                // vertex shader 선언 (vert 함수)
                // vert라는 이름의 함수를 vertex shader로 사용 선언
                // vert는 입력으로 Attributes 구조체를 받고, 처리된 결과를 반환
                #pragma vertex vert // vertex shader 선언 (vert 함수)
                #pragma fragment frag // fragment shader 선언 (frag 함수)

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

                // Constant Buffer 
                // Unity의 각 Material 상수를 정의
                CBUFFER_START(UnityPerMaterial) 
                    float4 _BaseMap_ST; // TEXTURE UV 좌표 변환에 사용되는 정보 (offset, tiling)
                    float4 _BaseColor; // 설정 색상
                CBUFFER_END

                TEXTURE2D(_BaseMap);  // TEXTURE2D 선언
                SAMPLER(sampler_BaseMap); // SAMPLER 선언

                // vertex shader의 입력 구조체 
                struct Attributes
                {
                    float4 positionOS : POSITION;  // 모델 공간에서의 정점 위치 (float3, float4)
                    float3 normalOS : NORMAL;  // 모델 공간에서의 정점 법선 (float3)
                    float2 uv : TEXCOORD0;   // 첫 번째 UV 텍스처 좌표 (float2, float3, float4)
                    float2 uv2 : TEXCOORD1;  // 두 번째 UV 텍스처 좌표 (float2, float3, float4)
                    float2 uv3 : TEXCOORD2;  // 세 번째 UV 텍스처 좌표 (float2, float3, float4)
                    float2 uv4 : TEXCOORD3;  // 넷 번째 UV 텍스처 좌표 (float2, float3, float4)
                    float4 tangentOS : TANGENT;  // 모델 공간에서의 접선 벡터 (normal mapping에 사용)
                    float4 color : COLOR;  // 정점 별 색상  (float4)
                    int4 blendIndices : BLENDINDICES;  // 스킨 매싱에서 뼈대 인덱스
                };

                // Varyings 구조체 정의
                // 출력 구조체로, fragment Shader에서 사용할 데이터(예: 변환된 위치, UV 좌표 등)를 포함
                struct Varyings
                {
                    float4 positionCS : SV_POSITION;
                    float2 uv : TEXCOORD0;
                    float4 color : COLOR;
                };


                // vertex shader가 Attributes를 사용
                Varyings vert(Attributes input)
                {
                    // 출력 변수를 정의
                    Varyings output = (Varyings)0; // Varyings 초기화, 모든 필드에 기본값을 할당

                    // 모델 공간에서의 정점 위치를 float4 형태로 저장
                    float4 positionOS = input.positionOS;

                    // 모델 공간에서 월드 공간으로의 변환을 수행
                    float3 positionWS = TransformObjectToWorld(positionOS.xyz);

                    // 월드 공간에서 뷰 공간으로의 변환을 수행
                    float3 positionVS = TransformWorldToView(positionWS);

                    // 월드 공간에서 클립 공간으로의 변환을 수행
                    // 클립 공간 : 렌더링 파이프라인에서 최종적으로 화면에 출력될 좌표계
                    float4 positionCS = TransformWorldToHClip(positionWS);

                    // 변환된 클립 공간 위치를 출력 구조체 output에 저장
                    output.positionCS = positionCS;
                    // 입력으로 받은 UV 좌표를 출력 구조체 output에 저장
                    output.uv = input.uv;
                    output.color = input.color;

                    return output;
                }

                // 프래그먼트 셰이더(fragment shader) 
                // 픽셀 단위로 호출되며, 각 픽셀의 최종 색상을 계산해 화면에 출력
                // 기본적으로 입력된 UV 좌표를 이용해 텍스처 색상을 샘플링하고, 
                // 최종적으로 머티리얼의 색상과 결합하여 픽셀의 색상을 반환하는 역할
                float4 frag(Varyings input) : SV_Target
                {
                    // UV 좌표 변환을 위한 계산
                    // input.uv.xy는 입력된 UV 좌표이며, _BaseMap_ST.xy는 텍스처 타일링(scale)을 나타내고,
                    // _BaseMap_ST.zw는 오프셋을 나타냅니다.
                    // 따라서, 기본 UV 좌표에 타일링 및 오프셋을 적용하여 최종적으로 텍스처 좌표를 결정합니다.
                    float2 baseMapUV = input.uv.xy * _BaseMap_ST.xy + _BaseMap_ST.zw;

                    // SAMPLE_TEXTURE2D 함수를 사용하여 텍스처를 샘플링합니다.
                    // _BaseMap은 텍스처 리소스, sampler_BaseMap은 해당 텍스처를 샘플링하는 샘플러입니다.
                    // baseMapUV는 변환된 UV 좌표입니다.
                    // 이 과정에서 지정된 텍스처 좌표를 기준으로 텍스처 색상을 가져옵니다.
                    float4 texColor = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, baseMapUV);

                    // 텍스처 색상과 기본 색상을 곱하여 최종 색상을 계산합니다.
                    // _BaseColor는 머티리얼에서 설정된 색상이며, 이를 텍스처 샘플링 결과와 곱하여 결과적으로
                    // 텍스처와 색상이 결합된 최종 색상을 생성합니다.
                    float4 finalColor = texColor * _BaseColor;

                    // 최종 계산된 색상을 출력합니다. SV_Target은 이 값이 픽셀 셰이더의 출력으로 화면에 렌더링된다는 것을 의미합니다.
                    return finalColor;
                }

                ENDHLSL
            }
        }
}

참고

“Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl“

#ifndef UNIVERSAL_PIPELINE_CORE_INCLUDED
#define UNIVERSAL_PIPELINE_CORE_INCLUDED

// 현재 URP에서는 가상 텍스처링(Virtual Texturing)을 지원하지 않으므로,
// 가상 텍스처링을 사용하는 셰이더가 일반 텍스처 샘플링으로 대체되도록 강제합니다.
#define FORCE_VIRTUAL_TEXTURING_OFF 1

// 포워드 플러스(Forward+) 렌더링이 활성화된 경우와 그렇지 않은 경우에 따라
// 추가 조명을 지원하는지 여부와 포워드 플러스 사용 여부를 설정합니다.
#if defined(_FORWARD_PLUS)
#define _ADDITIONAL_LIGHTS 1
#undef _ADDITIONAL_LIGHTS_VERTEX
#define USE_FORWARD_PLUS 1
#else
#define USE_FORWARD_PLUS 0
#endif

// URP와 관련된 공통 헤더 파일들을 포함합니다.
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Packing.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Version.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl"

// Z-버퍼의 방향과 관련된 매크로 정의
#if UNITY_REVERSED_Z
    // Z-버퍼가 반전된 경우에 대한 처리입니다. 
    // GL과 D3D의 경우 Z-값의 클립 범위를 조정합니다.
    #if (defined(SHADER_API_GLCORE) && !defined(SHADER_API_SWITCH)) || defined(SHADER_API_GLES) || defined(SHADER_API_GLES3)
        // GL에서는 Z-클립 범위가 [near, -far]이므로, 이를 [0, far]로 변환합니다.
        #define UNITY_Z_0_FAR_FROM_CLIPSPACE(coord) max((coord - _ProjectionParams.y)/(-_ProjectionParams.z-_ProjectionParams.y)*_ProjectionParams.z, 0)
    #else
        // D3D에서는 Z-클립 범위가 [near, 0]이므로, 이를 [0, far]로 변환합니다.
        // max를 사용하는 것은 경사 행렬의 경우 근접 평면이 올바르지 않거나 의미가 없을 때를 대비합니다.
        #define UNITY_Z_0_FAR_FROM_CLIPSPACE(coord) max(((1.0-(coord)/_ProjectionParams.y)*_ProjectionParams.z),0)
    #endif
#elif UNITY_UV_STARTS_AT_TOP
    // D3D에서는 Z-클립 범위가 [0, far]이므로, 추가적인 변환이 필요하지 않습니다.
    #define UNITY_Z_0_FAR_FROM_CLIPSPACE(coord) (coord)
#else
    // OpenGL에서는 Z-클립 범위가 [-near, far]이므로, 이를 [0, far]로 변환합니다.
    #define UNITY_Z_0_FAR_FROM_CLIPSPACE(coord) max(((coord + _ProjectionParams.y)/(_ProjectionParams.z+_ProjectionParams.y))*_ProjectionParams.z, 0)
#endif

// 스테레오 렌더링 관련 매크로 정의
#if defined(UNITY_STEREO_INSTANCING_ENABLED) || defined(UNITY_STEREO_MULTIVIEW_ENABLED)
    // 스테레오 렌더링이 활성화된 경우, 텍스처를 배열로 처리합니다.
    #define SLICE_ARRAY_INDEX   unity_StereoEyeIndex

    // 스테레오 렌더링 시 사용하는 텍스처 배열 매크로 정의
    #define TEXTURE2D_X(textureName)                                        TEXTURE2D_ARRAY(textureName)
    #define TEXTURE2D_X_PARAM(textureName, samplerName)                     TEXTURE2D_ARRAY_PARAM(textureName, samplerName)
    #define TEXTURE2D_X_ARGS(textureName, samplerName)                      TEXTURE2D_ARRAY_ARGS(textureName, samplerName)
    #define TEXTURE2D_X_HALF(textureName)                                   TEXTURE2D_ARRAY_HALF(textureName)
    #define TEXTURE2D_X_FLOAT(textureName)                                  TEXTURE2D_ARRAY_FLOAT(textureName)

    #define LOAD_TEXTURE2D_X(textureName, unCoord2)                         LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, SLICE_ARRAY_INDEX)
    #define LOAD_TEXTURE2D_X_LOD(textureName, unCoord2, lod)                LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, SLICE_ARRAY_INDEX, lod)
    #define SAMPLE_TEXTURE2D_X(textureName, samplerName, coord2)            SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, SLICE_ARRAY_INDEX)
    #define SAMPLE_TEXTURE2D_X_LOD(textureName, samplerName, coord2, lod)   SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, SLICE_ARRAY_INDEX, lod)
    #define GATHER_TEXTURE2D_X(textureName, samplerName, coord2)            GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, SLICE_ARRAY_INDEX)
    #define GATHER_RED_TEXTURE2D_X(textureName, samplerName, coord2)        GATHER_RED_TEXTURE2D(textureName, samplerName, float3(coord2, SLICE_ARRAY_INDEX))
    #define GATHER_GREEN_TEXTURE2D_X(textureName, samplerName, coord2)      GATHER_GREEN_TEXTURE2D(textureName, samplerName, float3(coord2, SLICE_ARRAY_INDEX))
    #define GATHER_BLUE_TEXTURE2D_X(textureName, samplerName, coord2)       GATHER_BLUE_TEXTURE2D(textureName, samplerName, float3(coord2, SLICE_ARRAY_INDEX))

#else
    // 스테레오 렌더링이 비활성화된 경우, 일반적인 2D 텍스처 샘플링 매크로 정의
    #define SLICE_ARRAY_INDEX       0

    #define TEXTURE2D_X(textureName)                                        TEXTURE2D(textureName)
    #define TEXTURE2D_X_PARAM(textureName, samplerName)                     TEXTURE2D_PARAM(textureName, samplerName)
    #define TEXTURE2D_X_ARGS(textureName, samplerName)                      TEXTURE2D_ARGS(textureName, samplerName)
    #define TEXTURE2D_X_HALF(textureName)                                   TEXTURE2D_HALF(textureName)
    #define TEXTURE2D_X_FLOAT(textureName)                                  TEXTURE2D_FLOAT(textureName)

    #define LOAD_TEXTURE2D_X(textureName, unCoord2)                         LOAD_TEXTURE2D(textureName, unCoord2)
    #define LOAD_TEXTURE2D_X_LOD(textureName, unCoord2, lod)                LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)
    #define SAMPLE_TEXTURE2D_X(textureName, samplerName, coord2)            SAMPLE_TEXTURE2D(textureName, samplerName, coord2)
    #define SAMPLE_TEXTURE2D_X_LOD(textureName, samplerName, coord2, lod)   SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)
    #define GATHER_TEXTURE2D_X(textureName, samplerName, coord2)            GATHER_TEXTURE2D(textureName, samplerName, coord2)
    #define GATHER_RED_TEXTURE2D_X(textureName, samplerName, coord2)        GATHER_RED_TEXTURE2D(textureName, samplerName, coord2)
    #define GATHER_GREEN_TEXTURE2D_X(textureName, samplerName, coord2)      GATHER_GREEN_TEXTURE2D(textureName, samplerName, coord2)
    #define GATHER_BLUE_TEXTURE2D_X(textureName, samplerName, coord2)       GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2)
#endif

///
/// 텍스처 샘플링 매크로 오버라이드: 스케일링 지원
///
/// mip bias가 지원되는 플랫폼에서는 모든 2D 텍스처 샘플링 작업을 글로벌 mip bias 기능을 지원하도록 재정의합니다.
/// 이 기능은 이미지 스케일링이 활성화된 경우 렌더링 품질을 향상시키기 위해 사용됩니다.
/// 최종 이미지 해상도에 따라 mip 레벨을 선택할 수 있도록 mip lod 계산에 bias 값을 추가합니다.

#ifdef PLATFORM_SAMPLE_TEXTURE2D_BIAS
    #ifdef  SAMPLE_TEXTURE2D
        #undef  SAMPLE_TEXTURE2D
        #define SAMPLE_TEXTURE2D(textureName, samplerName, coord2) \
            PLATFORM_SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2,  _GlobalMipBias.x)
    #endif
    #ifdef  SAMPLE_TEXTURE2D_BIAS
        #undef  SAMPLE_TEXTURE2D_BIAS
        #define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias) \
            PLATFORM_SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2,  (bias + _GlobalMipBias.x))
    #endif
#endif

#ifdef PLATFORM_SAMPLE_TEXTURE2D_GRAD
    #ifdef  SAMPLE_TEXTURE2D_GRAD
        #undef  SAMPLE_TEXTURE2D_GRAD
        #define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy) \
            PLATFORM_SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, (dpdx * _GlobalMipBias.y), (dpdy * _GlobalMipBias.y))
    #endif
#endif

#ifdef PLATFORM_SAMPLE_TEXTURE2D_ARRAY_BIAS
    #ifdef  SAMPLE_TEXTURE2D_ARRAY
        #undef  SAMPLE_TEXTURE2D_ARRAY
        #define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index) \
            PLATFORM_SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, _GlobalMipBias.x)
    #endif
    #ifdef  SAMPLE_TEXTURE2D_ARRAY_BIAS
        #undef  SAMPLE_TEXTURE2D_ARRAY_BIAS
        #define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias) \
            PLATFORM_SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, (bias + _GlobalMipBias.x))
    #endif
#endif

#ifdef PLATFORM_SAMPLE_TEXTURECUBE_BIAS
    #ifdef  SAMPLE_TEXTURECUBE
        #undef  SAMPLE_TEXTURECUBE
        #define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3) \
            PLATFORM_SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, _GlobalMipBias.x)
    #endif
    #ifdef  SAMPLE_TEXTURECUBE_BIAS
        #undef  SAMPLE_TEXTURECUBE_BIAS
        #define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias) \
            PLATFORM_SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, (bias + _GlobalMipBias.x))
    #endif
#endif

#ifdef PLATFORM_SAMPLE_TEXTURECUBE_ARRAY_BIAS
    #ifdef  SAMPLE_TEXTURECUBE_ARRAY
        #undef  SAMPLE_TEXTURECUBE_ARRAY
        #define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)\
            PLATFORM_SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, _GlobalMipBias.x)
    #endif

    #ifdef  SAMPLE_TEXTURECUBE_ARRAY_BIAS
        #undef  SAMPLE_TEXTURECUBE_ARRAY_BIAS
        #define SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, bias)\
            PLATFORM_SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, (bias + _GlobalMipBias.x))
    #endif
#endif

// 글로벌 mip bias 곱셈기
#define VT_GLOBAL_MIP_BIAS_MULTIPLIER (_GlobalMipBias.y)

// 구조체 정의
// 정점의 위치 정보를 담는 구조체입니다.
struct VertexPositionInputs
{
    float3 positionWS; // 월드 공간에서의 위치
    float3 positionVS; // 뷰 공간에서의 위치
    float4 positionCS; // 동차 클립 공간에서의 위치
    float4 positionNDC;// 동차 정규화된 장치 좌표
};

// 정점의 법선 정보를 담는 구조체입니다.
struct VertexNormalInputs
{
    real3 tangentWS;   // 월드 공간에서의 탄젠트 벡터
    real3 bitangentWS; // 월드 공간에서의 비탄젠트 벡터
    float3 normalWS;   // 월드 공간에서의 법선 벡터
}

// 추가적인 셰이더 변수와 함수 정의를 포함한 헤더 파일들
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderVariablesFunctions.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Deprecated.hlsl"

#endif

“Packages/com.unity.render-pipelines.core/ShaderLibrary/SpaceTransforms.hlsl”

#ifndef UNITY_SHADER_VARIABLES_FUNCTIONS_INCLUDED
#define UNITY_SHADER_VARIABLES_FUNCTIONS_INCLUDED

#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/SpaceTransforms.hlsl"

// 주의: '_WorldSpaceCameraPos'는 Unity의 레거시 코드에 의해 설정됩니다.
float3 GetPrimaryCameraPosition()
{
#if (SHADEROPTIONS_CAMERA_RELATIVE_RENDERING != 0)
    // 카메라 상대 렌더링이 활성화된 경우, 카메라 위치는 (0, 0, 0)으로 간주합니다.
    return float3(0, 0, 0);
#else
    // 그렇지 않은 경우, 실제 월드 좌표계를 기준으로 카메라 위치를 반환합니다.
    return _WorldSpaceCameraPos;
#endif
}

// 예: 주 카메라 또는 그림자를 캐스팅하는 빛의 위치일 수 있습니다.
float3 GetCurrentViewPosition()
{
#if defined(SHADERPASS) && (SHADERPASS != SHADERPASS_SHADOWS)
    // 그림자 패스가 아닌 경우 주 카메라 위치를 반환합니다.
    return GetPrimaryCameraPosition();
#else
    // 일반적인 해결책입니다.
    // 그러나 주 카메라의 경우 '_WorldSpaceCameraPos'를 사용하는 것이 더 좋습니다. 이는 캐시 일관성에도 유리하고, 
    // 카메라 상대 렌더링이 활성화된 경우 위치를 0으로 설정할 수 있기 때문입니다.
    return UNITY_MATRIX_I_V._14_24_34;
#endif
}

// 현재 뷰의 월드 공간에서의 전방(중앙) 방향을 반환합니다.
float3 GetViewForwardDir()
{
    float4x4 viewMat = GetWorldToViewMatrix();
    return -viewMat[2].xyz;
}

// 현재 뷰가 원근 투영을 수행하는 경우 'true'를 반환합니다.
bool IsPerspectiveProjection()
{
#if defined(SHADERPASS) && (SHADERPASS != SHADERPASS_SHADOWS)
    // 그림자 패스가 아닌 경우 원근 투영 여부를 검사합니다.
    return (unity_OrthoParams.w == 0);
#else
    // TODO: 그림자 패스에서 'unity_OrthoParams'를 설정해야 합니다.
    return UNITY_MATRIX_P[3][3] == 0;
#endif
}

// 월드 공간에서의 뷰 방향을 정규화하여 계산합니다 (뷰어를 향해 있음).
float3 GetWorldSpaceNormalizeViewDir(float3 positionWS)
{
    if (IsPerspectiveProjection())
    {
        // 원근 투영인 경우
        float3 V = GetCurrentViewPosition() - positionWS;
        return normalize(V);
    }
    else
    {
        // 정사영인 경우
        return -GetViewForwardDir();
    }
}

// UNITY_MATRIX_V는 Z 축이 뷰어를 향하는 오른손 좌표계를 정의합니다.
// 이 함수는 Z 축의 방향을 반전하여(앞쪽을 향하게) 뷰 공간 좌표계를 왼손 좌표계로 만듭니다.
void GetLeftHandedViewSpaceMatrices(out float4x4 viewMatrix, out float4x4 projMatrix)
{
    viewMatrix = UNITY_MATRIX_V;
    viewMatrix._31_32_33_34 = -viewMatrix._31_32_33_34;

    projMatrix = UNITY_MATRIX_P;
    projMatrix._13_23_33_43 = -projMatrix._13_23_33_43;
}

// Z 클리핑과 관련된 부분으로, 뒤집어진 Z 버퍼를 사용하는 경우에 대한 조건부 매크로 정의
#if UNITY_REVERSED_Z
    #if (defined(SHADER_API_GLCORE) && !defined(SHADER_API_SWITCH)) || defined(SHADER_API_GLES) || defined(SHADER_API_GLES3)
        // 뒤집어진 Z를 사용하는 OpenGL에서는 클리핑 범위가 [near, -far]입니다.
        // 성능을 위해 리매핑하지 않고 그대로 사용합니다 (범위가 충분히 가깝기 때문입니다).
        #define UNITY_Z_0_FAR_FROM_CLIPSPACE(coord) max(-(coord), 0)
    #else
        // 뒤집어진 Z를 사용하는 Direct3D에서는 클리핑 범위가 [near, 0]입니다.
        // [0, far]로 리매핑합니다.
        #define UNITY_Z_0_FAR_FROM_CLIPSPACE(coord) max(((1.0-(coord)/_ProjectionParams.y)*_ProjectionParams.z),0)
    #endif
#elif UNITY_UV_STARTS_AT_TOP
    // 뒤집어진 Z를 사용하지 않는 Direct3D에서는 클리핑 범위가 [0, far]이므로 아무것도 할 필요가 없습니다.
    #define UNITY_Z_0_FAR_FROM_CLIPSPACE(coord) (coord)
#else
    // OpenGL에서는 클리핑 범위가 [-near, far]이므로 성능을 위해 리매핑하지 않고 그대로 사용합니다 (범위가 충분히 가깝기 때문입니다).
    #define UNITY_Z_0_FAR_FROM_CLIPSPACE(coord) (coord)
#endif

#endif // UNITY_SHADER_VARIABLES_FUNCTIONS_INCLUDED

The post Unity Urp Shader Vertex, Attributes, fragment Unlit 예시 appeared first on 어제와 내일의 나 그 사이의 이야기.

The post Unity UniversalRenderPipelineAsset&Data 변경 appeared first on 어제와 내일의 나 그 사이의 이야기.

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 어제와 내일의 나 그 사이의 이야기.

RGB 가산 혼합

가산 : 더하여 셈하는 것

RGB 색 모형은 빛의 삼원색을 이용하여 색을 표현하는 방식이다. 

빨강(RED), 초록(GREEN), 파랑(BLUE) 세 종류의 광원(光源)을 이용하여 색을 혼합하며 색을 섞을수록 밝아지기 때문에 ‘가산 혼합’이라고 한다.

RGB의 덧셈과 곱셈

RGB의 덧셈과 곱셈은 R은 R, G는 G, B는 B와 계산한다.

The post RGB 가산 혼합 appeared first on 어제와 내일의 나 그 사이의 이야기.

HSV(= HSB) Color

색상을 설명하는 모델

HSV(색조, 채도, 명도) 또는 HSB(색조, 채도, 밝기)는 색상을 설명하는 컬러 모델 중 하나로 아티스트 혹은 일러스트레이터들에게 매우 친숙한 컬러 모델입니다.

색상(Hue), 채도(Saturation), 명도(Value) or 밝기 (Brightness)

RGB(Red, Green, Blue) 모델과 함께 가장 널리 사용되는 컬러 모델 중 하나입니다.

Hue 색상

360도 무지개 색상

색을 표현하는 요소 중 하나로 일반적으로 0에서 360도 사이의 각도를 나타냅니다

0도와 360도는 동일한 색상인 빨간색을, 120도는 녹색을, 240도는 파란색을 나타냅니다.

Saturation 채도

풍부함(richness)과 선명함(vividness)

색의 순도 또는 강도를 나타내는 색상 속성입니다.

높은 채도는 순수한 색에 가깝고, 낮은 채도는 회색조에 가까운 색을 의미합니다.

채도는 일반적으로 0부터 100 또는 0부터 1 사이의 값으로 표현됩니다.

0% 채도는 해당 색상이 회색조에 가깝다는 것을 의미하며, 100% 채도는 해당 색상이 순수한 색상임을 나타냅니다.

Value 명도 (= Brightness 밝기)

색의 밝기

명도는 색의 밝기를 나타냅니다.

명도는 일반적으로 0부터 100 사이의 숫자로 나타내며 높을수록 색은 더 밝게 나타납니다.

명도가 0에 가까울수록 해당 색상은 검은색에 가깝고, 명도가 최대가 되면 해당 색상은 가장 밝은 상태가 됩니다.

The post HSV(= HSB) Color 정리 appeared first on 어제와 내일의 나 그 사이의 이야기.

Description

Master Stack은 셰이더의 최종 표면 모습을 정의하는 Shader Graph의 끝점입니다.
The Master Stack is the end point of a Shader Graph that defines the final surface appearance of a shader.

Shader Graph에는 항상 하나의 마스터 스택만 포함되어야 합니다.
Your Shader Graph should always contain only one Master Stack.

마스터 스택의 내용은 선택한 Graph Settings에 따라 변경될 수 있습니다.
The content of the Master Stack might change depending on the Graph Settings you select.

마스터 스택은 Block nodes를 포함하는 컨텍스트로 구성됩니다.
The Master Stack is made up of Contexts, which contain Block nodes.

마스터 스택에는 두 개의 컨텍스트인 Vertex와 Fragment가 포함되어 있습니다.
The Master Stack contains two Contexts: Vertex and Fragment.

이들은 shader의 두 단계를 나타냅니다.
These represent the two stages of a shader.

Vertex Context의 Block에 연결하는 노드는 최종 shader의 Vertex function의 일부가 됩니다.
Nodes that you connect to Blocks in the Vertex Context become part of the final shader’s vertex function.

Fragment Context의 블록에 연결하는 Node는 최종 shader의 Fragment(또는 픽셀) function의 일부가 됩니다.
Nodes that you connect to Blocks in the Fragment Context become part of the final shader’s fragment (or pixel) function.

두 컨텍스트에 모두 노드를 연결하면 해당 node가 Vertex function에서 한 번 실행되고 Fragment function에서 다시 한 번 실행됩니다.
If you connect any nodes to both Contexts, they are executed twice, once in the vertex function and then again in the fragment function.

컨텍스트를 잘라내거나 복사하거나 붙여넣을 수 없습니다.
You can’t cut, copy, or paste Contexts.

https://docs.unity3d.com/Packages/com.unity.shadergraph@17.0/manual/Sticky-Notes.html

Sticky Notes

Sticky Note는 그래프 보기에서 작성할 수 있는 객체로, 코드의 주석과 유사합니다. 제목(title)과 본문(body)으로 구성되어 있습니다.
Sticky Notes are objects in a graph view that you can write in. They are the graph view equivalent of a comment in code, and consist of a title and body.

그래프에서 원하는 만큼 만들 수 있으며 다음과 같은 다양한 용도로 사용할 수 있습니다:
You can create as many as you want in the graph, and use them for a variety of purposes, for example:

• 그래프의 섹션 작동 방식을 설명하는 데 사용할 수 있습니다.
  To describe how a section of your graph works.
• 유니티 프로젝트에서 공동 작업하는 사용자 또는 다른 사용자에게 메모를 남깁니다.
  To leave notes for yourself or others collaborating in your Unity Project.
• 나중에 완료할 작업을 포함하는 할 일 목록으로 사용할 수 있습니다.
  As a to-do list that includes tasks to complete at a later date.

Using Sticky Notes

Sticky Note를 만들려면 그래프 보기에서 빈 공간을 마우스 오른쪽 단추로 클릭하고 컨텍스트 메뉴에서 Create Sticky Note를 클릭합니다.
To create a Sticky Note, right-click an empty space in the graph view and, in the context menu, click Create Sticky Note.

그런 다음 새 Sticky Note에 내용을 사용자 정의하고 추가할 수 있습니다. 
You can then customize and add content to the new Sticky Note.

다음에 쓸 수 있는 텍스트 영역은 두 가지입니다:
There are two text areas that you can write in:

• 제목 : Sticky Note 상단에 있는 텍스트 영역이 제목입니다. 이를 사용하여 Sticky Note에 어떤 정보가 포함되어 있는지 간결하게 설명할 수 있습니다.
  Title: The text area at the top of the Sticky Note is the title. You can use it to concisely describe what information the Sticky Note contains.
• 본문: 제목 영역 아래에 있는 더 큰 텍스트 영역은 본문입니다. 여기에 메모의 전체 내용을 작성하시면 됩니다.
  Body: The larger text area below the title area is the body. You can write the full contents of the note here.

Editing text

Sticky Note에서 텍스트를 편집하려면 텍스트 영역을 두 번 클릭합니다.
To edit text on a Sticky Note, double-click on a text area.

또한 전체 텍스트 영역을 선택하므로 텍스트를 편집하기 전에 커서를 이동해야 합니다.
This also selects the entire text area, so be sure to move the cursor before you edit the text.

Moving and resizing

그래프의 아무 곳이나 스티커 메모를 이동할 수 있습니다.
You can move Sticky Notes anywhere on the graph.

클릭한 후 드래그하여 Sticky Note의 크기를 수동으로 조정하거나 Sticky Note가 내용에 맞게 자동으로 크기를 조정하도록 할 수도 있습니다.
You can also click and drag to manually resize Sticky Notes, or have a Sticky Note automatically resize itself to fit the content.

Sticky Note 크기를 직접 조정하는 방법에 대한 자세한 내용은 아래 Context menu 섹션의 Fit To Text를 참조하십시오.
For information on how to make the Sticky Note resize itself, see Fit To Text in the Context menu section below.

Duplicating

다음 키보드 바로 가기를 사용하여 Sticky Note를 자르고, 복사하고, 붙여넣고, 복제합니다.
Use the following keyboard shortcuts to cut, copy, paste, and duplicate Sticky Notes.

• Copy: Ctrl+C
• Cut: Ctrl+X
• Paste: Ctrl+V
• Duplicate: Ctrl+D

Context menu

Sticky Note의 컨텍스트 메뉴를 열려면 해당 메뉴의 아무 곳이나 마우스 오른쪽 단추로 클릭합니다.
To open the context menu for a Sticky Note, right-click anywhere on it.

컨텍스트 메뉴의 옵션은 다음과 같습니다.
The options in the context menu are as follows.

The post Getting started with Shader Graph – Master Stack / Sticky Notes appeared first on 어제와 내일의 나 그 사이의 이야기.

https://docs.unity3d.com/Packages/com.unity.shadergraph@17.0/manual/Create-Node-Menu.html

Description

Shader Graph에서 nodes를 생성하기 위해 Create Node Menu를 사용합니다.
Use the Create Node Menu to create nodes in Shader Graph.

노드 생성 메뉴를 열려면 Shader Graph 창의 작업 공간을 마우스 오른쪽 버튼으로 클릭하고 “Create Node”을 선택하거나, 스페이스바를 누릅니다.
To open the Create Node Menu, either right-click on the workspace in the Shader Graph Window and select Create Node, or press the spacebar.

Create Node Menu의 맨 위에는 검색 창이 있습니다.
At the top of the Create Node Menu is a search bar.

node를 검색하려면 검색 필드에 이름의 일부를 입력하십시오.
To search for a node, type any part of its name in the search field.

검색 상자는 자동 완성 옵션을 제공하며, 예측 텍스트를 수락하려면 Tab을 누르십시오.
The search box gives you autocomplete options, and you can press Tab to accept the predictive text.

일치하는 텍스트를 노란색으로 강조합니다.
It highlights matching text in yellow.

Create Node Menu lists에는 기능별로 분류된 Shader Graph에서 사용 가능한 모든 노드가 나열됩니다.
The Create Node Menu lists all nodes that are available in Shader Graph, categorized by their function.

사용자가 작성한 Sub Graphs는 서브 그래프 에셋 하위의 Create Node Menu에서 사용할 수 있으며, Sub Graph Assets에서 정의한 사용자 지정 카테고리에도 사용할 수 있습니다.
User-created Sub Graphs are also available in the Create Node Menu under Sub Graph Assets, or in a custom category that you define in the Sub Graph Asset.

작업 공간에 노드를 추가하려면 Create Node Menu에서 해당 노드를 두 번 클릭하십시오.
To add a node to the workspace, double-click it in the Create Node Menu.

Contextual Create Node Menu

컨텍스트에 맞는 Create Node Menu는 사용 가능한 노드를 필터링하고 선택한 엣지의 Data Type을 사용하는 노드만 표시합니다.
A contextual Create Node Menu filters the available nodes, and only shows those that use the Data Type of a selected edge.

해당 Data Type과 일치하는 노드의 모든 사용 가능한 Port를 나열합니다.
It lists every available Port on nodes that match that Data Type.

컨텍스트에 맞는  Create Node Menu를 열려면 포트에서 Edge를 클릭하고 드래그한 다음 작업 공간의 빈 영역에 놓으면 됩니다.
To open a contextual Create Node Menu, click and drag an Edge from a Port, and then release it in an empty area of the workspace.

Master Stack Create Node Menu

새로운 Block Node를 Master Stack에 추가하려면 마우스 오른쪽 버튼을 클릭하고 “Create Node“을 선택하거나 스택을 선택한 상태에서 스페이스바를 누르세요.
To add a new Block Node to the Master Stack, either right click and select Create Node or press spacebar with the stack selected.

“Create Node Menu“는 프로젝트의 렌더 파이프라인을 기반으로 마스터 스택에 사용 가능한 모든 블록을 표시합니다.
The Create Node Menu will display all available blocks for the master stack based on the render pipelines in your project.

“Create Node Menu“를 통해 마스터 스택에 어떤 블록이든 추가할 수 있습니다.
Any block can be added to the master stack via the Create Node Menu.

추가된 block이 현재 Graph settings과 호환되지 않는 경우, 해당 block은 설정이 지원될 때까지 비활성화됩니다.
If the block added is not compatible with the current Graph settings, the block will be disabled until the settings are configured to support it.

The post Getting started with Shader Graph – Create Node Menu appeared first on 어제와 내일의 나 그 사이의 이야기.

https://docs.unity3d.com/Packages/com.unity.shadergraph@17.0/manual/Shader-Graph-Window.html

Description

Shader Graph Window에는Shader Graph 시스템을 사용하여 셰이더를 생성하는 작업 공간이 포함되어 있습니다.
The Shader Graph Window contains the workspace for creating shaders using the Shader Graph system.

Shader Graph Window을 열려면 먼저 Shader Graph Asset을 생성해야 합니다. 자세한 정보는 시작하기 섹션을 참조하십시오.
To open the Shader Graph Window you must first create a Shader Graph Asset. For more information see the Getting Started section.

Title Bar

Title Bar는 Shader Graph Window 상단에 위치하며 Graph에 수행할 수 있는 작업을 포함하고 있습니다.
The title bar at the top of the Shader Graph Window contains actions that can be performed on the Graph.

Item	Description
Save Asset	Shader Graph Asset을 업데이트하기 위해 그래프를 저장합니다. Saves the graph to update the Shader Graph Asset
Save As	새 이름으로 Shader Graph Asset을 저장할 수 있는 파일 대화 상자를 엽니다. Opens a file dialog that allows the user to save out the Shader Graph Asset under a new name.
Show In Project	Project Window에서 Shader Graph Asset을 강조 표시합니다. Highlights the Shader Graph Asset in the Project Window
Check Out	버전 관리가 활성화된 경우, 소스 제어 공급자로부터 Shader Graph Asset을 체크아웃합니다. If version control is enabled, this will check out the Shader Graph Asset from the source control provider.
Color Mode	그래프의 Color Mode를 선택할 수 있는 드롭다운 메뉴를 제공합니다. Provides the drop down menu to select a Color Mode for the graph.
Blackboard	Blackboard의 가시성을 전환합니다. Toggles visibility of the Blackboard.
Graph Inspector	Graph Inspector의 가시성을 전환합니다. Toggles visibility of the Graph Inspector.
Main Preview	Main Preview의 가시성을 전환합니다. Toggles visbility of the Main Preview.

Workspace

Workspace는 Node networks를 생성하는 곳입니다.
The workspace is where you create Node networks.

Alt 키를 누른 채로 왼쪽 마우스 버튼을 눌러서 마우스 스크롤 휠로 패닝 및 줌할 수 있습니다.
You can navigate the workspace by holding Alt and left mouse button to pan and zoom with the scroll wheel.

마우스 왼쪽 버튼을 누른 채로 드래그하여 마르키를 사용하여 여러 Nodes를 선택할 수 있습니다.
You can hold left mouse button and drag to select multiple Nodes with a marquee.
(“마르키(marquee)”는 그래픽 사용자 인터페이스에서 여러 항목을 선택하는 방법을 설명하는 용어)

더 나은 워크플로를 위해 다양한 바로 가기 키도 사용할 수 있습니다.
There are also various shortcut keys to use for better workflow.

Context Menu

작업 공간 내에서 마우스 오른쪽 버튼을 클릭하면 컨텍스트 메뉴가 열립니다.
Right clicking within the workspace will open a context menu.

작업 공간 내의 항목(예: Node)을 마우스 오른쪽 버튼으로 클릭하면 해당 항목의 컨텍스트 메뉴가 열리며 작업 공간의 메뉴가 열리지 않음에 유의하세요.
Note that right clicking on an item within the workspace, such as a Node, will open the context menu for that item and not the workspace.

https://docs.unity3d.com/Packages/com.unity.shadergraph@17.0/manual/Blackboard.html

Description

Blackboard를 사용하여 그래프의  Properties 및 Keywords를 정의, 정렬 및 분류할 수 있습니다.
You can use the Blackboard to define, order, and categorize the Properties and Keywords in a graph.

Blackboard에서 선택한 Shader Graph 에셋 또는 Sub Graph의 경로도 편집할 수 있습니다.
From the Blackboard, you can also edit the path for the selected Shader Graph Asset or Sub Graph.

Accessing the Blackboard

Blackboard는 기본적으로 표시되며, 그래프에서 끌어내려서 분실할 수 없습니다.
The Blackboard is visible by default, and you cannot drag it off the graph and lose it.

하지만, 블랙보드를 Shader Graph Window. 의 어디든 위치시킬 수 있습니다.
However, you are able to position it anywhere in the Shader Graph Window.

창 크기를 조정하더라도 블랙보드는 항상 가장 가까운 모퉁이로부터 동일한 거리를 유지합니다.
It always maintains the same distance from the nearest corner, even if you resize the window.

Adding properties and keywords to the Blackboard

새로운 속성 또는 키워드를 생성하려면 블랙보드의 제목 표시줄에 있는 추가 Add (+) 버튼을 클릭하고 유형을 선택하십시오.
To create a new property or keyword, click the Add (+) button on the Blackboard’s title bar and select a type.

속성 유형의 전체 목록은 “Property Types“을 참조하십시오.
For a full list of property types, see Property Types.

Editing properties and keywords

Blackboard 또는 Graph에서 속성 또는 키워드를 선택하여 노드 설정 메뉴에서 설정을 수정합니다.
Select a property or keyword in the Blackboard or graph to modify its settings in the Node Settings Menu.

Modifying and selecting keywords and properties

• 블랙보드에 나열된 항목의 순서를 변경하려면 해당 항목을 끌어다 놓으십시오.
  To reorder items listed on the Blackboard, drag and drop them.
• 항목을 삭제하려면 Windows에서는 Delete 키를 누르거나 macOS에서는 Command + Backspace 키를 사용하십시오.
  To delete items, use the Delete key on Windows or Command + Backspace keys on macOS.
• 여러 항목을 선택하려면 선택을 하면서 Ctrl 키를 누르십시오.
  To select multiple items, hold down the Ctrl key while making your selections.
• 하나 또는 여러 항목의 선택을 취소하려면 해당 항목을 클릭하면서 Ctrl 키를 누른 채로 제거하려는 항목을 클릭하십시오.
  To cancel the selection of one or multiple items, hold down the Ctrl key while clicking on the items you want to remove from the selection.

Using Blackboard categories

셰이더의 속성을 더 쉽게 검색하려면 categories로 구성하십시오.
To make the properties in your shader more discoverable, organize them into categories.

범주를 확장하고 축소하여 Blackboard을 더 쉽게 탐색할 수 있습니다.
Expand and collapse categories to make the Blackboard easier to navigate.

Creating, renaming, moving, and deleting categories

• 카테고리를 추가하려면 Blackboard에서 +를 사용하십시오.
  To add a category, use + on the Blackboard.
• 카테고리 이름을 바꾸려면 카테고리 이름을 두 번 클릭하거나 오른쪽 클릭하여 Rename을 선택하십시오.
  To rename a category, double-click on the category name, or right-click and select Rename.
• Blackboard 내에서 카테고리를 이동하려면 해당 카테고리를 선택하고 드래그하십시오.
  To move a category within the Blackboard, select and drag it.
• 카테고리를 제거하려면 해당 카테고리를 선택한 후 Delete를 누르거나 오른쪽 클릭하여 Delete를 선택하십시오.
  To remove a category, select it and press Delete, or right-click and select Delete.
  카테고리를 삭제하면 해당 카테고리 내의 속성도 삭제되므로 보관하려는 속성을 옮기십시오.
  Deleting a category also deletes the properties within it, so move those you wish to keep.

Adding, removing, and reordering properties and keywords

• 카테고리에 속성이나 키워드를 추가하려면 펼침 기호 (⌄)로 해당 카테고리를 확장한 다음 속성이나 키워드를 확장된 카테고리로 끌어다 놓으십시오.
  To add a property or keyword to a category, expand the category with the foldout (⌄) symbol, then drag and drop the property or keyword onto the expanded category.
• 속성이나 키워드를 제거하려면 해당 항목을 선택하고 Delete를 누르거나 오른쪽 클릭하여 Delete를 선택하십시오.
  To remove a property or keyword, select it and press Delete, or right-click and select Delete.
• 속성이나 키워드의 순서를 변경하려면 해당 카테고리 내에서 드래그하여 끌어다 놓거나 다른 카테고리로 이동시키십시오.
  To re-order properties or keywords, drag and drop them within a category or move them into other categories.

Creating a category for specific properties and keywords

여러 속성 또는 키워드를 선택하고 Blackboard에서 +를 사용하여 선택한 모든 항목을 포함하는 카테고리를 만듭니다.
Select multiple properties or keywords and use + on the Blackboard to create a category that contains all of the items you have selected.

Copying and pasting categories, with or without properties

빈 카테고리, 모든 속성을 포함한 카테고리 및 일부 속성을 포함한 카테고리를 하나 이상의 그래프로 복사 및 붙여넣기할 수 있습니다.
You can paste empty categories, categories with all of their properties, and categories with some of their properties into one or more graphs.

모든 속성을 포함한 카테고리를 복사하려면:
To copy a category with all of its properties:

1. 해당 속성을 선택하십시오.
   Select the property.
2. Ctrl+C를 사용하여 복사하십시오.
   Copy it with Ctrl+C.
3. Ctrl+V로 대상 그래프에 붙여넣으십시오.
   Paste it into your target graph with Ctrl+V.

특정 속성 집합을 복사하려면:
To copy a specific set of properties:

1. 해당 카테고리를 선택하십시오.
   Select the category.
2. Ctrl 키를 누른 상태로 유지하십시오.
   Hold down the Ctrl key.
3. 포함하지 않을 속성을 클릭하여 선택을 제거하십시오.
   Click the properties you do not want to include to remove them from the selection.
4. Ctrl+C를 사용하여 속성을 복사하십시오.
   Copy the property with Ctrl+C.
5. Ctrl+V를 사용하여 대상 그래프에 붙여넣으십시오.
   Paste it into your target graph with Ctrl+V.

Using categories in the Material Inspector

Shader Graph로 만든 재료를 수정하려면 재료 검사기에서 특정 속성 또는 키워드 값을 조정하거나 그래프 자체를 편집할 수 있습니다.
To modify a material you have created with a Shader Graph, you can adjust specific property or keyword values in the Material Inspector, or edit the graph itself.

Working with Streaming Virtual Textures

Streaming Virtual Texture Properties은 샘플 텍스처 레이어를 나타냅니다.
Streaming Virtual Texture Properties sample texture layers.

이러한 레이어에 액세스하려면 머티리얼 인스펙터에서 해당 이름 옆의 ⌄ 기호로 관련 Virtual Texture section을 확장하십시오.
To access these layers in the Material Inspector, expand the relevant Virtual Texture section with the ⌄ symbol next to its name.

인스펙터를 통해 레이어를 추가하거나 제거할 수 있습니다.
You can add and remove layers via the Inspector.

Exposing properties and keywords

Unity는 기본적으로 속성과 키워드를 노출시킵니다.
Unity exposes properties and keywords by default.

스크립트에서 쓰기 액세스가 가능하므로 그래프 외에도 C# API를 통해 스크립트를 편집할 수 있습니다.
This enables write access from scripts, so that you can edit them via the C# API, in addition to the graph.

노출된 항목은 레이블에 녹색 점이 있습니다.
Exposed items have a green dot in their label.

이 기능을 Node Settings 메뉴에서 활성화 또는 비활성화할 수 있습니다.
Enable or disable this feature in the Node Settings menu.

Creating nodes

Blackboard에서 속성이나 키워드를 끌어다 그래프에 놓으면 해당 종류의 노드가 생성됩니다.
Drag a property or keyword from the Blackboard into the graph to create a node of that kind.

그래프에서 노드의 설정은 Blackboard에서 해당 속성이나 키워드에 대한 설정과 동일합니다.
Settings for a node in the graph are identical to those for the related property or keyword in the Blackboard.

이러한 노드를 확장하여 속성 값의 하위 멤버를 사용할 수 있습니다.
Expand these nodes to use a sub-member of the property value.

노드 이름에는 노출된 속성인 경우 녹색 점이 포함됩니다.
Property node names include a green dot if the property is exposed.

Description

The Main Preview displays a representation of the shader on the active Render Pipeline.
Main Preview는 Render Pipeline에서 셰이더의 표현을 표시합니다.

It updates in real-time and automatically updates to display any changes you make in the Shader Graph.
실시간으로 업데이트되며 Shader Graph에서 만든 변경 사항을 자동으로 업데이트하여 표시합니다.

The title bar of the Main Preview displays the name of the current shader.
Main Preview의 제목 표시줄에는 현재 셰이더의 이름이 표시됩니다.

The Main Preview can be moved to anywhere in the Shader Graph Window and will automatically move with the nearest corner of that window.
Main Preview는 Shader Graph Window에서 어디든지 이동할 수 있으며 해당 창의 가장 가까운 모퉁이로 자동으로 이동합니다.

Description

Graph Inspector를 사용하면 Shader Graph Asset의 선택 가능한 그래프 요소 및 그래프 전역 설정과 상호 작용할 수 있습니다.
The Graph Inspector makes it possible for you to interact with any selectable graph elements and graph-wide settings for a Shader Graph Asset.

Graph Inspector를 사용하여 속성 및 기본값을 편집할 수 있습니다.
You can use the Graph Inspector to edit attributes and default values.

Graph Settings를 열 때 Graph Inspector는 기본적으로 그래프 설정 탭을 표시합니다.
When you open a Shader Graph, the Graph Inspector displays the Graph Settings tab by default.

해당 Shader Graph에 대한 그래프 전역 설정이 이 탭에 나타납니다.
Graph-wide settings for that specific Shader Graph appear in this tab.

How to use

Graph Inspector에서 해당 노드에 사용할 수 있는 설정을 표시하려면 그래프에서 노드를 선택합니다.
Select a node in the graph to display settings available for that node in the Graph Inspector.

해당 노드에 사용할 수 있는 설정이 Graph Inspector의 Node Settings에 나타납니다.
Settings available for that node appear in the Node Settings tab of the Graph Inspector.

예를 들어, 그래프 또는 Blackboard에서 속성 노드를 선택하면 Node Settings 탭에 편집할 수 있는 속성의 속성이 표시됩니다.
For example, if you select a Property node either in the graph or the Blackboard, the Node Settings tab displays attributes of the Property that you can edit.

현재 Graph Inspector와 함께 작동하는 그래프 요소:
Graph elements that currently work with the Graph Inspector:

• Properties

• Keywords

• Custom Function nodes

• Subgraph Output nodes

• Per-node precision

현재 Graph Inspector와 함께 작동하지 않는 그래프 요소:
Graph elements that currently do not work with the Graph Inspector:

• Edges
• Sticky Notes
• Groups

Material Override

그래프 설정에서 Allow Material Override 옵션을 사용하면 재료 검사기를 통해 특정 그래프 속성을 재정의할 수 있습니다.
Enabling the Allow Material Override option in the Graph Settings makes it possible for you to override certain graph properties via the Material Inspector.

The post Getting started with Shader Graph – Shader Graph Window appeared first on 어제와 내일의 나 그 사이의 이야기.