gg.easy.airship 0.1.2103 → 0.1.2105

package/Editor/Accessories/AccessoryEditorWindow.cs

@@ -34,8 +34,8 @@ namespace Editor.Accessories {
         private AccessoryPrefabEditor prefabEditor;
         private GameObject characterGO;
         List<AccessoryComponent> allAccessories = new List<AccessoryComponent>();
-        private AccessoryComponent _editingAccessoryComponent;
-        private AccessoryComponent _referenceAccessoryComponent;
+        private AccessoryComponent editingAccessoryComponent;
+        private AccessoryComponent referenceAccessoryComponent;
         private ListView _listPane;
 
         private Label _selectedItemLabel;
@@ -57,8 +57,8 @@ namespace Editor.Accessories {
             }
 
             _prefabStage = null;
-            _editingAccessoryComponent = null;
-            _referenceAccessoryComponent = null;
+            editingAccessoryComponent = null;
+            referenceAccessoryComponent = null;
             
             if (characterGO) {
                 DestroyImmediate(characterGO);
@@ -130,7 +130,7 @@ namespace Editor.Accessories {
             saveBtn.text = "Save";
             buttonPanel.Add(saveBtn);
             saveBtn.clickable.clicked += () => {
-                if (_editingAccessoryComponent == null || _referenceAccessoryComponent == null) return;
+                if (editingAccessoryComponent == null || referenceAccessoryComponent == null) return;
                 SaveCurrentAccessory();
             };
 
@@ -139,7 +139,7 @@ namespace Editor.Accessories {
             resetBtn.text = "Reset";
             buttonPanel.Add(resetBtn);
             resetBtn.clickable.clicked += () => {
-                if (_editingAccessoryComponent == null || _referenceAccessoryComponent == null) return;
+                if (editingAccessoryComponent == null || referenceAccessoryComponent == null) return;
                 ResetCurrentAccessory();
             };
 
@@ -219,9 +219,9 @@ namespace Editor.Accessories {
 
         private void ClearCurrentAccessory() {
             Log("ClearCurrentAccessory");
-            if (_editingAccessoryComponent) {
-                DestroyImmediate(_editingAccessoryComponent.gameObject);
-                _editingAccessoryComponent = null;
+            if (editingAccessoryComponent) {
+                DestroyImmediate(editingAccessoryComponent.gameObject);
+                editingAccessoryComponent = null;
             }
 
             if (_selectedItemLabel != null) {
@@ -229,9 +229,11 @@ namespace Editor.Accessories {
             }
         }
 
+
+        private bool hasFramedView = false;
         private void BuildScene(AccessoryComponent accessoryComponent, bool forceRedraw = false) {
-            var newItem = accessoryComponent != _referenceAccessoryComponent;
-            Log("Building Scene. New Item: " + newItem + " acc: " + accessoryComponent?.gameObject.name + " oldAcc: " + _referenceAccessoryComponent?.gameObject.name);
+            var newItem = accessoryComponent != referenceAccessoryComponent;
+            Log("Building Scene. New Item: " + newItem + " acc: " + accessoryComponent?.gameObject.name + " oldAcc: " + referenceAccessoryComponent?.gameObject.name);
             if (_prefabStage == null || characterGO == null) {
                 CreateStage();
             }
@@ -252,17 +254,24 @@ namespace Editor.Accessories {
                     return;
                 }
 
-                
                 var go = (GameObject)PrefabUtility.InstantiatePrefab(accessoryComponent.gameObject, parent);
                 if (go != null) {
-                    _editingAccessoryComponent = go.GetComponent<AccessoryComponent>();
-                    _referenceAccessoryComponent = accessoryComponent;
+                    this.editingAccessoryComponent = go.GetComponent<AccessoryComponent>();
+                    this.referenceAccessoryComponent = accessoryComponent;
                     //accessoryComponent.gameObject.hideFlags = HideFlags.DontSave;
                     Selection.activeObject = go;
                     Selection.activeGameObject = go;
-                    SceneView.FrameLastActiveSceneView();
+                    // SceneView.FrameLastActiveSceneView();
 
                     _selectedItemLabel.text = accessoryComponent.name;
+
+                    if (this.editingAccessoryComponent.skinnedToCharacter) {
+                        var skinnedMeshRenderers = go.GetComponentsInChildren<SkinnedMeshRenderer>();
+                        foreach (var skinnedMeshRenderer in skinnedMeshRenderers) {
+                            skinnedMeshRenderer.rootBone = rig.bodyMesh.rootBone;
+                            skinnedMeshRenderer.bones = rig.bodyMesh.bones;
+                        }
+                    }
                 }
             }
         }
@@ -366,30 +375,30 @@ namespace Editor.Accessories {
         }
 
         private void SaveCurrentAccessory() {
-            if (!_referenceAccessoryComponent) {
+            if (!referenceAccessoryComponent) {
                 Debug.LogError("Trying to save with an empty accessory component");
                 return;
             }
 
-            Log("Saving acc: " + _referenceAccessoryComponent.gameObject.name);
-            Undo.RecordObject(_referenceAccessoryComponent, "Save Accessory");
-            _referenceAccessoryComponent.Copy(_editingAccessoryComponent);
-            PrefabUtility.RecordPrefabInstancePropertyModifications(_referenceAccessoryComponent);
-            EditorUtility.SetDirty(_referenceAccessoryComponent);
-            PrefabUtility.ApplyPrefabInstance(_editingAccessoryComponent.gameObject, InteractionMode.UserAction);
+            Log("Saving acc: " + referenceAccessoryComponent.gameObject.name);
+            Undo.RecordObject(referenceAccessoryComponent, "Save Accessory");
+            referenceAccessoryComponent.Copy(editingAccessoryComponent);
+            PrefabUtility.RecordPrefabInstancePropertyModifications(referenceAccessoryComponent);
+            EditorUtility.SetDirty(referenceAccessoryComponent);
+            PrefabUtility.ApplyPrefabInstance(editingAccessoryComponent.gameObject, InteractionMode.UserAction);
             AssetDatabase.SaveAssets();
         }
 
         private void ResetCurrentAccessory() {
-            if(!_referenceAccessoryComponent){
+            if(!referenceAccessoryComponent){
                 Debug.LogError("Trying to reset an empty accessory component");
                 return;
             }
-            Log("Resetting acc: " + _referenceAccessoryComponent.gameObject.name);
-            Undo.RecordObject(_editingAccessoryComponent.transform, "ResetTransform");
-            _editingAccessoryComponent.transform.SetLocalPositionAndRotation(_referenceAccessoryComponent.localPosition, _referenceAccessoryComponent.localRotation);
-            _editingAccessoryComponent.localScale = _referenceAccessoryComponent.localScale;
-            PrefabUtility.RevertPrefabInstance(_editingAccessoryComponent.gameObject, InteractionMode.UserAction);
+            Log("Resetting acc: " + referenceAccessoryComponent.gameObject.name);
+            Undo.RecordObject(editingAccessoryComponent.transform, "ResetTransform");
+            editingAccessoryComponent.transform.SetLocalPositionAndRotation(referenceAccessoryComponent.localPosition, referenceAccessoryComponent.localRotation);
+            editingAccessoryComponent.localScale = referenceAccessoryComponent.localScale;
+            PrefabUtility.RevertPrefabInstance(editingAccessoryComponent.gameObject, InteractionMode.UserAction);
         }
 
         private void SetPose(PoseType poseType){

package/Editor/Accessories/Clothing/PlatformGearBundleManifestEditor.cs

@@ -224,7 +224,8 @@ namespace Editor.Accessories.Clothing {
                     category = category,
                     subcategory = subcategory,
                 };
-                var req = UnityWebRequest.Put($"{AirshipPlatformUrl.contentService}/gear/class-id/{gear.classId}",
+                var url = $"{AirshipPlatformUrl.contentService}/gear/class-id/{gear.classId}";
+                var req = UnityWebRequest.Put(url,
                     JsonUtility.ToJson(data));
                 req.method = "PATCH";
                 req.SetRequestHeader("Content-Type","application/json");
@@ -232,7 +233,7 @@ namespace Editor.Accessories.Clothing {
                 req.SetRequestHeader("x-airship-ignore-rate-limit", "true");
                 await req.SendWebRequest();
                 if (req.result != UnityWebRequest.Result.Success) {
-                    Debug.LogError("patch classId response: " + req.downloadHandler.text);
+                    Debug.LogError($"patch classId. url: {url}, response: {req.downloadHandler.text}, authToken: {InternalHttpManager.editorAuthToken}");
                     return;
                 }
             }

package/Editor/AirAsset/AirAssetBundleEditor.cs

@@ -0,0 +1,225 @@
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Code.Accessories.Clothing;
+using Code.AirAssetBundle;
+using Code.Bootstrap;
+using Code.Http.Internal;
+using Code.Platform.Shared;
+using Editor.Accessories.Clothing;
+using Editor.Packages;
+using UnityEditor;
+using UnityEditor.Build.Pipeline;
+using UnityEngine;
+using UnityEngine.Networking;
+using Debug = UnityEngine.Debug;
+
+namespace Editor.AirAsset {
+    [CustomEditor(typeof(AirAssetBundle))]
+    [CanEditMultipleObjects]
+    public class AirAssetBundleEditor : UnityEditor.Editor {
+        private static string easyOrgId = "6b62d6e3-9d74-449c-aeac-b4feed2012b1";
+        private bool skipBuild = false;
+
+        private void OnEnable() {
+            skipBuild = false;
+        }
+
+        public override void OnInspectorGUI() {
+            base.DrawDefaultInspector();
+
+            GUILayout.Space(20);
+            AirshipEditorGUI.HorizontalLine();
+            GUILayout.Space(20);
+
+            if (GUILayout.Button("Publish")) {
+                this.BuildAllPlatforms();
+            }
+
+            GUILayout.Space(10);
+            this.skipBuild = EditorGUILayout.Toggle("Skip Build", this.skipBuild);
+        }
+
+        private async void BuildAllPlatforms() {
+            var st = Stopwatch.StartNew();
+            bool success = true;
+
+            List<AirshipPlatform> platforms = new();
+            platforms.AddRange(AirshipPlatformUtil.livePlatforms);
+            // platforms.Add(AirshipPlatform.Mac); // debug
+
+            // ********************************* //
+            var airAssetBundle = (AirAssetBundle)this.target;
+
+            if (!CreateAssetBundles.PrePublishChecks()) return;
+
+            string airId = airAssetBundle.airId;
+
+            var contentName = airAssetBundle.name;
+            var contentDescription = "Air Asset Bundle";
+
+            if (string.IsNullOrEmpty(airId)) {
+                // Create new air asset
+                var req = UnityWebRequest.PostWwwForm(
+                    AirshipPlatformUrl.deploymentService + $"/air-assets/owner-type/ORGANIZATION/owner-id/{easyOrgId}",
+                    JsonUtility.ToJson(new AirAssetCreateRequest() {
+                        contentType = "application/airasset",
+                        contentLength = 1,
+                        name = contentName,
+                        description = contentDescription,
+                        platforms = platforms.Select((p) => AirshipPlatformUtil.GetStringName(p)).ToArray(),
+                    }));
+                req.SetRequestHeader("Authorization", "Bearer " + InternalHttpManager.editorAuthToken);
+                await req.SendWebRequest();
+                Debug.Log("create response: " + req.downloadHandler.text);
+                var data = JsonUtility.FromJson<AirAssetCreateResponse>(req.downloadHandler.text);
+                airAssetBundle.airId = data.airAssetId;
+                EditorUtility.SetDirty(this.target);
+                this.SaveChanges();
+                airId = data.airAssetId;
+            }
+
+            List<string> bundlePaths = new();
+            foreach (var platform in platforms) {
+                var path = await this.BuildPlatform(platform, airId);
+                if (string.IsNullOrEmpty(path)) {
+                    success = false;
+                    return;
+                }
+
+                bundlePaths.Add(path);
+            }
+
+            if (!success) return;
+
+            // ******************** //
+
+            int bytesCount = 0;
+            for (int i = 0; i < platforms.Count; i++) {
+                var platform = platforms[i];
+                var buildOutputFile = bundlePaths[i];
+
+                // Update air asset
+                var bytes = await File.ReadAllBytesAsync(buildOutputFile);
+                Debug.Log("bytes length: " + bytes.Length + ", path: " + buildOutputFile);
+                bytesCount = bytes.Length;
+                var updateReq = UnityWebRequest.Put(AirshipPlatformUrl.deploymentService + $"/air-assets/{airId}",
+                    JsonUtility.ToJson(new AirAssetCreateRequest() {
+                        contentType = "application/airasset",
+                        contentLength = bytes.Length,
+                        name = contentName,
+                        description = contentDescription,
+                        platforms = platforms.Select((p) => AirshipPlatformUtil.GetStringName(p)).ToArray(),
+                    }));
+                updateReq.SetRequestHeader("Content-Type", "application/json");
+                updateReq.SetRequestHeader("Authorization", "Bearer " + InternalHttpManager.editorAuthToken);
+                updateReq.SetRequestHeader("x-airship-ignore-rate-limit", "true");
+                await updateReq.SendWebRequest();
+                if (updateReq.result != UnityWebRequest.Result.Success) {
+                    Debug.LogError("Failed to update air asset: " + updateReq.downloadHandler.text);
+                    return;
+                }
+                var updateData = JsonUtility.FromJson<AirAssetCreateResponse>(updateReq.downloadHandler.text);
+                var uploadUrl = updateData.urls.UrlFromPlatform(platform);
+
+                // Upload asset bundle
+                {
+                    UnityWebRequest putReq = UnityWebRequest.Put(uploadUrl, bytes);
+                    foreach (var pair in updateData.headers) {
+                        putReq.SetRequestHeader(pair.key, pair.value);
+                    }
+                    putReq.SetRequestHeader("x-airship-ignore-rate-limit", "true");
+
+                    Debug.Log("Uploading asset bundle...");
+                    await putReq.SendWebRequest();
+                    if (putReq.result != UnityWebRequest.Result.Success) {
+                        Debug.LogError(putReq.error);
+                        Debug.LogError(putReq.downloadHandler.text);
+                        return;
+                    }
+                }
+            }
+
+            Debug.Log($"<color=green>Finished building {bundlePaths.Count} asset bundles for all platforms in {st.Elapsed.Seconds} seconds.</color> File size: " + AirshipEditorUtil.GetFileSizeText(bytesCount));
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="platform"></param>
+        /// <returns>Path to built bundle. Empty string if it failed.</returns>
+        private async Task<string> BuildPlatform(AirshipPlatform platform, string airId) {
+            var st = Stopwatch.StartNew();
+            var airAssetBundle = (AirAssetBundle)this.target;
+
+            var buildOutputFolder = "bundles/airassetbundle/";
+            var buildOutputFile = $"bundles/airassetbundle/{airId}_{AirshipPlatformUtil.GetStringName(platform)}.bundle";
+            var sourceFolderPath = Path.GetRelativePath(".", Directory.GetParent(AssetDatabase.GetAssetPath(airAssetBundle))!.FullName);
+
+            List<AssetBundleBuild> builds = CreateAssetBundles.GetPackageAssetBundleBuilds();
+
+            var assetGuids = AssetDatabase.FindAssets("*", new string[] {sourceFolderPath}).ToList();
+            var assetPaths = assetGuids
+                .Select((guid) => AssetDatabase.GUIDToAssetPath(guid))
+                .Where((path) => !path.ToLower().Contains("editor/"))
+                .Where((path) => !path.ToLower().Contains("exclude/"))
+                .Where((p) => !AssetDatabase.IsValidFolder(p))
+                .ToArray();
+            Debug.Log("Resources:");
+            foreach (var path in assetPaths) {
+                Debug.Log("  - " + path);
+            }
+            var addressableNames = assetPaths
+                .Select((p) => p.ToLower())
+                .Select((p) => {
+                    if (p.Contains(target.name.ToLower() + ".asset")) {
+                        // custom name so it's easier to find when loading
+                        return "_AirAssetBundle";
+                    }
+                    return p;
+                })
+                .ToArray();
+            builds.Add(new AssetBundleBuild() {
+                assetBundleName = airId + $"_{AirshipPlatformUtil.GetStringName(platform)}.bundle",
+                assetNames = assetPaths,
+                addressableNames = addressableNames
+            });
+
+            // --------------------- //
+            // Build
+            if (!this.skipBuild) {
+                var buildTarget = AirshipPlatformUtil.ToBuildTarget(platform);
+                var buildTargetGroup = BuildPipeline.GetBuildTargetGroup(buildTarget);
+                if (platform is AirshipPlatform.Windows or AirshipPlatform.Mac or AirshipPlatform.Linux) {
+                    buildTargetGroup = BuildTargetGroup.Standalone;
+                }
+                EditorUserBuildSettings.SwitchActiveBuildTarget(buildTargetGroup, buildTarget);
+                var buildParams = new BundleBuildParameters(
+                    buildTarget,
+                    buildTargetGroup,
+                    buildOutputFolder
+                );
+                buildParams.UseCache = true;
+                EditorUserBuildSettings.switchRomCompressionType = SwitchRomCompressionType.Lz4;
+                buildParams.BundleCompression = BuildCompression.LZ4;
+                var buildContent = new BundleBuildContent(builds);
+
+                AirshipPackagesWindow.buildingPackageId = "game";
+                CreateAssetBundles.buildingBundles = true;
+                AirshipScriptableBuildPipelineConfig.buildingGameBundles = true;
+                ReturnCode returnCode = ContentPipeline.BuildAssetBundles(buildParams, buildContent, out var result);
+                CreateAssetBundles.buildingBundles = false;
+                AirshipScriptableBuildPipelineConfig.buildingGameBundles = false;
+                if (returnCode != ReturnCode.Success) {
+                    Debug.LogError("Failed to build asset bundles. ReturnCode=" + returnCode);
+                    return null;
+                }
+                Debug.Log($"Finished building {platform} in {st.Elapsed.TotalSeconds} seconds.");
+            }
+
+            return buildOutputFile;
+        }
+    }
+}

package/Editor/AirAsset/AirAssetBundleEditor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f904e44e8af44766958843de9fabd3c6
+timeCreated: 1741066138

package/Editor/AirAsset.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 118b4a8adb0a43d7ae94269c1191f2e3
+timeCreated: 1741066124

package/Editor/EditorIntegrationsConfig.cs

@@ -54,7 +54,7 @@ public class EditorIntegrationsConfig : ScriptableSingleton<EditorIntegrationsCo
     
     [FormerlySerializedAs("automaticTypeScriptCompilation")] 
     [SerializeField] public bool typescriptAutostartCompiler = true;
-
+    
     /// <summary>
     /// The version of the compiler to use
     /// </summary>

package/Editor/Publish/Deploy.cs

@@ -124,12 +124,23 @@ public class Deploy {
 		}
 
 		// Rebuild Typescript
-		var shouldResumeTypescriptWatch = TypescriptCompilationService.IsWatchModeRunning;
-		var compileFlags = TypeScriptCompileFlags.FullClean | TypeScriptCompileFlags.Publishing; // FullClean will clear the incremental file & Publishing will omit editor data
-
+		var skipRecompileOnCodeDeploy = skipBuild && TypescriptServicesLocalConfig.instance.skipCompileOnCodeDeploy;
+		var shouldRecompile = !skipBuild || !skipRecompileOnCodeDeploy;
+		var shouldResumeTypescriptWatch = shouldRecompile && TypescriptCompilationService.IsWatchModeRunning;
+		
 		// We want to do a full publish
-		TypescriptCompilationService.StopCompilers();
-		TypescriptCompilationService.BuildTypescript(compileFlags);
+		
+		if (shouldRecompile) {
+			TypescriptCompilationService.StopCompilers();
+			
+			var compileFlags = TypeScriptCompileFlags.Publishing | TypeScriptCompileFlags.DisplayProgressBar; // FullClean will clear the incremental file & Publishing will omit editor data
+
+			if (skipBuild) {
+				compileFlags |= TypeScriptCompileFlags.SkipReimportQueue; // code publish does not require asset reimport
+			}
+			
+			TypescriptCompilationService.BuildTypescript(compileFlags);
+		}
 		
 		if (TypescriptCompilationService.ErrorCount > 0) {
 			Debug.LogError($"Could not publish the project with {TypescriptCompilationService.ErrorCount} compilation error{(TypescriptCompilationService.ErrorCount == 1 ? "" : "s")}");