Define Invoker

Unity 6000.1.15f1

----

 

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

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

 

[파일]

DefineInvoker.cs

0.02MB

DefineInvokerExample.cs

0.00MB

 

 

[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