속성창 UI 작업

Reviewed-on: http://220.90.135.190:3000/UVCXR/Studio/pulls/64

.cursorignore

@@ -0,0 +1,71 @@
+# Unity 생성 디렉토리
+/[Ll]ibrary/
+/[Tt]emp/
+/[Oo]bj/
+/[Bb]uild/
+/[Bb]uilds/
+/[Ll]ogs/
+/[Uu]ser[Ss]ettings/
+
+# Unity 자동 생성 파일
+*.pidb.meta
+*.pdb.meta
+*.mdb.meta
+
+# Unity3D 충돌 파일
+sysinfo.txt
+
+# 빌드 결과물
+*.apk
+*.aab
+*.unitypackage
+*.app
+
+# VS/VS Code 설정
+.vs/
+.vscode/
+*.csproj
+*.sln
+*.suo
+*.tmp
+*.user
+*.userprefs
+*.lock
+*.ide
+*.ide-shm
+*.ide-wal
+
+# OS 생성 파일
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# 로그 파일
+*.log
+
+# 임시 파일
+*.tmp
+*.temp
+*~
+
+# Unity 에셋 파일
+*.fbx
+*.obj
+*.max
+*.blend
+*.dae
+*.mb
+*.ma
+
+# 프로젝트 특정 설정
+/Assets/SpecialAssets/
+/Assets/Plugins/ThirdParty/
+/Assets/StreamingAssets/Config/
+
+# 임시 작업 디렉토리
+_temp/
+_backup/

.vscode/extensions.json

@@ -0,0 +1,5 @@
+{
+    "recommendations": [
+      "visualstudiotoolsforunity.vstuc"
+    ]
+}

.vscode/launch.json

@@ -0,0 +1,10 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Attach to Unity",
+            "type": "vstuc",
+            "request": "attach"
+        }
+     ]
+}

.vscode/settings.json

@@ -0,0 +1,60 @@
+{
+    "files.exclude": {
+        "**/.DS_Store": true,
+        "**/.git": true,
+        "**/.vs": true,
+        "**/.gitmodules": true,
+        "**/.vsconfig": true,
+        "**/*.booproj": true,
+        "**/*.pidb": true,
+        "**/*.suo": true,
+        "**/*.user": true,
+        "**/*.userprefs": true,
+        "**/*.unityproj": true,
+        "**/*.dll": true,
+        "**/*.exe": true,
+        "**/*.pdf": true,
+        "**/*.mid": true,
+        "**/*.midi": true,
+        "**/*.wav": true,
+        "**/*.gif": true,
+        "**/*.ico": true,
+        "**/*.jpg": true,
+        "**/*.jpeg": true,
+        "**/*.png": true,
+        "**/*.psd": true,
+        "**/*.tga": true,
+        "**/*.tif": true,
+        "**/*.tiff": true,
+        "**/*.3ds": true,
+        "**/*.3DS": true,
+        "**/*.fbx": true,
+        "**/*.FBX": true,
+        "**/*.lxo": true,
+        "**/*.LXO": true,
+        "**/*.ma": true,
+        "**/*.MA": true,
+        "**/*.obj": true,
+        "**/*.OBJ": true,
+        "**/*.asset": true,
+        "**/*.cubemap": true,
+        "**/*.flare": true,
+        "**/*.mat": true,
+        "**/*.meta": true,
+        "**/*.prefab": true,
+        "**/*.unity": true,
+        "build/": true,
+        "Build/": true,
+        "Library/": true,
+        "library/": true,
+        "obj/": true,
+        "Obj/": true,
+        "Logs/": true,
+        "logs/": true,
+        "ProjectSettings/": true,
+        "UserSettings/": true,
+        "temp/": true,
+        "Temp/": true
+    },
+    "dotnet.defaultSolution": "OctopusStudio.sln"
+}

Assets/AGVNeedsScanner.cs

@@ -1,5 +1,6 @@
 using NUnit.Framework;
 using System.Collections.Generic;
+using XED.Manage;
 
 namespace XED.VirtualFactory
 {

Assets/NewStudioJYM.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7f1ab105e95a7ee44965ac5927623809
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioJYM/AlarmModal.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 07b2c65fe41bd8e43a7bcbd12ddeda0d
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioJYM/DataModal.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 760eabef824940d46a364a011f425b80
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioJYM/Inspector.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 83dffcb445724e44eab4e5f3a2fec973
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioJYM/Language.json

@@ -0,0 +1,8 @@
+{
+  "defaultLanguage": "Ko",
+  "languages": {
+    "Ko": "한국어",
+    "En": "English",
+    "Ja": "日本語"
+  }
+}

Assets/NewStudioJYM/Language.json.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: be71b5d18f50b9f4791093ac7cf722d7
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioJYM/LogingModal.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 259f375e4270b6243af7dd67c3770d95
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioJYM/Multilingual.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: bb4fd155efe15a040bf1c1c936399a6a
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioJYM/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4e0d5bd459141d14892f068ccc1d6c13
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioJYM/Scripts/ConnectDataManager.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace XED
+{
+    public class ConnectDataManager : MonoBehaviour
+    {
+        private Dictionary<string, SaveConnectedData> saveData = new Dictionary<string, SaveConnectedData>();
+        public Action<string, SaveConnectedData> onConnectData;
+        public Action<SaveConnectedData> onLoadData;
+
+        private Dictionary<string, SaveConnectAlarmData> saveAlarmData = new Dictionary<string, SaveConnectAlarmData>();
+        public Action<string, SaveConnectAlarmData> onConnectAlarm;
+        public Action<SaveConnectAlarmData> onLoadAlarm;
+
+        public void SaveData(string className, SaveConnectedData savedConnetedData)
+        {
+            if (saveData.ContainsKey(className))
+            {
+                saveData.Remove(className);
+            }
+            saveData.Add(className, savedConnetedData);
+            onConnectData?.Invoke(className, savedConnetedData);
+        }
+        public void LoadData(string className)
+        {
+            onLoadData?.Invoke(saveData[className]);
+        }
+        public void RemoveData(string className)
+        {
+            saveData.Remove(className);
+        }
+
+        public void SaveAlarmData(string alarmName, SaveConnectAlarmData saveConnectAlarmData)
+        {
+            if (saveAlarmData.ContainsKey(alarmName))
+            {
+                saveAlarmData.Remove(alarmName);
+            }
+            saveAlarmData.Add(alarmName, saveConnectAlarmData);
+            onConnectAlarm?.Invoke(alarmName, saveConnectAlarmData);
+        }
+        public void LoadAlarmData(string alarmName)
+        {
+            onLoadAlarm?.Invoke(saveAlarmData[alarmName]);
+        }
+        public void RemoveAlarmData(string alarmName)
+        {
+            saveAlarmData.Remove(alarmName);
+        }
+    }
+}

Assets/NewStudioJYM/Scripts/ConnectDataManager.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: f170dee81887b63429a6f12f6a68123f

Assets/NewStudioJYM/Scripts/Panel_AlarmConnectModal.cs

@@ -0,0 +1,174 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+using XRLib.UI;
+
+namespace XED
+{
+    public class Panel_AlarmConnectModal : PanelBase
+    {
+        public Data dataStorage;
+        public EventData eventData;
+
+        private RectTransform StorageDataContent;
+        private TMP_Dropdown Dropdown_DataStorage;
+        private Button Button_Save;
+        private Button Button_Cancel;
+
+        private List<DataClass> dataList = new List<DataClass>();
+
+        private List<UI_AlarmDataItem> alarmDatas = new List<UI_AlarmDataItem>();
+
+        private UI_AlarmDataItem prf_AlarmDataItem;
+        private UI_ComparisonSettingItem prf_ComparisonSettingItem;
+        private UI_EventParameterItem prf_EventParameterItem;
+
+        public SaveConnectAlarmData saveConnectAlarmData;
+        public SaveConnectAlarmData loadData = null;
+
+        public Action<string, SaveConnectAlarmData> onSaveConnectAlarmData;
+
+        private void TestDataConnected()
+        {
+            var dataStorageJson = Resources.Load<TextAsset>("Test1").text;
+            dataStorage = JsonConvert.DeserializeObject<Data>(dataStorageJson);
+
+            var evnetJson = Resources.Load<TextAsset>("Test2").text;
+            eventData = JsonConvert.DeserializeObject<EventData>(evnetJson);
+        }
+        public override void AfterAwake()
+        {
+            TestDataConnected();
+
+            prf_AlarmDataItem = Resources.Load<UI_AlarmDataItem>("Prefabs/UI/PRF_AlarmDataItem");
+            prf_ComparisonSettingItem = Resources.Load<UI_ComparisonSettingItem>("Prefabs/UI/PRF_ComparisonSettingItem");
+            prf_EventParameterItem = Resources.Load<UI_EventParameterItem>("Prefabs/UI/PRF_EventParameterItem");
+
+            Button_Save.onClick.AddListener(Save);
+            Button_Cancel.onClick.AddListener(CloseModal);
+
+            SetStorageDataDropdown();
+        }
+
+        private void SetStorageDataDropdown()
+        {
+            Dropdown_DataStorage.ClearOptions();
+            dataList.Clear();
+
+            List<string> displayNames = new List<string>();
+
+            var data = dataStorage.dataList;
+
+            for (int i = 0; i < data.Count; i++)
+            {
+                dataList.Add(data[i]);
+                displayNames.Add(data[i].name);
+            }
+            Dropdown_DataStorage.AddOptions(displayNames);
+            Dropdown_DataStorage.onValueChanged.AddListener(OnValueChangedDataStorageDropDown);
+        }
+        private void OnValueChangedDataStorageDropDown(int index)
+        {
+            loadData = new SaveConnectAlarmData();
+            AddStorageDataItem(index);
+        }
+        private void AddStorageDataItem(int index)
+        {
+            foreach(var alarmData in alarmDatas)
+            {
+                Destroy(alarmData.gameObject);
+            }
+            alarmDatas.Clear();
+
+            if (loadData.alarmDataName == null || loadData.alarmDataName == string.Empty)
+            {
+                foreach (var data in dataList[index].fields)
+                {
+                    var item = Instantiate(prf_AlarmDataItem, StorageDataContent);
+                    item.onUpdateLayout += UpdateLayout;
+                    item.SetItem(data, prf_ComparisonSettingItem, prf_EventParameterItem, eventData);
+                    alarmDatas.Add(item);
+                }
+            }
+            else
+            {
+                foreach (var data in loadData.alarmFields)
+                {
+                    var item = Instantiate(prf_AlarmDataItem, StorageDataContent);
+                    item.onUpdateLayout += UpdateLayout;
+                    item.SetItem(data, prf_ComparisonSettingItem, prf_EventParameterItem, eventData);
+                    alarmDatas.Add(item);
+                }
+            }
+        }
+
+        public void OpenModal()
+        {
+            gameObject.SetActive(true);
+        }
+        private void CloseModal()
+        {
+            gameObject.SetActive(false);
+        }
+        private void Save()
+        {
+            var saveConnectAlarmData = GetAlarmData();
+            onSaveConnectAlarmData?.Invoke(saveConnectAlarmData.alarmDataName, saveConnectAlarmData);
+
+            Initialize();
+            gameObject.SetActive(false);
+        }
+        private void Initialize()
+        {
+            Dropdown_DataStorage.ClearOptions();
+
+            foreach (var alarmData in alarmDatas)
+            {
+                Destroy(alarmData.gameObject);
+            }
+            alarmDatas.Clear();
+        }
+        private void UpdateLayout()
+        {
+            LayoutRebuilder.ForceRebuildLayoutImmediate(StorageDataContent);
+        }
+        private SaveConnectAlarmData GetAlarmData()
+        {
+            var saveConnectAlarmData = new SaveConnectAlarmData();
+            saveConnectAlarmData.alarmDataName = Dropdown_DataStorage.options[Dropdown_DataStorage.value].text;
+
+            foreach (var item in alarmDatas)
+            {
+                var alarmField = item.GetData();
+
+                if (alarmField != null)
+                {
+                    saveConnectAlarmData.alarmFields.Add(alarmField);
+                }
+            }
+            return saveConnectAlarmData;
+        }
+        public void LoadData(SaveConnectAlarmData savedData)
+        {
+            OpenModal();
+
+            loadData = savedData;
+
+            SetStorageDataDropdown();
+            // dropdown¿¡¼­ ¾Ë¸ÂÀº dataStorage index ã±â
+            for (int i = 0; i < dataList.Count; i++)
+            {
+                if(savedData.alarmDataName == dataList[i].name)
+                {
+                    Dropdown_DataStorage.SetValueWithoutNotify(i);
+                    AddStorageDataItem(i);
+                    break;
+                }
+            }
+        }
+    }
+}

Assets/NewStudioJYM/Scripts/Panel_AlarmConnectModal.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 6531d3243f1b04943b5395aa2558066b

Assets/NewStudioJYM/Scripts/Panel_DataConnectModal.cs

@@ -0,0 +1,356 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+using XRLib;
+using XRLib.UI;
+
+namespace XED
+{
+    public class Panel_DataConnectModal : PanelBase
+    {
+        public Data api;
+        public Data dataStorage;
+
+        private List<DataClass> apiDatas = new List<DataClass>();
+        private List<DataClass> dataStorageDatas = new List<DataClass>();
+        private bool isAPI;
+
+        public Toggle Toggle_Api;
+        public Toggle Toggle_Storage;
+        public TMP_Dropdown Dropdown_DataList;
+        public Button Button_Cancel;
+        public Button Button_Save;
+
+        private RectTransform RectTransform_APIData;
+        private RectTransform AddStorageDataButtonArea;
+        private RectTransform APIDataListContent;
+        private RectTransform APIContent;
+        private Button Button_loadAPIData;
+        private Button Button_AddStorageData;
+        
+        private DataClass loadAPIData;
+        private List<UI_LoadAPIDataItem> currentAPIDataItems = new List<UI_LoadAPIDataItem>();
+       
+        private RectTransform RectTransform_DataStorage;
+        private RectTransform DataStorageContent;
+        private RectTransform AddAPIDataButtonArea;
+        private Button Button_AddAPIData;
+        private Toggle Toggle_limitStorageSetting;
+
+        private UI_LoadAPIDataItem prf_loadAPIDataItem;
+        private UI_DataSettingItem prf_DataSettingItem;
+        private UI_DataTypeSelectedItem prf_DataTypeSelectedItem;
+        private UI_MatchingTypeDataItem prf_MatchingTypeDataItem;
+        private UI_AddOtherDataItem prf_AddOtherDataItem;
+        private UI_AddOtherDataTypeItem prf_AddOtherDataTypeItem;
+
+        private RectTransform currentContent;
+        private RectTransform currentButtonArea;
+        public UI_DataSettingItem currentDataSettingItem;
+        public List<UI_AddOtherDataItem> currentAddOtherDataItems = new List<UI_AddOtherDataItem>();
+
+        private string currentDataListOptionName;
+        private DataClass currentClass;
+
+        public Action<string, SaveConnectedData> onSaveConnectedData;
+
+        private void TestDataConnected()
+        {
+            var apiJson = Resources.Load<TextAsset>("Test").text;
+            api = JsonConvert.DeserializeObject<Data>(apiJson);
+
+            var dataStorageJson = Resources.Load<TextAsset>("Test1").text;
+            dataStorage = JsonConvert.DeserializeObject<Data>(dataStorageJson);
+        }
+        public override void AfterAwake()
+        {
+            TestDataConnected();
+
+            prf_loadAPIDataItem = Resources.Load<UI_LoadAPIDataItem>("Prefabs/UI/PRF_LoadAPIDataItem");
+            prf_DataSettingItem = Resources.Load<UI_DataSettingItem>("Prefabs/UI/PRF_DataSettingItem");
+            prf_DataTypeSelectedItem = Resources.Load<UI_DataTypeSelectedItem>("Prefabs/UI/PRF_DataTypeSelectedItem");
+            prf_MatchingTypeDataItem = Resources.Load<UI_MatchingTypeDataItem>("Prefabs/UI/PRF_MatchingTypeDataItem");
+            prf_AddOtherDataItem = Resources.Load<UI_AddOtherDataItem>("Prefabs/UI/PRF_AddOtherDataItem");
+            prf_AddOtherDataTypeItem = Resources.Load<UI_AddOtherDataTypeItem>("Prefabs/UI/PRF_AddOtherDataTypeItem");
+
+            Toggle_Api.onValueChanged.AddListener(OnAPIToggleValueChanged);
+            Toggle_Storage.onValueChanged.AddListener(OnDataStorageToggleValueChanged);
+            Toggle_limitStorageSetting.onValueChanged.AddListener(OnLimitStorageSettingToggleValueChanged);
+
+            Button_loadAPIData.onClick.AddListener(LoadAPIData);
+            Button_AddStorageData.onClick.AddListener(() => AddOtherDataItem(null));
+            Button_AddAPIData.onClick.AddListener(() => AddOtherDataItem(null));
+            Button_Cancel.onClick.AddListener(CloseModal);
+            Button_Save.onClick.AddListener(Save);
+
+            RectTransform_APIData.gameObject.SetActive(false);
+            RectTransform_DataStorage.gameObject.SetActive(false);
+        }
+        private void OnAPIToggleValueChanged(bool isOn)
+        {
+            if (isOn)
+            {
+                RectTransform_APIData.gameObject.SetActive(true);
+                ChangePanel(APIContent, AddStorageDataButtonArea);
+
+                isAPI = true;
+                PopulateDataListDropdown(api.dataList);
+                Toggle_Storage.isOn = false;
+                Toggle_limitStorageSetting.isOn = true;
+            }
+            else
+            {
+                RectTransform_APIData.gameObject.SetActive(false);
+            }
+        }
+        private void OnDataStorageToggleValueChanged(bool isOn)
+        {
+            if (isOn)
+            {
+                RectTransform_DataStorage.gameObject.SetActive(true);
+                ChangePanel(DataStorageContent, AddAPIDataButtonArea);
+
+                isAPI = false;
+                PopulateDataListDropdown(dataStorage.dataList);
+                Toggle_Api.isOn = false;
+                Toggle_limitStorageSetting.isOn = false;
+            }
+            else
+            {
+                RectTransform_DataStorage.gameObject.SetActive(false);
+            }
+        }
+        private void ChangePanel(RectTransform dataContent, RectTransform buttonArea)
+        {
+            currentContent = dataContent;
+            currentButtonArea = buttonArea;
+
+            currentDataSettingItem = currentContent.GetComponentInChildren<UI_DataSettingItem>();
+            currentAddOtherDataItems.Clear();
+            var currentAddOtherDataItem = currentContent.GetComponentsInChildren<UI_AddOtherDataItem>().ToList();
+            currentAddOtherDataItems.AddRange(currentAddOtherDataItem);
+        }
+        private void OnLimitStorageSettingToggleValueChanged(bool isOn)
+        {
+            var isActive = isOn;
+            DataStorageContent.gameObject.SetActive(isActive);
+        }
+        private void PopulateDataListDropdown(List<DataClass> data)
+        {
+            Dropdown_DataList.ClearOptions();
+            List<string> displayNames = new List<string>();
+
+            if (isAPI)
+            {
+                apiDatas.Clear();
+
+                foreach (var api in data)
+                {
+                    apiDatas.Add(api);
+                    displayNames.Add(api.name);
+                }
+
+                Dropdown_DataList.AddOptions(displayNames);
+                Dropdown_DataList.onValueChanged.RemoveAllListeners();
+                Dropdown_DataList.onValueChanged.AddListener(OnValueChangedAPIDropDown);
+
+                var notCheckIndex = currentDataListOptionName != null ? displayNames.IndexOf(currentDataListOptionName) : 0;
+                var index = notCheckIndex >= 0 ? notCheckIndex : 0;
+
+                Dropdown_DataList.SetValueWithoutNotify(index);
+                SetLoadApiData(index);
+            }
+            else
+            {
+                dataStorageDatas.Clear();
+
+                foreach (var storageData in data)
+                {
+                    dataStorageDatas.Add(storageData);
+                    displayNames.Add(storageData.name);
+                }
+
+                Dropdown_DataList.AddOptions(displayNames);
+                Dropdown_DataList.onValueChanged.RemoveAllListeners();
+                Dropdown_DataList.onValueChanged.AddListener(OnValueChangedDataStorageDropDown);
+
+                var notCheckIndex = currentDataListOptionName != null ? displayNames.IndexOf(currentDataListOptionName) : 0;
+                var index = notCheckIndex >= 0 ? notCheckIndex : 0;
+
+                Dropdown_DataList.SetValueWithoutNotify(index);
+                OnValueChangedDataStorageDropDown(index);
+            }
+        }
+        
+        private void OnValueChangedAPIDropDown(int index)
+        {
+            SetLoadApiData(index);
+        }
+        private void SetLoadApiData(int index)
+        {
+            var apiData = apiDatas[index];
+            loadAPIData = apiData;
+        }
+
+        void LoadAPIData()
+        {
+            foreach (var dataItem in currentAPIDataItems)
+                Destroy(dataItem.gameObject);
+
+            currentAPIDataItems.Clear();
+
+            var item = Instantiate(prf_loadAPIDataItem, APIDataListContent);
+            item.SetData(loadAPIData);
+            item.onClickItem += OnClickAPIDataItem;
+            currentAPIDataItems.Add(item);
+        }
+        private void OnClickAPIDataItem(DataClass data)
+        {
+            AddDataSettingItem(data);
+        }
+        private void OnValueChangedDataStorageDropDown(int index)
+        {
+            AddDataSettingItem(dataStorageDatas[index]);
+        }
+        private void UpdateLayout()
+        {
+            LayoutRebuilder.ForceRebuildLayoutImmediate(currentContent);
+        }
+        private void AddDataSettingItem(DataClass data)
+        {
+            if (currentDataSettingItem != null)
+            {
+                Destroy(currentDataSettingItem.gameObject);
+                currentDataSettingItem = null;
+            }
+
+            var item = Instantiate(prf_DataSettingItem, currentContent);
+            var index = currentButtonArea.transform.GetSiblingIndex();
+            item.transform.SetSiblingIndex(index);
+            item.SetData(data, prf_DataTypeSelectedItem, prf_MatchingTypeDataItem);
+            item.onUpdateLayout += UpdateLayout;
+            currentDataSettingItem = item;
+        }
+        private void AddOtherDataItem(DataClass data)
+        {
+            var item = Instantiate(prf_AddOtherDataItem, currentContent);
+            item.onUpdateLayout += UpdateLayout;
+            item.onDestory += RemoveOtherDataItem;
+            item.SetItem(dataStorage.dataList, data, prf_AddOtherDataTypeItem);
+            item.transform.SetAsLastSibling();
+            currentAddOtherDataItems.Add(item);
+        }
+        private void RemoveOtherDataItem(UI_AddOtherDataItem item)
+        {
+            currentAddOtherDataItems.Remove(item);
+            Destroy(item.gameObject);
+        }
+        void Save()
+        {
+            var saveData = GetData();
+            onSaveConnectedData?.Invoke(saveData.dataSource, saveData);
+            Initialize();
+            gameObject.SetActive(false);
+        }
+
+        public void OpenModal()
+        {
+            gameObject.SetActive(true);
+        }
+        void CloseModal()
+        {
+            gameObject.SetActive(false);
+        }
+        private void Initialize()
+        {
+            Toggle_Api.SetIsOnWithoutNotify(false);
+            Toggle_Storage.SetIsOnWithoutNotify(false);
+
+            Toggle_limitStorageSetting.SetIsOnWithoutNotify(false);
+
+            currentContent = null;
+            currentButtonArea = null;
+
+            loadAPIData = null;
+
+            foreach (var item in currentAPIDataItems)
+            {
+                Destroy(item.gameObject);
+            }
+            currentAPIDataItems.Clear();
+
+            if (currentDataSettingItem != null)
+            {
+                Destroy(currentDataSettingItem.gameObject);
+                currentDataSettingItem = null;
+            }
+
+            foreach (var item in currentAddOtherDataItems)
+            {
+                Destroy(item.gameObject);
+            }
+            currentAddOtherDataItems.Clear();
+
+            RectTransform_APIData.gameObject.SetActive(false);
+            RectTransform_DataStorage.gameObject.SetActive(false);
+        }
+        private SaveConnectedData GetData()
+        {
+            SaveConnectedData saveData = new SaveConnectedData();
+            saveData.connectDataClass.Clear();
+            saveData.otherDataClasses.Clear();
+
+            saveData.isAPI = isAPI;
+            saveData.dataListOptionName = Dropdown_DataList.options[Dropdown_DataList.value].text;
+
+            saveData.isLimitStorageSetting = Toggle_limitStorageSetting.isOn;
+
+            var dataclass = currentDataSettingItem.GetData();
+            saveData.dataSource = dataclass.name;
+            saveData.connectDataClass.Add(dataclass);
+
+            foreach (var item in currentAddOtherDataItems)
+            {
+                var otehrDataClass = item.GetData();
+                saveData.otherDataClasses.Add(otehrDataClass);
+            }
+
+            return saveData;
+        }
+        public void SetLoadSaveData(SaveConnectedData saveData)
+        {
+            OpenModal();
+
+            currentClass = saveData.connectDataClass[0];
+            currentDataListOptionName = saveData.dataListOptionName;
+
+            if (saveData.isAPI)
+            {
+                Toggle_Api.isOn = true;
+                LoadAPIData();
+            }
+            else
+            {
+                Toggle_Storage.isOn = true;
+                Toggle_limitStorageSetting.isOn = !saveData.isLimitStorageSetting;
+                Toggle_limitStorageSetting.isOn = saveData.isLimitStorageSetting;
+            }
+            AddDataSettingItem(currentClass);
+
+            foreach (var item in currentAddOtherDataItems)
+            {
+                Destroy(item.gameObject);
+            }
+            currentAddOtherDataItems.Clear();
+
+            foreach (var otherClass in saveData.otherDataClasses)
+            {
+                AddOtherDataItem(otherClass);
+            }
+        }
+    }
+}

Assets/NewStudioJYM/Scripts/Panel_DataConnectModal.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 91ad386df90464f42afdad28100d8037

Assets/NewStudioJYM/Scripts/Panel_DynamicObjectInfo.cs

@@ -0,0 +1,359 @@
+using System.Collections.Generic; 
+using TMPro;
+using UnityEngine;
+using XRLib.UI;
+using XED.Manage;
+using System.Linq;
+using XED.Core;
+using XED.Command;
+using UnityEngine.UI;
+using System;
+
+namespace XED.UI
+{
+    public class Panel_DynamicObjectInfo : PanelBase
+    { 
+        public enum InputFieldType
+        {
+            none,
+            posX, posY, posZ,
+            rotX, rotY, rotZ,
+            scaX, scaY, scaZ,
+        }
+        public class SelectedInput
+        {
+            public InputFieldType type = InputFieldType.none;
+            public float value = 0.0f;
+            public SelectedInput(InputFieldType type, float value)
+            {
+                this.type = type;
+                this.value = value;
+            }
+        }
+
+        public TextMeshProUGUI Text_Name;
+
+        public TMP_InputField InputField_PositionX;
+        public TMP_InputField InputField_PositionY;
+        public TMP_InputField InputField_PositionZ;
+        public TMP_InputField InputField_RotationX;
+        public TMP_InputField InputField_RotationY;
+        public TMP_InputField InputField_RotationZ;
+        public TMP_InputField InputField_ScaleX;
+        public TMP_InputField InputField_ScaleY;
+        public TMP_InputField InputField_ScaleZ;
+
+        public TextMeshProUGUI Text_DataName;
+        public Button Button_ConnectData;
+        public Button Button_RetouchData;
+        public Button Button_DeleteData;
+
+        public TextMeshProUGUI Text_AlarmName;
+        public Button Button_ConnectAlarm;
+        public Button Button_RetouchAlarm;
+        public Button Button_DeleteAlarm;
+
+        public event System.Action<List<GameObject>> onTransformChanged;
+        private List<GameObject> selectedObjects = new List<GameObject>();
+        private SelectedInput lastSelectedInputField = new SelectedInput(InputFieldType.none ,0.0f);
+
+        public Action onConnectedData;
+        public Action<string> onRetouchData;
+        public Action<string> onDeleteData;
+
+        public Action onConnectedAlarm;
+        public Action<string> onRetouchAlarm;
+        public Action<string> onDeleteAlarm;
+
+        public SaveConnectedData connectedData;
+        public SaveConnectAlarmData connectedAlarmData;
+
+        public override void AfterAwake()
+        { 
+            InputField_PositionX.onValueChanged.AddListener(OnPosXChanged);
+            InputField_PositionY.onValueChanged.AddListener(OnPosYChanged);
+            InputField_PositionZ.onValueChanged.AddListener(OnPosZChanged);
+            InputField_RotationX.onValueChanged.AddListener(OnRotXChanged);
+            InputField_RotationY.onValueChanged.AddListener(OnRotYChanged);
+            InputField_RotationZ.onValueChanged.AddListener(OnRotZChanged);
+            InputField_ScaleX.onValueChanged.AddListener(OnScaXChanged);
+            InputField_ScaleY.onValueChanged.AddListener(OnScaYChanged);
+            InputField_ScaleZ.onValueChanged.AddListener(OnScaZChanged);
+            InputField_PositionX.onDeselect.AddListener(OnDeselectInputField);
+            InputField_PositionY.onDeselect.AddListener(OnDeselectInputField);
+            InputField_PositionZ.onDeselect.AddListener(OnDeselectInputField);
+            InputField_RotationX.onDeselect.AddListener(OnDeselectInputField);
+            InputField_RotationY.onDeselect.AddListener(OnDeselectInputField);
+            InputField_RotationZ.onDeselect.AddListener(OnDeselectInputField);
+            InputField_ScaleX.onDeselect.AddListener(OnDeselectInputField);
+            InputField_ScaleY.onDeselect.AddListener(OnDeselectInputField);
+            InputField_ScaleZ.onDeselect.AddListener(OnDeselectInputField);
+            ResetObjectInfo();
+            Text_DataName.SetText("없음");
+            Button_ConnectData.onClick.AddListener(OnClickConnectDataButton);
+            Button_RetouchData.onClick.AddListener(OnClickRetouchDataButton);
+            Button_DeleteData.onClick.AddListener(OnClickDeleteDataButton);
+            Text_AlarmName.SetText("없음");
+            Button_ConnectAlarm.onClick.AddListener(OnClickConnectAlarmButton);
+            Button_RetouchAlarm.onClick.AddListener(OnClickRetouchAlarmButton);
+            Button_DeleteAlarm.onClick.AddListener(OnClickDeleteAlarmButton);
+        }
+
+        void OnPosXChanged(string input)
+        { 
+            OnTransformChanged(InputFieldType.posX, input);
+        }
+        void OnPosYChanged(string input)
+        {
+            OnTransformChanged(InputFieldType.posY, input);
+        }
+        void OnPosZChanged(string input)
+        {
+            OnTransformChanged(InputFieldType.posZ, input);
+        }
+        void OnRotXChanged(string input)
+        {
+            OnTransformChanged(InputFieldType.rotX, input);
+        }
+        void OnRotYChanged(string input)
+        {
+            OnTransformChanged(InputFieldType.rotY, input);
+        }
+        void OnRotZChanged(string input)
+        {
+            OnTransformChanged(InputFieldType.rotZ, input);
+        }
+        void OnScaXChanged(string input)
+        {
+            OnTransformChanged(InputFieldType.scaX, input);
+        }
+        void OnScaYChanged(string input)
+        {
+            OnTransformChanged(InputFieldType.scaY, input);
+        }
+        void OnScaZChanged(string input)
+        {
+            OnTransformChanged(InputFieldType.scaZ, input);
+        }
+        void OnTransformChanged(InputFieldType type, string input)
+        {
+            if (selectedObjects.Count == 0)
+            {
+                return;
+            }
+            float value = 0.0f;
+            if (!float.TryParse(input, out value))
+            {
+                return;
+            }
+            if (lastSelectedInputField.type != type)
+            {
+                AddUndoRedo(type, value);
+            }
+            lastSelectedInputField.value = value;
+            foreach (GameObject gb in selectedObjects)
+            {
+                ChangeTransformValue(gb.transform, type, value); 
+            }
+            onTransformChanged?.Invoke(selectedObjects);
+        }
+        public void OnTransformChanged(List<GameObject> objectTransforms)
+        {
+            selectedObjects = objectTransforms;
+            if (objectTransforms.Count == 0)
+            {
+                ResetObjectInfo();
+                return;
+            }
+            bool equalPosX = selectedObjects.All(gb => Mathf.Approximately(gb.transform.position.x, selectedObjects[0].transform.position.x));
+            bool equalPosY = selectedObjects.All(gb => Mathf.Approximately(gb.transform.position.y, selectedObjects[0].transform.position.y));
+            bool equalPosZ = selectedObjects.All(gb => Mathf.Approximately(gb.transform.position.z, selectedObjects[0].transform.position.z));
+            bool equalRotX = selectedObjects.All(gb => Mathf.Approximately(gb.transform.eulerAngles.x, selectedObjects[0].transform.eulerAngles.x));
+            bool equalRotY = selectedObjects.All(gb => Mathf.Approximately(gb.transform.eulerAngles.y, selectedObjects[0].transform.eulerAngles.y));
+            bool equalRotZ = selectedObjects.All(gb => Mathf.Approximately(gb.transform.eulerAngles.z, selectedObjects[0].transform.eulerAngles.z));
+            bool equalScaX = selectedObjects.All(gb => Mathf.Approximately(gb.transform.localScale.x, selectedObjects[0].transform.localScale.x));
+            bool equalScaY = selectedObjects.All(gb => Mathf.Approximately(gb.transform.localScale.y, selectedObjects[0].transform.localScale.y));
+            bool equalScaZ = selectedObjects.All(gb => Mathf.Approximately(gb.transform.localScale.z, selectedObjects[0].transform.localScale.z));
+
+            Transform t = selectedObjects[0].transform;
+            if (equalPosX) InputField_PositionX.SetTextWithoutNotify(t.position.x.ToString("F2"));
+            if (equalPosY) InputField_PositionY.SetTextWithoutNotify(t.position.y.ToString("F2"));
+            if (equalPosZ) InputField_PositionZ.SetTextWithoutNotify(t.position.z.ToString("F2"));
+            if (equalRotX) InputField_RotationX.SetTextWithoutNotify(t.eulerAngles.x.ToString("F2"));
+            if (equalRotY) InputField_RotationY.SetTextWithoutNotify(t.eulerAngles.y.ToString("F2"));
+            if (equalRotZ) InputField_RotationZ.SetTextWithoutNotify(t.eulerAngles.z.ToString("F2"));
+            if (equalScaX) InputField_ScaleX.SetTextWithoutNotify(t.localScale.x.ToString("F2"));
+            if (equalScaY) InputField_ScaleY.SetTextWithoutNotify(t.localScale.y.ToString("F2"));
+            if (equalScaZ) InputField_ScaleZ.SetTextWithoutNotify(t.localScale.z.ToString("F2"));
+        }
+        void AddUndoRedo(InputFieldType type, float value)
+        {
+            lastSelectedInputField = new SelectedInput(type, value);
+            SelectedInput saveSelectedInput = lastSelectedInputField;
+            List<GameObject> transformsChanged = new List<GameObject>(selectedObjects);
+            List<float> origValues;
+            switch (type)
+            {
+                case InputFieldType.posX: origValues = transformsChanged.Select(t => t.transform.position.x).ToList(); break;
+                case InputFieldType.posY: origValues = transformsChanged.Select(t => t.transform.position.y).ToList(); break;
+                case InputFieldType.posZ: origValues = transformsChanged.Select(t => t.transform.position.z).ToList(); break;
+                case InputFieldType.rotX: origValues = transformsChanged.Select(t => t.transform.eulerAngles.x).ToList(); break;
+                case InputFieldType.rotY: origValues = transformsChanged.Select(t => t.transform.eulerAngles.y).ToList(); break;
+                case InputFieldType.rotZ: origValues = transformsChanged.Select(t => t.transform.eulerAngles.z).ToList(); break;
+                case InputFieldType.scaX: origValues = transformsChanged.Select(t => t.transform.localScale.x).ToList(); break;
+                case InputFieldType.scaY: origValues = transformsChanged.Select(t => t.transform.localScale.y).ToList(); break;
+                case InputFieldType.scaZ: origValues = transformsChanged.Select(t => t.transform.localScale.z).ToList(); break;
+                default: origValues = new List<float>(transformsChanged.Count); break;
+            }
+            
+            ActionCommand command = new ActionCommand(
+                () =>
+                { 
+                    for (int i = 0; i< transformsChanged.Count; i++)
+                    {
+                        ChangeTransformValue(transformsChanged[i].transform, type, saveSelectedInput.value);
+                    }
+                    onTransformChanged?.Invoke(transformsChanged);
+                },
+                () =>
+                {
+                    for (int i = 0; i < transformsChanged.Count; i++)
+                    {
+                        ChangeTransformValue(transformsChanged[i].transform, type, origValues[i]);
+                    }
+                    onTransformChanged?.Invoke(transformsChanged);
+                });
+            CommandInvoker.instance.Invoke(command);
+        }
+        void ChangeTransformValue(Transform t, InputFieldType type, float v)
+        {
+            switch (type)
+            {
+                case InputFieldType.posX: t.position = new Vector3(v, t.position.y, t.position.z); break;
+                case InputFieldType.posY: t.position = new Vector3(t.position.x, v, t.position.z); break;
+                case InputFieldType.posZ: t.position = new Vector3(t.position.x, t.position.y, v); break;
+                case InputFieldType.rotX: t.eulerAngles = new Vector3(v, t.eulerAngles.y, t.eulerAngles.z); break;
+                case InputFieldType.rotY: t.eulerAngles = new Vector3(t.eulerAngles.x, v, t.eulerAngles.z); break;
+                case InputFieldType.rotZ: t.eulerAngles = new Vector3(t.eulerAngles.x, t.eulerAngles.y, v); break;
+                case InputFieldType.scaX: t.localScale = new Vector3(v, t.localScale.y, t.localScale.z); break;
+                case InputFieldType.scaY: t.localScale = new Vector3(t.localScale.x, v, t.localScale.z); break;
+                case InputFieldType.scaZ: t.localScale = new Vector3(t.localScale.x, t.localScale.y, v); break;
+            }
+        }
+        void OnDeselectInputField(string lastInput)
+        {
+            Debug.Log("Deselect Input Field");
+            if (lastSelectedInputField.type != InputFieldType.none)
+            {
+                lastSelectedInputField = new SelectedInput(InputFieldType.none, 0.0f);
+            }
+        }
+        public void SetObjectInfo(string name, List<GameObject> selectedObjects)
+        {
+            ResetObjectInfo();
+            if (name == null || selectedObjects == null)
+            {
+                return;
+            }
+            if (selectedObjects.Count == 0)
+            { 
+                return;
+            }
+            string append = "";
+            if (!name.Equals("-"))
+            {
+                append = string.Format(" ({0})", selectedObjects.Count);
+            }
+            Text_Name.text = name + append;
+            OnTransformChanged(selectedObjects);
+            if (lastSelectedInputField.type != InputFieldType.none)
+            {
+                lastSelectedInputField = new SelectedInput(InputFieldType.none, 0.0f);
+            }
+        }
+        public void ResetObjectInfo()
+        {
+            Text_Name.text = "-";
+            InputField_PositionX.SetTextWithoutNotify("-");
+            InputField_PositionY.SetTextWithoutNotify("-");
+            InputField_PositionZ.SetTextWithoutNotify("-");
+            InputField_RotationX.SetTextWithoutNotify("-");
+            InputField_RotationY.SetTextWithoutNotify("-");
+            InputField_RotationZ.SetTextWithoutNotify("-");
+            InputField_ScaleX.SetTextWithoutNotify("-");
+            InputField_ScaleY.SetTextWithoutNotify("-");
+            InputField_ScaleZ.SetTextWithoutNotify("-");
+            if (lastSelectedInputField.type != InputFieldType.none)
+            {
+                lastSelectedInputField = new SelectedInput(InputFieldType.none, 0.0f);
+            }
+        }
+        private void Update()
+        {
+            if (Text_DataName.text == "없음")
+            {
+                Button_ConnectData.gameObject.SetActive(true);
+                Button_RetouchData.gameObject.SetActive(false);
+                Button_DeleteData.gameObject.SetActive(false);
+            }
+            else
+            {
+                Button_ConnectData.gameObject.SetActive(false);
+                Button_RetouchData.gameObject.SetActive(true);
+                Button_DeleteData.gameObject.SetActive(true);
+            }
+
+            if (Text_AlarmName.text == "없음")
+            {
+                Button_ConnectAlarm.gameObject.SetActive(true);
+                Button_RetouchAlarm.gameObject.SetActive(false);
+                Button_DeleteAlarm.gameObject.SetActive(false);
+            }
+            else
+            {
+                Button_ConnectAlarm.gameObject.SetActive(false);
+                Button_RetouchAlarm.gameObject.SetActive(true);
+                Button_DeleteAlarm.gameObject.SetActive(true);
+            }
+        }
+        private void OnClickConnectDataButton()
+        {
+            onConnectedData?.Invoke();
+        }
+        private void OnClickRetouchDataButton()
+        {
+            onRetouchData?.Invoke(Text_DataName.text);
+        }
+        private void OnClickDeleteDataButton()
+        {
+            onDeleteData?.Invoke(Text_DataName.text);
+            Text_DataName.SetText("없음");
+        }
+
+        public void OnConnectData(string saveDataName, SaveConnectedData saveData)
+        {
+            Text_DataName.SetText(saveDataName);
+            connectedData = saveData;
+        }
+
+        private void OnClickConnectAlarmButton()
+        {
+            onConnectedAlarm?.Invoke();
+        }
+        private void OnClickRetouchAlarmButton()
+        {
+            onRetouchAlarm?.Invoke(Text_AlarmName.text);
+        }
+        private void OnClickDeleteAlarmButton()
+        {
+            onDeleteAlarm?.Invoke(Text_AlarmName.text);
+            Text_AlarmName.SetText("없음");
+        }
+
+        public void OnConnectAlarm(string saveAlarmName, SaveConnectAlarmData saveData)
+        {
+            Text_AlarmName.SetText(saveAlarmName);
+            connectedAlarmData = saveData;
+        }
+    }
+}

Assets/NewStudioJYM/Scripts/Panel_DynamicObjectInfo.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: f421057c874e14f4aae3877101e22b47

Assets/NewStudioJYM/Scripts/Panel_MultilingualSettingModal.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using UnityEngine;
+using XRLib.UI;
+using TMPro;
+using UnityEngine.UI;
+using Newtonsoft.Json;
+using TriLibCore.SFB;
+using System.Text;
+
+namespace XED
+{
+    [Serializable]
+    public class LanguageConfig
+    {
+        public string defaultLanguage;
+        public Dictionary<string, string> languages;
+    }
+    public class Panel_MultilingualSettingModal : PanelBase
+    {
+        public TMP_Dropdown Dropdown_Languages;
+        public Button Button_OpenFile;
+        public Button Button_Save;
+
+        private string selectedLanguage;
+        private Dictionary<string, string> languages = new Dictionary<string, string>();
+        private string json;
+        public string saveLanguage;
+
+        public override void AfterAwake()
+        {
+            Button_OpenFile.onClick.AddListener(OnClickOpenFileButton);
+            Button_Save.onClick.AddListener(OnClickSaveButton);
+        }
+        void OnClickOpenFileButton()
+        {
+            StandaloneFileBrowser.OpenFilePanelAsync("Open File", "", "json", false, LoadJson);
+        }
+        void OnClickSaveButton()
+        {
+            saveLanguage = selectedLanguage;
+        }
+        
+        void LoadJson(IList<ItemWithStream> items)
+        {
+            if (items != null && items.Count > 0)
+            {
+                var item = items[0];
+                using (var reader = new StreamReader(item.OpenStream(), Encoding.UTF8))
+                {
+                    json = reader.ReadToEnd();
+                }
+            }
+            else
+            {
+                Debug.LogWarning("파일을 선택하지 않았습니다.");
+            }
+
+            var data = JsonConvert.DeserializeObject<LanguageConfig>(json);
+            if (data == null || data.languages == null)
+            {
+                Debug.LogError("데이터가 존재하지 않습니다.");
+                return;
+            }
+
+            languages = data.languages;
+            SetLanguageDropdown();
+        }
+        private void SetLanguageDropdown()
+        {
+            Dropdown_Languages.ClearOptions();
+            List<string> options = new List<string>();
+
+            foreach (var language in languages.Keys)
+            {
+                options.Add(language);
+            }
+            Dropdown_Languages.AddOptions(options);
+            Dropdown_Languages.onValueChanged.AddListener(OnLanguageDropdownValueChanged);
+
+            var languageKey = Dropdown_Languages.options[0].text;
+            selectedLanguage = languages[languageKey];
+        }
+
+        private void OnLanguageDropdownValueChanged(int index)
+        {
+            var languageKey = Dropdown_Languages.options[index].text;
+            selectedLanguage = languages[languageKey];
+        }
+    }
+}

Assets/NewStudioJYM/Scripts/Panel_MultilingualSettingModal.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4af5f74e38688c3408f7bc2ef1ff30f8

Assets/NewStudioJYM/Scripts/StudioJYMCanvas_Popup.cs

@@ -0,0 +1,38 @@
+using UnityEngine;
+using XED.UI;
+using XRLib;
+using XRLib.UI;
+
+namespace XED
+{
+    public class StudioJYMCanvas_Popup : CanvasBase, ISingle
+    {
+        public Panel_DataConnectModal panel_dataconnectmodal;
+        public Panel_AlarmConnectModal panel_alarmconnectmodal;
+        public Panel_DynamicObjectInfo panel_dynamicobjectinfo;
+
+        private void Awake()
+        {
+            canvasHandler = new StudioJYMPopupCanvasHandler(this);
+        }
+        public override void AfterAwake()
+        {
+            var dataManager = FindAnyObjectByType<ConnectDataManager>();
+
+            panel_dataconnectmodal.onSaveConnectedData += dataManager.SaveData;
+            panel_alarmconnectmodal.onSaveConnectAlarmData += dataManager.SaveAlarmData;
+
+            panel_dynamicobjectinfo.onRetouchData += dataManager.LoadData;
+            panel_dynamicobjectinfo.onDeleteData += dataManager.RemoveData;
+
+            panel_dynamicobjectinfo.onRetouchAlarm += dataManager.LoadAlarmData;
+            panel_dynamicobjectinfo.onDeleteAlarm += dataManager.RemoveAlarmData;
+
+            dataManager.onConnectData += panel_dynamicobjectinfo.OnConnectData;
+            dataManager.onLoadData += panel_dataconnectmodal.SetLoadSaveData;
+
+            dataManager.onConnectAlarm += panel_dynamicobjectinfo.OnConnectAlarm;
+            dataManager.onLoadAlarm += panel_alarmconnectmodal.LoadData;
+        }
+    }
+}

Assets/NewStudioJYM/Scripts/StudioJYMCanvas_Popup.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: ce9c9e8dfd0d6774db8b84fbcc818a4e

Assets/NewStudioJYM/Scripts/StudioJYMPopupCanvasHandler.cs

@@ -0,0 +1,14 @@
+using UnityEngine;
+using XED.Manage;
+
+namespace XED
+{
+    public class StudioJYMPopupCanvasHandler : CanvasEventHandler
+    {
+        public StudioJYMPopupCanvasHandler(StudioJYMCanvas_Popup canvas_Popup)
+        {
+            canvas_Popup.panel_dynamicobjectinfo.onConnectedData += canvas_Popup.panel_dataconnectmodal.OpenModal;
+            canvas_Popup.panel_dynamicobjectinfo.onConnectedAlarm += canvas_Popup.panel_alarmconnectmodal.OpenModal;
+        }
+    }
+}

Assets/NewStudioJYM/Scripts/StudioJYMPopupCanvasHandler.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: b312c88a0bcbbd04c959de79c2c4cd71

Assets/NewStudioJYM/Scripts/TestAPIData.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace XED
+{
+    #region LoadData
+    [Serializable]
+    public class Data
+    {
+        public string name;
+        public List<DataClass> dataList;
+    }
+
+    [Serializable]
+    public class DataClass
+    {
+        public string name;
+        public List<FieldData> fields;
+    }
+
+    [Serializable]
+    public class FieldData
+    {
+        public string name;
+        public string type;
+        public string value;
+        public List<MatchingData> matchingValue = new List<MatchingData>();
+    }
+    #endregion
+
+    #region EvnetData
+    [Serializable]
+    public class EventData
+    {
+        public Dictionary<string, Dictionary<string, List<string>>> eventTargets;
+    }
+    #endregion
+
+    [Serializable]
+    public class MatchingData
+    {
+        public string matchingValue;
+        public string matchingType;
+    }
+
+    [Serializable]
+    public class SaveConnectedData
+    {
+        public bool isAPI;
+        public string dataListOptionName;
+
+        public bool isLimitStorageSetting;
+
+        public string dataSource;
+        public List<DataClass> connectDataClass = new List<DataClass>();
+        public List<DataClass> otherDataClasses = new List<DataClass>();
+    }
+
+    [Serializable]
+    public class SaveConnectAlarmData
+    {
+        public string alarmDataName;
+        public List<AlarmField> alarmFields = new List<AlarmField>();
+    }
+    [Serializable]
+    public class AlarmField
+    {
+        public string fieldName;
+        public List<ComparisonCondition> comparisons = new List<ComparisonCondition>();
+    }
+    [Serializable]
+    public class ComparisonCondition
+    {
+        public string comparisonOperator;
+        public string value;
+        public string eventTarget;
+        public List<EventParameter> parameters = new List<EventParameter>();
+    }
+    [Serializable]
+    public class EventParameter
+    {
+        public string eventType;
+        public string parameter;
+    }
+}

Assets/NewStudioJYM/Scripts/TestAPIData.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 95e66905521b2554fa13ad6c1e89ffae

Assets/NewStudioJYM/Scripts/UI_AddOtherDataItem.cs

@@ -0,0 +1,113 @@
+using UnityEngine;
+using TMPro;
+using System.Collections.Generic;
+using System;
+using XRLib.UI;
+using UnityEngine.UI;
+
+namespace XED
+{
+    public class UI_AddOtherDataItem : UIBase
+    {
+        private TMP_Dropdown Dropdown_ClassName;
+        private RectTransform ClassDataContent;
+        private Button Button_Delete;
+
+        private List<string> options = new List<string>();
+        public List<DataClass> datas = new List<DataClass>();
+        private DataClass currentDataClass;
+
+        private UI_AddOtherDataTypeItem addOtherDataTypeItem;
+        public List<UI_AddOtherDataTypeItem> addOtherDataTypeItems = new List<UI_AddOtherDataTypeItem>();
+        private RectTransform originRectTransform;
+
+        public Action onUpdateLayout;
+        public Action<UI_AddOtherDataItem> onDestory;
+
+        public void SetItem(List<DataClass> dataList, DataClass dataClass, UI_AddOtherDataTypeItem addOtherDataTypeItem)
+        {
+            currentDataClass = dataClass;
+
+            this.addOtherDataTypeItem = addOtherDataTypeItem;
+            originRectTransform = addOtherDataTypeItem.rectTransform;
+            Button_Delete.onClick.AddListener(OnClickDeleteButton);
+
+            options.Clear();
+            this.datas.Clear();
+
+            Dropdown_ClassName.ClearOptions();
+
+            for (int i = 0; i < dataList.Count; i++)
+            {
+                this.datas.Add(dataList[i]);
+                options.Add(dataList[i].name);
+            }
+            Dropdown_ClassName.AddOptions(options);
+            Dropdown_ClassName.onValueChanged.AddListener(OnValueChangedClassName);
+
+            var index = dataClass != null ? options.IndexOf(dataClass.name) : 0;
+
+            Dropdown_ClassName.SetValueWithoutNotify(index);
+            GenerateDatTypeItem(index);
+        }
+
+        private void OnClickDeleteButton()
+        {
+            onDestory?.Invoke(this);
+        }
+        private void OnValueChangedClassName(int index)
+        {
+            GenerateDatTypeItem(index);
+        }
+        private void GenerateDatTypeItem(int index)
+        {
+            rectTransform.sizeDelta = originRectTransform.sizeDelta;
+
+            foreach (var item in addOtherDataTypeItems)
+                Destroy(item.gameObject);
+
+            addOtherDataTypeItems.Clear();
+
+            if (currentDataClass == null)
+            {
+                currentDataClass = datas[index];
+            }
+
+            foreach (var field in currentDataClass.fields)
+            {
+                var item = Instantiate(addOtherDataTypeItem, ClassDataContent);
+                item.SetItem(field);
+                addOtherDataTypeItems.Add(item);
+
+                UpdateLayoutOnSettingDataAdded();
+            }
+        }
+        private void UpdateLayoutOnSettingDataAdded()
+        {
+            var height = rectTransform.sizeDelta;
+            height.y += addOtherDataTypeItem.rectTransform.rect.height;
+
+            rectTransform.sizeDelta = height;
+            onUpdateLayout?.Invoke();
+        }
+        public DataClass GetData()
+        {
+            var dataClass = new DataClass();
+            dataClass.name = Dropdown_ClassName.options[Dropdown_ClassName.value].text;
+            dataClass.fields = new List<FieldData>();
+
+            foreach (var item in addOtherDataTypeItems)
+            {
+                var field = item.GetFieldData();
+
+                Debug.Log(field);
+                if (field != null)
+                {
+                    dataClass.fields.Add(field);
+                }
+            }
+
+            return dataClass;
+        }
+    }
+}

Assets/NewStudioJYM/Scripts/UI_AddOtherDataItem.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 71268f3cfea70674bbc33729450e4844

Assets/NewStudioJYM/Scripts/UI_AddOtherDataTypeItem.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+using XRLib.UI;
+
+namespace XED
+{
+    public enum StorageDataType
+    {
+        Int,
+        Float,
+        Double,
+        String
+    }
+    public class UI_AddOtherDataTypeItem : UIBase
+    {
+        private Toggle Toggle_Use;
+        private TextMeshProUGUI DataName;
+        private TMP_Dropdown Dropdown_Type;
+
+        private Dictionary<int, string> options = new Dictionary<int, string>();
+        private bool isUse;
+
+        public void SetItem(FieldData field)
+        {
+            DataName.SetText(field.name);
+            Toggle_Use.onValueChanged.AddListener(OnUseToggleValueChanged);
+            Toggle_Use.isOn = true;
+
+            Dropdown_Type.ClearOptions();
+            var types = Enum.GetNames(typeof(StorageDataType));
+
+            for (int i = 0; i < types.Length; i++)
+            {
+                options.Add(i, types[i]);
+            }
+            Dropdown_Type.AddOptions(options.Values.ToList());
+            Dropdown_Type.onValueChanged.AddListener(OnTypeChanged);
+
+            for (int i = 0; i < options.Count; i++)
+            {
+                if (field.type == options[i])
+                {
+                    Dropdown_Type.value = i;
+                }
+            }
+        }
+
+        private void OnUseToggleValueChanged(bool isOn)
+        {
+            isUse = isOn;
+        }
+
+        private void OnTypeChanged(int value)
+        {
+
+        }
+        public FieldData GetFieldData()
+        {
+            if (!isUse)
+                return null;
+
+            FieldData field = new FieldData();
+            field.name = DataName.text;
+            field.type = Dropdown_Type.options[Dropdown_Type.value].text;
+
+            return field;
+        }
+    }
+}

Assets/NewStudioJYM/Scripts/UI_AddOtherDataTypeItem.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 2a57b7b4127cf0f42a36369f10b2b517

Assets/NewStudioJYM/Scripts/UI_AlarmDataItem.cs

@@ -0,0 +1,135 @@
+using UnityEngine;
+using UnityEngine.UI;
+using XRLib.UI;
+using TMPro;
+using System;
+using System.Collections.Generic;
+
+namespace XED
+{
+    public class UI_AlarmDataItem : UIBase
+    {
+        private Toggle Toggle_Select;
+        private TextMeshProUGUI DataName;
+        private Button Button_AddComparison;
+        private RectTransform ComparisonContent;
+
+        private EventData eventData;
+
+        private UI_ComparisonSettingItem comparisonSettingItem;
+        private UI_EventParameterItem eventParameterItem;
+        private List<UI_ComparisonSettingItem> comparisonSettingItems = new List<UI_ComparisonSettingItem>();
+
+        public Action onUpdateLayout;
+        private AlarmField loadData;
+        private bool isUse;
+
+        public void SetItem(FieldData data, UI_ComparisonSettingItem comparisonSettingItem, UI_EventParameterItem eventParameterItem, EventData eventData)
+        {
+            this.comparisonSettingItem = comparisonSettingItem;
+            this.eventParameterItem = eventParameterItem;
+            this.eventData = eventData;
+
+            DataName.SetText(data.name);
+            Toggle_Select.onValueChanged.AddListener(OnSelectToggleValueChanged);
+            Toggle_Select.isOn = true;
+
+            Button_AddComparison.onClick.AddListener(OnClickAddComparsionButton);
+            comparisonSettingItems.Clear();
+        }
+        public void SetItem(AlarmField data, UI_ComparisonSettingItem comparisonSettingItem, UI_EventParameterItem eventParameterItem, EventData eventData)
+        {
+            loadData = data;
+            this.comparisonSettingItem = comparisonSettingItem;
+            this.eventParameterItem = eventParameterItem;
+            this.eventData = eventData;
+
+            DataName.SetText(data.fieldName);
+            Toggle_Select.onValueChanged.AddListener(OnSelectToggleValueChanged);
+            Toggle_Select.isOn = true;
+
+            Button_AddComparison.onClick.AddListener(OnClickAddComparsionButton);
+            comparisonSettingItems.Clear();
+
+            if (loadData.comparisons.Count > 0)
+            {
+                foreach(var comparison in loadData.comparisons)
+                {
+                    var item = Instantiate(comparisonSettingItem, ComparisonContent);
+                    item.onUpdateLayoutAddParameter += UpdateLayoutAddParameterItem;
+                    item.onUpdateLayoutRemoveParameter += UpdateLayoutRemoveParameterItme;
+                    item.SetItem(comparison, eventParameterItem, eventData);
+                    comparisonSettingItems.Add(item);
+
+                    if (comparisonSettingItems.Count > 1)
+                    {
+                        UpdateLayoutAddComparisonSettingItem();
+                    }
+                }
+            }
+        }
+        private void OnSelectToggleValueChanged(bool isOn)
+        {
+            isUse = isOn;
+            Button_AddComparison.gameObject.SetActive(isOn);
+        }
+        private void OnClickAddComparsionButton()
+        {
+            var item = Instantiate(comparisonSettingItem, ComparisonContent);
+            item.onUpdateLayoutAddParameter += UpdateLayoutAddParameterItem;
+            item.onUpdateLayoutRemoveParameter += UpdateLayoutRemoveParameterItme;
+            item.SetItem(eventParameterItem, eventData);
+            comparisonSettingItems.Add(item);
+
+            if (comparisonSettingItems.Count > 1)
+            {
+                UpdateLayoutAddComparisonSettingItem();
+            }
+        }
+        private void UpdateLayoutAddParameterItem()
+        {
+            var height = rectTransform.sizeDelta;
+            height.y += eventParameterItem.rectTransform.rect.height;
+
+            rectTransform.sizeDelta = height;
+            LayoutRebuilder.ForceRebuildLayoutImmediate(ComparisonContent);
+            onUpdateLayout?.Invoke();
+        }
+        private void UpdateLayoutRemoveParameterItme()
+        {
+            var height = rectTransform.sizeDelta;
+            height.y -= eventParameterItem.rectTransform.rect.height;
+
+            rectTransform.sizeDelta = height;
+            LayoutRebuilder.ForceRebuildLayoutImmediate(ComparisonContent);
+            onUpdateLayout?.Invoke();
+
+        }
+        private void UpdateLayoutAddComparisonSettingItem()
+        {
+            var itemSizeDelta = rectTransform.sizeDelta;
+            itemSizeDelta.y += comparisonSettingItem.rectTransform.rect.height;
+
+            rectTransform.sizeDelta = itemSizeDelta;
+            LayoutRebuilder.ForceRebuildLayoutImmediate(ComparisonContent);
+            onUpdateLayout?.Invoke();
+        }
+
+        public AlarmField GetData()
+        {
+            if (!isUse)
+                return null;
+
+            var alarmField = new AlarmField();
+            alarmField.fieldName = DataName.text;
+            alarmField.comparisons = new List<ComparisonCondition>();
+
+            foreach (var item in comparisonSettingItems)
+            {
+                var field = item.GetComparisonData();
+                alarmField.comparisons.Add(field);
+            }
+            return alarmField;
+        }
+    }
+}

Assets/NewStudioJYM/Scripts/UI_AlarmDataItem.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8548106673f95f241a7b7ddec36c1514

Assets/NewStudioJYM/Scripts/UI_ComparisonSettingItem.cs

@@ -0,0 +1,165 @@
+using System.Collections.Generic;
+using UnityEngine;
+using XRLib.UI;
+using TMPro;
+using UnityEngine.UI;
+using System.Linq;
+using System;
+
+namespace XED
+{
+
+    public class UI_ComparisonSettingItem : UIBase
+    {
+        private TMP_Dropdown Dropdown_Comparison;
+        private TMP_InputField InputField_Value;
+        private Button Button_EventTarget;
+        private TMP_Dropdown Dropdown_EventTarget;
+        private Button Button_AddParameters;
+        private RectTransform EventParametersContent;
+
+        private List<UI_EventParameterItem> eventParameterItems = new List<UI_EventParameterItem>();
+        private UI_EventParameterItem eventParameterItem;
+
+        private List<string> comparisonOptions = new List<string> { ">", "<", ">=", "<=", "==", "!=" };
+        private EventData eventData;
+        private Dictionary<string, List<string>> eventTypes = new Dictionary<string, List<string>>();
+
+        public Action onUpdateLayoutAddParameter;
+        public Action onUpdateLayoutRemoveParameter;
+
+        internal void SetItem(UI_EventParameterItem eventParameterItem, EventData eventData)
+        {
+            this.eventParameterItem = eventParameterItem;
+            this.eventData = eventData;
+
+            SetComparisonDropdown();
+            SetEventTargetDropdown(eventData);
+            Button_EventTarget.onClick.AddListener(OnClickEvnetTargetButton);
+            Button_AddParameters.onClick.AddListener(OnClickAddParametersButton);
+            eventParameterItems.Clear();
+        }
+        public void SetItem(ComparisonCondition loadData, UI_EventParameterItem eventParameterItem , EventData eventData)
+        {
+            this.eventParameterItem = eventParameterItem;
+            this.eventData = eventData;
+
+            SetComparisonDropdown();
+            SetEventTargetDropdown(eventData);
+            Button_EventTarget.onClick.AddListener(OnClickEvnetTargetButton);
+            Button_AddParameters.onClick.AddListener(OnClickAddParametersButton);
+            eventParameterItems.Clear();
+
+            for(int i = 0; i < Dropdown_Comparison.options.Count; i++)
+            {
+                if(Dropdown_Comparison.options[i].text == loadData.comparisonOperator)
+                {
+                    Dropdown_Comparison.value = i;
+                }
+            }
+            InputField_Value.text = loadData.value;
+
+            for (int i = 0; i < Dropdown_EventTarget.options.Count; i++)
+            {
+                if (Dropdown_EventTarget.options[i].text == loadData.eventTarget)
+                {
+                    Dropdown_EventTarget.value = i;
+                }
+            }
+
+            if (loadData.parameters.Count > 0)
+            {
+                foreach (var parameter in loadData.parameters)
+                {
+                    var item = Instantiate(eventParameterItem, EventParametersContent);
+                    item.SetItem(parameter, eventTypes);
+                    eventParameterItems.Add(item);
+
+                    if (eventParameterItems.Count > 1)
+                    {
+                        UpdateLayoutAddParameter();
+                    }
+                }
+            }
+        }
+        private void SetComparisonDropdown()
+        {
+            Dropdown_Comparison.ClearOptions();
+            Dropdown_Comparison.AddOptions(comparisonOptions);
+        }
+        private void SetEventTargetDropdown(EventData eventData)
+        {
+            Dropdown_EventTarget.ClearOptions();
+            Dropdown_EventTarget.AddOptions(eventData.eventTargets.Keys.ToList());
+
+            Dropdown_EventTarget.onValueChanged.AddListener(OnEventTargetValueChanged);
+            OnEventTargetValueChanged(0);
+        }
+        private void OnEventTargetValueChanged(int index)
+        {
+            string selectedTarget = Dropdown_EventTarget.options[index].text;
+            if (!eventData.eventTargets.ContainsKey(selectedTarget)) 
+                return;
+
+            eventTypes = eventData.eventTargets[selectedTarget];
+
+            for(int i = 0; i < eventParameterItems.Count-1; i++)
+            {
+                UpdateLayoutRemoveParameter();
+            }
+
+            foreach (var eventParameterItem in eventParameterItems)
+            {
+                Destroy(eventParameterItem.gameObject);
+            }
+            eventParameterItems.Clear();
+        }
+
+        private void OnClickEvnetTargetButton()
+        {
+            Dropdown_EventTarget.Show();
+        }
+        private void OnClickAddParametersButton()
+        {
+            var item = Instantiate(eventParameterItem, EventParametersContent);
+            item.SetItem(eventTypes);
+            eventParameterItems.Add(item);
+
+            if (eventParameterItems.Count > 1)
+            {
+                UpdateLayoutAddParameter();
+            }
+        }
+        private void UpdateLayoutAddParameter()
+        {
+            var height = rectTransform.sizeDelta;
+            height.y += eventParameterItem.rectTransform.rect.height;
+
+            rectTransform.sizeDelta = height;
+            onUpdateLayoutAddParameter?.Invoke();
+        }
+        private void UpdateLayoutRemoveParameter()
+        {
+            var height = rectTransform.sizeDelta;
+            height.y -= eventParameterItem.rectTransform.rect.height;
+
+            rectTransform.sizeDelta = height;
+            onUpdateLayoutRemoveParameter?.Invoke();
+        }
+
+        public ComparisonCondition GetComparisonData()
+        {
+            var comparisonCondition = new ComparisonCondition();
+            comparisonCondition.comparisonOperator = Dropdown_Comparison.options[Dropdown_Comparison.value].text;
+            comparisonCondition.value = InputField_Value.text;
+            comparisonCondition.eventTarget = Dropdown_EventTarget.options[Dropdown_EventTarget.value].text;
+
+            foreach (var item in eventParameterItems)
+            {
+                var parameters = item.GetParametersData();
+                comparisonCondition.parameters.Add(parameters);
+            }
+            return comparisonCondition;
+        }
+    }
+}

Assets/NewStudioJYM/Scripts/UI_ComparisonSettingItem.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9ce839268adb26243b9f7af4461e6ef5

Assets/NewStudioJYM/Scripts/UI_DataSettingItem.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+using XRLib.UI;
+
+namespace XED
+{
+    public class UI_DataSettingItem : UIBase
+    {
+        public TMP_InputField InputField_ClassName;
+        private RectTransform ClassDataContent;
+
+        private List<UI_DataTypeSelectedItem> items = new List<UI_DataTypeSelectedItem>();
+        private UI_DataTypeSelectedItem dataTypeSelectedItem;
+
+        public Action onUpdateLayout;
+
+        public void SetData(DataClass data, UI_DataTypeSelectedItem typeItem, UI_MatchingTypeDataItem matchingItem)
+        {
+            items.Clear();
+
+            dataTypeSelectedItem = typeItem;
+            InputField_ClassName.text = data.name;
+
+            foreach (var field in data.fields)
+            {
+                var item = Instantiate(typeItem, ClassDataContent);
+                item.onAddMatchingData += UpdateLayoutAddMatchData;
+                item.onDestroyMatchingData += UpdateLayoutRemoveMatchData;
+                item.SetItem(field, matchingItem);
+                
+                items.Add(item);
+                UpdateLayoutOnSettingDataAdded();
+            }
+        }
+        private void UpdateLayoutAddMatchData()
+        {
+            var height = rectTransform.sizeDelta;
+            height.y += dataTypeSelectedItem.rectTransform.rect.height;
+
+            rectTransform.sizeDelta = height;
+            UpdateLayout();
+            onUpdateLayout?.Invoke();
+        }
+        private void UpdateLayoutRemoveMatchData()
+        {
+            var height = rectTransform.sizeDelta;
+            height.y -= dataTypeSelectedItem.rectTransform.rect.height;
+
+            rectTransform.sizeDelta = height;
+            UpdateLayout();
+            onUpdateLayout?.Invoke();
+        }
+        private void UpdateLayoutOnSettingDataAdded()
+        {
+            var height = rectTransform.sizeDelta;
+            height.y += dataTypeSelectedItem.rectTransform.rect.height;
+
+            rectTransform.sizeDelta = height;
+            onUpdateLayout?.Invoke();
+        }
+        private void UpdateLayout()
+        {
+            LayoutRebuilder.ForceRebuildLayoutImmediate(ClassDataContent);
+        }
+        public DataClass GetData()
+        {
+            var dataClass = new DataClass();
+            dataClass.name = InputField_ClassName.text;
+            dataClass.fields = new List<FieldData>();
+
+            foreach (var item in items)
+            {
+                var field = item.GetFieldData();
+
+                if (field != null)
+                {
+                    dataClass.fields.Add(field);
+                }
+            }
+            return dataClass;
+        }
+    }
+}

Assets/NewStudioJYM/Scripts/UI_DataSettingItem.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a946220b8630a2a45880933c6914c9d5

Assets/NewStudioJYM/Scripts/UI_DataTypeSelectedItem.cs

@@ -0,0 +1,151 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+using XRLib.UI;
+
+namespace XED
+{
+    public enum DataType
+    {
+        Int,
+        Float,
+        Double,
+        String,
+        Matching
+    }
+
+    public class UI_DataTypeSelectedItem : UIBase
+    {
+        private Toggle Toggle_Use;
+        private TextMeshProUGUI DataName;
+        private TextMeshProUGUI DataValue;
+        private TMP_Dropdown Dropdown_Type;
+        private Button Button_MatchingAddData;
+        private RectTransform MatchingItemContent;
+
+        private Dictionary<int, string> options = new Dictionary<int, string>();
+        private FieldData fieldData;
+        private MatchingData matchingData;
+
+        private List<UI_MatchingTypeDataItem> matchingTypeDataItems = new List<UI_MatchingTypeDataItem>();
+        private UI_MatchingTypeDataItem matchingTypeDataItem;
+        private bool isUse;
+
+        public Action onAddMatchingData;
+        public Action onDestroyMatchingData;
+
+        public void SetItem(FieldData field, UI_MatchingTypeDataItem matchingTypeDataItem)
+        {
+            matchingTypeDataItems.Clear();
+
+            this.matchingTypeDataItem = matchingTypeDataItem;
+            fieldData = field;
+
+            DataName.SetText(field.name);
+            DataValue.SetText(field.value);
+
+            Toggle_Use.onValueChanged.AddListener(OnUseToggleValueChanged);
+            Button_MatchingAddData.onClick.AddListener(OnClickAddDataButton);
+            SetDropDownData(field);
+
+            Button_MatchingAddData.gameObject.SetActive(false);
+            Toggle_Use.isOn = true;
+
+            if (fieldData.type == "Matching")
+            {
+                foreach (var matchingValue in fieldData.matchingValue)
+                {
+                    matchingData = matchingValue;
+
+                    var item = Instantiate(matchingTypeDataItem, MatchingItemContent);
+                    item.SetItemData(fieldData, matchingData);
+                    item.onDestory += OnDestoryAddDataItem;
+                    matchingTypeDataItems.Add(item);
+
+                    SetAddItem();
+                }
+            }
+        }
+        private void SetDropDownData(FieldData field)
+        {
+            Dropdown_Type.ClearOptions();
+            var types = Enum.GetNames(typeof(DataType));
+
+            for(int i = 0; i < types.Length; i++)
+            {
+                options.Add(i, types[i]);
+            }
+            Dropdown_Type.AddOptions(options.Values.ToList());
+            Dropdown_Type.onValueChanged.AddListener(OnTypeChanged);
+
+            for (int i = 0; i < options.Count; i++)
+            {
+                if (field.type == options[i])
+                {
+                    Dropdown_Type.value = i;
+                }
+            }
+        }
+        private void OnUseToggleValueChanged(bool isOn)
+        {
+            isUse = isOn;
+        }
+        private void OnClickAddDataButton()
+        {
+            var item = Instantiate(matchingTypeDataItem, MatchingItemContent);
+            item.SetItemData(fieldData, matchingData);
+            item.onDestory += OnDestoryAddDataItem;
+            matchingTypeDataItems.Add(item);
+
+            SetAddItem();
+        }
+        private void OnDestoryAddDataItem(UI_MatchingTypeDataItem item)
+        {
+            matchingTypeDataItems.Clear();
+            Destroy(item.gameObject);
+            SetRemoveItem();
+        }
+        private void OnTypeChanged(int value)
+        {
+            var isActive = options[value] == DataType.Matching.ToString();
+            Button_MatchingAddData.gameObject.SetActive(isActive);
+        }
+        private void SetAddItem()
+        {
+            var height = rectTransform.sizeDelta;
+            height.y += matchingTypeDataItem.rectTransform.rect.height;
+
+            rectTransform.sizeDelta = height;
+            onAddMatchingData?.Invoke();
+        }
+        private void SetRemoveItem()
+        {
+            var height = rectTransform.sizeDelta;
+            height.y -= matchingTypeDataItem.rectTransform.rect.height;
+
+            rectTransform.sizeDelta = height;
+            onDestroyMatchingData?.Invoke();
+        }
+        public FieldData GetFieldData()
+        {
+            if (!isUse)
+                return null;
+
+            FieldData field = new FieldData();
+            field.name = DataName.text;
+            field.value = DataValue.text;
+            field.type = Dropdown_Type.options[Dropdown_Type.value].text;
+
+            foreach (var item in matchingTypeDataItems)
+            {
+                var matchingValue = item.GetFieldData();
+                field.matchingValue.Add(matchingValue);
+            }
+
+            return field;
+        }
+    }
+}

Assets/NewStudioJYM/Scripts/UI_DataTypeSelectedItem.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: db7eacdda12e2074aa6c7cdf1daf46d1

Assets/NewStudioJYM/Scripts/UI_EventParameterItem.cs

@@ -0,0 +1,71 @@
+using UnityEngine;
+using XRLib.UI;
+using TMPro;
+using System.Collections.Generic;
+using System.Linq;
+using System;
+
+namespace XED
+{
+    public class UI_EventParameterItem : UIBase
+    {
+        private TMP_Dropdown Dropdown_EventType;
+        private TMP_Dropdown Dropdown_Parameters;
+
+        private Dictionary<string, List<string>> eventTypes = new Dictionary<string, List<string>>();
+
+        public void SetItem(Dictionary<string, List<string>> eventTypes)
+        {
+            this.eventTypes = eventTypes;
+            SetEventTypeDropdown(eventTypes.Keys.ToList());
+        }
+        public void SetItem(EventParameter parameter, Dictionary<string, List<string>> eventTypes)
+        {
+            this.eventTypes = eventTypes;
+            SetEventTypeDropdown(eventTypes.Keys.ToList());
+
+            for (int i = 0; i < Dropdown_EventType.options.Count; i++)
+            {
+                if (Dropdown_EventType.options[i].text == parameter.eventType)
+                {
+                    Dropdown_EventType.value = i;
+                }
+            }
+
+            for (int i = 0; i < Dropdown_Parameters.options.Count; i++)
+            {
+                if (Dropdown_Parameters.options[i].text == parameter.parameter)
+                {
+                    Dropdown_Parameters.value = i;
+                }
+            }
+        }
+        private void SetEventTypeDropdown(List<string> eventTypes)
+        {
+            Dropdown_EventType.ClearOptions();
+            Dropdown_EventType.AddOptions(eventTypes);
+
+            Dropdown_EventType.onValueChanged.AddListener(OnEventTypeChanged);
+            OnEventTypeChanged(0);
+        }
+        void OnEventTypeChanged(int typeIndex)
+        {
+            string selectedType = Dropdown_EventType.options[typeIndex].text;
+            var parameters = eventTypes[selectedType];
+
+            Dropdown_Parameters.ClearOptions();
+            Dropdown_Parameters.AddOptions(parameters);
+        }
+
+        public EventParameter GetParametersData()
+        {
+            var eventParameter = new EventParameter();
+            eventParameter.eventType = Dropdown_EventType.options[Dropdown_EventType.value].text;
+            eventParameter.parameter = Dropdown_Parameters.options[Dropdown_Parameters.value].text;
+
+            return eventParameter;
+        }
+
+        
+    }
+}

Assets/NewStudioJYM/Scripts/UI_EventParameterItem.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: cebef597a42cdd349b3bc10747c15368

Assets/NewStudioJYM/Scripts/UI_LoadAPIDataItem.cs

@@ -0,0 +1,54 @@
+using UnityEngine;
+using XRLib.UI;
+using TMPro;
+using UnityEngine.UI;
+using System;
+using System.Text;
+
+namespace XED
+{
+    public class UI_LoadAPIDataItem : UIBase
+    {
+        public DataClass data;
+        private Button button;
+        private TextMeshProUGUI DataName;
+
+        public Action<DataClass> onClickItem;
+
+        public override void AfterAwake()
+        {
+            button = GetComponent<Button>();
+
+            button.onClick.AddListener(OnClickDataItem);
+        }
+        public void SetData(DataClass data)
+        {
+            this.data = data;
+            var dataText = GenerateHierarchyText(data);
+            DataName.SetText(dataText);
+
+            AdjustHeightToFitText();
+        }
+        void AdjustHeightToFitText()
+        {
+            float preferredHeight = DataName.preferredHeight;
+            rectTransform.sizeDelta = new Vector2(rectTransform.sizeDelta.x, preferredHeight);
+        }
+        private void OnClickDataItem()
+        {
+            onClickItem?.Invoke(data);
+        }
+        private string GenerateHierarchyText(DataClass data)
+        {
+            StringBuilder sb = new StringBuilder();
+
+            sb.AppendLine($"<b>{data.name}</b>");
+            foreach (var field in data.fields)
+            {
+                sb.AppendLine($"\t{field.name} : {field.value}");
+            }
+
+            return sb.ToString();
+        }
+    }
+}

Assets/NewStudioJYM/Scripts/UI_LoadAPIDataItem.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 83d2016360c025f4a8ce58bef77cc43e

Assets/NewStudioJYM/Scripts/UI_MatchingTypeDataItem.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+using XRLib.UI;
+
+namespace XED
+{
+    public enum MatchingDataType
+    {
+        Int,
+        Float,
+        Double,
+        String
+    }
+    public class UI_MatchingTypeDataItem : UIBase
+    {
+        private TextMeshProUGUI OriginValue;
+        private TMP_InputField InputField_Value;
+        private TMP_Dropdown Dropdown_Type;
+        private Button Button_Delete;
+
+        private List<string> options = new List<string>();
+        public Action<UI_MatchingTypeDataItem> onDestory;
+        public void SetItemData(FieldData field, MatchingData matchingData)
+        {
+            OriginValue.SetText(field.value);
+            Button_Delete.onClick.AddListener(OnClickDeleteButton);
+
+            SetDropDownData();
+
+            if (matchingData != null)
+            {
+                InputField_Value.text = matchingData.matchingValue;
+                var types = Enum.GetNames(typeof(MatchingDataType));
+
+                for (int i = 0; i < types.Length; i++)
+                {
+                    if (types[i] == matchingData.matchingType)
+                    {
+                        Dropdown_Type.value = i;
+                    }
+                }
+            }
+        }
+        private void OnClickDeleteButton()
+        {
+            onDestory?.Invoke(this);
+        }
+        private void SetDropDownData()
+        {
+            Dropdown_Type.ClearOptions();
+            var types = Enum.GetNames(typeof(MatchingDataType));
+
+            for (int i = 0; i < types.Length; i++)
+            {
+                options.Add(types[i]);
+            }
+            Dropdown_Type.AddOptions(options);
+            Dropdown_Type.onValueChanged.AddListener(OnDataTypeChanged);
+        }
+        private void OnDataTypeChanged(int index)
+        {
+
+        }
+        public MatchingData GetFieldData()
+        {
+            MatchingData matchingData = new MatchingData();
+            matchingData.matchingValue = InputField_Value.text;
+            matchingData.matchingType = Dropdown_Type.options[Dropdown_Type.value].text;
+
+            return matchingData;
+        }
+    }
+}

Assets/NewStudioJYM/Scripts/UI_MatchingTypeDataItem.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: bac6ec32ddf18fc418e81eef2c42690f

Assets/NewStudioPGD.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9372de26e0b42914693d16bc5756940f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioPGD/NewStudioPGD.unity

@@ -0,0 +1,963 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+OcclusionCullingSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 10
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 0
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
+  m_SkyboxMaterial: {fileID: 10304, guid: 0000000000000000f000000000000000, type: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 0}
+  m_UseRadianceAmbientProbe: 0
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 13
+  m_BakeOnSceneLoad: 0
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 1
+    m_EnableRealtimeLightmaps: 0
+  m_LightmapEditorSettings:
+    serializedVersion: 12
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_AtlasSize: 1024
+    m_AO: 0
+    m_AOMaxDistance: 1
+    m_CompAOExponent: 1
+    m_CompAOExponentDirect: 0
+    m_ExtractAmbientOcclusion: 0
+    m_Padding: 2
+    m_LightmapParameters: {fileID: 0}
+    m_LightmapsBakeMode: 1
+    m_TextureCompression: 1
+    m_ReflectionCompression: 2
+    m_MixedBakeMode: 2
+    m_BakeBackend: 1
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 512
+    m_PVRBounces: 2
+    m_PVREnvironmentSampleCount: 256
+    m_PVREnvironmentReferencePointCount: 2048
+    m_PVRFilteringMode: 1
+    m_PVRDenoiserTypeDirect: 1
+    m_PVRDenoiserTypeIndirect: 1
+    m_PVRDenoiserTypeAO: 1
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
+    m_PVREnvironmentMIS: 1
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ExportTrainingData: 0
+    m_TrainingDataDestination: TrainingData
+    m_LightProbeSampleCountMultiplier: 4
+  m_LightingDataAsset: {fileID: 20201, guid: 0000000000000000f000000000000000, type: 0}
+  m_LightingSettings: {fileID: 0}
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 3
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    buildHeightMesh: 0
+    maxJobWorkers: 0
+    preserveTilesOutsideBounds: 0
+    debug:
+      m_Flags: 0
+  m_NavMeshData: {fileID: 0}
+--- !u!1 &203844586
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 203844589}
+  - component: {fileID: 203844588}
+  - component: {fileID: 203844587}
+  m_Layer: 0
+  m_Name: Directional Light
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &203844587
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 203844586}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 474bcb49853aa07438625e644c072ee6, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Version: 3
+  m_UsePipelineSettings: 1
+  m_AdditionalLightsShadowResolutionTier: 2
+  m_LightLayerMask: 1
+  m_RenderingLayers: 1
+  m_CustomShadowLayers: 0
+  m_ShadowLayerMask: 1
+  m_ShadowRenderingLayers: 1
+  m_LightCookieSize: {x: 1, y: 1}
+  m_LightCookieOffset: {x: 0, y: 0}
+  m_SoftShadowQuality: 0
+--- !u!108 &203844588
+Light:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 203844586}
+  m_Enabled: 1
+  serializedVersion: 11
+  m_Type: 1
+  m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
+  m_Intensity: 1
+  m_Range: 10
+  m_SpotAngle: 30
+  m_InnerSpotAngle: 21.80208
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 2
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+    m_CullingMatrixOverride:
+      e00: 1
+      e01: 0
+      e02: 0
+      e03: 0
+      e10: 0
+      e11: 1
+      e12: 0
+      e13: 0
+      e20: 0
+      e21: 0
+      e22: 1
+      e23: 0
+      e30: 0
+      e31: 0
+      e32: 0
+      e33: 1
+    m_UseCullingMatrixOverride: 0
+  m_Cookie: {fileID: 0}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingLayerMask: 1
+  m_Lightmapping: 4
+  m_LightShadowCasterMode: 0
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_ColorTemperature: 6570
+  m_UseColorTemperature: 0
+  m_BoundingSphereOverride: {x: 0, y: 0, z: 0, w: 0}
+  m_UseBoundingSphereOverride: 0
+  m_UseViewFrustumForShadowCasterCull: 1
+  m_ForceVisible: 0
+  m_ShadowRadius: 0
+  m_ShadowAngle: 0
+  m_LightUnit: 1
+  m_LuxAtDistance: 1
+  m_EnableSpotReflector: 1
+--- !u!4 &203844589
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 203844586}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0.40821788, y: -0.23456968, z: 0.10938163, w: 0.8754261}
+  m_LocalPosition: {x: 0, y: 3, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 50, y: -30, z: 0}
+--- !u!224 &311848408 stripped
+RectTransform:
+  m_CorrespondingSourceObject: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+  m_PrefabInstance: {fileID: 1887807626}
+  m_PrefabAsset: {fileID: 0}
+--- !u!224 &355386520 stripped
+RectTransform:
+  m_CorrespondingSourceObject: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+  m_PrefabInstance: {fileID: 2258882046505576748}
+  m_PrefabAsset: {fileID: 0}
+--- !u!1 &961739749
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 961739753}
+  - component: {fileID: 961739752}
+  - component: {fileID: 961739751}
+  - component: {fileID: 961739750}
+  m_Layer: 0
+  m_Name: Main Camera
+  m_TagString: MainCamera
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &961739750
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 961739749}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: a79441f348de89743a2939f4d699eac1, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_RenderShadows: 1
+  m_RequiresDepthTextureOption: 2
+  m_RequiresOpaqueTextureOption: 2
+  m_CameraType: 0
+  m_Cameras: []
+  m_RendererIndex: -1
+  m_VolumeLayerMask:
+    serializedVersion: 2
+    m_Bits: 1
+  m_VolumeTrigger: {fileID: 0}
+  m_VolumeFrameworkUpdateModeOption: 2
+  m_RenderPostProcessing: 0
+  m_Antialiasing: 0
+  m_AntialiasingQuality: 2
+  m_StopNaN: 0
+  m_Dithering: 0
+  m_ClearDepth: 1
+  m_AllowXRRendering: 1
+  m_AllowHDROutput: 1
+  m_UseScreenCoordOverride: 0
+  m_ScreenSizeOverride: {x: 0, y: 0, z: 0, w: 0}
+  m_ScreenCoordScaleBias: {x: 0, y: 0, z: 0, w: 0}
+  m_RequiresDepthTexture: 0
+  m_RequiresColorTexture: 0
+  m_Version: 2
+  m_TaaSettings:
+    m_Quality: 3
+    m_FrameInfluence: 0.1
+    m_JitterScale: 1
+    m_MipBias: 0
+    m_VarianceClampScale: 0.9
+    m_ContrastAdaptiveSharpening: 0
+--- !u!81 &961739751
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 961739749}
+  m_Enabled: 1
+--- !u!20 &961739752
+Camera:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 961739749}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 1
+  m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
+  m_projectionMatrixMode: 1
+  m_GateFitMode: 2
+  m_FOVAxisMode: 0
+  m_Iso: 200
+  m_ShutterSpeed: 0.005
+  m_Aperture: 16
+  m_FocusDistance: 10
+  m_FocalLength: 50
+  m_BladeCount: 5
+  m_Curvature: {x: 2, y: 11}
+  m_BarrelClipping: 0.25
+  m_Anamorphism: 0
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 60
+  orthographic: 0
+  orthographic size: 5
+  m_Depth: -1
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: -1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 3
+  m_HDR: 1
+  m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+--- !u!4 &961739753
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 961739749}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 1, z: -10}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1370426181
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1370426183}
+  m_Layer: 0
+  m_Name: System
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1370426183
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1370426181}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 2079092962}
+  - {fileID: 1942233514}
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1391670570
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1391670571}
+  m_Layer: 0
+  m_Name: UI
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1391670571
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1391670570}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 311848408}
+  - {fileID: 355386520}
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1001 &1887807626
+PrefabInstance:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    serializedVersion: 3
+    m_TransformParent: {fileID: 1391670571}
+    m_Modifications:
+    - target: {fileID: 253525657185505309, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_SizeDelta.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 1239730593560251137, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMax.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 1239730593560251137, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMin.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 1239730593560251137, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_SizeDelta.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 1239730593560251137, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 1239730593560251137, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 2312695739334003167, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMax.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 2312695739334003167, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMin.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 2312695739334003167, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_SizeDelta.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 2312695739334003167, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 2312695739334003167, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 2432156536456442612, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMax.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 2432156536456442612, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMin.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 2432156536456442612, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_SizeDelta.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 2432156536456442612, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 2432156536456442612, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 2753418293061660152, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_SizeDelta.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 2798069683234581577, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMax.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 2798069683234581577, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMin.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 2798069683234581577, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_SizeDelta.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 2798069683234581577, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 2798069683234581577, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3084249013495611570, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMax.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3084249013495611570, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMin.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3084249013495611570, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_SizeDelta.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3084249013495611570, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3084249013495611570, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_Pivot.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_Pivot.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMax.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMax.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMin.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMin.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_SizeDelta.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_SizeDelta.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_LocalPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_LocalPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_LocalPosition.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_LocalRotation.w
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_LocalRotation.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_LocalRotation.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_LocalRotation.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_LocalEulerAnglesHint.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_LocalEulerAnglesHint.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3552315189416210175, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_LocalEulerAnglesHint.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3866747563631100739, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_SizeDelta.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 5855980027867806708, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMax.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 5855980027867806708, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMin.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 5855980027867806708, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_SizeDelta.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 5855980027867806708, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 5855980027867806708, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7451172879358009799, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_Name
+      value: Canvas_Static
+      objectReference: {fileID: 0}
+    - target: {fileID: 7944627880090399774, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMax.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7944627880090399774, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMin.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7944627880090399774, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_SizeDelta.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7944627880090399774, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7944627880090399774, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 8025648610965927151, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMax.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 8025648610965927151, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMin.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 8025648610965927151, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_SizeDelta.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 8025648610965927151, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 8025648610965927151, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 9162147835510035703, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMax.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 9162147835510035703, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchorMin.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 9162147835510035703, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_SizeDelta.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 9162147835510035703, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 9162147835510035703, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+      propertyPath: m_AnchoredPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+    m_RemovedGameObjects: []
+    m_AddedGameObjects: []
+    m_AddedComponents: []
+  m_SourcePrefab: {fileID: 100100000, guid: f2aeca4b33a9e7948ab82c4f02cae2f2, type: 3}
+--- !u!1 &1942233513
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1942233514}
+  - component: {fileID: 1942233516}
+  - component: {fileID: 1942233515}
+  m_Layer: 0
+  m_Name: EventSystem
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1942233514
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1942233513}
+  serializedVersion: 2
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 1370426183}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &1942233515
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1942233513}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 4f231c4fb786f3946a6b90b886c48677, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_SendPointerHoverToParent: 1
+  m_HorizontalAxis: Horizontal
+  m_VerticalAxis: Vertical
+  m_SubmitButton: Submit
+  m_CancelButton: Cancel
+  m_InputActionsPerSecond: 10
+  m_RepeatDelay: 0.5
+  m_ForceModuleActive: 0
+--- !u!114 &1942233516
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1942233513}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 76c392e42b5098c458856cdf6ecaaaa1, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_FirstSelected: {fileID: 0}
+  m_sendNavigationEvents: 1
+  m_DragThreshold: 10
+--- !u!1 &2079092961
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2079092962}
+  - component: {fileID: 2079092963}
+  m_Layer: 0
+  m_Name: Initializer
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &2079092962
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2079092961}
+  serializedVersion: 2
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 1370426183}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &2079092963
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2079092961}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 8f5ed8769a673ad45ad3ee3267e97c7c, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  targets: []
+  baseUIs: []
+--- !u!1001 &2258882046505576748
+PrefabInstance:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    serializedVersion: 3
+    m_TransformParent: {fileID: 1391670571}
+    m_Modifications:
+    - target: {fileID: 452827164730347798, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_Name
+      value: Canvas_Popup
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_Pivot.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_Pivot.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_AnchorMax.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_AnchorMax.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_AnchorMin.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_AnchorMin.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_SizeDelta.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_SizeDelta.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_LocalPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_LocalPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_LocalPosition.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_LocalRotation.w
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_LocalRotation.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_LocalRotation.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_LocalRotation.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_AnchoredPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_AnchoredPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_LocalEulerAnglesHint.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_LocalEulerAnglesHint.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 7792190748593936658, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+      propertyPath: m_LocalEulerAnglesHint.z
+      value: 0
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+    m_RemovedGameObjects: []
+    m_AddedGameObjects: []
+    m_AddedComponents: []
+  m_SourcePrefab: {fileID: 100100000, guid: 23a5b62354b63214e81741610e6e66e2, type: 3}
+--- !u!1660057539 &9223372036854775807
+SceneRoots:
+  m_ObjectHideFlags: 0
+  m_Roots:
+  - {fileID: 1370426183}
+  - {fileID: 961739753}
+  - {fileID: 203844589}
+  - {fileID: 1391670571}

Assets/NewStudioPGD/NewStudioPGD.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: da3cfbbc493fa584d966b4b64ee3839e
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioPGD/Prefabs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: aaaff30873d6161488de14af0f2d2d10
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioPGD/Prefabs/Canvas_Popup.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 23a5b62354b63214e81741610e6e66e2
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioPGD/Prefabs/Canvas_Static.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: f2aeca4b33a9e7948ab82c4f02cae2f2
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioPGD/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d40a29733fa39c140bd24756d24d50e3
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioPGD/Scripts/Command.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: af761925d50d5024fb038ceb9cb1e386
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioPGD/Scripts/Command/ExitProgramCommand.cs

@@ -0,0 +1,25 @@
+using UnityEngine;
+
+namespace XED.Command
+{
+    public class ExitProgramCommand : IIrreversibleCommand
+    {
+        public ExitProgramCommand()
+        {
+
+        }
+
+        public string id { get => throw new System.NotImplementedException(); set => throw new System.NotImplementedException(); }
+
+        public bool CanExecute()
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public void Execute()
+        {
+            Debug.Log("Exit");
+            Application.Quit();
+        }
+    }
+}

Assets/NewStudioPGD/Scripts/Command/ExitProgramCommand.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a5e265f61efc5e44f8dcaad35017208a

Assets/NewStudioPGD/Scripts/Manager.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 474df4a4abb15124fad7ca53534b2ffc
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioPGD/Scripts/Manager/StudioPopupCanvasHandler.cs

@@ -0,0 +1,18 @@
+namespace XED.Manage
+{
+    public class StudioPopupCanvasHandler : CanvasEventHandler
+    {
+        public StudioPopupCanvasHandler(StudioCanvas_Popup canvas_popup)
+        {
+            canvas_popup.panel_selectlogic.onClickAppSetting += canvas_popup.panel_applogiclist.OnSelectLogic;
+            canvas_popup.panel_selectlogic.onClickAuthentication += canvas_popup.panel_applogiclist.OnSelectLogic;
+            canvas_popup.panel_selectlogic.onClickLanguage += canvas_popup.panel_applogiclist.OnSelectLogic;
+            canvas_popup.panel_selectlogic.onClickLogging += canvas_popup.panel_applogiclist.OnSelectLogic;
+            canvas_popup.panel_selectlogic.onClickAPIConnection += canvas_popup.panel_applogiclist.OnSelectLogic;
+            canvas_popup.panel_selectlogic.onClickMQTTConnection += canvas_popup.panel_applogiclist.OnSelectLogic;
+            canvas_popup.panel_selectlogic.onClickCreate3DObject += canvas_popup.panel_applogiclist.OnSelectLogic;
+            canvas_popup.panel_selectlogic.onClickCreateUI += canvas_popup.panel_applogiclist.OnSelectLogic;
+        }
+    }
+}
+ 

Assets/NewStudioPGD/Scripts/Manager/StudioPopupCanvasHandler.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: e53080ee638fbac49a75cb27bf53baf1

Assets/NewStudioPGD/Scripts/UI.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7b2f4e9a44961314f97ab6ed193f2111
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioPGD/Scripts/UI/Canvas.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 11ad716c898895042b9e60cfb315cd6a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioPGD/Scripts/UI/Canvas/StudioCanvas_Popup.cs

@@ -0,0 +1,20 @@
+using UnityEngine;
+using XED.Manage;
+using XED.UI;
+using XRLib.UI;
+
+namespace XED
+{
+    public class StudioCanvas_Popup : CanvasBase
+    {
+        public Panel_AppLogicList panel_applogiclist;
+        public Panel_SelectLogic panel_selectlogic;
+        public Panel_AppSetting panel_appsetting;
+        public Panel_Authentication panel_authentication;
+
+        private void Awake()
+        {
+            canvasHandler = new StudioPopupCanvasHandler(this);
+        }
+    }
+}

Assets/NewStudioPGD/Scripts/UI/Canvas/StudioCanvas_Popup.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 962441d825727c54b92657b0c4e5fc72

Assets/NewStudioPGD/Scripts/UI/Canvas/StudioCanvas_Static.cs

@@ -0,0 +1,15 @@
+using XED.Command;
+using XRLib.UI;
+
+namespace XED.UI
+{
+    public class StudioCanvas_Static : CanvasBase
+    {
+        public StudioPanel_Topbar studiopanel_topbar;
+
+        public override void AfterAwake()
+        {
+            //studiopanel_topbar.onClickExit += () => CommandInvoker.instance.Invoke(new ExitProgramCommand());
+        }
+    }
+}

Assets/NewStudioPGD/Scripts/UI/Canvas/StudioCanvas_Static.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7b45b7347fd0fe24f80dc309e5f1917a

Assets/NewStudioPGD/Scripts/UI/Element.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e302619c0636cb24c99e8052db74db52
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioPGD/Scripts/UI/Element/UI_LogicItem.cs

@@ -0,0 +1,63 @@
+using System;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+using XRLib.UI;
+
+namespace XED.UI
+{
+    public class UI_LogicItem : UIBase
+    {
+        public Button Button_Edit;
+        public Button Button_Remove;
+        public Button Button_Add;
+
+        public TextMeshProUGUI Text_Title;
+
+        public Action<UI_LogicItem> onClickAdd;
+        public Action<ELogic> onClickEdit;
+        public Action<UI_LogicItem> onClickRemove;
+
+        private ELogic currentLogic;
+
+        public void Awake()
+        {
+            Button_Edit = transform.Find(nameof(Button_Edit)).GetComponent<Button>();
+            Button_Remove = transform.Find(nameof(Button_Remove)).GetComponent<Button>();  
+            Button_Add = transform.Find(nameof(Button_Add)).GetComponent<Button>();
+            Text_Title = transform.Find(nameof(Text_Title)).GetComponent<TextMeshProUGUI>();
+
+            Button_Edit.onClick.AddListener(OnClickEdit);
+            Button_Remove.onClick.AddListener(OnClickRemove);   
+            Button_Add.onClick.AddListener(OnClickAdd);
+
+            Button_Edit.gameObject.SetActive(false);
+            Button_Remove.gameObject.SetActive(false);  
+        }
+
+        private void OnClickEdit()
+        {
+            onClickEdit?.Invoke(currentLogic);
+        }
+
+        private void OnClickRemove()
+        {
+            onClickRemove?.Invoke(this);
+        }
+
+        private void OnClickAdd()
+        {
+            onClickAdd?.Invoke(this);
+        }
+
+        public void OnSelectLogic(ELogic logic)
+        {
+            currentLogic = logic;
+            Text_Title.text = logic.GetDescription();
+            Button_Add.gameObject.SetActive(false);
+            Button_Edit.gameObject.SetActive(true);
+            Button_Remove.gameObject.SetActive(true);
+            Text_Title.gameObject.SetActive(true);
+        }
+    }
+}

Assets/NewStudioPGD/Scripts/UI/Element/UI_LogicItem.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 2004e1ed528dd79428503210325c9aa0

Assets/NewStudioPGD/Scripts/UI/Panel.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 57f9d4f8767e32144acafc24cabc8d0f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/NewStudioPGD/Scripts/UI/Panel/Panel_AppLogicList.cs

@@ -0,0 +1,102 @@
+using NUnit.Framework;
+using Ookii.Dialogs;
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEditor.UIElements;
+using UnityEngine;
+using XED.Manage;
+using XRLib.UI;
+using static UnityEngine.Rendering.DebugUI;
+
+namespace XED.UI
+{
+    public class Panel_AppLogicList : PanelBase
+    {
+        private List<UI_LogicItem> itemList = new();
+        public GameObject logicItem;
+        public RectTransform itemRoot;
+
+        public UI_LogicItem selectItem;
+        public GameObject curInspectorPanel;
+
+        public override void AfterAwake()
+        {
+            logicItem = Resources.Load<GameObject>("Prefabs/UI/PRF_LogicItem");
+            CreateItem();
+        }
+
+        private void CreateItem()
+        {
+            UI_LogicItem item = Instantiate(logicItem, itemRoot).GetComponent<UI_LogicItem>();
+            item.onClickAdd += OnClickAdd;
+            item.onClickEdit += OnClickEdit;
+            item.onClickRemove += OnClickRemove;
+            itemList.Add(item);
+        }
+
+        private void OnClickAdd(UI_LogicItem item)
+        { 
+            selectItem = item;
+            EventConnector.instance.GetCanvas<StudioCanvas_Popup>().panel_selectlogic.Open(true);
+        }
+
+        private void OnClickEdit(ELogic logic)
+        {
+            if (curInspectorPanel != null)
+            {
+                curInspectorPanel.gameObject.SetActive(false);
+                curInspectorPanel = null;
+            }
+
+            switch (logic)
+            {
+                case ELogic.AppSetting:
+                    curInspectorPanel = EventConnector.instance.GetCanvas<StudioCanvas_Popup>().panel_appsetting.gameObject;
+                    break;
+                case ELogic.Authentication:
+                    curInspectorPanel = EventConnector.instance.GetCanvas<StudioCanvas_Popup>().panel_authentication.gameObject;
+                    break;
+                case ELogic.Language:
+                    break;
+                case ELogic.Logging:
+                    break;
+                case ELogic.APIConnection:
+                    break;
+                case ELogic.MQTTConnection:
+                    break;
+                case ELogic.Create3DObject:
+                    break;
+                case ELogic.CreateUI:
+                    break;
+                default:
+                    break;
+            }
+
+            if (curInspectorPanel != null)
+                curInspectorPanel.gameObject.SetActive(true);
+        }
+
+        private void OnClickRemove(UI_LogicItem item)
+        {
+            itemList.Remove(item);
+            Destroy(item.gameObject);  
+
+            if(selectItem == item)
+            {
+                selectItem = null;
+                if (curInspectorPanel != null)
+                    curInspectorPanel.gameObject.SetActive(false);
+            }       
+
+            if (itemList.Count == 0)
+                CreateItem();
+        }
+
+        public void OnSelectLogic(ELogic logic)
+        {       
+            selectItem.OnSelectLogic(logic);
+            CreateItem();
+            EventConnector.instance.GetCanvas<StudioCanvas_Popup>().panel_selectlogic.Open(false);
+        }
+    }
+}

Assets/NewStudioPGD/Scripts/UI/Panel/Panel_AppLogicList.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 046f1781b15f8e5488ff7d69458b910b

Assets/NewStudioPGD/Scripts/UI/Panel/Panel_AppSetting.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+using XRLib.UI;
+
+namespace XED.UI
+{
+    public class Panel_AppSetting : PanelBase
+    {
+        public void Open(bool isOpen)
+        {
+            SetActive(isOpen);
+        }
+    }
+}

Assets/NewStudioPGD/Scripts/UI/Panel/Panel_AppSetting.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 23dd749ccecbdb84ba80499b04cb5082

Assets/NewStudioPGD/Scripts/UI/Panel/Panel_Authentication.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+using XRLib.UI;
+
+namespace XED.UI
+{
+    public class Panel_Authentication : PanelBase
+    {
+        public void Open(bool isOpen)
+        {
+            SetActive(isOpen);
+        }
+    }
+}

Assets/NewStudioPGD/Scripts/UI/Panel/Panel_Authentication.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 0357488cd0c62c94d975970a56f1c0b7

Assets/NewStudioPGD/Scripts/UI/Panel/Panel_SelectLogic.cs

@@ -0,0 +1,119 @@
+using System;
+using System.ComponentModel;
+using System.Security.Cryptography;
+using UnityEngine;
+using UnityEngine.UI;
+using XRLib.UI;
+
+namespace XED.UI
+{
+    public class Panel_SelectLogic : PanelBase
+    {
+        public Button Button_AppSetting;
+        public Button Button_Authentication;
+        public Button Button_Language;
+        public Button Button_Logging;
+        public Button Button_APIConnection;
+        public Button Button_MQTTConnection;
+        public Button Button_Create3DObject;
+        public Button Button_CreateUI;
+
+        public Button Button_Close;
+
+        public Action<ELogic> onClickAppSetting;
+        public Action<ELogic> onClickAuthentication;
+        public Action<ELogic> onClickLanguage;
+        public Action<ELogic> onClickLogging;
+        public Action<ELogic> onClickAPIConnection;
+        public Action<ELogic> onClickMQTTConnection;
+        public Action<ELogic> onClickCreate3DObject;
+        public Action<ELogic> onClickCreateUI;
+
+
+        public override async void AfterAwake()
+        {
+            Button_AppSetting.onClick.AddListener(OnClickAppSetting);
+            Button_Authentication.onClick.AddListener(OnClickAuthentication);
+            Button_Language.onClick.AddListener(OnClickLanguage);
+            Button_Logging.onClick.AddListener(OnClickLogging);
+            Button_APIConnection.onClick.AddListener(OnClickAPIConnection);
+            Button_MQTTConnection.onClick.AddListener(OnClickMQTTConnection);
+            Button_Create3DObject.onClick.AddListener(OnClickCreate3DObject);
+            Button_CreateUI.onClick.AddListener(OnClickCreateUI);   
+
+            Button_Close.onClick.AddListener(() => Open(false));
+        }
+
+        public void Open(bool isOpen)
+        {
+            SetActive(isOpen);
+        }
+
+        public void OnClickAppSetting()
+        {
+            onClickAppSetting?.Invoke(ELogic.AppSetting);
+        }
+
+        public void OnClickAuthentication()
+        {
+            onClickAuthentication?.Invoke(ELogic.Authentication);
+        }
+
+        public void OnClickLanguage()
+        {
+            onClickLanguage?.Invoke(ELogic.Language);
+        }
+
+        public void OnClickLogging()
+        {
+            onClickLogging?.Invoke(ELogic.Logging);
+        }
+
+        public void OnClickAPIConnection()
+        {
+            onClickAPIConnection?.Invoke(ELogic.APIConnection);
+        }
+
+        public void OnClickMQTTConnection()
+        {
+            onClickMQTTConnection?.Invoke(ELogic.MQTTConnection);
+        }
+
+        public void OnClickCreate3DObject()
+        {
+            onClickCreate3DObject?.Invoke(ELogic.Create3DObject);
+        }
+
+        public void OnClickCreateUI()
+        {
+            onClickCreateUI?.Invoke(ELogic.CreateUI);
+        }
+    }
+
+    public enum ELogic
+    {
+        [Description("App 설정")]
+        AppSetting,
+
+        [Description("인증")]
+        Authentication,
+
+        [Description("다국어")]
+        Language,
+
+        [Description("로깅")]
+        Logging,
+
+        [Description("API 연결")]
+        APIConnection,
+
+        [Description("MQTT 연결")]
+        MQTTConnection,
+
+        [Description("3D 객체 생성")]
+        Create3DObject,
+
+        [Description("UI 생성")]
+        CreateUI
+    }
+}

Assets/NewStudioPGD/Scripts/UI/Panel/Panel_SelectLogic.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7b75b0c147e31664fbde00c4ada8826e

Assets/NewStudioPGD/Scripts/UI/Panel/Panel_StartImage.cs

@@ -0,0 +1,17 @@
+using UnityEngine;
+using UnityEngine.UI;
+using XRLib.UI;
+
+namespace XED.UI
+{
+    public class Panel_StartImage : PanelBase
+    {
+        public RawImage image;
+        public Button Button_Open;
+
+        public override void AfterAwake()
+        {
+
+        }
+    }
+}

Assets/NewStudioPGD/Scripts/UI/Panel/Panel_StartImage.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 946307f17551bea41a53e238e2832384

Assets/NewStudioPGD/Scripts/UI/Panel/StudioPanel_Topbar.cs

@@ -0,0 +1,96 @@
+using System;
+using UnityEngine.UI;
+using XRLib.UI;
+
+namespace XED.UI
+{
+    public class StudioPanel_Topbar : PanelBase
+    {
+        /*File*/
+        public Button Button_NewProject;
+        public Button Button_OpenProject;
+        public Button Button_SaveProject;
+        public Button Button_SaveAsProject;
+        public Button Button_Exit;
+
+        public event Action onClickNewProject;
+        public event Action onClickOpenProject;
+        public event Action onClickSaveProject;
+        public event Action onClickSaveAsProject;
+        public event Action onClickExit;
+
+        /*Window*/
+        public Button Button_DataStorage;
+        public Button Button_DataUpdateSetting;
+
+        public event Action onClickDataStorage;
+        public event Action onClickDataUpdateSetting;
+
+        /*Build*/
+        public Button Button_Build;
+        public Button Button_Run;
+
+        public event Action onClickBuild;
+        public event Action onClickRun;
+    
+        public override void AfterAwake()
+        {
+            Button_NewProject.onClick.AddListener(OnClickNewProject);
+            Button_OpenProject.onClick.AddListener(OnClickOpenProject);
+            Button_SaveProject.onClick.AddListener(OnClickSaveProject);
+            Button_SaveAsProject.onClick.AddListener(OnClickSaveAsProject);
+            Button_Exit.onClick.AddListener(OnClickExit);
+
+            Button_DataStorage.onClick.AddListener(OnClickDataStorage);
+            Button_DataUpdateSetting.onClick.AddListener(OnClickDataUpdateSetting);
+
+            Button_Build.onClick.AddListener(OnClickBuild);
+            Button_Run.onClick.AddListener(OnClickRun);
+        }
+
+        private void OnClickNewProject()
+        {
+            onClickNewProject?.Invoke();
+        }
+
+        private void OnClickOpenProject()
+        {
+            onClickOpenProject?.Invoke();
+        }
+
+        private void OnClickSaveProject()
+        {
+            onClickSaveProject?.Invoke();
+        }
+
+        private void OnClickSaveAsProject()
+        {
+            onClickSaveAsProject?.Invoke();
+        }
+
+        private void OnClickExit()
+        {
+            onClickExit?.Invoke();
+        }
+
+        private void OnClickDataStorage()
+        {
+            onClickOpenProject?.Invoke();
+        }
+
+        private void OnClickDataUpdateSetting()
+        {
+            onClickSaveProject?.Invoke();
+        }
+
+        private void OnClickBuild()
+        {
+            onClickSaveAsProject?.Invoke();
+        }
+
+        private void OnClickRun()
+        {
+            onClickExit?.Invoke();
+        }
+    }
+}

Assets/NewStudioPGD/Scripts/UI/Panel/StudioPanel_Topbar.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7f6987e1739948249a379338af8a6cbc

Assets/Prefabs/Manager/AGVNodeManager.prefab

@@ -9,8 +9,6 @@ GameObject:
   serializedVersion: 6
   m_Component:
   - component: {fileID: 1821569750776054505}
-  - component: {fileID: 7245323945551537659}
-  - component: {fileID: 2051839441129491893}
   - component: {fileID: 4636811485307056759}
   - component: {fileID: 8127948644408097011}
   m_Layer: 0
@@ -35,43 +33,6 @@ Transform:
   m_Children: []
   m_Father: {fileID: 0}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!114 &7245323945551537659
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1409607586026230811}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 2bb472437f31bb444ac3a380ebdd2f3f, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: 
-  nodePrefab: {fileID: 2579942234611465176, guid: 5b3355ff1ae888e428ebf6ad2853e303, type: 3}
-  markerPrefab: {fileID: 2579942234611465176, guid: f2ef013240a7d2548b78c9434734181a, type: 3}
-  nodeSelectMode: 2
-  currentlySelectedNode: {fileID: 0}
-  agvNodeMap:
-    maxid: 0
-    agvNodeData: []
---- !u!114 &2051839441129491893
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1409607586026230811}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: a6552f9ab96d944459a5e5a6f3eb6463, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: 
-  moveGizmo:
-    _settings:
-      _canBeDisplayed: 1
-      _isExpanded: 1
-      _transformableLayers: -1
-  target: {fileID: 0}
 --- !u!114 &4636811485307056759
 MonoBehaviour:
   m_ObjectHideFlags: 0
@@ -98,6 +59,6 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 43c2fa2860dfa344d856558ec881bb8a, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  agvPrefab: {fileID: 1505508720499862715, guid: 03eb7e95fc0cb334d848d40c49b4110e, type: 3}
-  agvs: []
-  fileName: Assets/AGVsLog.csv
+  prf_AGV: {fileID: 0}
+  prf_Spec: {fileID: 0}
+  autoIndexing: 0

Assets/Resources/Prefabs/UI/PRF_AddOtherDataItem.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: ed353b04ca4062c4ba550704c7c0e2ec
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Resources/Prefabs/UI/PRF_AddOtherDataTypeItem.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: e52b0f3c33e70bf438cd83f1d6cbd540
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Resources/Prefabs/UI/PRF_AlarmDataItem.prefab

@@ -0,0 +1,763 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &580650275896055364
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 7885574299830805302}
+  - component: {fileID: 3512329071412578955}
+  m_Layer: 5
+  m_Name: Toggle_Select
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &7885574299830805302
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 580650275896055364}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 1860536856826159754}
+  m_Father: {fileID: 8330830032428453570}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMax: {x: 0, y: 1}
+  m_AnchoredPosition: {x: 20, y: -25}
+  m_SizeDelta: {x: 30, y: 30}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &3512329071412578955
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 580650275896055364}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 9085046f02f69544eb97fd06b6048fe2, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Navigation:
+    m_Mode: 3
+    m_WrapAround: 0
+    m_SelectOnUp: {fileID: 0}
+    m_SelectOnDown: {fileID: 0}
+    m_SelectOnLeft: {fileID: 0}
+    m_SelectOnRight: {fileID: 0}
+  m_Transition: 1
+  m_Colors:
+    m_NormalColor: {r: 1, g: 1, b: 1, a: 1}
+    m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1}
+    m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608}
+    m_ColorMultiplier: 1
+    m_FadeDuration: 0.1
+  m_SpriteState:
+    m_HighlightedSprite: {fileID: 0}
+    m_PressedSprite: {fileID: 0}
+    m_SelectedSprite: {fileID: 0}
+    m_DisabledSprite: {fileID: 0}
+  m_AnimationTriggers:
+    m_NormalTrigger: Normal
+    m_HighlightedTrigger: Highlighted
+    m_PressedTrigger: Pressed
+    m_SelectedTrigger: Selected
+    m_DisabledTrigger: Disabled
+  m_Interactable: 1
+  m_TargetGraphic: {fileID: 6647817114326598145}
+  toggleTransition: 1
+  graphic: {fileID: 1269924820877808733}
+  m_Group: {fileID: 0}
+  onValueChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_IsOn: 0
+--- !u!1 &1821972484055790974
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4805910123159231676}
+  - component: {fileID: 1105825744325459895}
+  - component: {fileID: 58234951300460856}
+  m_Layer: 5
+  m_Name: DataName
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &4805910123159231676
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1821972484055790974}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 8330830032428453570}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMax: {x: 0, y: 1}
+  m_AnchoredPosition: {x: 100, y: -25}
+  m_SizeDelta: {x: 120, y: 40}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &1105825744325459895
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1821972484055790974}
+  m_CullTransparentMesh: 1
+--- !u!114 &58234951300460856
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1821972484055790974}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
+  m_Maskable: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_text: data
+  m_isRightToLeft: 0
+  m_fontAsset: {fileID: 11400000, guid: 4f170a218dfffe4489dc7ddd54bc15cf, type: 2}
+  m_sharedMaterial: {fileID: 6975767319296004534, guid: 4f170a218dfffe4489dc7ddd54bc15cf, type: 2}
+  m_fontSharedMaterials: []
+  m_fontMaterial: {fileID: 0}
+  m_fontMaterials: []
+  m_fontColor32:
+    serializedVersion: 2
+    rgba: 4278190080
+  m_fontColor: {r: 0, g: 0, b: 0, a: 1}
+  m_enableVertexGradient: 0
+  m_colorMode: 3
+  m_fontColorGradient:
+    topLeft: {r: 1, g: 1, b: 1, a: 1}
+    topRight: {r: 1, g: 1, b: 1, a: 1}
+    bottomLeft: {r: 1, g: 1, b: 1, a: 1}
+    bottomRight: {r: 1, g: 1, b: 1, a: 1}
+  m_fontColorGradientPreset: {fileID: 0}
+  m_spriteAsset: {fileID: 0}
+  m_tintAllSprites: 0
+  m_StyleSheet: {fileID: 0}
+  m_TextStyleHashCode: -1183493901
+  m_overrideHtmlColors: 0
+  m_faceColor:
+    serializedVersion: 2
+    rgba: 4294967295
+  m_fontSize: 20
+  m_fontSizeBase: 20
+  m_fontWeight: 400
+  m_enableAutoSizing: 0
+  m_fontSizeMin: 18
+  m_fontSizeMax: 72
+  m_fontStyle: 0
+  m_HorizontalAlignment: 2
+  m_VerticalAlignment: 512
+  m_textAlignment: 65535
+  m_characterSpacing: 0
+  m_wordSpacing: 0
+  m_lineSpacing: 0
+  m_lineSpacingMax: 0
+  m_paragraphSpacing: 0
+  m_charWidthMaxAdj: 0
+  m_TextWrappingMode: 1
+  m_wordWrappingRatios: 0.4
+  m_overflowMode: 0
+  m_linkedTextComponent: {fileID: 0}
+  parentLinkedComponent: {fileID: 0}
+  m_enableKerning: 0
+  m_ActiveFontFeatures: 6e72656b
+  m_enableExtraPadding: 0
+  checkPaddingRequired: 0
+  m_isRichText: 1
+  m_EmojiFallbackSupport: 1
+  m_parseCtrlCharacters: 1
+  m_isOrthographic: 1
+  m_isCullingEnabled: 0
+  m_horizontalMapping: 0
+  m_verticalMapping: 0
+  m_uvLineOffset: 0
+  m_geometrySortingOrder: 0
+  m_IsTextObjectScaleStatic: 0
+  m_VertexBufferAutoSizeReduction: 0
+  m_useMaxVisibleDescender: 1
+  m_pageToDisplay: 1
+  m_margin: {x: 0, y: 0, z: 0, w: 0}
+  m_isUsingLegacyAnimationComponent: 0
+  m_isVolumetricText: 0
+  m_hasFontAssetChanged: 0
+  m_baseMaterial: {fileID: 0}
+  m_maskOffset: {x: 0, y: 0, z: 0, w: 0}
+--- !u!1 &6511882735575238398
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 7689405792261404046}
+  - component: {fileID: 4735248028288402880}
+  - component: {fileID: 1269924820877808733}
+  m_Layer: 5
+  m_Name: Checkmark
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &7689405792261404046
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6511882735575238398}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 1860536856826159754}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0.5, y: 0.5}
+  m_AnchorMax: {x: 0.5, y: 0.5}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 30, y: 30}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &4735248028288402880
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6511882735575238398}
+  m_CullTransparentMesh: 1
+--- !u!114 &1269924820877808733
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6511882735575238398}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
+  m_Maskable: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 10901, guid: 0000000000000000f000000000000000, type: 0}
+  m_Type: 0
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1
+--- !u!1 &7129588682176583959
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 8330830032428453570}
+  - component: {fileID: 8542306398605029070}
+  - component: {fileID: 4280132367170485869}
+  m_Layer: 5
+  m_Name: PRF_AlarmDataItem
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &8330830032428453570
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7129588682176583959}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 7885574299830805302}
+  - {fileID: 4805910123159231676}
+  - {fileID: 6887532054169147474}
+  - {fileID: 9007934292354328552}
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 0}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 1518, y: 50}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &8542306398605029070
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7129588682176583959}
+  m_CullTransparentMesh: 1
+--- !u!114 &4280132367170485869
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7129588682176583959}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 8548106673f95f241a7b7ddec36c1514, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+--- !u!1 &7231081533701205692
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 3284476053162506490}
+  - component: {fileID: 3262731639988721273}
+  - component: {fileID: 4973999785011315393}
+  m_Layer: 5
+  m_Name: Text (TMP)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &3284476053162506490
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7231081533701205692}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 6887532054169147474}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &3262731639988721273
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7231081533701205692}
+  m_CullTransparentMesh: 1
+--- !u!114 &4973999785011315393
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7231081533701205692}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
+  m_Maskable: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_text: +
+  m_isRightToLeft: 0
+  m_fontAsset: {fileID: 11400000, guid: 4f170a218dfffe4489dc7ddd54bc15cf, type: 2}
+  m_sharedMaterial: {fileID: 6975767319296004534, guid: 4f170a218dfffe4489dc7ddd54bc15cf, type: 2}
+  m_fontSharedMaterials: []
+  m_fontMaterial: {fileID: 0}
+  m_fontMaterials: []
+  m_fontColor32:
+    serializedVersion: 2
+    rgba: 4281479730
+  m_fontColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1}
+  m_enableVertexGradient: 0
+  m_colorMode: 3
+  m_fontColorGradient:
+    topLeft: {r: 1, g: 1, b: 1, a: 1}
+    topRight: {r: 1, g: 1, b: 1, a: 1}
+    bottomLeft: {r: 1, g: 1, b: 1, a: 1}
+    bottomRight: {r: 1, g: 1, b: 1, a: 1}
+  m_fontColorGradientPreset: {fileID: 0}
+  m_spriteAsset: {fileID: 0}
+  m_tintAllSprites: 0
+  m_StyleSheet: {fileID: 0}
+  m_TextStyleHashCode: -1183493901
+  m_overrideHtmlColors: 0
+  m_faceColor:
+    serializedVersion: 2
+    rgba: 4294967295
+  m_fontSize: 24
+  m_fontSizeBase: 24
+  m_fontWeight: 400
+  m_enableAutoSizing: 0
+  m_fontSizeMin: 18
+  m_fontSizeMax: 72
+  m_fontStyle: 0
+  m_HorizontalAlignment: 2
+  m_VerticalAlignment: 512
+  m_textAlignment: 65535
+  m_characterSpacing: 0
+  m_wordSpacing: 0
+  m_lineSpacing: 0
+  m_lineSpacingMax: 0
+  m_paragraphSpacing: 0
+  m_charWidthMaxAdj: 0
+  m_TextWrappingMode: 1
+  m_wordWrappingRatios: 0.4
+  m_overflowMode: 0
+  m_linkedTextComponent: {fileID: 0}
+  parentLinkedComponent: {fileID: 0}
+  m_enableKerning: 0
+  m_ActiveFontFeatures: 6e72656b
+  m_enableExtraPadding: 0
+  checkPaddingRequired: 0
+  m_isRichText: 1
+  m_EmojiFallbackSupport: 1
+  m_parseCtrlCharacters: 1
+  m_isOrthographic: 1
+  m_isCullingEnabled: 0
+  m_horizontalMapping: 0
+  m_verticalMapping: 0
+  m_uvLineOffset: 0
+  m_geometrySortingOrder: 0
+  m_IsTextObjectScaleStatic: 0
+  m_VertexBufferAutoSizeReduction: 0
+  m_useMaxVisibleDescender: 1
+  m_pageToDisplay: 1
+  m_margin: {x: 0, y: 0, z: 0, w: 0}
+  m_isUsingLegacyAnimationComponent: 0
+  m_isVolumetricText: 0
+  m_hasFontAssetChanged: 0
+  m_baseMaterial: {fileID: 0}
+  m_maskOffset: {x: 0, y: 0, z: 0, w: 0}
+--- !u!1 &7730347637062935159
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 9007934292354328552}
+  - component: {fileID: 1258315587987901983}
+  - component: {fileID: 3194288757223014262}
+  m_Layer: 5
+  m_Name: ComparisonContent
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &9007934292354328552
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7730347637062935159}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 8330830032428453570}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMax: {x: 0, y: 1}
+  m_AnchoredPosition: {x: 638.04, y: -25}
+  m_SizeDelta: {x: 876.0835, y: 50}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &1258315587987901983
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7730347637062935159}
+  m_CullTransparentMesh: 1
+--- !u!114 &3194288757223014262
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7730347637062935159}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 59f8146938fff824cb5fd77236b75775, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Padding:
+    m_Left: 0
+    m_Right: 0
+    m_Top: 0
+    m_Bottom: 0
+  m_ChildAlignment: 0
+  m_Spacing: 0
+  m_ChildForceExpandWidth: 0
+  m_ChildForceExpandHeight: 0
+  m_ChildControlWidth: 0
+  m_ChildControlHeight: 0
+  m_ChildScaleWidth: 0
+  m_ChildScaleHeight: 0
+  m_ReverseArrangement: 0
+--- !u!1 &8908414945336457589
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 6887532054169147474}
+  - component: {fileID: 2913010496988415797}
+  - component: {fileID: 1149622448526824162}
+  - component: {fileID: 7408597591433957505}
+  m_Layer: 5
+  m_Name: Button_AddComparison
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &6887532054169147474
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8908414945336457589}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 3284476053162506490}
+  m_Father: {fileID: 8330830032428453570}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMax: {x: 0, y: 1}
+  m_AnchoredPosition: {x: 180, y: -25}
+  m_SizeDelta: {x: 40, y: 40}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &2913010496988415797
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8908414945336457589}
+  m_CullTransparentMesh: 1
+--- !u!114 &1149622448526824162
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8908414945336457589}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
+  m_Maskable: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 10905, guid: 0000000000000000f000000000000000, type: 0}
+  m_Type: 1
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1
+--- !u!114 &7408597591433957505
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8908414945336457589}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 4e29b1a8efbd4b44bb3f3716e73f07ff, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Navigation:
+    m_Mode: 3
+    m_WrapAround: 0
+    m_SelectOnUp: {fileID: 0}
+    m_SelectOnDown: {fileID: 0}
+    m_SelectOnLeft: {fileID: 0}
+    m_SelectOnRight: {fileID: 0}
+  m_Transition: 1
+  m_Colors:
+    m_NormalColor: {r: 1, g: 1, b: 1, a: 1}
+    m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1}
+    m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608}
+    m_ColorMultiplier: 1
+    m_FadeDuration: 0.1
+  m_SpriteState:
+    m_HighlightedSprite: {fileID: 0}
+    m_PressedSprite: {fileID: 0}
+    m_SelectedSprite: {fileID: 0}
+    m_DisabledSprite: {fileID: 0}
+  m_AnimationTriggers:
+    m_NormalTrigger: Normal
+    m_HighlightedTrigger: Highlighted
+    m_PressedTrigger: Pressed
+    m_SelectedTrigger: Selected
+    m_DisabledTrigger: Disabled
+  m_Interactable: 1
+  m_TargetGraphic: {fileID: 1149622448526824162}
+  m_OnClick:
+    m_PersistentCalls:
+      m_Calls: []
+--- !u!1 &9198743607145138306
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1860536856826159754}
+  - component: {fileID: 5886912097486708208}
+  - component: {fileID: 6647817114326598145}
+  m_Layer: 5
+  m_Name: Background
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1860536856826159754
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 9198743607145138306}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 7689405792261404046}
+  m_Father: {fileID: 7885574299830805302}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMax: {x: 0, y: 1}
+  m_AnchoredPosition: {x: 15, y: -15}
+  m_SizeDelta: {x: 30, y: 30}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &5886912097486708208
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 9198743607145138306}
+  m_CullTransparentMesh: 1
+--- !u!114 &6647817114326598145
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 9198743607145138306}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
+  m_Maskable: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 10905, guid: 0000000000000000f000000000000000, type: 0}
+  m_Type: 1
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1

Assets/Resources/Prefabs/UI/PRF_AlarmDataItem.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 92cbd34864323164ab25ea3096e48087
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Resources/Prefabs/UI/PRF_AssetLibraryItem.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 9e62001ea460aa642abd1fbdaf7aeef4
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: