Unity 6 - 6000.0.32f1
Visual Effect Graph - 17.0.3

URP_VFX_Learning_Templates (2)

11. TexIndex Attribute

VFX 아티스트들은 스프라이트 시트(Sprite Sheet) 를 자주 사용합니다.

이 VFX 예제는 출력(Output) 에서 UV 옵션 을 사용하여 스프라이트 시트 를 활용하는 방법을 보여줍니다.

또한 Flipbook 설정 을 구성하는 방법과 texIndex 속성 과의 관계를 설명합니다.

Covered Aspects:

• TexIndex Attribute
• UVs Mode
• Flipbook

12. Flipbook Mode

이 VFX는 Output(출력)의 UV 모드를 Flipbook으로 설정하여 스프라이트 시트를 사용하는 방법을 보여줍니다.

또한 Flipbook Blend Frames 사용법과 Flipbook Player Block의 기본적인 활용 방법을 설명합니다.

Flipbook Blend Frames 설정을 사용하면 프레임 간 보간(Interpolation)이 적용되어 부드러운 애니메이션 효과를 얻을 수 있습니다.

Covered Aspects:

• Flipbook Player
• UVs Mode
• TexIndex Attribute

13. Flipbook Blending

이 VFX는 일반적인 프레임 블렌딩(Frame Blending)과 모션 벡터(Motion Vectors)를 이용한 프레임 블렌딩의 차이를 보여줍니다.

모션 벡터 블렌딩(Motion Vector Blending)은 프레임 간 픽셀 이동 정보를 포함한 텍스처를 활용하여 프레임 간 부드러운 전환을 구현합니다.

이 방식은 플립북의 프레임 수를 줄이거나, 슬로우 모션(Slow Motion) 애니메이션을 구현할 때 유용합니다.

Covered Aspects:

• Flipbook Player
• UVs Mode
• TexIndex Attribute

일반적인 Blend Frame은 단순한 알파 블렌딩(Alpha Blending) 방식으로, 프레임 수가 부족할 경우 끊김 현상이 발생할 수 있음.

Flipbook Player를 사용하면 자동으로 TexIndex가 증가하며 애니메이션이 진행됨.

Motion Vector Blending을 사용하면 픽셀 이동 정보를 활용하여 더욱 부드러운 전환을 구현할 수 있음.

• 이 방법은 플립북 애니메이션의 프레임 수를 줄이면서도 부드러운 모션을 유지하는 데 유용함.

14. TexIndex Advanced

이 고급 VFX는 texIndex 속성을 창의적으로 활용하는 여러 시스템으로 구성되어 있습니다.

시간(Time), 노이즈(Noise), 심지어 파티클의 위치(Position)까지 사용하여

texIndex 속성을 제어하며, 이를 통해 생동감 있는 VFX를 만듭니다.

Covered Aspects:

• Flipbook UVs
• TexIndex Attribute
• Flipbook Player

15. Pivot Attribute

피벗 속성(Pivot Attribute) 은 출력 렌더(output render) 가 파티클 위치를 기준으로 어디에서 생성되는지 를 제어합니다.

기본적으로 피벗은 파티클의 중심(Position)에 위치하지만, X, Y, Z 축을 따라 이동(offset) 시킬 수 있습니다.

피벗을 오프셋하면 스케일(크기) 조정 및 회전(rotation) 시 보다 매력적인 움직임을 만들 수 있습니다.

Covered Aspects:

• Pivot Attribute
• Angle Attribute

16. Pivot Advanced

파티클의 피벗(Pivot) 을 제어하는 것은 자연스럽고 흥미로운 움직임을 구현하는 핵심 요소입니다.

이 VFX에서는 피벗을 조작하여 꽃잎, 잎사귀, 가시 등이 자연스럽게 배치 및 애니메이션되는 과정을 보여줍니다.

또한, Shader Graph와 VFX Graph의 연동을 통해 셰이더를 제어하는 방법도 시연합니다.

Covered Aspects:

• Pivot Attribute
• Shader Graph integration
• Activation Port

17. Sample Mesh

이 VFX는 메시 샘플링(Sample Mesh) 을 활용하여 파티클을 메시 표면에 생성 하고, 메시의 버텍스 색상(Vertex Color) 을 상속 하는 방법을 보여줍니다.

또한, 메시의 버텍스 색상에 앰비언트 오클루전(Ambient Occlusion, AO) 값을 미리 베이크(Bake) 해두었으며, 이를 이용해 파티클의 색상을 설정 합니다.

Covered Aspects:

• Mesh Sampling
• Sample Mesh Operator

The post URP VFX Learning Templates (2) appeared first on 어제와 내일의 나 그 사이의 이야기.

Unity 6 - 6000.0.32f1
Visual Effect Graph - 17.0.3

URP_VFX_Learning_Templates

https://docs.unity3d.com/Packages/com.unity.visualeffectgraph@17.0/manual/index.html

1. Context&Flow

컨텍스트 및 데이터 흐름

VFX Graph에서 데이터 흐름이 어떻게 구성되는지 설명하고, 자주 사용되는 컨텍스트 블록을 개요로 제공

Covered Aspects:

• Data Flow (데이터 흐름)
• Context Block (컨텍스트 블록)

2. Spawn Context

이 VFX는 스폰 컨텍스트(Spawn Context) 와 관련된 정보를 제공하기 위한 것입니다.

스폰 컨텍스트란 무엇이며, Inspector에서 어떤 옵션을 설정할 수 있는지, 그리고 추가적으로 다음과 같은 정보를 포함합니다:

• 스폰 이벤트 속성(Spawn Event Attributes)이란 무엇인가?
• 스폰 이벤트 속성을 어떻게 설정하는가?
• 스폰 상태 연산자(Spawn State Operator)란 무엇인가?

Covered Aspects:

• Spawn Context
• Spawn Event Attributes
• Spawn State

3. Capacity Count

Capacity Count는 시스템의 파티클 메모리 할당(Memory allocation)에 사용됩니다.

이 값을 증가시키면 할당되는 메모리 양도 증가합니다.

이 용량은 최대 활성 입자 수(Max active particles) 로 볼 수 있습니다.

최대 살아있는 파티클 수에 최대한 가깝게 이 값을 설정하는 것이 좋은 방법입니다.

이 VFX는 Capacity가 무엇인지, 그리고 VFX Control을 사용하여 Capacity를 설정하는 방법을 설명합니다.

Covered Aspects:

• Capacity
• Memory allocation
• VFX Control

4. Multiple Outputs

• 출력(Context)에서 파티클을 렌더링하는 방식을 정의.
• 하나의 파티클 시스템에서 여러 개의 출력(Renderer)을 추가하여 다양한 표현 가능.
• 예: 빌보드 쿼드, 메시, 포인트, 데칼 등을 활용해 입자를 여러 방식으로 렌더링 가능.

Covered Aspects:

• Composition Mode (속성 조합 모드)
• Output Context (출력 컨텍스트)

5. Bounds

• Bounds(바운딩 박스)는 VFX가 카메라의 프러스텀(FOV) 안에 있을 때만 렌더링되도록 함.
• 바운드는 수동(Manual), 기록(Recorded), 자동(Automatic)으로 설정 가능.
• 컬링(Culling)을 활용하여 불필요한 연산을 줄여 성능 최적화 가능.

Covered Aspects:

• Bounds (바운드, 바운딩 박스 설정)
• Culling (컬링, 최적화 기법)

6. Orient Face Camera

출력이 쿼드(Quad), 메시(Mesh), 스트립(Strip) 등으로 설정된 경우, 우리는 종종 파티클의 기하학적 형태(Geometry)가 어떻게 배치되는지 제어해야 합니다.

파티클이 카메라를 바라보아야 할까요? 파티클의 전방(Forward) 방향과 위쪽(Up) 방향은 무엇일까요?

Orient 블록을 사용하면 다양한 모드를 통해 파티클의 방향을 쉽게 제어할 수 있습니다.

해당 예제는 “Face Camera Position” 모드를 사용하여 입자가 항상 카메라의 위치를 바라보도록 설정하였습니다.

Covered Aspects:

• Orient (정렬)
• AxisX, AxisY, AxisZ (축 설정)

7. Orient Fixed Axis

파티클의 출력(Quads, Meshes, Strips) 방식과 관계없이, 우리는 종종 파티클이 배치될 방향을 제어하고 싶습니다.

파티클가 카메라를 향해야 할까요?

파티클의 전방(Forward) 방향과 상향(Up-Axis)은 무엇인가요?

이때 Orient(정렬) 블록을 사용하면 쉽게 파티클의 방향을 설정할 수 있습니다.

이 예제에서는 “Fixed Axis(고정 축)” 모드를 사용하는 방법을 설명합니다.

Covered Aspects:

• Orient
• AxisX AxisY AxisZ
• Custom Attribute

8. Orient Advanced

파티클의 출력(Quads, Meshes, Strips) 방식과 관계없이, 우리는 파티클의 지오메트리 방향을 제어하고 싶을 때가 많습니다.

파티클이 카메라를 향해야 할까요?

파티클의 전방(Forward) 방향과 상향(Up-Axis)은 무엇인가요?

Orient(정렬) 블록을 사용하면 쉽게 파티클의 방향을 설정할 수 있으며, 다양한 모드를 제공합니다.

이번에는 “Advanced Mode(고급 모드)” 를 사용하는 방법을 설명합니다.

Covered Aspects:

• Orient
• AxisX AxisY AxisZ

9. Rotation & Angle

VFX Graph에서 파티클의 회전은 Angle 속성을 조정하여 컨트롤할 수 있습니다.

하지만 보다 현실적인 회전 효과를 구현하려면 Angular Velocity(각속도)를 활용하는 것이 좋습니다.

이 속성은 일반적을 Initialize Context에서 설정되며, Update Context에서 이를 통합하여 회전을 업데이트합니다.

Covered Aspects:

• Rotation
• Angle attribute
• Pivot attribute

10. Falling Coins

해당 내용은 Unity VFX Graph에서 파티클의 회전 및 물리적 움직임을 설정하는 방법을 설명합니다.

파티클의 각속도(Angular Velocity), 충돌, 위치 변화(Position Offset), 랜덤한 회전 효과 등을 적용하는 방식에 대해 다룹니다.

Covered Aspects:

• Angular Velocity
• Angle
• Update Rotation

The post URP VFX Learning Templates (1) appeared first on 어제와 내일의 나 그 사이의 이야기.

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

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

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

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

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

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

        CGPROGRAM
        #pragma surface surf Lambert noambient

        #pragma target 3.0
        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

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

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

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

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

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

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

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

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

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

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

전체 코드

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

        CGPROGRAM
        #pragma surface surf Lambert noambient alpha:fade

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

        struct Input
        {
            float2 uv_MainTex;
            float3 viewDir;
        };

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

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

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

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

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

깜빡임 속도 증가

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

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

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

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

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

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

sin(_Time.y) * 0.5 + 0.5;

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

abs(sin(_Time.y));

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

        CGPROGRAM
        #pragma surface surf Lambert noambient alpha:fade

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

        struct Input
        {
            float2 uv_MainTex;
            float3 viewDir;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

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

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

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

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

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

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

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

표면 셰이더 입력 구조

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        CGPROGRAM
        #pragma surface surf Lambert noambient alpha:fade

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

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

        void surf (Input IN, inout SurfaceOutput o)
        {

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

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

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

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

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

홀로그램 2Pass

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

        ZWrite On
        ColorMask 0

        LOD 200

        CGPROGRAM
        #pragma surface surf _NoLight
        #pragma target 3.0

        struct Input
        {
            float4 color:COLOR;
        };

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

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

        ZWrite Off

        CGPROGRAM
        #pragma surface surf Lambert noambient alpha:fade

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fresnel 공식 구현

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

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

        CGPROGRAM
        
        #pragma surface surf Lambert noambient
        #pragma target 3.0

        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };

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

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

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

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

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

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

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

표면 셰이더 입력 구조

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

반전

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

        CGPROGRAM
        
        #pragma surface surf Lambert noambient
        #pragma target 3.0

        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
            float3 viewDir;
        };

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

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

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

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

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

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

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

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

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

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

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

NormalMap 추가

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        CGPROGRAM
        #pragma surface surf _MyLight noambient  
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _BumpMap;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_BumpMap;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

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

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

        ENDCG
    }
    FallBack "Diffuse"
}

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

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

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

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

변경 전

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

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

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

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

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

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

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

        CGPROGRAM
        #pragma surface surf _MyLight noambient  
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _BumpMap;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_BumpMap;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

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

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

        ENDCG
    }
    FallBack "Diffuse"
}

pow   제곱 적용 후

Lambert 라이트 완성하기

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

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

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

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

전체 코드

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

        CGPROGRAM
        #pragma surface surf _MyLight noambient  
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _BumpMap;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_BumpMap;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

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

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

        ENDCG
    }
    FallBack "Diffuse"
}

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

s.Albedo 

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

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

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

_LightColor0.rgb

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

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

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

atten

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

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

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

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

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

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

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

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

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

atten 미적용

atten 적용

//  noambient  제거

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

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

        sampler2D _MainTex;
        sampler2D _BumpMap;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_BumpMap;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

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

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

        ENDCG
    }
    FallBack "Diffuse"
}

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

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

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

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

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

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

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

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

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

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

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

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

        struct Input
        {
            float2 uv_MainTex;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

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

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

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

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

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

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

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

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

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

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

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

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

float atten

atten ( attenuation ) 감쇠

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

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

Lambert 라이트 연산

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

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

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

        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

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

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

            return ndotl;
        }

        ENDCG
    }
    FallBack "Diffuse"
}

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

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

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

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

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

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

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

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

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

        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

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

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

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

            return ndotl;
        }

        ENDCG
    }
    FallBack "Diffuse"
}

NormalMap 적용

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

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

        sampler2D _MainTex;
        sampler2D _BumpMap;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_BumpMap;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {

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

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

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

            return ndotl;
        }

        ENDCG
    }
    FallBack "Diffuse"
}

환경광 제거

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

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

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

램버트 라이팅 초기 구조

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

        CGPROGRAM
        #pragma surface surf Lambert
        #pragma target 3.0

        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };

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

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

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

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

간단한 Blinn Phong 라이트 구현 

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

        CGPROGRAM
        #pragma surface surf BlinnPhong
        #pragma target 3.0

        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };


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

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

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

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

        CGPROGRAM
        #pragma surface surf BlinnPhong
        #pragma target 3.0

        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };


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

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

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

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

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

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

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

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

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

확인용 코드

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

        CGPROGRAM
        #pragma surface surf BlinnPhong
        #pragma target 3.0

        sampler2D _MainTex;
        float _SpecAmount;
        float _GlossAmount;

        struct Input
        {
            float2 uv_MainTex;
        };


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

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