Try & Error

NiloToon 같이 만들어 보고 싶어서 NiloToon 공개 소스를 참조한 URPSimpleGenshin Shader를 좀 개조해서 기능 추가 해봄.

// Based on SimpleGenshinFacial shader
// Simplified NiloToon Shader for Unity URP

/*
CustomURPToon Shader - A simplified toon shader based on SimpleGenshinFacial
Features:
- Basic toon lighting with cel shading
- Rim lighting
- Outline rendering
- Face shadow mapping support
- Mobile optimized
*/

[파일]

[참조] https://github.com/NoiRC256/URPSimpleGenshinShaders

[링크] https://github.com/NoiRC256/URPSimpleGenshinShaders

[링크] https://docs.backnd.com/sdk-docs/backend/base/user/federation/example-using-gpgs2/

[링크] https://developer.android.com/games/pgs/unity/overview?hl=ko

[링크] ttps://developer.android.com/games/pgs/unity/unity-start?hl=ko

[링크] https://github.com/playgameservices/play-games-plugin-for-unity

[링크] https://nybot-house.tistory.com/99

[파일]

using UnityEngine;

#if UNITY_ANDROID || UNITY_IOS
using LunarConsolePlugin;
#endif

/// <summary>
/// 모바일 기기에서 멀티터치를 통해 LunarConsole을 활성화하는 도우미 클래스
/// </summary>
public class LunarConsoleAssist : MonoBehaviour
{
    [Header("Touch Settings")]
    [SerializeField, Range(2, 5)]
    private int requiredFingers = 3;

    [SerializeField, Range(0.1f, 2.0f)]
    private float requiredHoldTime = 0.3f;

    [Header("Debug")]
    [SerializeField]
    private bool enableDebugLog = false;

    private float currentHoldTimer;
    private bool isConsoleShown;

    // 성능 최적화를 위한 캐싱
    private Touch[] cachedTouches;

    private void Awake()
    {
        // 필요한 경우에만 초기화
#if !(UNITY_ANDROID || UNITY_IOS) || UNITY_EDITOR
        if (enableDebugLog)
            Debug.LogWarning("[LunarConsoleAssist] This component only works on Android/iOS devices.");
#endif
    }

    private void Update()
    {
#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
        HandleTouchInput();
#endif
    }

#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
    private void HandleTouchInput()
    {
        int touchCount = Input.touchCount;
        
        // 필요한 손가락 수가 맞는지 확인
        if (requiredFingers <= touchCount)
        {
            if (AreRequiredTouchesValid(touchCount))
            {
                currentHoldTimer += Time.unscaledDeltaTime;
                
                if (requiredHoldTime <= currentHoldTimer && !isConsoleShown)
                {
                    ShowLunarConsole();
                }
            }
            else
            {
                ResetTimer();
            }
        }
        else
        {
            ResetTimer();
        }
    }
    
    private bool AreRequiredTouchesValid(int touchCount)
    {
        // 성능 최적화: 필요한 터치만 확인
        int validTouchCount = 0;
        
        for (int i = 0; i < touchCount && validTouchCount < requiredFingers; i++)
        {
            TouchPhase phase = Input.touches[i].phase;
            
            if (IsTouchPhaseValid(phase))
            {
                validTouchCount++;
            }
        }
        
        return requiredFingers <= validTouchCount;
    }
    
    private bool IsTouchPhaseValid(TouchPhase phase)
    {
        return phase == TouchPhase.Began || 
               phase == TouchPhase.Stationary || 
               phase == TouchPhase.Moved;
    }
    
    private void ShowLunarConsole()
    {
        try
        {
            LunarConsole.Show();
            isConsoleShown = true;
            
            if (enableDebugLog)
                Debug.Log("[LunarConsoleAssist] Console activated!");
                
            ResetTimer();
        }
        catch (System.Exception e)
        {
            if (enableDebugLog)
                Debug.LogError($"[LunarConsoleAssist] Failed to show console: {e.Message}");
        }
    }
    
    private void ResetTimer()
    {
        currentHoldTimer = 0f;
        isConsoleShown = false;
    }
#endif

#if UNITY_EDITOR
    private void OnValidate()
    {
        // 에디터에서 값 검증
        requiredFingers = Mathf.Clamp(requiredFingers, 2, 5);
        requiredHoldTime = Mathf.Clamp(requiredHoldTime, 0.1f, 2.0f);
    }
#endif
}

[출처] 지인

[링크] https://docs.unity3d.com/6000.2/Documentation/Manual/scripting-symbol-reference.html

----

Platform symbols

Unity automatically defines certain symbols based on the authoring and build target platform. These are as follows:

DefineFunction

Unity Editor version symbols

Unity automatically defines certain scripting symbols based on the version of the Unity Editor that you’re currently using.

Given a version number X.Y.Z (for example, 6000.0.33), Unity exposes three global scripting symbols in the following formats: UNITY_X, UNITY_X_Y and UNITY_X_Y_Z.

Here is an example of scripting symbols exposed in Unity 6000.0.33:

DefineFunction

You can also compile code selectively based on the earliest version of Unity required to compile or execute a section of code snippet. Following the same version format describd previously (X.Y), Unity exposes one global #define in the format UNITY_X_Y_OR_NEWER (for example, UNITY_6000_0_OR_NEWER), that you can use for this purpose.

Other symbols

The other symbols Unity defines are:

DefineFunction

Note: The DEBUG symbol is predefined in C# and in Unity using the directive #if DEBUG is equivalent to #if UNITY_EDITOR || DEVELOPMENT_BUILD

Additional resources

• Test your conditionally compiled code
• Custom scripting symbols

Unity 6000.1.15f1

----

유니티 Platform Define Symbols를 직접 사용하지 않고 Invoke Class로 묶어서

내가 작성한 코드가 Define 때문에 비활성화 되어서 빌드 할 때 에러를 보게 되는 경우를 방지하기 위해 제작(Cursor AI 시킴)

[파일]

[DefineInvoker.cs]

using System;

/// <summary>
/// Unity platform define을 사용하여 플랫폼별 조건부 실행을 지원하는 클래스
/// </summary>
public static class DefineInvoker
{
    /// <summary>
    /// 메서드 체이닝을 지원하는 InvokerChain 클래스
    /// </summary>
    public class InvokerChain
    {
        /// <summary>
        /// Android 플랫폼에서만 실행되는 코드 (에디터 제외)
        /// </summary>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain Android(Action action)
        {
#if UNITY_ANDROID && !UNITY_EDITOR
            action?.Invoke();
#endif
            return this;
        }

        /// <summary>
        /// Android 플랫폼에서만 실행되는 코드 (에디터 제외, 반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T Android<T>(Func<T> func)
        {
#if UNITY_ANDROID && !UNITY_EDITOR
            return func != null ? func.Invoke() : default(T);
#else
            return default(T);
#endif
        }

        /// <summary>
        /// iOS 플랫폼에서만 실행되는 코드 (에디터 제외)
        /// </summary>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain iOS(Action action)
        {
#if UNITY_IOS && !UNITY_EDITOR
            action?.Invoke();
#endif
            return this;
        }

        /// <summary>
        /// iOS 플랫폼에서만 실행되는 코드 (에디터 제외, 반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T iOS<T>(Func<T> func)
        {
#if UNITY_IOS && !UNITY_EDITOR
            return func != null ? func.Invoke() : default(T);
#else
            return default(T);
#endif
        }

        /// <summary>
        /// Windows 플랫폼에서만 실행되는 코드
        /// </summary>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain Windows(Action action)
        {
#if UNITY_STANDALONE_WIN && !UNITY_EDITOR
            action?.Invoke();
#endif
            return this;
        }

        /// <summary>
        /// Windows 플랫폼에서만 실행되는 코드 (반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T Windows<T>(Func<T> func)
        {
#if UNITY_STANDALONE_WIN && !UNITY_EDITOR
            return func != null ? func.Invoke() : default(T);
#else
            return default(T);
#endif
        }

        /// <summary>
        /// macOS 플랫폼에서만 실행되는 코드
        /// </summary>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain macOS(Action action)
        {
#if UNITY_STANDALONE_OSX && !UNITY_EDITOR
            action?.Invoke();
#endif
            return this;
        }

        /// <summary>
        /// macOS 플랫폼에서만 실행되는 코드 (반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T macOS<T>(Func<T> func)
        {
#if UNITY_STANDALONE_OSX && !UNITY_EDITOR
            return func != null ? func.Invoke() : default(T);
#else
            return default(T);
#endif
        }

        /// <summary>
        /// Linux 플랫폼에서만 실행되는 코드
        /// </summary>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain Linux(Action action)
        {
#if UNITY_STANDALONE_LINUX && !UNITY_EDITOR
            action?.Invoke();
#endif
            return this;
        }

        /// <summary>
        /// Linux 플랫폼에서만 실행되는 코드 (반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T Linux<T>(Func<T> func)
        {
#if UNITY_STANDALONE_LINUX && !UNITY_EDITOR
            return func != null ? func.Invoke() : default(T);
#else
            return default(T);
#endif
        }

        /// <summary>
        /// WebGL 플랫폼에서만 실행되는 코드
        /// </summary>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain WebGL(Action action)
        {
#if UNITY_WEBGL && !UNITY_EDITOR
            action?.Invoke();
#endif
            return this;
        }

        /// <summary>
        /// WebGL 플랫폼에서만 실행되는 코드 (반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T WebGL<T>(Func<T> func)
        {
#if UNITY_WEBGL && !UNITY_EDITOR
            return func != null ? func.Invoke() : default(T);
#else
            return default(T);
#endif
        }

        /// <summary>
        /// Unity 에디터에서만 실행되는 코드
        /// </summary>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain Editor(Action action)
        {
#if UNITY_EDITOR
            action?.Invoke();
#endif
            return this;
        }

        /// <summary>
        /// Unity 에디터에서만 실행되는 코드 (반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T Editor<T>(Func<T> func)
        {
#if UNITY_EDITOR
            return func != null ? func.Invoke() : default(T);
#else
            return default(T);
#endif
        }

        /// <summary>
        /// Standalone 플랫폼(Windows, macOS, Linux)에서만 실행되는 코드
        /// </summary>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain Standalone(Action action)
        {
#if UNITY_STANDALONE && !UNITY_EDITOR
            action?.Invoke();
#endif
            return this;
        }

        /// <summary>
        /// Standalone 플랫폼(Windows, macOS, Linux)에서만 실행되는 코드 (반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T Standalone<T>(Func<T> func)
        {
#if UNITY_STANDALONE && !UNITY_EDITOR
            return func != null ? func.Invoke() : default(T);
#else
            return default(T);
#endif
        }

        /// <summary>
        /// 모바일 플랫폼(Android, iOS)에서만 실행되는 코드 (에디터 제외)
        /// </summary>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain Mobile(Action action)
        {
#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
            action?.Invoke();
#endif
            return this;
        }

        /// <summary>
        /// 모바일 플랫폼(Android, iOS)에서만 실행되는 코드 (에디터 제외, 반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T Mobile<T>(Func<T> func)
        {
#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
            return func != null ? func.Invoke() : default(T);
#else
            return default(T);
#endif
        }

        /// <summary>
        /// 커스텀 조건문을 사용하여 실행
        /// </summary>
        /// <param name="condition">실행 조건</param>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain When(bool condition, Action action)
        {
            if (condition)
            {
                action?.Invoke();
            }
            return this;
        }

        /// <summary>
        /// 커스텀 조건문을 사용하여 실행 (반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="condition">실행 조건</param>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T When<T>(bool condition, Func<T> func)
        {
            if (condition)
            {
                return func != null ? func.Invoke() : default(T);
            }
            return default(T);
        }
    }

    // 정적 메서드들 - 단일 플랫폼 실행용
    
    /// <summary>
    /// Android 플랫폼에서만 실행되는 코드 (에디터 제외)
    /// </summary>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain Android(Action action)
    {
#if UNITY_ANDROID && !UNITY_EDITOR
        action?.Invoke();
#endif
        return new InvokerChain();
    }

    /// <summary>
    /// Android 플랫폼에서만 실행되는 코드 (에디터 제외, 반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T Android<T>(Func<T> func)
    {
#if UNITY_ANDROID && !UNITY_EDITOR
        return func != null ? func.Invoke() : default(T);
#else
        return default(T);
#endif
    }

    /// <summary>
    /// iOS 플랫폼에서만 실행되는 코드 (에디터 제외)
    /// </summary>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain iOS(Action action)
    {
#if UNITY_IOS && !UNITY_EDITOR
        action?.Invoke();
#endif
        return new InvokerChain();
    }

    /// <summary>
    /// iOS 플랫폼에서만 실행되는 코드 (에디터 제외, 반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T iOS<T>(Func<T> func)
    {
#if UNITY_IOS && !UNITY_EDITOR
        return func != null ? func.Invoke() : default(T);
#else
        return default(T);
#endif
    }

    /// <summary>
    /// Windows 플랫폼에서만 실행되는 코드
    /// </summary>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain Windows(Action action)
    {
#if UNITY_STANDALONE_WIN && !UNITY_EDITOR
        action?.Invoke();
#endif
        return new InvokerChain();
    }

    /// <summary>
    /// Windows 플랫폼에서만 실행되는 코드 (반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T Windows<T>(Func<T> func)
    {
#if UNITY_STANDALONE_WIN && !UNITY_EDITOR
        return func != null ? func.Invoke() : default(T);
#else
        return default(T);
#endif
    }

    /// <summary>
    /// macOS 플랫폼에서만 실행되는 코드
    /// </summary>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain macOS(Action action)
    {
#if UNITY_STANDALONE_OSX && !UNITY_EDITOR
        action?.Invoke();
#endif
        return new InvokerChain();
    }

    /// <summary>
    /// macOS 플랫폼에서만 실행되는 코드 (반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T macOS<T>(Func<T> func)
    {
#if UNITY_STANDALONE_OSX && !UNITY_EDITOR
        return func != null ? func.Invoke() : default(T);
#else
        return default(T);
#endif
    }

    /// <summary>
    /// Linux 플랫폼에서만 실행되는 코드
    /// </summary>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain Linux(Action action)
    {
#if UNITY_STANDALONE_LINUX && !UNITY_EDITOR
        action?.Invoke();
#endif
        return new InvokerChain();
    }

    /// <summary>
    /// Linux 플랫폼에서만 실행되는 코드 (반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T Linux<T>(Func<T> func)
    {
#if UNITY_STANDALONE_LINUX && !UNITY_EDITOR
        return func != null ? func.Invoke() : default(T);
#else
        return default(T);
#endif
    }

    /// <summary>
    /// WebGL 플랫폼에서만 실행되는 코드
    /// </summary>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain WebGL(Action action)
    {
#if UNITY_WEBGL && !UNITY_EDITOR
        action?.Invoke();
#endif
        return new InvokerChain();
    }

    /// <summary>
    /// WebGL 플랫폼에서만 실행되는 코드 (반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T WebGL<T>(Func<T> func)
    {
#if UNITY_WEBGL && !UNITY_EDITOR
        return func != null ? func.Invoke() : default(T);
#else
        return default(T);
#endif
    }

    /// <summary>
    /// Unity 에디터에서만 실행되는 코드
    /// </summary>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain Editor(Action action)
    {
#if UNITY_EDITOR
        action?.Invoke();
#endif
        return new InvokerChain();
    }

    /// <summary>
    /// Unity 에디터에서만 실행되는 코드 (반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T Editor<T>(Func<T> func)
    {
#if UNITY_EDITOR
        return func != null ? func.Invoke() : default(T);
#else
        return default(T);
#endif
    }

    /// <summary>
    /// Standalone 플랫폼(Windows, macOS, Linux)에서만 실행되는 코드
    /// </summary>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain Standalone(Action action)
    {
#if UNITY_STANDALONE && !UNITY_EDITOR
        action?.Invoke();
#endif
        return new InvokerChain();
    }

    /// <summary>
    /// Standalone 플랫폼(Windows, macOS, Linux)에서만 실행되는 코드 (반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T Standalone<T>(Func<T> func)
    {
#if UNITY_STANDALONE && !UNITY_EDITOR
        return func != null ? func.Invoke() : default(T);
#else
        return default(T);
#endif
    }

    /// <summary>
    /// 모바일 플랫폼(Android, iOS)에서만 실행되는 코드 (에디터 제외)
    /// </summary>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain Mobile(Action action)
    {
#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
        action?.Invoke();
#endif
        return new InvokerChain();
    }

    /// <summary>
    /// 모바일 플랫폼(Android, iOS)에서만 실행되는 코드 (에디터 제외, 반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T Mobile<T>(Func<T> func)
    {
#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
        return func != null ? func.Invoke() : default(T);
#else
        return default(T);
#endif
    }

    /// <summary>
    /// 커스텀 조건문을 사용하여 실행
    /// </summary>
    /// <param name="condition">실행 조건</param>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain When(bool condition, Action action)
    {
        if (condition)
        {
            action?.Invoke();
        }
        return new InvokerChain();
    }

    /// <summary>
    /// 커스텀 조건문을 사용하여 실행 (반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="condition">실행 조건</param>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T When<T>(bool condition, Func<T> func)
    {
        if (condition)
        {
            return func != null ? func.Invoke() : default(T);
        }
        return default(T);
    }

    /// <summary>
    /// 체이닝을 시작하기 위한 메서드
    /// </summary>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain Chain()
    {
        return new InvokerChain();
    }
}

[DefineInvokerExample.cs]

using UnityEngine;

/// <summary>
/// DefineInvoker 사용 예시 클래스
/// </summary>
public class DefineInvokerExample : MonoBehaviour
{
    void Start()
    {
        // 예시 1: 단일 플랫폼 실행
        DefineInvoker.Android(() => 
        {
            Debug.Log("Android 플랫폼에서 실행됨");
            // Android 전용 코드
        });

        DefineInvoker.iOS(() => 
        {
            Debug.Log("iOS 플랫폼에서 실행됨");
            // iOS 전용 코드
        });

        DefineInvoker.Editor(() => 
        {
            Debug.Log("Unity 에디터에서 실행됨");
            // 에디터 전용 코드
        });

        // 예시 2: 메서드 체이닝 사용
        DefineInvoker.Android(() => 
            {
                Debug.Log("Android 초기화");
                InitializeAndroid();
            })
            .iOS(() => 
            {
                Debug.Log("iOS 초기화");
                InitializeiOS();
            })
            .Windows(() => 
            {
                Debug.Log("Windows 초기화");
                InitializeWindows();
            })
            .Editor(() => 
            {
                Debug.Log("에디터 초기화");
                InitializeEditor();
            });

        // 예시 3: Chain() 메서드로 시작하는 체이닝
        DefineInvoker.Chain()
            .Mobile(() => 
            {
                Debug.Log("모바일 플랫폼 공통 설정");
                SetupMobileSettings();
            })
            .Standalone(() => 
            {
                Debug.Log("PC 플랫폼 공통 설정");
                SetupDesktopSettings();
            })
            .WebGL(() => 
            {
                Debug.Log("WebGL 플랫폼 설정");
                SetupWebGLSettings();
            });

        // 예시 4: 커스텀 조건과 함께 사용
        bool isDebugBuild = Debug.isDebugBuild;
        DefineInvoker.When(isDebugBuild, () => 
        {
            Debug.Log("디버그 빌드에서만 실행되는 코드");
            EnableDebugFeatures();
        })
        .Android(() => 
        {
            Debug.Log("Android + 추가 설정");
        });

        // 예시 5: 복잡한 조건부 실행
        DefineInvoker.Chain()
            .When(Application.platform == RuntimePlatform.Android, () => 
            {
                Debug.Log("런타임에서 Android 플랫폼 확인");
            })
            .When(SystemInfo.deviceType == DeviceType.Handheld, () => 
            {
                Debug.Log("핸드헬드 기기에서 실행");
            })
            .Editor(() => 
            {
                Debug.Log("에디터에서 테스트 실행");
            });

        // 예시 6: Func 사용 (반환값 있는 함수)
        string platformName = DefineInvoker.Android(() => 
        {
            return "Android 플랫폼";
        });
        Debug.Log($"플랫폼 이름: {platformName}");

        int playerLevel = DefineInvoker.Mobile(() => 
        {
            return GetMobilePlayerLevel();
        });
        Debug.Log($"모바일 플레이어 레벨: {playerLevel}");

        // 예시 7: 여러 플랫폼에서 다른 값 반환
        string apiUrl = DefineInvoker.Android(() => "https://android-api.game.com")
                     ?? DefineInvoker.iOS(() => "https://ios-api.game.com")
                     ?? DefineInvoker.Editor(() => "https://dev-api.game.com")
                     ?? "https://default-api.game.com";
        Debug.Log($"API URL: {apiUrl}");

        // 예시 8: 조건부 값 반환
        bool isDevelopment = DefineInvoker.Editor(() => true);
        Debug.Log($"개발 모드: {isDevelopment}");
    }

    private void InitializeAndroid()
    {
        // Android 초기화 로직
        Debug.Log("Android 특화 초기화 완료");
    }

    private void InitializeiOS()
    {
        // iOS 초기화 로직
        Debug.Log("iOS 특화 초기화 완료");
    }

    private void InitializeWindows()
    {
        // Windows 초기화 로직
        Debug.Log("Windows 특화 초기화 완료");
    }

    private void InitializeEditor()
    {
        // 에디터 초기화 로직
        Debug.Log("에디터 특화 초기화 완료");
    }

    private void SetupMobileSettings()
    {
        // 모바일 공통 설정
        Debug.Log("모바일 공통 설정 적용");
        Screen.sleepTimeout = SleepTimeout.NeverSleep;
    }

    private void SetupDesktopSettings()
    {
        // 데스크탑 공통 설정
        Debug.Log("데스크탑 공통 설정 적용");
        Screen.fullScreen = true;
    }

    private void SetupWebGLSettings()
    {
        // WebGL 설정
        Debug.Log("WebGL 특화 설정 적용");
    }

    private void EnableDebugFeatures()
    {
        // 디버그 기능 활성화
        Debug.Log("디버그 기능 활성화됨");
    }

    private int GetMobilePlayerLevel()
    {
        // 모바일 플레이어 레벨 반환 예시
        return 42;
    }
}

[참조] https://docs.unity3d.com/6000.2/Documentation/Manual/scripting-symbol-reference.html

[링크] https://github.com/ColinLeung-NiloCat/UnityURPToonLitShaderExample