'Unity'에 해당되는 글 93건

https://www.youtube.com/watch?v=u2EQtrdgfNs 

• 사용 이유
  • Scene에 Asset으로 불러온 아주 많은 3D Object가 있는데, 그것들이 전부 메시 컬라이더를 갖고 있었기 때문에, 그걸 한꺼번에 제거하고 싶었음
  • 응용해서 Box Collider 등 다른 것도 전부 제거

#if UNITY_EDITOR
using UnityEngine;
using UnityEditor;

public class RemoveMeshCollidersEditor : MonoBehaviour
{
    [MenuItem("Tools/Remove All Mesh Colliders")]
    public static void RemoveAllMeshColliders()
    {
        // Scene에 있는 모든 MeshCollider 컴포넌트를 찾습니다.
        MeshCollider[] meshColliders = FindObjectsOfType<MeshCollider>();

        // 각 MeshCollider를 순회하면서 제거합니다.
        foreach (MeshCollider collider in meshColliders)
        {
            DestroyImmediate(collider);
        }

        // 변동 사항을 저장합니다.
        UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(UnityEngine.SceneManagement.SceneManager.GetActiveScene());
    }
}
#endif

1. 중국어 폰트(ttf 등) 찾기
2. 일본어 폰트 변환

진위여부 확인 안됨

유니티에서의 TMP_InputField와 TMP_Text의 text 반환값은 모두 string 타입이지만, InputField에서 반환되는 text는 사용자가 입력한 값만을 포함하고, TMP_Text의 text는 추가적으로 포매팅이나 스타일에 대한 정보를 포함할 수 있습니다. 이는 TMP_Text에서 텍스트를 처리하는 방식과 관련되어 있습니다.

사용자가 "5004"라는 값을 입력했더라도, TMP_Text의 text 값을 가져오면 "\u200B5004" 또는 "5004\u200B"와 같이 보이지 않는 특수 문자가 포함된 문자열을 얻을 수 있습니다. 이 경우, int로 변환하는 과정에서 FormatException이 발생할 수 있습니다. 이는 int.Parse 또는 int.TryParse 메서드가 숫자 이외의 문자를 포함한 문자열을 int로 변환할 수 없기 때문입니다.

이 문제를 해결하려면, TMP_Text의 text에서 숫자만 추출하여 int로 변환하는 것이 필요합니다. 이를 위해서는 정규 표현식 등을 사용하여 숫자만 추출할 수 있습니다.

string inputString = _text.text;
string cleanedString = System.Text.RegularExpressions.Regex.Replace(inputString, "[^0-9]", "");

int stageIDX;
if (int.TryParse(cleanedString, out stageIDX))
{
    // stageIDX 사용 가능
}
else
{
    Debug.LogError($"Failed to parse {_text.text} to int");
}

이 코드는 _text.text에서 숫자 이외의 문자를 모두 제거한 후, 그 결과 문자열을 int로 변환하려고 시도합니다. 숫자 이외의 문자를 제거하는 것이 필요한 경우에 유용하게 사용될 수 있습니다.

• 저장용

using System.Linq;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Networking;
using Newtonsoft.Json;

public class ModuleDataDownloadTable : MonoBehaviour
{
    // Constants used for API call
    private const string KeyTable = "여기에 전체 공유된 구글 스프레드시트 번호 넣기";
    private const string KeyAuth = "여기에 구글 스프레드시트 인증 넣기(참고: https://ajh322.tistory.com/247)";
    private const string UrlFormat = "https://sheets.googleapis.com/v4/spreadsheets/{0}/values/{1}?key={2}";

    // Initialization method
    public void Init()
    {
    }

    // Coroutine for downloading table data
    public IEnumerator DownloadTable(string tableName, System.Action<string> afterAction)
    {
        Debug.LogWarning($":: Download Table : {tableName} Start");

        // Create a new web request with the appropriate URL
        using UnityWebRequest req = UnityWebRequest.Get(PickURL(tableName));
        yield return req.SendWebRequest();

        // Handle potential request errors
        if (req.result == UnityWebRequest.Result.ConnectionError || req.result == UnityWebRequest.Result.ProtocolError)
        {
            Debug.LogError(req.error);
            yield break;
        }

        // Deserialize the response and convert to JSON
        string[][] values = DeserializeResponse(req.downloadHandler.text);
        afterAction(ConvertValuesToJson(values));

        Debug.Log($":: Download Table : {tableName} Complete");
    }

    // Deserialize the HTTP response
    private string[][] DeserializeResponse(string response)
    {
        return JsonConvert.DeserializeObject<GoogleSheetClass>(response).values;
    }

    // Convert the data values to a JSON string
    private string ConvertValuesToJson(string[][] values)
    {
        Dictionary<int, string> keys = new();
        List<string> jsonObjects = new List<string>();

        for (int i = 0; i < values.Length; i++)
        {
            if (i == 0)
            {
                // Set keys from the first row of values
                SetKeys(keys, values[i]);
                continue;
            }

            // Create JSON objects from subsequent rows of values
            jsonObjects.Add(GenerateJsonObject(keys, values[i]));
        }

        return $"[{string.Join(",", jsonObjects)}]";
    }

    // Set keys for JSON objects from the first row of data
    private void SetKeys(Dictionary<int, string> keys, string[] row)
    {
        for (int i = 0; i < row.Length; i++)
        {
            keys.Add(i, row[i]);
        }
    }

    // Generate a JSON object as a string
    private string GenerateJsonObject(Dictionary<int, string> keys, string[] row)
    {
        List<string> properties = new List<string>();

        for (int i = 0; i < row.Length; i++)
        {
            if (keys[i].Contains('~')) continue;

            properties.Add($"\"{keys[i]}\":\"{row[i]}\"");
        }

        return $"{{{string.Join(",", properties)}}}";
    }

    // Form URL for HTTP request
    private string PickURL(string tableName)
    {
        return string.Format(UrlFormat, KeyTable, tableName, KeyAuth);
    }

    // Inner class to match the structure of the HTTP response for deserialization
    private class GoogleSheetClass
    {
        public string range { get; set; }
        public string majorDimension { get; set; }
        public string[][] values { get; set; }
    }
}

#region Download Table
    public bool IsTableDownloaded { get; private set; } = false;
    private async void DownloadTable()
    {
        IsTableDownloaded = false;

        this._moduleDownloadTable = this.gameObject.AddComponent<ModuleDataDownloadTable>();

        var task1 = InitializeData<DataText>(Constants.PATH_DATA_TEXT, (texts) =>
        {
            _texts = texts.ToDictionary(ele => ele.idx);
        });

        var task2 = InitializeData<DataCard>(Constants.PATH_DATA_CARD, (cards) =>
        {
            _cards = cards.ToDictionary(ele => ele.idx);
            _cardsGroup = cards.GroupBy(ele => ele.group).ToDictionary(ele => ele.Key, ele => ele.ToArray());
        });

        var task3 = InitializeData<DataCardDropGroup>(Constants.PATH_DATA_CARD_DROP_GROUP, (cardDropGroups) =>
        {
            _cardDropGroup = cardDropGroups.GroupBy(ele => ele.group_idx).ToDictionary(ele => ele.Key, ele => ele.ToArray());
        });

        var task4 = InitializeData<DataCardBuyGroup>(Constants.PATH_DATA_CARD_BUY_GROUP, (cardBuyGroups) =>
        {
            _cardBuyGroup = cardBuyGroups.GroupBy(ele => ele.group_idx).ToDictionary(ele => ele.Key, ele => ele.ToArray());
        });

        await Task.WhenAll(task1, task2, task3, task4);

        IsTableDownloaded = true;
    }
    async Task InitializeData<T>(string path, System.Action<T[]> afterDeserialize)
    {
        string cleanedPath = path.Replace("Data/", "");
        var deserializedData = await Deserialize<T>(cleanedPath);
        afterDeserialize(deserializedData);
    }
    private async Task<T[]> Deserialize<T>(string path)
    {
        // Create a task completion source.
        TaskCompletionSource<T[]> tcs = new TaskCompletionSource<T[]>();

        // Start the download table task.
        StartCoroutine(_moduleDownloadTable.DownloadTable(path, (string json) =>
        {
            // Deserialize the json data to the specific object type array.
            T[] result = JsonConvert.DeserializeObject<T[]>(json);

            // Set the result to the task completion source.
            tcs.SetResult(result);
        }));

        // Await for the task to be completed.
        T[] data = await tcs.Task;

        // Return the deserialized data.
        return data;
    }
    #endregion

원문: Visual Studio Code and Unity

Visual Studio Code는 Unity에서 C# 파일을 편집하는 데 큰 도움이 될 수 있습니다. 모든 C# 기능이 지원되며 더 많은 기능이 있습니다. 아래 화면에서 코드 색상화, 괄호 매칭, 인텔리센스, 코드렌즈 등의 기능을 확인할 수 있습니다. 그리고 이것은 시작일 뿐입니다.

계속 읽어서 Unity와 프로젝트를 최상의 경험을 얻기 위해 어떻게 설정하는지 알아보세요.

사전 요구 사항

Visual Studio Code에서 .NET 사용하기:

1. 런타임과 dotnet 명령어를 포함한 .NET SDK를 설치합니다.
2. [Windows] %PATH%의 변경 사항이 적용되도록 로그아웃하거나 Windows를 다시 시작합니다.
3. [macOS only] "일부 프로젝트가 로드하는 데 문제가 있습니다. 출력을 검토하여 자세한 내용을 확인하십시오."라는 메시지를 보지 않으려면 최신 안정된 Mono 릴리스를 설치하세요.
4. 참고: 시스템에 설치되는 이 버전의 Mono는 Unity가 설치하는 MonoDevelop 버전과 충돌하지 않습니다.
5. VS 코드 마켓플레이스에서 C# 확장 프로그램을 설치합니다.
6. VS 코드 설정 편집기에서 (Ctrl+,), C# 확장 프로그램의 Omnisharp: Use Modern Net 설정의 체크를 해제합니다. ("omnisharp.useModernNet": false).

Install Build Tools for Visual Studio (Windows only)

The C# extension no longer ships with Microsoft Build Tools so they must be installed manually.

1. Download the Build Tools for Visual Studio 2022.
2. Install the .NET desktop build tools workload. No other components are required.

Setup VS Code as Unity Script Editor

Open up Unity Preferences, External Tools, then browse for the Visual Studio Code executable as External Script Editor.

The Visual Studio Code executable can be found at /Applications/Visual Studio Code.app on macOS, %localappdata%\Programs\Microsoft VS Code\Code.exe on Windows by default.

Unity has built-in support for opening scripts in Visual Studio Code as an external script editor on Windows and macOS. Unity will detect when Visual Studio Code is selected as an external script editor and pass the correct arguments to it when opening scripts from Unity. Unity will also set up a default .vscode/settings.json with file excludes, if it does not already exist (from Unity 5.5 Release notes).

Unity version 2019.2 or above

Since 2019.2, it is required to use the Visual Studio Code Editor package. The built-in support for opening scripts from Unity and getting csproj and sln files generated has been removed.

Editing Evolved

With the solution file selected, you are now ready to start editing with VS Code. Here is a list of some of the things you can expect:

• Syntax Highlighting
• Bracket matching
• IntelliSense
• Snippets
• CodeLens
• Peek
• Go-to Definition
• Code Actions/Lightbulbs
• Go to symbol
• Hover

Two topics that will help you are Basic Editing and C#. In the image below, you can see VS Code showing hover context, peeking references and more.

Enabling code completion (For recent versions of Unity)

If you are installing VS Code for the first time, you might be missing targeting packs required for Unity's code-completion (IntelliSense) in VS Code.

Targeting pack download links:

• Windows: .NET Framework 4.7.1 Developer Pack
• macOS: Download .NET SDK

Steps:

1. Stop VS Code or Unity running.
2. Download and install the targeting pack for your targeted framework version / preferred version from one of the above links.
3. Start Unity.
4. Create and/or open an existing script in VS Code, through Unity, and you should now see code completions.

Enabling Unity warnings

Unity has a set of custom C# warnings, called analyzers, that check for common issues with your source code. These analyzers ship out of the box with Visual Studio but need to be set up manually in Visual Studio Code.

Due to how Unity handles its .csproj files, it does not seem possible to install packages automatically. You will need to download the analyzers from the NuGet website manually. Make sure to download the .nupkg file, the source code from GitHub will not work.

When you're done, open the package file using a tool such as 7zip and extract Microsoft.Unity.Analyzers.dll onto your project's root folder. You can place it inside a folder named NuGet, for example. Do not place it inside Assets or Packages, as that will cause Unity to try to process the .dll, which will make it output an error in the console.

Note: 7zip cannot open a .nupkg file by right-click and Open with. Instead, you have to open the 7zip application, navigate to the file, and then select Extract.

Next, create an omnisharp.json file at the root folder of your project, as explained here. Analyzer support in OmniSharp is experimental at the moment, so we need to enable it explicitly. We also need to point it to the .dll file we just extracted.

Your omnisharp.json file should end up looking like this:

{
  "RoslynExtensionsOptions": {
    "EnableAnalyzersSupport": true,
    "LocationPaths": ["./NuGet/microsoft.unity.analyzers.1.14.0/analyzers/dotnet/cs"]
  }
}

where "./NuGet/microsoft.unity.analyzers.1.14.0/analyzers/dotnet/cs" is a relative path pointing to the folder containing the .dll file. Depending on where you placed it, your path may look different.

The Unity analyzers should now be working in your project. You can test them by creating an empty FixedUpdate() method inside one of your MonoBehavior classes, which should trigger a The Unity message 'FixedUpdate' is empty warning (UNT0001).

Note that while it is possible to activate these analyzers, the suppressors they ship with the package (that turn off other C# warnings that may conflict with these custom ones) may not be picked up by OmniSharp at the moment, according to this thread. You can still turn off specific rules manually by following these steps:

1. Create a .editorconfig file in your project's root folder (next to Unity's .csproj files).
2. Add the following contents to the file:

root=true

[*.cs]
dotnet_diagnostic.IDE0051.severity = none

root=true tells OmniSharp that this is your project root and it should stop looking for parent .editorconfig files outside of this folder.

dotnet_diagnostic.IDE0051.severity = none is an example of turning off the analyzer with ID IDE0051 by setting its severity level to none. You can read more about these settings in the Analyzer overview. You can add as many of these rules as you want to this file.

[*.cs] indicates that our custom rules should apply to all C# scripts (files with the .cs extension).

You are now ready to code in Visual Studio Code, while getting the same warnings as you would when using Visual Studio!

Next steps

Read on to learn more about:

• Basic Editing - Learn about the powerful VS Code editor.
• Code Navigation - Move quickly through your source code.
• C# - learn about the C# support in VS Code

Common questions

I don't have IntelliSense

You need to ensure that your solution is open in VS Code (not just a single file). Open the folder with your solution and you usually will not need to do anything else. If for some reason VS Code has not selected the right solution context, you can change the selected project by clicking on the OmniSharp flame icon on the status bar.

Choose the -CSharp version of the solution file and VS Code will light up.

How can I change the file exclusions?

Unity creates a number of additional files that can clutter your workspace in VS Code. You can easily hide these so that you can focus on the files you actually want to edit.

To do this, add the following JSON to your workspace settings. By adding these excludes to your workspace settings, you will not change your global user settings and it allows anyone also working on the project to have the same file excludes.

    // Configure glob patterns for excluding files and folders.
    "files.exclude": {
        "**/.git": true,
        "**/.DS_Store": true,
        "**/*.meta": true,
        "**/*.*.meta": true,
        "**/*.unity": true,
        "**/*.unityproj": true,
        "**/*.mat": true,
        "**/*.fbx": true,
        "**/*.FBX": true,
        "**/*.tga": true,
        "**/*.cubemap": true,
        "**/*.prefab": true,
        "**/Library": true,
        "**/ProjectSettings": true,
        "**/Temp": true
    }

As you can see below this will clean things up a lot...

Before

After

To edit this directly within VS Code Settings editor, go to File > Preferences > Settings (Code > Preferences > Settings on macOS). Switch to the Workspace tab and then type "files exclude" into the Settings editor search bar. Add a glob pattern similar to the pattern shown below by clicking the Add Pattern button for the Files: Exclude setting. You will need to add each pattern separately.

**/.git
**/*.fbx
**/*.FBX
**/*.mat
**/*.*.meta
**/*.meta
**/*.prefab
**/*.unityproj
**/Library
**/Packages
**/ProjectSettings
**/Temp

[System.Flags]는 C#(.NET 프레임워크의 일부)에서 열거형(enum)을 플래그(flag)의 모음으로 처리해야 함을 나타내는 속성입니다. 이를 통해 비트 연산을 사용하여 enum 값을 결합할 수 있으며, 이는 코드에서 옵션 또는 상태 조합을 효율적으로 나타내는 데 도움이 됩니다.

[System.Flags]의 주요 사용 사례는 다양한 방식으로 결합될 수 있는 독립적인 옵션 또는 속성 집합이 있을 때입니다. 플래그 속성을 사용하면 단일 정수 값으로 이러한 옵션의 모든 조합을 나타낼 수 있습니다.

다음은 이 개념을 설명하는 예입니다:

[System.Flags]를 사용하지 않는 경우:

public enum Colors { Red, Green, Blue }

이 경우 변수에 한 번에 하나의 색상만 할당할 수 있습니다.

[System.Flags]를 사용하는 경우:

[System.Flags] public enum Colors { None = 0, Red = 1, Green = 2, Blue = 4 }

이제 비트 OR 연산을 사용하여 색상을 결합할 수 있습니다:

Colors combinedColors = Colors.Red | Colors.Green;

combinedColors는 이제 Red와 Green 플래그를 모두 가지게 됩니다. 비트 AND 연산을 사용하여 특정 플래그가 설정되어 있는지 확인할 수도 있습니다:

bool isRedSet = (combinedColors & Colors.Red) == Colors.Red;

이를 통해 단일 정수 값으로 여러 옵션, 상태 또는 속성을 효율적으로 저장하고 조작할 수 있습니다. 그러나 플래그를 결합할 때 비트가 겹치지 않도록 열거 값으로 2의 거듭제곱(2^n)을 할당하는 것이 중요합니다.

• Custom Range 범위
  • 32-126, 44032-55203, 12593-12643, 8200-9900

1. 일본어 폰트(ttf 등) 찾기
   • 일본어 검색 사이트 목록
2. 일본어 폰트 변환

Mono를 계속 설치하라고 나오고, 설치해도  처리가 안될 때

• C# Extension의 버전을 v1.25.0로 변경해볼 것
  • v1.25.1 ~ v1.25.4까지 문제 발생하는 경우 있음