微信小程序编译

.gitea/workflows/.gitlab-ci.yml

@@ -35,10 +35,10 @@ jobs:
           - 10.StoryEditor
           - 10.XNode
           - 11.PointCloudTools
-
+          - 12.WeixinMinigame
     steps:
       - name: Checkout
-        uses: http://106.52.62.106:3000/unity-registry/checkout@v4 
+        uses: http://106.52.62.106:3000/unity-registry/checkout@v4
         with:
           fetch-depth: 1
           single-branch: true
@@ -56,19 +56,19 @@ jobs:
         working-directory: Assets/${{ matrix.module }}
         run: |
           echo "📦 开始处理 ${{ matrix.module }}"
-          
+
           # 获取当前版本号
           CURRENT_VERSION=$(node -p "require('./package.json').version")
           PACKAGE_NAME=$(node -p "require('./package.json').name")
           REGISTRY_URL="http://${SERVER_HOST}/npm"
-          
+
           echo "当前版本: $PACKAGE_NAME@$CURRENT_VERSION"
           echo "Registry: $REGISTRY_URL"
-          
+
           # 配置 npm
           npm config set registry "$REGISTRY_URL"
           npm config set "//${SERVER_HOST}/:_authToken" "${AuthToken}"
-          
+
           # 关键：先检查远程是否已存在该版本
           echo "🔍 检查远程版本..."
           if npm view "$PACKAGE_NAME@$CURRENT_VERSION" --registry="$REGISTRY_URL" version >/dev/null 2>&1; then
@@ -76,7 +76,7 @@ jobs:
             echo "💡 提示：如需更新，请修改 package.json 中的 version 字段"
             exit 0  # 正常退出，不算失败
           fi
-          
+
           # 版本不存在，执行发布
           echo "🚀 版本 $CURRENT_VERSION 不存在，开始发布..."
           if npm publish; then
@@ -88,4 +88,4 @@ jobs:
 
       - name: Complete
         if: always()
-        run: echo "====== ${{ matrix.module }} 发布完成 ========="
+        run: echo "====== ${{ matrix.module }} 发布完成 ========="

Assets/00.StaryEvoTools/Runtime/com.staryevo.tools.runtime.asmdef

@@ -12,7 +12,7 @@
         "GUID:13ba8ce62aa80c74598530029cb2d649",
         "GUID:5efd170ecd8084500bed5692932fe14e",
         "GUID:5830d4a11fa1e8f46a8e7ea664a8de75",
-        "GUID:839b8c2cb327b8a43afe86fd33563571"
+        "GUID:0df458501c7f0fd448853201fa335248"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],

Assets/00.StaryEvoTools/WechatFileSystem/YooAsset.MiniGame.asmdef

@@ -3,10 +3,10 @@
     "rootNamespace": "",
     "references": [
         "GUID:e34a5702dd353724aa315fb8011f08c3",
-        "GUID:5efd170ecd8084500bed5692932fe14e",
         "GUID:bb21d6197862c4c3e863390dec9859a7",
         "GUID:870f26a2ffa82429195df0861505c5d5",
-        "GUID:6921e41464907054da1a045ea64ca16f"
+        "GUID:6921e41464907054da1a045ea64ca16f",
+        "GUID:0df458501c7f0fd448853201fa335248"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],

Assets/00.StaryEvoTools/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.staryevo.tools",
-  "version": "1.4.23",
+  "version": "1.4.24",
   "displayName": "00.StaryEvo.Tools",
   "description": "This is an Framework package(后台服务器版本，端口9527)",
   "unity": "2021.3",

Assets/12.WeixinMinigame/CHANGELOG.md.meta

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

Assets/12.WeixinMinigame/Editor.meta

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

Assets/12.WeixinMinigame/Editor/Brotli.meta

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

Assets/12.WeixinMinigame/Editor/Brotli/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2009, 2010, 2013-2016 by the Brotli Authors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

Assets/12.WeixinMinigame/Editor/Brotli/LICENSE.txt.meta

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

Assets/12.WeixinMinigame/Editor/Brotli/commits.txt

@@ -0,0 +1,2 @@
+https://github.com/Unity-Technologies/brotli
+359ceef04a4eae97cb8a161c4b768fd639eef98b

Assets/12.WeixinMinigame/Editor/Brotli/commits.txt.meta

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

Assets/12.WeixinMinigame/Editor/Brotli/linux_x86_64.meta

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

Assets/12.WeixinMinigame/Editor/Brotli/linux_x86_64/brotli.meta

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

Assets/12.WeixinMinigame/Editor/Brotli/linux_x86_64/libbrotlicommon.so.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: 4d221d2990bb625459ad28c5cc82f033
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/Brotli/linux_x86_64/libbrotlienc.so.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: 1c2d0375e3d2f314a9ab351d6f954331
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/Brotli/macos.meta

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

Assets/12.WeixinMinigame/Editor/Brotli/macos/brotli.meta

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

Assets/12.WeixinMinigame/Editor/Brotli/macos/libbrotlicommon.dylib.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: 21a2d588bd0dfaa49a1d251a5d69157f
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/Brotli/macos/libbrotlienc.dylib.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: ded9774c9a864904bb4b43e2b16dc2cf
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/Brotli/win_x86_64.meta

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

Assets/12.WeixinMinigame/Editor/Brotli/win_x86_64/brotli.exe.meta

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

Assets/12.WeixinMinigame/Editor/Brotli/win_x86_64/libbrotlicommon.dll.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: 55c00a936618c4d42b0bd00398d6bf58
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/Brotli/win_x86_64/libbrotlienc.dll.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: 8e25a0eabcc294743bac515db166c928
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/Brotli/win_x86_64/msvcp140.dll.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: 4898422d612278444b1d03fb7a3a7d15
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/Brotli/win_x86_64/msvcp140_1.dll.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: c8888352ba72f4840bc88d9a9d8671b5
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/Brotli/win_x86_64/msvcp140_2.dll.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: addd8385fb2da6b40ac6edae11d4747c
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/Brotli/win_x86_64/vcruntime140.dll.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: 945638f4a2a219b4c9710be5503e574d
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/Brotli/win_x86_64/vcruntime140_1.dll.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: d233652bd8fcdb44297dd11f3efa81de
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/BuildProfile.meta

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

Assets/12.WeixinMinigame/Editor/BuildProfile/WeixinMiniGameSettings.cs

@@ -0,0 +1,136 @@
+#if TUANJIE_1_6_OR_NEWER
+using System;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+using UnityEditor.Build.Profile;
+
+namespace WeChatWASM
+{
+    public class WeixinMiniGameSettings : MiniGameSettings
+    {
+        public WXProjectConf ProjectConf;
+        public SDKOptions SDKOptions;
+        public CompileOptions CompileOptions;
+        public CompressTexture CompressTexture;
+        public List<string> PlayerPrefsKeys = new List<string>();
+        public FontOptions FontOptions;
+
+        [SerializeField] public bool m_AutomaticFillInstantGame = true;
+
+        public WeixinMiniGameSettings(MiniGameSettingsEditor editor) : base(editor)
+        {
+        }
+
+        public bool PreprocessBuild(BuildProfile buildProfile, BuildOptions options)
+        {
+            bool result = true;
+            if (!string.IsNullOrEmpty(buildProfile.buildPath))
+            {
+                this.ProjectConf.DST = buildProfile.buildPath;
+            }
+            else
+            {
+                Debug.LogError("Build Path is empty!");
+                result = false;
+            }
+            this.CompileOptions.DevelopBuild = buildProfile.platformSettings.development;
+            this.CompileOptions.AutoProfile = buildProfile.platformSettings.connectProfiler;
+
+            this.CompileOptions.CleanBuild = ((int)options & (int)BuildOptions.CleanBuildCache) != 0;
+            this.CompileOptions.ScriptOnly = ((int)options & (int)BuildOptions.BuildScriptsOnly) != 0;
+
+            return result;
+        }
+
+        internal void FillAutoStreamingAutomatically()
+        {
+            // Instant Game
+            if (WXConvertCore.IsInstantGameAutoStreaming())
+            {
+                if (m_AutomaticFillInstantGame)
+                {
+                    ProjectConf.CDN = WXConvertCore.GetInstantGameAutoStreamingCDN();
+                    if (!ProjectConf.bundlePathIdentifier.Contains("CUS/CustomAB;"))
+                    {
+                        ProjectConf.bundlePathIdentifier = "CUS/CustomAB;" + ProjectConf.bundlePathIdentifier;
+                    }
+                    if (!ProjectConf.bundlePathIdentifier.Contains("AS;"))
+                    {
+                        ProjectConf.bundlePathIdentifier = "AS;" + ProjectConf.bundlePathIdentifier;
+                    }
+                    ProjectConf.dataFileSubPrefix = "CUS";
+                }
+            }
+        }
+
+        public static void AutoStreamingLoad()
+        {
+            if (!WXConvertCore.IsInstantGameAutoStreaming())
+            {
+                return;
+            }
+
+            // Generate
+            Type asTextureUIType = Type.GetType("Unity.AutoStreaming.ASTextureUI,Unity.InstantGame.Editor");
+            if (asTextureUIType == null)
+            {
+                Debug.LogError("Type 'Unity.AutoStreaming.ASTextureUI' not found. ");
+                return;
+            }
+            MethodInfo generateTextureAssetBundlesMethod = asTextureUIType.GetMethod("GenerateTextureAssetBundles", BindingFlags.NonPublic | BindingFlags.Static);
+            generateTextureAssetBundlesMethod?.Invoke(null, new object[] { false });
+
+            // reflection to get WXConvertCore.FirstBundlePath
+            String FirstBundlePath = "";
+            var type = Type.GetType("WeChatWASM.WXConvertCore,WxEditor");
+            if (type == null)
+            {
+                Debug.LogError("Type 'WeChatWASM.WXConvertCore,WxEditor' not found. ");
+                return;
+            }
+            FieldInfo fieldInfo = type.GetField("FirstBundlePath", BindingFlags.Public | BindingFlags.Static);
+            if (fieldInfo != null)
+            {
+                FirstBundlePath = fieldInfo.GetValue(null) as String;
+            }
+
+            if (!string.IsNullOrEmpty(FirstBundlePath) && File.Exists(FirstBundlePath))
+            {
+                Type igBuildPipelineType = Type.GetType("Unity.InstantGame.IGBuildPipeline,Unity.InstantGame.Editor");
+                if (igBuildPipelineType == null)
+                {
+                    Debug.LogError("Type 'Unity.InstantGame.IGBuildPipeline' not found. ");
+                    return;
+                }
+                MethodInfo uploadMethod = igBuildPipelineType.GetMethod("UploadWeChatDataFile", BindingFlags.Public | BindingFlags.Static);
+
+                bool returnValue = false;
+                if (uploadMethod != null)
+                {
+                    object[] parameters = new object[] { FirstBundlePath };
+                    object result = uploadMethod.Invoke(null, parameters);
+                    returnValue = Convert.ToBoolean(result);
+                }
+
+                if (returnValue)
+                {
+                    Debug.Log("转换完成并成功上传首包资源");
+                }
+                else
+                {
+                    Debug.LogError("首包资源上传失败，请检查网络以及Auto Streaming配置是否正确。");
+                }
+            }
+            else
+            {
+                Debug.LogError("转换失败");
+            }
+        }
+    
+    }
+}
+#endif

Assets/12.WeixinMinigame/Editor/BuildProfile/WeixinMiniGameSettings.cs.meta

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

Assets/12.WeixinMinigame/Editor/BuildProfile/WeixinMiniGameSettingsEditor.cs

@@ -0,0 +1,586 @@
+#if TUANJIE_1_6_OR_NEWER
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using UnityEditor;
+using UnityEditor.Build.Profile;
+using UnityEngine;
+using static WeChatWASM.WXConvertCore;
+
+namespace WeChatWASM
+{
+    public class WeixinMiniGameSettingsEditor : MiniGameSettingsEditor
+    {
+        private Vector2 scrollRoot;
+        private bool foldBaseInfo = true;
+        private bool foldLoadingConfig = true;
+        private bool foldSDKOptions = true;
+        private bool foldDebugOptions = true;
+
+        private bool foldInstantGame = false;
+
+        private bool foldFontOptions = false;
+        private Dictionary<string, string> formInputData = new Dictionary<string, string>();
+        private Dictionary<string, int> formIntPopupData = new Dictionary<string, int>();
+        private Dictionary<string, bool> formCheckboxData = new Dictionary<string, bool>();
+        public Texture tex;
+
+        public override void OnMiniGameSettingsIMGUI(SerializedObject serializedObject, SerializedProperty miniGameProperty)
+        {
+            OnSettingsGUI(serializedObject, miniGameProperty);
+        }
+
+        public void OnSettingsGUI(SerializedObject serializedObject, SerializedProperty miniGameProperty)
+        {
+            loadData(serializedObject, miniGameProperty);
+
+            scrollRoot = EditorGUILayout.BeginScrollView(scrollRoot);
+
+            GUIStyle linkStyle = new GUIStyle(GUI.skin.label);
+            linkStyle.normal.textColor = Color.yellow;
+            linkStyle.hover.textColor = Color.yellow;
+            linkStyle.stretchWidth = false;
+            linkStyle.alignment = TextAnchor.UpperLeft;
+            linkStyle.wordWrap = true;
+
+            foldBaseInfo = EditorGUILayout.Foldout(foldBaseInfo, "基本信息");
+            if (foldBaseInfo)
+            {
+                EditorGUILayout.BeginVertical("frameBox", GUILayout.ExpandWidth(true));
+
+                formInput("appid", "游戏AppID");
+                formInput("cdn", "游戏资源CDN");
+                formInput("projectName", "小游戏项目名");
+                formIntPopup("orientation", "游戏方向", new[] { "Portrait", "Landscape", "LandscapeLeft", "LandscapeRight" }, new[] { 0, 1, 2, 3 });
+                formInput("memorySize", "UnityHeap预留内存(?)", "单位MB，预分配内存值，超休闲游戏256/中轻度496/重度游戏768，需预估游戏最大UnityHeap值以防止内存自动扩容带来的峰值尖刺。预估方法请查看GIT文档《优化Unity WebGL的内存》");
+
+                EditorGUILayout.EndVertical();
+            }
+
+            foldLoadingConfig = EditorGUILayout.Foldout(foldLoadingConfig, "启动Loading配置");
+            if (foldLoadingConfig)
+            {
+                EditorGUILayout.BeginVertical("frameBox", GUILayout.ExpandWidth(true));
+
+                GUILayout.BeginHorizontal();
+                string targetBg = "bgImageSrc";
+                EditorGUILayout.LabelField(string.Empty, GUILayout.Width(10));
+                tex = (Texture)EditorGUILayout.ObjectField("启动背景图/视频封面", tex, typeof(Texture2D), false);
+                var currentBgSrc = AssetDatabase.GetAssetPath(tex);
+                if (!string.IsNullOrEmpty(currentBgSrc) && currentBgSrc != formInputData[targetBg])
+                {
+                    formInputData[targetBg] = currentBgSrc;
+                    saveData(serializedObject, miniGameProperty);
+                }
+                GUILayout.EndHorizontal();
+
+                formInput("videoUrl", "加载阶段视频URL");
+                formIntPopup("assetLoadType", "首包资源加载方式", new[] { "CDN", "小游戏包内" }, new[] { 0, 1 });
+                formCheckbox("compressDataPackage", "压缩首包资源(?)", "将首包资源Brotli压缩, 降低资源大小. 注意: 首次启动耗时可能会增加200ms, 仅推荐使用小游戏分包加载时节省包体大小使用");
+                formInput("bundleExcludeExtensions", "不自动缓存文件类型(?)", "(使用;分割)当请求url包含资源'cdn+StreamingAssets'时会自动缓存，但StreamingAssets目录下不是所有文件都需缓存，此选项配置不需要自动缓存的文件拓展名。默认值json");
+                formInput("bundleHashLength", "Bundle名称Hash长度(?)", "自定义Bundle文件名中hash部分长度，默认值32，用于缓存控制。");
+                formInput("preloadFiles", "预下载文件列表(?)", "使用;间隔，支持模糊匹配");
+
+                EditorGUILayout.EndVertical();
+            }
+
+            foldSDKOptions = EditorGUILayout.Foldout(foldSDKOptions, "SDK功能选项");
+            if (foldSDKOptions)
+            {
+                EditorGUILayout.BeginVertical("frameBox", GUILayout.ExpandWidth(true));
+
+                formCheckbox("useFriendRelation", "使用好友关系链");
+                formCheckbox("useMiniGameChat", "使用社交组件");
+                formCheckbox("preloadWXFont", "预加载微信字体(?)", "在game.js执行开始时预载微信系统字体，运行期间可使用WX.GetWXFont获取微信字体");
+                formCheckbox("disableMultiTouch", "禁止多点触控");
+
+                EditorGUILayout.EndVertical();
+            }
+
+            foldDebugOptions = EditorGUILayout.Foldout(foldDebugOptions, "调试编译选项");
+            if (foldDebugOptions)
+            {
+                EditorGUILayout.BeginVertical("frameBox", GUILayout.ExpandWidth(true));
+                // formCheckbox("developBuild", "Development Build");
+                formCheckbox("autoProfile", "Auto connect Profiler");
+                formCheckbox("scriptOnly", "Scripts Only Build");
+#if TUANJIE_2022_3_OR_NEWER
+                // TODO: if overwrite by OverwritePlayerSettings
+                bool UseIL2CPP = PlayerSettings.GetScriptingBackend(BuildTargetGroup.WeixinMiniGame) == ScriptingImplementation.IL2CPP;
+#else
+                bool UseIL2CPP = true;
+#endif
+                formCheckbox("il2CppOptimizeSize", "Il2Cpp Optimize Size(?)", "对应于Il2CppCodeGeneration选项，勾选时使用OptimizeSize(默认推荐)，生成代码小15%左右，取消勾选则使用OptimizeSpeed。游戏中大量泛型集合的高频访问建议OptimizeSpeed，在使用HybridCLR等第三方组件时只能用OptimizeSpeed。(Dotnet Runtime模式下该选项无效)", !UseIL2CPP);
+                formCheckbox("profilingFuncs", "Profiling Funcs");
+                formCheckbox("profilingMemory", "Profiling Memory");
+
+                formCheckbox("webgl2", "WebGL2.0(beta)");
+                formCheckbox("iOSPerformancePlus", "iOSPerformancePlus(?)", "是否使用iOS高性能+渲染方案，有助于提升渲染兼容性、降低WebContent进程内存");
+                formCheckbox("EmscriptenGLX", "EmscriptenGLX(?)", "是否使用EmscriptenGLX渲染方案");
+                formCheckbox("iOSMetal", "iOSMetal(?)", "是否使用iOSMetal渲染方案，需要开启iOS高性能+模式，有助于提升运行性能，降低iOS功耗");
+                formCheckbox("deleteStreamingAssets", "Clear Streaming Assets");
+                 formCheckbox("cleanBuild", "Clean WebGL Build");
+                // formCheckbox("cleanCloudDev", "Clean Cloud Dev");
+                formCheckbox("fbslim", "首包资源优化(?)", "导出时自动清理UnityEditor默认打包但游戏项目从未使用的资源，瘦身首包资源体积。（团结引擎已无需开启该能力）", UnityUtil.GetEngineVersion() > 0, (res) =>
+                {
+                    var fbWin = EditorWindow.GetWindow(typeof(WXFbSettingWindow), false, "首包资源优化配置面板", true);
+                    fbWin.minSize = new Vector2(680, 350);
+                    fbWin.Show();
+                });
+                formCheckbox("autoAdaptScreen", "自适应屏幕尺寸(?)", "移动端旋转屏幕和PC端拉伸窗口时，自动调整画布尺寸");
+                formCheckbox("showMonitorSuggestModal", "显示优化建议弹窗");
+                formCheckbox("enableProfileStats", "显示性能面板");
+                formCheckbox("enableRenderAnalysis", "显示渲染日志(dev only)");
+
+                {
+                    formCheckbox("brotliMT", "brotli多线程压缩(?)", "开启多线程压缩可以提高出包速度，但会降低压缩率。如若不使用wasm代码分包请勿用多线程出包上线");
+                }
+                EditorGUILayout.EndVertical();
+            }
+
+            if (WXConvertCore.IsInstantGameAutoStreaming())
+            {
+                foldInstantGame = EditorGUILayout.Foldout(foldInstantGame, "Instant Game - AutoStreaming");
+                if (foldInstantGame)
+                {
+                    var automaticfillinstantgame = miniGameProperty.FindPropertyRelative("m_AutomaticFillInstantGame");
+                    EditorGUILayout.BeginVertical("frameBox", GUILayout.ExpandWidth(true));
+                    GUILayout.BeginHorizontal();
+                    EditorGUILayout.LabelField(string.Empty, GUILayout.Width(10));
+                    formCheckbox("m_AutomaticFillInstantGame", "自动填写AutoStreaming", "仅在开启AutoStreaming生效");
+                    GUILayout.EndHorizontal();
+                    formInput("bundlePathIdentifier", "Bundle Path Identifier");
+                    formInput("dataFileSubPrefix", "Data File Sub Prefix");
+
+                    EditorGUI.BeginDisabledGroup(true);
+                    formCheckbox("autoUploadFirstBundle", "构建后自动上传首包(?)", "仅在开启AutoStreaming生效", true);
+                    EditorGUI.EndDisabledGroup();
+
+                    GUILayout.BeginHorizontal();
+                    EditorGUILayout.LabelField(string.Empty, GUILayout.Width(10));
+                    GUILayout.Label(new GUIContent("清理AS配置(?)", "如需关闭AutoStreaming选用默认发布方案则需要清理AS配置项目。"), GUILayout.Width(140));
+                    EditorGUI.BeginDisabledGroup(WXConvertCore.IsInstantGameAutoStreaming());
+                    if (GUILayout.Button(new GUIContent("恢复"), GUILayout.Width(60)))
+                    {
+                        var ProjectConf = miniGameProperty.FindPropertyRelative("ProjectConf");
+                        string identifier = ProjectConf.FindPropertyRelative("bundlePathIdentifier").stringValue;
+                        string[] identifiers = identifier.Split(";");
+                        string idStr = "";
+                        foreach (string id in identifiers)
+                        {
+                            if (id != "AS" && id != "CUS/CustomAB")
+                            {
+                                idStr += id + ";";
+                            }
+                        }
+                        ProjectConf.FindPropertyRelative("bundlePathIdentifier").stringValue = idStr.Trim(';');
+
+                        if (ProjectConf.FindPropertyRelative("dataFileSubPrefix").stringValue == "CUS")
+                        {
+                            ProjectConf.FindPropertyRelative("dataFileSubPrefix").stringValue = "";
+                        }
+                        loadData(serializedObject, miniGameProperty);
+                    }
+                    EditorGUI.EndDisabledGroup();
+                    GUILayout.EndHorizontal();
+
+                    EditorGUILayout.BeginHorizontal();
+                    EditorGUILayout.LabelField(string.Empty);
+                    if (GUILayout.Button(new GUIContent("了解Instant Game AutoStreaming", ""), linkStyle))
+                    {
+                        Application.OpenURL("https://github.com/wechat-miniprogram/minigame-unity-webgl-transform/blob/main/Design/InstantGameGuide.md");
+                    }
+                    EditorGUILayout.EndHorizontal();
+                    EditorGUILayout.EndVertical();
+                }
+            }
+
+            {
+                foldFontOptions = EditorGUILayout.Foldout(foldFontOptions, "字体配置");
+                if (foldFontOptions)
+                {
+                    EditorGUILayout.BeginVertical("frameBox", GUILayout.ExpandWidth(true));
+                    formCheckbox("CJK_Unified_Ideographs", "基本汉字(?)", "Unicode [0x4e00, 0x9fff]");
+                    formCheckbox("C0_Controls_and_Basic_Latin", "基本拉丁语（英文大小写、数字、英文标点）(?)", "Unicode [0x0, 0x7f]");
+                    formCheckbox("CJK_Symbols_and_Punctuation", "中文标点符号(?)", "Unicode [0x3000, 0x303f]");
+                    formCheckbox("General_Punctuation", "通用标点符号(?)", "Unicode [0x2000, 0x206f]");
+                    formCheckbox("Enclosed_CJK_Letters_and_Months", "CJK字母及月份(?)", "Unicode [0x3200, 0x32ff]");
+                    formCheckbox("Vertical_Forms", "中文竖排标点(?)", "Unicode [0xfe10, 0xfe1f]");
+                    formCheckbox("CJK_Compatibility_Forms", "CJK兼容符号(?)", "Unicode [0xfe30, 0xfe4f]");
+                    formCheckbox("Miscellaneous_Symbols", "杂项符号(?)", "Unicode [0x2600, 0x26ff]");
+                    formCheckbox("CJK_Compatibility", "CJK特殊符号(?)", "Unicode [0x3300, 0x33ff]");
+                    formCheckbox("Halfwidth_and_Fullwidth_Forms", "全角ASCII、全角中英文标点、半宽片假名、半宽平假名、半宽韩文字母(?)", "Unicode [0xff00, 0xffef]");
+                    formCheckbox("Dingbats", "装饰符号(?)", "Unicode [0x2700, 0x27bf]");
+                    formCheckbox("Letterlike_Symbols", "字母式符号(?)", "Unicode [0x2100, 0x214f]");
+                    formCheckbox("Enclosed_Alphanumerics", "带圈或括号的字母数字(?)", "Unicode [0x2460, 0x24ff]");
+                    formCheckbox("Number_Forms", "数字形式(?)", "Unicode [0x2150, 0x218f]");
+                    formCheckbox("Currency_Symbols", "货币符号(?)", "Unicode [0x20a0, 0x20cf]");
+                    formCheckbox("Arrows", "箭头(?)", "Unicode [0x2190, 0x21ff]");
+                    formCheckbox("Geometric_Shapes", "几何图形(?)", "Unicode [0x25a0, 0x25ff]");
+                    formCheckbox("Mathematical_Operators", "数学运算符号(?)", "Unicode [0x2200, 0x22ff]");
+                    formInput("CustomUnicode", "自定义Unicode(?)", "将填入的所有字符强制加入字体预加载列表");
+                    EditorGUILayout.EndVertical();
+                }
+            }
+
+            EditorGUILayout.EndScrollView();
+            saveData(serializedObject, miniGameProperty);
+        }
+
+        private void loadData(SerializedObject serializedObject, SerializedProperty miniGameProperty)
+        {
+            serializedObject.UpdateIfRequiredOrScript();
+            var ProjectConf = miniGameProperty.FindPropertyRelative("ProjectConf");
+
+            // Instant Game
+            if (WXConvertCore.IsInstantGameAutoStreaming())
+            {
+                var automaticfillinstantgame = miniGameProperty.FindPropertyRelative("m_AutomaticFillInstantGame");
+                if (automaticfillinstantgame.boolValue)
+                {
+                    ProjectConf.FindPropertyRelative("CDN").stringValue = WXConvertCore.GetInstantGameAutoStreamingCDN();
+                    if (!ProjectConf.FindPropertyRelative("bundlePathIdentifier").stringValue.Contains("AS;"))
+                    {
+                        ProjectConf.FindPropertyRelative("bundlePathIdentifier").stringValue += "AS;";
+                    }
+                    if (!ProjectConf.FindPropertyRelative("bundlePathIdentifier").stringValue.Contains("CUS/CustomAB;"))
+                    {
+                        ProjectConf.FindPropertyRelative("bundlePathIdentifier").stringValue += "CUS/CustomAB;";
+                    }
+                    ProjectConf.FindPropertyRelative("dataFileSubPrefix").stringValue = "CUS";
+                }
+            }
+
+            setData("projectName", ProjectConf.FindPropertyRelative("projectName").stringValue);
+            setData("appid", ProjectConf.FindPropertyRelative("Appid").stringValue);
+            setData("cdn", ProjectConf.FindPropertyRelative("CDN").stringValue);
+            setData("assetLoadType", ProjectConf.FindPropertyRelative("assetLoadType").intValue);
+            setData("compressDataPackage", ProjectConf.FindPropertyRelative("compressDataPackage").boolValue);
+            setData("videoUrl", ProjectConf.FindPropertyRelative("VideoUrl").stringValue);
+            setData("orientation", (int)ProjectConf.FindPropertyRelative("Orientation").enumValueIndex);
+            //setData("dst", ProjectConf.FindPropertyRelative("relativeDST").stringValue);
+            setData("bundleHashLength", ProjectConf.FindPropertyRelative("bundleHashLength").intValue.ToString());
+            setData("bundlePathIdentifier", ProjectConf.FindPropertyRelative("bundlePathIdentifier").stringValue);
+            setData("bundleExcludeExtensions", ProjectConf.FindPropertyRelative("bundleExcludeExtensions").stringValue);
+            setData("preloadFiles", ProjectConf.FindPropertyRelative("preloadFiles").stringValue);
+
+            var CompileOptions = miniGameProperty.FindPropertyRelative("CompileOptions");
+            // setData("developBuild", CompileOptions.FindPropertyRelative("DevelopBuild").boolValue);
+            setData("autoProfile", CompileOptions.FindPropertyRelative("AutoProfile").boolValue);
+            setData("scriptOnly", CompileOptions.FindPropertyRelative("ScriptOnly").boolValue);
+            setData("il2CppOptimizeSize", CompileOptions.FindPropertyRelative("Il2CppOptimizeSize").boolValue);
+            setData("profilingFuncs", CompileOptions.FindPropertyRelative("profilingFuncs").boolValue);
+            setData("profilingMemory", CompileOptions.FindPropertyRelative("ProfilingMemory").boolValue);
+            setData("deleteStreamingAssets", CompileOptions.FindPropertyRelative("DeleteStreamingAssets").boolValue);
+            setData("cleanBuild", CompileOptions.FindPropertyRelative("CleanBuild").boolValue);
+            setData("customNodePath", CompileOptions.FindPropertyRelative("CustomNodePath").stringValue);
+            setData("webgl2", CompileOptions.FindPropertyRelative("Webgl2").boolValue);
+            setData("iOSPerformancePlus", CompileOptions.FindPropertyRelative("enableIOSPerformancePlus").boolValue);
+            setData("iOSMetal", CompileOptions.FindPropertyRelative("enableiOSMetal").boolValue);
+            setData("EmscriptenGLX", CompileOptions.FindPropertyRelative("enableEmscriptenGLX").boolValue);
+            setData("fbslim", CompileOptions.FindPropertyRelative("fbslim").boolValue);
+
+            var SDKOptions = miniGameProperty.FindPropertyRelative("SDKOptions");
+            setData("useFriendRelation", SDKOptions.FindPropertyRelative("UseFriendRelation").boolValue);
+            setData("useMiniGameChat", SDKOptions.FindPropertyRelative("UseMiniGameChat").boolValue);
+            setData("preloadWXFont", SDKOptions.FindPropertyRelative("PreloadWXFont").boolValue);
+            setData("disableMultiTouch", SDKOptions.FindPropertyRelative("disableMultiTouch").boolValue);
+            setData("bgImageSrc", ProjectConf.FindPropertyRelative("bgImageSrc").stringValue);
+            tex = AssetDatabase.LoadAssetAtPath<Texture>(ProjectConf.FindPropertyRelative("bgImageSrc").stringValue);
+            setData("memorySize", ProjectConf.FindPropertyRelative("MemorySize").intValue.ToString());
+            setData("hideAfterCallMain", ProjectConf.FindPropertyRelative("HideAfterCallMain").boolValue);
+
+            setData("dataFileSubPrefix", ProjectConf.FindPropertyRelative("dataFileSubPrefix").stringValue);
+            setData("maxStorage", ProjectConf.FindPropertyRelative("maxStorage").intValue.ToString());
+            setData("defaultReleaseSize", ProjectConf.FindPropertyRelative("defaultReleaseSize").intValue.ToString());
+            setData("texturesHashLength", ProjectConf.FindPropertyRelative("texturesHashLength").intValue.ToString());
+            setData("texturesPath", ProjectConf.FindPropertyRelative("texturesPath").stringValue);
+            setData("needCacheTextures", ProjectConf.FindPropertyRelative("needCacheTextures").boolValue);
+            setData("loadingBarWidth", ProjectConf.FindPropertyRelative("loadingBarWidth").intValue.ToString());
+            setData("needCheckUpdate", ProjectConf.FindPropertyRelative("needCheckUpdate").boolValue);
+            setData("disableHighPerformanceFallback", ProjectConf.FindPropertyRelative("disableHighPerformanceFallback").boolValue);
+            setData("autoAdaptScreen", CompileOptions.FindPropertyRelative("autoAdaptScreen").boolValue);
+            setData("showMonitorSuggestModal", CompileOptions.FindPropertyRelative("showMonitorSuggestModal").boolValue);
+            setData("enableProfileStats", CompileOptions.FindPropertyRelative("enableProfileStats").boolValue);
+            setData("enableRenderAnalysis", CompileOptions.FindPropertyRelative("enableRenderAnalysis").boolValue);
+            setData("brotliMT", CompileOptions.FindPropertyRelative("brotliMT").boolValue);
+            setData("autoUploadFirstBundle", true);
+            setData("m_AutomaticFillInstantGame", miniGameProperty.FindPropertyRelative("m_AutomaticFillInstantGame").boolValue);
+
+            // font options
+            var FontOptions = miniGameProperty.FindPropertyRelative("FontOptions");
+            setData("CJK_Unified_Ideographs", FontOptions.FindPropertyRelative("CJK_Unified_Ideographs").boolValue);
+            setData("C0_Controls_and_Basic_Latin", FontOptions.FindPropertyRelative("C0_Controls_and_Basic_Latin").boolValue);
+            setData("CJK_Symbols_and_Punctuation", FontOptions.FindPropertyRelative("CJK_Symbols_and_Punctuation").boolValue);
+            setData("General_Punctuation", FontOptions.FindPropertyRelative("General_Punctuation").boolValue);
+            setData("Enclosed_CJK_Letters_and_Months", FontOptions.FindPropertyRelative("Enclosed_CJK_Letters_and_Months").boolValue);
+            setData("Vertical_Forms", FontOptions.FindPropertyRelative("Vertical_Forms").boolValue);
+            setData("CJK_Compatibility_Forms", FontOptions.FindPropertyRelative("CJK_Compatibility_Forms").boolValue);
+            setData("Miscellaneous_Symbols", FontOptions.FindPropertyRelative("Miscellaneous_Symbols").boolValue);
+            setData("CJK_Compatibility", FontOptions.FindPropertyRelative("CJK_Compatibility").boolValue);
+            setData("Halfwidth_and_Fullwidth_Forms", FontOptions.FindPropertyRelative("Halfwidth_and_Fullwidth_Forms").boolValue);
+            setData("Dingbats", FontOptions.FindPropertyRelative("Dingbats").boolValue);
+            setData("Letterlike_Symbols", FontOptions.FindPropertyRelative("Letterlike_Symbols").boolValue);
+            setData("Enclosed_Alphanumerics", FontOptions.FindPropertyRelative("Enclosed_Alphanumerics").boolValue);
+            setData("Number_Forms", FontOptions.FindPropertyRelative("Number_Forms").boolValue);
+            setData("Currency_Symbols", FontOptions.FindPropertyRelative("Currency_Symbols").boolValue);
+            setData("Arrows", FontOptions.FindPropertyRelative("Arrows").boolValue);
+            setData("Geometric_Shapes", FontOptions.FindPropertyRelative("Geometric_Shapes").boolValue);
+            setData("Mathematical_Operators", FontOptions.FindPropertyRelative("Mathematical_Operators").boolValue);
+            setData("CustomUnicode", FontOptions.FindPropertyRelative("CustomUnicode").stringValue);
+        }
+
+        private void saveData(SerializedObject serializedObject, SerializedProperty miniGameProperty)
+        {
+            serializedObject.UpdateIfRequiredOrScript();
+
+            var ProjectConf = miniGameProperty.FindPropertyRelative("ProjectConf");
+            ProjectConf.FindPropertyRelative("projectName").stringValue = getDataInput("projectName");
+            ProjectConf.FindPropertyRelative("Appid").stringValue = getDataInput("appid");
+            ProjectConf.FindPropertyRelative("CDN").stringValue = getDataInput("cdn");
+            ProjectConf.FindPropertyRelative("assetLoadType").intValue = getDataPop("assetLoadType");
+            ProjectConf.FindPropertyRelative("compressDataPackage").boolValue = getDataCheckbox("compressDataPackage");
+            ProjectConf.FindPropertyRelative("VideoUrl").stringValue = getDataInput("videoUrl");
+            ProjectConf.FindPropertyRelative("Orientation").enumValueIndex = getDataPop("orientation");
+            ProjectConf.FindPropertyRelative("relativeDST").stringValue = serializedObject.FindProperty("m_BuildPath").stringValue;
+            ProjectConf.FindPropertyRelative("DST").stringValue = GetAbsolutePath(config.ProjectConf.relativeDST);
+
+            ProjectConf.FindPropertyRelative("bundleHashLength").intValue = int.Parse(getDataInput("bundleHashLength"));
+            ProjectConf.FindPropertyRelative("bundlePathIdentifier").stringValue = getDataInput("bundlePathIdentifier");
+            ProjectConf.FindPropertyRelative("bundleExcludeExtensions").stringValue = getDataInput("bundleExcludeExtensions");
+            ProjectConf.FindPropertyRelative("preloadFiles").stringValue = getDataInput("preloadFiles");
+
+            var CompileOptions = miniGameProperty.FindPropertyRelative("CompileOptions");
+
+            CompileOptions.FindPropertyRelative("DevelopBuild").boolValue = serializedObject.FindProperty("m_PlatformSettings").FindPropertyRelative("m_Development").boolValue;
+            CompileOptions.FindPropertyRelative("AutoProfile").boolValue = getDataCheckbox("autoProfile");
+            CompileOptions.FindPropertyRelative("ScriptOnly").boolValue = getDataCheckbox("scriptOnly");
+            CompileOptions.FindPropertyRelative("Il2CppOptimizeSize").boolValue = getDataCheckbox("il2CppOptimizeSize");
+            CompileOptions.FindPropertyRelative("profilingFuncs").boolValue = getDataCheckbox("profilingFuncs");
+            CompileOptions.FindPropertyRelative("ProfilingMemory").boolValue = getDataCheckbox("profilingMemory");
+            CompileOptions.FindPropertyRelative("DeleteStreamingAssets").boolValue = getDataCheckbox("deleteStreamingAssets");
+            CompileOptions.FindPropertyRelative("CleanBuild").boolValue = getDataCheckbox("cleanBuild");
+            CompileOptions.FindPropertyRelative("CustomNodePath").stringValue = getDataInput("customNodePath");
+            CompileOptions.FindPropertyRelative("Webgl2").boolValue = getDataCheckbox("webgl2");
+            CompileOptions.FindPropertyRelative("enableIOSPerformancePlus").boolValue = getDataCheckbox("iOSPerformancePlus");
+            CompileOptions.FindPropertyRelative("enableiOSMetal").boolValue = getDataCheckbox("iOSMetal");
+            CompileOptions.FindPropertyRelative("enableEmscriptenGLX").boolValue = getDataCheckbox("EmscriptenGLX");
+            CompileOptions.FindPropertyRelative("fbslim").boolValue = getDataCheckbox("fbslim");
+
+            var SDKOptions = miniGameProperty.FindPropertyRelative("SDKOptions");
+            SDKOptions.FindPropertyRelative("UseFriendRelation").boolValue = getDataCheckbox("useFriendRelation");
+            SDKOptions.FindPropertyRelative("UseMiniGameChat").boolValue = getDataCheckbox("useMiniGameChat");
+            SDKOptions.FindPropertyRelative("PreloadWXFont").boolValue = getDataCheckbox("preloadWXFont");
+            SDKOptions.FindPropertyRelative("disableMultiTouch").boolValue = getDataCheckbox("disableMultiTouch");
+            ProjectConf.FindPropertyRelative("bgImageSrc").stringValue = getDataInput("bgImageSrc");
+            ProjectConf.FindPropertyRelative("MemorySize").intValue = int.Parse(getDataInput("memorySize"));
+            ProjectConf.FindPropertyRelative("HideAfterCallMain").boolValue = getDataCheckbox("hideAfterCallMain");
+            ProjectConf.FindPropertyRelative("dataFileSubPrefix").stringValue = getDataInput("dataFileSubPrefix");
+            ProjectConf.FindPropertyRelative("maxStorage").intValue = int.Parse(getDataInput("maxStorage"));
+            ProjectConf.FindPropertyRelative("defaultReleaseSize").intValue = int.Parse(getDataInput("defaultReleaseSize"));
+            ProjectConf.FindPropertyRelative("texturesHashLength").intValue = int.Parse(getDataInput("texturesHashLength"));
+            ProjectConf.FindPropertyRelative("texturesPath").stringValue = getDataInput("texturesPath");
+            ProjectConf.FindPropertyRelative("needCacheTextures").boolValue = getDataCheckbox("needCacheTextures");
+            ProjectConf.FindPropertyRelative("loadingBarWidth").intValue = int.Parse(getDataInput("loadingBarWidth"));
+            ProjectConf.FindPropertyRelative("needCheckUpdate").boolValue = getDataCheckbox("needCheckUpdate");
+            ProjectConf.FindPropertyRelative("disableHighPerformanceFallback").boolValue = getDataCheckbox("disableHighPerformanceFallback");
+            CompileOptions.FindPropertyRelative("autoAdaptScreen").boolValue = getDataCheckbox("autoAdaptScreen");
+            CompileOptions.FindPropertyRelative("showMonitorSuggestModal").boolValue = getDataCheckbox("showMonitorSuggestModal");
+            CompileOptions.FindPropertyRelative("enableProfileStats").boolValue = getDataCheckbox("enableProfileStats");
+            CompileOptions.FindPropertyRelative("enableRenderAnalysis").boolValue = getDataCheckbox("enableRenderAnalysis");
+            CompileOptions.FindPropertyRelative("brotliMT").boolValue = getDataCheckbox("brotliMT");
+
+            // font options
+            var FontOptions = miniGameProperty.FindPropertyRelative("FontOptions");
+            FontOptions.FindPropertyRelative("CJK_Unified_Ideographs").boolValue = getDataCheckbox("CJK_Unified_Ideographs");
+            FontOptions.FindPropertyRelative("C0_Controls_and_Basic_Latin").boolValue = getDataCheckbox("C0_Controls_and_Basic_Latin");
+            FontOptions.FindPropertyRelative("CJK_Symbols_and_Punctuation").boolValue = getDataCheckbox("CJK_Symbols_and_Punctuation");
+            FontOptions.FindPropertyRelative("General_Punctuation").boolValue = getDataCheckbox("General_Punctuation");
+            FontOptions.FindPropertyRelative("Enclosed_CJK_Letters_and_Months").boolValue = getDataCheckbox("Enclosed_CJK_Letters_and_Months");
+            FontOptions.FindPropertyRelative("Vertical_Forms").boolValue = getDataCheckbox("Vertical_Forms");
+            FontOptions.FindPropertyRelative("CJK_Compatibility_Forms").boolValue = getDataCheckbox("CJK_Compatibility_Forms");
+            FontOptions.FindPropertyRelative("Miscellaneous_Symbols").boolValue = getDataCheckbox("Miscellaneous_Symbols");
+            FontOptions.FindPropertyRelative("CJK_Compatibility").boolValue = getDataCheckbox("CJK_Compatibility");
+            FontOptions.FindPropertyRelative("Halfwidth_and_Fullwidth_Forms").boolValue = getDataCheckbox("Halfwidth_and_Fullwidth_Forms");
+            FontOptions.FindPropertyRelative("Dingbats").boolValue = getDataCheckbox("Dingbats");
+            FontOptions.FindPropertyRelative("Letterlike_Symbols").boolValue = getDataCheckbox("Letterlike_Symbols");
+            FontOptions.FindPropertyRelative("Enclosed_Alphanumerics").boolValue = getDataCheckbox("Enclosed_Alphanumerics");
+            FontOptions.FindPropertyRelative("Number_Forms").boolValue = getDataCheckbox("Number_Forms");
+            FontOptions.FindPropertyRelative("Currency_Symbols").boolValue = getDataCheckbox("Currency_Symbols");
+            FontOptions.FindPropertyRelative("Arrows").boolValue = getDataCheckbox("Arrows");
+            FontOptions.FindPropertyRelative("Geometric_Shapes").boolValue = getDataCheckbox("Geometric_Shapes");
+            FontOptions.FindPropertyRelative("Mathematical_Operators").boolValue = getDataCheckbox("Mathematical_Operators");
+            FontOptions.FindPropertyRelative("CustomUnicode").stringValue = getDataInput("CustomUnicode");
+            FontOptions.FindPropertyRelative("Arrows").boolValue = getDataCheckbox("Arrows");
+            FontOptions.FindPropertyRelative("Geometric_Shapes").boolValue = getDataCheckbox("Geometric_Shapes");
+            FontOptions.FindPropertyRelative("Mathematical_Operators").boolValue = getDataCheckbox("Mathematical_Operators");
+            FontOptions.FindPropertyRelative("CustomUnicode").stringValue = getDataInput("CustomUnicode");
+
+            miniGameProperty.FindPropertyRelative("m_AutomaticFillInstantGame").boolValue = getDataCheckbox("m_AutomaticFillInstantGame");
+
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        private bool getDataCheckbox(string target)
+        {
+            if (formCheckboxData.ContainsKey(target))
+                return formCheckboxData[target];
+            return false;
+        }
+
+        private string getDataInput(string target)
+        {
+            if (formInputData.ContainsKey(target))
+                return formInputData[target];
+            return "";
+        }
+
+        private int getDataPop(string target)
+        {
+            if (formIntPopupData.ContainsKey(target))
+                return formIntPopupData[target];
+            return 0;
+        }
+
+        private void setData(string target, string value)
+        {
+            if (formInputData.ContainsKey(target))
+            {
+                formInputData[target] = value;
+            }
+            else
+            {
+                formInputData.Add(target, value);
+            }
+        }
+        
+        private void setData(string target, bool value)
+        {
+            if (formCheckboxData.ContainsKey(target))
+            {
+                formCheckboxData[target] = value;
+            }
+            else
+            {
+                formCheckboxData.Add(target, value);
+            }
+        }
+        
+        private void setData(string target, int value)
+        {
+            if (formIntPopupData.ContainsKey(target))
+            {
+                formIntPopupData[target] = value;
+            }
+            else
+            {
+                formIntPopupData.Add(target, value);
+            }
+        }
+
+        private void formInput(string target, string label, string help = null)
+        {
+            if (!formInputData.ContainsKey(target))
+            {
+                formInputData[target] = "";
+            }
+            GUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField(string.Empty, GUILayout.Width(10));
+            if (help == null)
+            {
+                GUILayout.Label(label, GUILayout.Width(140));
+            }
+            else
+            {
+                GUILayout.Label(new GUIContent(label, help), GUILayout.Width(140));
+            }
+            formInputData[target] = GUILayout.TextField(formInputData[target], GUILayout.MaxWidth(EditorGUIUtility.currentViewWidth - 195));
+            GUILayout.EndHorizontal();
+        }
+
+        private void formCheckbox(string target, string label, string help = null, bool disable = false, Action<bool> setting = null)
+        {
+            if (!formCheckboxData.ContainsKey(target))
+            {
+                formCheckboxData[target] = false;
+            }
+            GUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField(string.Empty, GUILayout.Width(10));
+            if (help == null)
+            {
+                GUILayout.Label(label, GUILayout.Width(140));
+            }
+            else
+            {
+                GUILayout.Label(new GUIContent(label, help), GUILayout.Width(140));
+            }
+            EditorGUI.BeginDisabledGroup(disable);
+            formCheckboxData[target] = EditorGUILayout.Toggle(disable ? false : formCheckboxData[target]);
+
+            if (setting != null)
+            {
+                EditorGUILayout.LabelField("", GUILayout.Width(10));
+                // <20><><EFBFBD>ð<EFBFBD>ť
+                if (GUILayout.Button(new GUIContent("<22><><EFBFBD><EFBFBD>"), GUILayout.Width(40), GUILayout.Height(18)))
+                {
+                    setting?.Invoke(true);
+                }
+                EditorGUILayout.LabelField("", GUILayout.MinWidth(10));
+            }
+
+            EditorGUI.EndDisabledGroup();
+
+            if (setting == null)
+                EditorGUILayout.LabelField(string.Empty);
+            GUILayout.EndHorizontal();
+        }
+
+        private void formIntPopup(string target, string label, string[] options, int[] values)
+        {
+            if (!formIntPopupData.ContainsKey(target))
+            {
+                formIntPopupData[target] = 0;
+            }
+            GUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField(string.Empty, GUILayout.Width(10));
+            GUILayout.Label(label, GUILayout.Width(140));
+            formIntPopupData[target] = EditorGUILayout.IntPopup(formIntPopupData[target], options, values, GUILayout.MaxWidth(EditorGUIUtility.currentViewWidth - 195));
+            GUILayout.EndHorizontal();
+        }
+
+        public static bool IsAbsolutePath(string path)
+        {
+            // 检查是否为空或空白
+            if (string.IsNullOrWhiteSpace(path))
+            {
+                return false;
+            }
+
+            // 在 Windows 上，检查驱动器字母或网络路径
+            if (Application.platform == RuntimePlatform.WindowsEditor && Path.IsPathRooted(path))
+            {
+                return true;
+            }
+
+            // 在 Unix/Linux 和 macOS 上，检查是否以 '/' 开头
+            if (Application.platform == RuntimePlatform.OSXEditor && path.StartsWith("/"))
+            {
+                return true;
+            }
+
+            return false; // 否则为相对路径
+        }
+
+        public static string GetAbsolutePath(string path)
+        {
+            if (IsAbsolutePath(path))
+            {
+                return path;
+            }
+            string projectRootPath = System.IO.Path.GetFullPath(Application.dataPath + "/../");
+            return Path.Combine(projectRootPath, path);
+        }
+    }
+}
+#endif

Assets/12.WeixinMinigame/Editor/BuildProfile/WeixinMiniGameSettingsEditor.cs.meta

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

Assets/12.WeixinMinigame/Editor/BuildProfile/WeixinSubplatformInterface.cs

@@ -0,0 +1,177 @@
+#if TUANJIE_1_6_OR_NEWER
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+using UnityEditor.Build.Profile;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+
+namespace WeChatWASM
+{
+    [InitializeOnLoad]
+    public static class WeixinSubTargetManager
+    {
+        static WeixinSubTargetManager()
+        {
+            MiniGameSubplatformManager.RegisterSubplatform(new WeixinSubplatformInterface());
+        }
+    }
+
+    public class WeixinSubplatformInterface : MiniGameSubplatformInterface
+    {
+        class CacheConfig
+        {
+            public WXProjectConf ProjectConf;
+            public SDKOptions SDKOptions;
+            public CompileOptions CompileOptions;
+            public CompressTexture CompressTexture;
+            public List<string> PlayerPrefsKeys = new List<string>();
+            public FontOptions FontOptions;
+        }
+
+        private CacheConfig cacheConfig = new CacheConfig();
+
+        public override string GetSubplatformName()
+        {
+            return "WeChat:微信小游戏";
+        }
+
+        public override MiniGameSettings GetSubplatformSettings()
+        {
+            return new WeixinMiniGameSettings(new WeixinMiniGameSettingsEditor());
+        }
+
+        public override BuildMiniGameError Build(BuildProfile buildProfile)
+        {
+            // Useless
+            return BuildMiniGameError.InvalidInput;
+        }
+
+        public override BuildMiniGameError Build(BuildProfile buildProfile, BuildOptions options)
+        {
+            WeixinMiniGameSettings settings = buildProfile.miniGameSettings as WeixinMiniGameSettings;
+
+            BuildMiniGameError buildMiniGameError = BuildMiniGameError.Unknown;
+            bool preprocessSuccess = WechatBuildPreprocess(buildProfile);
+            if (!preprocessSuccess)
+            {
+                return BuildMiniGameError.InvalidInput;
+            }
+
+            if (settings is not null)
+            {
+                settings.FillAutoStreamingAutomatically();
+                if (settings.PreprocessBuild(buildProfile, options))
+                {
+
+                    var error = CallDoExport(buildProfile);
+                    int enumIntValue = Convert.ToInt32(error);
+                    switch (enumIntValue)
+                    {
+                        case 0: // SUCCEED
+                            {
+                                WeixinMiniGameSettings.AutoStreamingLoad();
+                                buildMiniGameError = BuildMiniGameError.Succeeded;
+                                break;
+                            }
+                        case 2: // BUILD_WEBGL_FAILED
+                            {
+                                buildMiniGameError = BuildMiniGameError.PlayerBuildFailed;
+                                break;
+                            }
+                        case 1: // NODE_NOT_FOUND
+                        default:
+                            {
+                                buildMiniGameError = BuildMiniGameError.Unknown;
+                                break;
+                            }
+                    }
+                }
+            }
+            BuildPostProcess(buildProfile);
+            return buildMiniGameError;
+        }
+
+        private bool WechatBuildPreprocess(BuildProfile buildProfile)
+        {
+            // Check GFX API and Color Space
+            if (buildProfile != null)
+            {
+                PlayerSettings playerSettings = buildProfile.playerSettings;
+                // Global PlayerSettings
+                ColorSpace colorSpace = PlayerSettings.colorSpace;
+                GraphicsDeviceType[] apis = PlayerSettings.GetGraphicsAPIs(buildProfile.buildTarget);
+                bool isAutomatic = PlayerSettings.GetUseDefaultGraphicsAPIs(buildProfile.buildTarget);
+
+                if (playerSettings != null)
+                {
+                    // BuildProfile PlayerSettings Override
+                    colorSpace = PlayerSettings.GetColorSpace_Internal(playerSettings);
+                    apis = PlayerSettings.GetGraphicsAPIs_Internal(playerSettings, buildProfile.buildTarget);
+                    isAutomatic = PlayerSettings.GetUseDefaultGraphicsAPIs_Internal(playerSettings, buildProfile.buildTarget);
+
+                    // set override templatePath
+                    var absolutePath = Path.GetFullPath(Path.Combine("Packages", "com.qq.weixin.minigame", "WebGLTemplates/WXTemplate2022TJ"));
+                    if (!Directory.Exists(absolutePath))
+                        absolutePath = Path.GetFullPath(Path.Combine(Application.dataPath, "WebGLTemplates/WXTemplate2022TJ"));
+
+                    if (Directory.Exists(absolutePath))
+                        PlayerSettings.MiniGame.SetTemplatePath_Internal(playerSettings, $"PATH:{absolutePath}");
+
+                    PlayerSettings.MiniGame.SetThreadsSupport_Internal(playerSettings, false);
+                    PlayerSettings.MiniGame.SetCompressionFormat_Internal(playerSettings, MiniGameCompressionFormat.Disabled);
+                    PlayerSettings.MiniGame.SetLinkerTarget_Internal(playerSettings, MiniGameLinkerTarget.Wasm);
+                    PlayerSettings.MiniGame.SetDataCaching_Internal(playerSettings, false);
+                    PlayerSettings.MiniGame.SetDebugSymbolMode_Internal(playerSettings, MiniGameDebugSymbolMode.External);
+                    PlayerSettings.SetRunInBackground_Internal(playerSettings, false);
+                }
+                return true;
+            }
+            else
+            {
+                throw new InvalidOperationException("Build profile has not been initialized.");
+            }
+        }
+
+        private WXConvertCore.WXExportError CallDoExport(BuildProfile buildProfile)
+        {
+            WXEditorScriptObject config = UnityUtil.GetEditorConf();
+            cacheConfig.ProjectConf = config.ProjectConf;
+            cacheConfig.SDKOptions = config.SDKOptions;
+            cacheConfig.CompileOptions = config.CompileOptions;
+            cacheConfig.CompressTexture = config.CompressTexture;
+            cacheConfig.PlayerPrefsKeys = config.PlayerPrefsKeys;
+            cacheConfig.FontOptions = config.FontOptions;
+
+            WeixinMiniGameSettings weixinSettings = buildProfile.miniGameSettings as WeixinMiniGameSettings;
+            config.ProjectConf = weixinSettings.ProjectConf;
+            config.SDKOptions = weixinSettings.SDKOptions;
+            config.CompileOptions = weixinSettings.CompileOptions;
+            config.CompressTexture = weixinSettings.CompressTexture;
+            config.PlayerPrefsKeys = weixinSettings.PlayerPrefsKeys;
+            config.FontOptions = weixinSettings.FontOptions;
+            EditorUtility.SetDirty(config);
+            AssetDatabase.SaveAssets();
+            return WXConvertCore.DoExport();
+        }
+
+        private void BuildPostProcess(BuildProfile buildProfile)
+        {
+            // Restore the original settings
+            WXEditorScriptObject config = UnityUtil.GetEditorConf();
+            config.ProjectConf = cacheConfig.ProjectConf;
+            config.SDKOptions = cacheConfig.SDKOptions;
+            config.CompileOptions = cacheConfig.CompileOptions;
+            config.CompressTexture = cacheConfig.CompressTexture;
+            config.PlayerPrefsKeys = cacheConfig.PlayerPrefsKeys;
+            config.FontOptions = cacheConfig.FontOptions;
+            EditorUtility.SetDirty(config);
+            AssetDatabase.SaveAssets();
+        }
+
+    }
+}
+#endif

Assets/12.WeixinMinigame/Editor/BuildProfile/WeixinSubplatformInterface.cs.meta

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

Assets/12.WeixinMinigame/Editor/BuildProfile/lib.meta

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

Assets/12.WeixinMinigame/Editor/BuildProfile/lib/libwx-metal-cpp.bc.meta

@@ -0,0 +1,93 @@
+fileFormatVersion: 2
+guid: af52190d872f5be4ea197a203b7a8c54
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 1
+        Exclude Editor: 1
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude WebGL: 1
+        Exclude Win: 1
+        Exclude Win64: 1
+        Exclude WindowsStoreApps: 1
+  - first:
+      Android: Android
+    second:
+      enabled: 0
+      settings:
+        AndroidSharedLibraryType: Executable
+        CPU: ARMv7
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: AnyOS
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      WebGL: WebGL
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      WeixinMiniGame: WeixinMiniGame
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DontProcess: false
+        PlaceholderPath: 
+        SDK: AnySDK
+        ScriptingBackend: AnyScriptingBackend
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/BuildProfile/lib/mtl_library.jslib

@@ -0,0 +1,38 @@
+mergeInto(LibraryManager.library, {
+    // 定义供 C/C++ 调用的 JS 函数  
+    js_batchRender_malloc: function(data, size, isSync) {
+        // 直接从 WASM 内存创建视图（零拷贝）
+        const targetBuffer = new Uint8Array(Module.HEAPU8.buffer, data, size);
+        //console.log("processBinaryData invoke");
+        const extBuffer = new ArrayBuffer(1); 
+
+        if(!isSync){
+            mtl.batchRenderAsync(targetBuffer, extBuffer); 
+            return null;
+        }
+        const response = mtl.batchRender(targetBuffer, extBuffer);
+        if (!response) {
+          return null;
+        }
+        const result = response.buffer;
+        if(!result || result.byteLength == 0){
+            return null;
+        }
+        // 申请内存空间,后续在cpp wasm部分使用，记得释放
+        const ptr = Module._malloc(result.byteLength);
+        // 将数据拷贝到WASM内存
+        Module.HEAPU8.set(new Uint8Array(result), ptr);
+        // 返回结构化的数据信息（指针和长度）
+        const ret = new DataView(new ArrayBuffer(8));
+        ret.setUint32(0, ptr, true);    // 指针地址（4字节）
+        ret.setUint32(4, result.byteLength, true);  // 数据长度（4字节）
+        // 返回合并后的8字节缓冲区指针，记得也要在cpp部分释放
+        const retPtr = Module._malloc(8);
+        Module.HEAPU8.set(new Uint8Array(ret.buffer), retPtr);
+        return retPtr;
+
+    },
+    js_swapWindow: function(){
+        mtl.swapWindow();
+    }
+  });

Assets/12.WeixinMinigame/Editor/BuildProfile/lib/mtl_library.jslib.meta

@@ -0,0 +1,93 @@
+fileFormatVersion: 2
+guid: f7e741a46e962cb40b59baaebd1fb1ba
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 1
+        Exclude Editor: 1
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude WebGL: 1
+        Exclude Win: 1
+        Exclude Win64: 1
+        Exclude WindowsStoreApps: 1
+  - first:
+      Android: Android
+    second:
+      enabled: 0
+      settings:
+        AndroidSharedLibraryType: Executable
+        CPU: ARMv7
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: AnyOS
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      WebGL: WebGL
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      WeixinMiniGame: WeixinMiniGame
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DontProcess: false
+        PlaceholderPath: 
+        SDK: AnySDK
+        ScriptingBackend: AnyScriptingBackend
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/LuaHooker.meta

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

Assets/12.WeixinMinigame/Editor/LuaHooker/mac.meta

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

Assets/12.WeixinMinigame/Editor/LuaHooker/mac/newstatehooker.dylib.meta

@@ -0,0 +1,64 @@
+fileFormatVersion: 2
+guid: aa0d8a48ffb06524e919540188bfb786
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Editor: 0
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude WebGL: 1
+        Exclude Win: 1
+        Exclude Win64: 1
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: OSX
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/LuaHooker/win.meta

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

Assets/12.WeixinMinigame/Editor/LuaHooker/win/newstatehooker.dll.meta

@@ -0,0 +1,82 @@
+fileFormatVersion: 2
+guid: 582fd2fccdc97574fb4f81c5dc0201fa
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 1
+        Exclude Editor: 0
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude WebGL: 1
+        Exclude Win: 1
+        Exclude Win64: 1
+        Exclude WindowsStoreApps: 1
+  - first:
+      Android: Android
+    second:
+      enabled: 0
+      settings:
+        CPU: ARMv7
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        CPU: x86_64
+        DefaultValueInitialized: true
+        OS: Windows
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: x86
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: x86_64
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DontProcess: false
+        PlaceholderPath: 
+        SDK: AnySDK
+        ScriptingBackend: AnyScriptingBackend
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/LuaHooker/win/ucrtbased.dll.meta

@@ -0,0 +1,82 @@
+fileFormatVersion: 2
+guid: 9ffd8ebc8a017514a919d4b29ff678c6
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 1
+        Exclude Editor: 0
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude WebGL: 1
+        Exclude Win: 1
+        Exclude Win64: 1
+        Exclude WindowsStoreApps: 1
+  - first:
+      Android: Android
+    second:
+      enabled: 0
+      settings:
+        CPU: ARMv7
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        CPU: x86_64
+        DefaultValueInitialized: true
+        OS: Windows
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: x86
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: x86_64
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DontProcess: false
+        PlaceholderPath: 
+        SDK: AnySDK
+        ScriptingBackend: AnyScriptingBackend
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/MiniGameConfig.asset

@@ -0,0 +1,95 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 1795359250, guid: 1cf430f187a0b40eda7f668318d8be23, type: 3}
+  m_Name: MiniGameConfig
+  m_EditorClassIdentifier: 
+  ProjectConf:
+    projectName: 
+    Appid: 
+    CDN: 
+    assetLoadType: 0
+    compressDataPackage: 0
+    VideoUrl: 
+    DST: 
+    StreamCDN: 
+    bundleHashLength: 32
+    bundlePathIdentifier: StreamingAssets;
+    bundleExcludeExtensions: json;
+    AssetsUrl: 
+    MemorySize: 256
+    HideAfterCallMain: 1
+    preloadFiles: 
+    Orientation: 0
+    bgImageSrc: Assets/WX-WASM-SDK-V2/Runtime/wechat-default/images/background.jpg
+    dataFileSubPrefix: 
+    maxStorage: 200
+    defaultReleaseSize: 31457280
+    texturesHashLength: 8
+    texturesPath: Assets/Textures
+    needCacheTextures: 1
+    loadingBarWidth: 240
+    needCheckUpdate: 0
+    disableHighPerformanceFallback: 0
+    IOSDevicePixelRatio: 0
+  SDKOptions:
+    UseFriendRelation: 0
+    UseCompressedTexture: 0
+    UseMiniGameChat: 0
+    PreloadWXFont: 0
+  CompileOptions:
+    DevelopBuild: 0
+    AutoProfile: 0
+    ScriptOnly: 0
+    Il2CppOptimizeSize: 1
+    profilingFuncs: 1
+    Webgl2: 0
+    fbslim: 0
+    DeleteStreamingAssets: 1
+    ProfilingMemory: 0
+    CleanBuild: 0
+    CustomNodePath: 
+    showMonitorSuggestModal: 1
+    enableProfileStats: 0
+    enableRenderAnalysis: 0
+    iOSAutoGCInterval: 10000
+    enableIOSPerformancePlus: 0
+    brotliMT: 0
+  CompressTexture:
+    halfSize: 0
+    useDXT5: 0
+    bundleSuffix: bundle
+    parallelWithBundle: 0
+    bundleDir: 
+    dstMinDir: 
+    debugMode: 0
+    force: 0
+  PlayerPrefsKeys: []
+  FontOptions:
+    CJK_Unified_Ideographs: 1
+    C0_Controls_and_Basic_Latin: 1
+    CJK_Symbols_and_Punctuation: 1
+    General_Punctuation: 1
+    Enclosed_CJK_Letters_and_Months: 1
+    Vertical_Forms: 1
+    CJK_Compatibility_Forms: 1
+    Miscellaneous_Symbols: 1
+    CJK_Compatibility: 1
+    Halfwidth_and_Fullwidth_Forms: 1
+    Dingbats: 1
+    Letterlike_Symbols: 1
+    Enclosed_Alphanumerics: 1
+    Number_Forms: 1
+    Currency_Symbols: 1
+    Arrows: 1
+    Geometric_Shapes: 1
+    Mathematical_Operators: 1
+    CustomUnicode: 

Assets/12.WeixinMinigame/Editor/MiniGameConfig.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f95f77282940aac4d8adbd357c4dcb71
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/Node.meta

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

Assets/12.WeixinMinigame/Editor/Node/dump_wasm_symbol.mjs

@@ -0,0 +1,23 @@
+import binaryen from "binaryen";
+import process from "process";
+import fs from "fs";
+
+if (process.argv.length < 3) {
+    console.error("cannot find wasmcode, Usage: node dump_wasm_symbo.mjs <your_minigame_dir>");
+    process.exit(-1);
+}
+let dir = process.argv[2];
+if (!dir.endsWith("/")) {
+    dir += "/";
+}
+let bin = fs.readFileSync(dir + "webgl/Build/webgl.wasm");
+binaryen.then(function(binaryenOb){
+    let mod = binaryenOb.readBinary(bin);
+    let symbols = {};
+    for (let i = 0; i < mod.getNumFunctions(); ++i) {
+        let ref = mod.getFunctionByIndex(i);
+        let func = binaryenOb.getFunctionInfo(ref);
+        symbols[i] = func.name;
+    }
+    fs.writeFileSync(dir + "minigame/webgl.wasm.symbols.unityweb", JSON.stringify(symbols));
+})

Assets/12.WeixinMinigame/Editor/Node/dump_wasm_symbol.mjs.meta

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

Assets/12.WeixinMinigame/Editor/Node/node_modules.meta

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

Assets/12.WeixinMinigame/Editor/Node/node_modules/binaryen.meta

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

Assets/12.WeixinMinigame/Editor/Node/node_modules/binaryen/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Assets/12.WeixinMinigame/Editor/Node/node_modules/binaryen/LICENSE.meta

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

Assets/12.WeixinMinigame/Editor/Node/node_modules/binaryen/README.md.meta

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

Assets/12.WeixinMinigame/Editor/Node/node_modules/binaryen/bin.meta

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

Assets/12.WeixinMinigame/Editor/Node/node_modules/binaryen/bin/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

Assets/12.WeixinMinigame/Editor/Node/node_modules/binaryen/bin/package.json.meta

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

Assets/12.WeixinMinigame/Editor/Node/node_modules/binaryen/bin/wasm-opt.meta

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

Assets/12.WeixinMinigame/Editor/Node/node_modules/binaryen/bin/wasm2js.meta

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

Assets/12.WeixinMinigame/Editor/Node/node_modules/binaryen/index.d.ts.meta

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

Assets/12.WeixinMinigame/Editor/Node/node_modules/binaryen/index.js.meta

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

Assets/12.WeixinMinigame/Editor/Node/node_modules/binaryen/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "binaryen",
+  "description": "Browser & Node.js builds of Binaryen, a compiler infrastructure and toolchain library for WebAssembly.",
+  "version": "103.0.0",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AssemblyScript/binaryen.js.git"
+  },
+  "keywords": [
+    "webassembly",
+    "wasm"
+  ],
+  "type": "module",
+  "main": "index.js",
+  "typings": "index.d.ts",
+  "bin": {
+    "wasm-opt": "bin/wasm-opt",
+    "wasm2js": "bin/wasm2js"
+  },
+  "scripts": {
+    "readme": "doctoc README.md --github --title \"### Contents\"",
+    "check": "tsc index.d.ts --noEmit --strict --noImplicitAny --strictNullChecks --listFiles --diagnostics",
+    "test": "npm run check && node tests/sanity && node tests/example",
+    "bundle": "node scripts/bundle.js"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "package.json",
+    "package-lock.json",
+    "README.md",
+    "bin/package.json",
+    "bin/wasm-opt",
+    "bin/wasm2js"
+  ],
+  "devDependencies": {
+    "dateformat": "^5.0.2",
+    "doctoc": "^2.1.0",
+    "esbuild": "^0.13.14",
+    "semver": "^7.1.3",
+    "simple-git": "^2.47.0",
+    "typescript": "^4.4.4"
+  }
+}

Assets/12.WeixinMinigame/Editor/Node/node_modules/binaryen/package.json.meta

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

Assets/12.WeixinMinigame/Editor/Node/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "unity-wasm",
+  "version": "1.0.0",
+  "description": "",
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "binaryen": "^103.0.0"
+  }
+}

Assets/12.WeixinMinigame/Editor/Node/package.json.meta

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

Assets/12.WeixinMinigame/Editor/PicCompressor.cs

@@ -0,0 +1,120 @@
+using System.IO;
+using System.Threading;
+
+using UnityEngine;
+
+namespace WeChatWASM
+{
+    public class PicTask
+    {
+        /// <summary>
+        /// 0: png, 1:astc, 2:etc2，3：pvrtc
+        /// </summary>
+        public int type;
+
+        /// <summary>
+        /// 图片路径
+        /// </summary>
+        public string src;
+        public string dst;
+        public int width;
+        public int height;
+    }
+
+    /// <summary>
+    /// 基于ImageMagick的图片处理
+    /// </summary>
+    ///
+    public static class PicCompressor
+    {
+        private static string ASTCPath;
+        private static string PVRTCPath;
+        private static string PNGPath;
+        private static string DXT5Path;
+        private static Semaphore sempore = new Semaphore(8, 8); // 最多设置8个进程
+
+        public static string GetASTCPath()
+        {
+            if (Application.platform == RuntimePlatform.WindowsEditor)
+            {
+                return Path.Combine(UnityUtil.GetWxSDKRootPath(), "Editor/TextureEditor/Node/astcenc-sse4.1.exe");
+            }
+
+            if (UnityEngine.SystemInfo.processorType.ToLower().Contains("apple"))
+            {
+                return Path.Combine(UnityUtil.GetWxSDKRootPath(), "Editor/TextureEditor/Node/astcenc-neon");
+            }
+
+            return Path.Combine(UnityUtil.GetWxSDKRootPath(), "Editor/TextureEditor/Node/astcenc-avx2");
+        }
+
+        public static string GetPVRTCPath()
+        {
+            return Path.Combine(UnityUtil.GetWxSDKRootPath(), "Editor/TextureEditor/Node/PVRTexToolCLI" + (Application.platform == RuntimePlatform.WindowsEditor ? ".exe" : string.Empty));
+        }
+
+        public static string GetDXT5Path()
+        {
+            return Path.Combine(UnityUtil.GetWxSDKRootPath(), "Editor/TextureEditor/Node/PVRTexToolCLI" + (Application.platform == RuntimePlatform.WindowsEditor ? ".exe" : string.Empty));
+        }
+
+        public static string GetPNGPath()
+        {
+            return Path.Combine(UnityUtil.GetWxSDKRootPath(), "Editor/TextureEditor/Node/pngquant" + (Application.platform == RuntimePlatform.WindowsEditor ? ".exe" : string.Empty));
+        }
+
+        public static void TestASTC()
+        {
+            var p = new System.Diagnostics.Process();
+            p.StartInfo.FileName = GetASTCPath();
+            p.StartInfo.UseShellExecute = false;
+            p.StartInfo.RedirectStandardInput = true;
+            p.StartInfo.RedirectStandardOutput = true;
+            p.StartInfo.RedirectStandardError = true;
+            p.StartInfo.CreateNoWindow = true;
+            p.StartInfo.Arguments = " -help";
+
+            p.Start();
+
+            string strOuput = p.StandardOutput.ReadToEnd();
+            Debug.Log(strOuput);
+            p.WaitForExit();
+            p.Close();
+        }
+
+        public static void TestMinPNG()
+        {
+            var p = new System.Diagnostics.Process();
+            p.StartInfo.FileName = GetPNGPath();
+            p.StartInfo.UseShellExecute = false;
+            p.StartInfo.RedirectStandardInput = true;
+            p.StartInfo.RedirectStandardOutput = true;
+            p.StartInfo.RedirectStandardError = true;
+            p.StartInfo.CreateNoWindow = true;
+            p.StartInfo.Arguments = " -help";
+
+            p.Start();
+
+            /*
+            string strOuput = p.StandardOutput.ReadToEnd();
+            Debug.Log(strOuput);
+            p.WaitForExit();
+            p.Close();
+            */
+        }
+
+        public static void TestPVRTC()
+        {
+            var p = new System.Diagnostics.Process();
+            p.StartInfo.FileName = GetPVRTCPath();
+            p.StartInfo.UseShellExecute = false;
+            p.StartInfo.RedirectStandardInput = true;
+            p.StartInfo.RedirectStandardOutput = true;
+            p.StartInfo.RedirectStandardError = true;
+            p.StartInfo.CreateNoWindow = true;
+            p.StartInfo.Arguments = " -help";
+
+            p.Start();
+        }
+    }
+}

Assets/12.WeixinMinigame/Editor/PicCompressor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fbf2c3e2666895a439fb1b9a2195bab4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/Playable.meta

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

Assets/12.WeixinMinigame/Editor/Playable/WXPlayableConvertCore.cs

@@ -0,0 +1,138 @@
+using System;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace WeChatWASM
+{
+    public class WXPlayableConvertCore
+    {
+        static WXPlayableConvertCore() { }
+        public static WXPlayableEditorScriptObject config => UnityUtil.GetPlayableEditorConf();
+
+        public static WXConvertCore.WXExportError DoExport(bool buildWebGL = true)
+        {
+            WXConvertCore.isPlayableBuild = true;
+            // var preCheckResult = WXConvertCore.PreCheck();
+            // if (preCheckResult != WXConvertCore.WXExportError.SUCCEED)
+            // {
+            //   WXConvertCore.isPlayableBuild = false;
+            //   return preCheckResult;
+            // }
+            // WXConvertCore.PreInit();
+            var exportResult = WXConvertCore.DoExport();
+
+            WXConvertCore.isPlayableBuild = false;
+            return exportResult;
+        }
+
+        public static WXEditorScriptObject GetFakeScriptObject()
+        {
+            return SetDefaultProperties(ConvertPlayableConfigToCommon(config));
+        }
+
+        public static WXEditorScriptObject ConvertPlayableConfigToCommon(
+            WXPlayableEditorScriptObject source,
+            WXEditorScriptObject target = null)
+        {
+            // 创建或使用现有的目标实例
+            var newTarget = target ?? ScriptableObject.CreateInstance<WXEditorScriptObject>();
+
+            // 使用序列化方式深度拷贝公共字段
+            var so = new SerializedObject(newTarget);
+
+            // 遍历源对象的所有字段
+            var sourceType = source.GetType();
+            foreach (var sourceField in sourceType.GetFields(
+                System.Reflection.BindingFlags.Public |
+                System.Reflection.BindingFlags.Instance |
+                System.Reflection.BindingFlags.NonPublic))
+            {
+                // 跳过readonly字段
+                if (sourceField.IsInitOnly) continue;
+
+                // 查找目标对象中的对应字段
+                var targetField = typeof(WXEditorScriptObject).GetField(
+                    sourceField.Name,
+                    System.Reflection.BindingFlags.Public |
+                    System.Reflection.BindingFlags.Instance |
+                    System.Reflection.BindingFlags.NonPublic);
+
+                // if (targetField != null && !targetField.FieldType.IsValueType && !targetField.FieldType.IsEnum)
+                // {
+                //   // // 复制字段值
+                //   // var value = sourceField.GetValue(source);
+                //   // targetField.SetValue(newTarget, value);
+                //   // 递归复制子对象属性
+                //   var subObj = targetField.GetValue(newTarget) ?? Activator.CreateInstance(targetField.FieldType);
+                //   CopySubObjectProperties(value, subObj);
+                //   targetField.SetValue(newTarget, subObj);
+                // }
+
+                // if (targetField != null && 
+                //     (targetField.FieldType.IsAssignableFrom(sourceField.FieldType) || 
+                //     (targetField.FieldType.IsValueType && sourceField.FieldType.IsValueType && 
+                //      targetField.FieldType == sourceField.FieldType)))
+                // {
+                // 复制字段值
+                var value = sourceField.GetValue(source);
+                // 特殊处理嵌套对象类型的字段
+                if (value != null && !targetField.FieldType.IsValueType && !targetField.FieldType.IsEnum)
+                {
+                    // 递归复制子对象属性
+                    var subObj = targetField.GetValue(newTarget) ?? Activator.CreateInstance(targetField.FieldType);
+                    CopySubObjectProperties(value, subObj);
+                    targetField.SetValue(newTarget, subObj);
+                }
+                else
+                {
+                    targetField.SetValue(newTarget, value);
+                }
+                // }
+            }
+
+            // 应用修改到序列化对象
+            so.ApplyModifiedProperties();
+            return newTarget;
+        }
+
+        private static void CopySubObjectProperties(object source, object target)
+        {
+            var sourceType = source.GetType();
+            var targetType = target.GetType();
+
+            foreach (var sourceField in sourceType.GetFields(
+                System.Reflection.BindingFlags.Public |
+                System.Reflection.BindingFlags.Instance |
+                System.Reflection.BindingFlags.NonPublic))
+            {
+                if (sourceField.IsInitOnly) continue;
+
+                var targetField = targetType.GetField(
+                    sourceField.Name,
+                    System.Reflection.BindingFlags.Public |
+                    System.Reflection.BindingFlags.Instance |
+                    System.Reflection.BindingFlags.NonPublic);
+
+                if (targetField != null &&
+                    (targetField.FieldType.IsAssignableFrom(sourceField.FieldType) ||
+                    (targetField.FieldType.IsValueType && sourceField.FieldType.IsValueType &&
+                     targetField.FieldType == sourceField.FieldType)))
+                {
+                    var value = sourceField.GetValue(source);
+                    targetField.SetValue(target, value);
+                }
+            }
+        }
+
+        public static WXEditorScriptObject SetDefaultProperties(WXEditorScriptObject target)
+        {
+            target.ProjectConf.CDN = "";
+            target.ProjectConf.assetLoadType = 1;
+            target.ProjectConf.compressDataPackage = true;
+
+            target.CompileOptions.showMonitorSuggestModal = false;
+            return target;
+        }
+    }
+}

Assets/12.WeixinMinigame/Editor/Playable/WXPlayableConvertCore.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0ec712f2bebf9ba4a87d104511814fdd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/Playable/WXPlayableEditorSettingHelper.cs

@@ -0,0 +1,359 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace WeChatWASM
+{
+    [InitializeOnLoad]
+    public class WXPlayableSettingsHelperInterface
+    {
+        public static WXPlayableSettingsHelper helper = new WXPlayableSettingsHelper();
+    }
+
+    public class WXPlayableSettingsHelper
+    {
+        public static string projectRootPath;
+        private static WXPlayableEditorScriptObject config;
+        private static bool m_EnablePerfTool = false;
+        public static bool UseIL2CPP
+        {
+            get
+            {
+#if TUANJIE_2022_3_OR_NEWER
+                return PlayerSettings.GetScriptingBackend(BuildTargetGroup.WeixinMiniGame) == ScriptingImplementation.IL2CPP;
+#else
+                return true;
+#endif
+            }
+        }
+
+        public WXPlayableSettingsHelper()
+        {
+            projectRootPath = System.IO.Path.GetFullPath(Application.dataPath + "/../");
+        }
+
+        public void OnFocus()
+        {
+            loadData();
+        }
+
+        public void OnLostFocus()
+        {
+            saveData();
+        }
+
+        public void OnDisable()
+        {
+            EditorUtility.SetDirty(config);
+        }
+
+        private Vector2 scrollRoot;
+        private bool foldBaseInfo = true;
+        private bool foldDebugOptions = true;
+        public void OnSettingsGUI(EditorWindow window)
+        {
+            scrollRoot = EditorGUILayout.BeginScrollView(scrollRoot);
+            GUIStyle linkStyle = new GUIStyle(GUI.skin.label);
+            linkStyle.normal.textColor = Color.yellow;
+            linkStyle.hover.textColor = Color.yellow;
+            linkStyle.stretchWidth = false;
+            linkStyle.alignment = TextAnchor.UpperLeft;
+            linkStyle.wordWrap = true;
+
+            foldBaseInfo = EditorGUILayout.Foldout(foldBaseInfo, "基本信息");
+            if (foldBaseInfo)
+            {
+                EditorGUILayout.BeginVertical("frameBox", GUILayout.ExpandWidth(true));
+                this.formInput("appid", "小游戏试玩AppID");
+                this.formInput("projectName", "小游戏试玩项目名");
+                this.formIntPopup("orientation", "游戏方向", new[] { "Portrait", "Landscape" }, new[] { 0, 1, 2, 3 });
+                this.formInput("memorySize", "UnityHeap预留内存(?)", "单位MB，预分配内存值，超休闲游戏256/中轻度496/重度游戏768，需预估游戏最大UnityHeap值以防止内存自动扩容带来的峰值尖刺。预估方法请查看GIT文档《优化Unity WebGL的内存》");
+
+                GUILayout.BeginHorizontal();
+                string targetDst = "dst";
+                if (!formInputData.ContainsKey(targetDst))
+                {
+                    formInputData[targetDst] = "";
+                }
+                EditorGUILayout.LabelField(string.Empty, GUILayout.Width(10));
+                GUILayout.Label(new GUIContent("导出路径(?)", "支持输入相对于项目根目录的相对路径，如：wxbuild"), GUILayout.Width(140));
+                formInputData[targetDst] = GUILayout.TextField(formInputData[targetDst], GUILayout.MaxWidth(EditorGUIUtility.currentViewWidth - 270));
+                if (GUILayout.Button(new GUIContent("打开"), GUILayout.Width(40)))
+                {
+                    if (!formInputData[targetDst].Trim().Equals(string.Empty))
+                    {
+                        EditorUtility.RevealInFinder(GetAbsolutePath(formInputData[targetDst]));
+                    }
+                    GUIUtility.ExitGUI();
+                }
+                if (GUILayout.Button(new GUIContent("选择"), GUILayout.Width(40)))
+                {
+                    var dstPath = EditorUtility.SaveFolderPanel("选择你的游戏导出目录", string.Empty, string.Empty);
+                    if (dstPath != string.Empty)
+                    {
+                        formInputData[targetDst] = dstPath;
+                        this.saveData();
+                    }
+                    GUIUtility.ExitGUI();
+                }
+                GUILayout.EndHorizontal();
+
+
+                EditorGUILayout.EndVertical();
+            }
+
+            foldDebugOptions = EditorGUILayout.Foldout(foldDebugOptions, "调试编译选项");
+            if (foldDebugOptions)
+            {
+                EditorGUILayout.BeginVertical("frameBox", GUILayout.ExpandWidth(true));
+                this.formCheckbox("developBuild", "Development Build", "", false, null, OnDevelopmentBuildToggleChanged);
+                this.formCheckbox("il2CppOptimizeSize", "Il2Cpp Optimize Size(?)", "对应于Il2CppCodeGeneration选项，勾选时使用OptimizeSize(默认推荐)，生成代码小15%左右，取消勾选则使用OptimizeSpeed。游戏中大量泛型集合的高频访问建议OptimizeSpeed，在使用HybridCLR等第三方组件时只能用OptimizeSpeed。(Dotnet Runtime模式下该选项无效)", !UseIL2CPP);
+                this.formCheckbox("profilingFuncs", "Profiling Funcs");
+                this.formCheckbox("webgl2", "WebGL2.0");
+                EditorGUILayout.EndVertical();
+            }
+
+            EditorGUILayout.EndScrollView();
+        }
+        public void OnBuildButtonGUI(EditorWindow window)
+        {
+            GUIStyle linkStyle = new GUIStyle(GUI.skin.label);
+            linkStyle.normal.textColor = Color.yellow;
+            linkStyle.hover.textColor = Color.yellow;
+            linkStyle.stretchWidth = false;
+            linkStyle.alignment = TextAnchor.UpperLeft;
+            linkStyle.wordWrap = true;
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField(string.Empty, GUILayout.MinWidth(10));
+            if (GUILayout.Button(new GUIContent("生成并转换"), GUILayout.Width(100), GUILayout.Height(25)))
+            {
+                this.saveData();
+                if (WXPlayableConvertCore.DoExport() == WXConvertCore.WXExportError.SUCCEED)
+                {
+                    window.ShowNotification(new GUIContent("转换完成"));
+                }
+                GUIUtility.ExitGUI();
+            }
+            EditorGUILayout.EndHorizontal();
+        }
+        private void OnDevelopmentBuildToggleChanged(bool InNewValue)
+        {
+            // 针对non-dev build，取消性能分析工具的集成
+            if (!InNewValue)
+            {
+                this.setData("enablePerfAnalysis", false);
+            }
+        }
+
+        private string SDKFilePath;
+
+        private void loadData()
+        {
+            SDKFilePath = Path.Combine(UnityUtil.GetWxSDKRootPath(), "Runtime", "wechat-playable-default", "unity-sdk", "index.js");
+            config = UnityUtil.GetPlayableEditorConf();
+
+            this.setData("projectName", config.ProjectConf.projectName);
+            this.setData("appid", config.ProjectConf.Appid);
+            this.setData("orientation", (int)config.ProjectConf.Orientation);
+            this.setData("dst", config.ProjectConf.relativeDST);
+
+            this.setData("developBuild", config.CompileOptions.DevelopBuild);
+            this.setData("il2CppOptimizeSize", config.CompileOptions.Il2CppOptimizeSize);
+            this.setData("profilingFuncs", config.CompileOptions.profilingFuncs);
+            this.setData("webgl2", config.CompileOptions.Webgl2);
+            this.setData("customNodePath", config.CompileOptions.CustomNodePath);
+
+            this.setData("memorySize", config.ProjectConf.MemorySize.ToString());
+        }
+
+        private void saveData()
+        {
+            config.ProjectConf.projectName = this.getDataInput("projectName");
+            config.ProjectConf.Appid = this.getDataInput("appid");
+            config.ProjectConf.Orientation = (WXScreenOritation)this.getDataPop("orientation");
+            config.ProjectConf.relativeDST = this.getDataInput("dst");
+            config.ProjectConf.DST = GetAbsolutePath(config.ProjectConf.relativeDST);
+
+            config.CompileOptions.DevelopBuild = this.getDataCheckbox("developBuild");
+            config.CompileOptions.Il2CppOptimizeSize = this.getDataCheckbox("il2CppOptimizeSize");
+            config.CompileOptions.profilingFuncs = this.getDataCheckbox("profilingFuncs");
+            config.CompileOptions.CustomNodePath = this.getDataInput("customNodePath");
+            config.CompileOptions.Webgl2 = this.getDataCheckbox("webgl2");
+            config.ProjectConf.MemorySize = int.Parse(this.getDataInput("memorySize"));
+        }
+
+        private Dictionary<string, string> formInputData = new Dictionary<string, string>();
+        private Dictionary<string, int> formIntPopupData = new Dictionary<string, int>();
+        private Dictionary<string, bool> formCheckboxData = new Dictionary<string, bool>();
+
+        private string getDataInput(string target)
+        {
+            if (this.formInputData.ContainsKey(target))
+                return this.formInputData[target];
+            return "";
+        }
+
+        private int getDataPop(string target)
+        {
+            if (this.formIntPopupData.ContainsKey(target))
+                return this.formIntPopupData[target];
+            return 0;
+        }
+
+        private bool getDataCheckbox(string target)
+        {
+            if (this.formCheckboxData.ContainsKey(target))
+                return this.formCheckboxData[target];
+            return false;
+        }
+
+        private void formCheckbox(string target, string label, string help = null, bool disable = false, Action<bool> setting = null, Action<bool> onValueChanged = null)
+        {
+            if (!formCheckboxData.ContainsKey(target))
+            {
+                formCheckboxData[target] = false;
+            }
+            GUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField(string.Empty, GUILayout.Width(10));
+            if (help == null)
+            {
+                GUILayout.Label(label, GUILayout.Width(140));
+            }
+            else
+            {
+                GUILayout.Label(new GUIContent(label, help), GUILayout.Width(140));
+            }
+            EditorGUI.BeginDisabledGroup(disable);
+
+            // Toggle the checkbox value based on the disable condition
+            bool newValue = EditorGUILayout.Toggle(disable ? false : formCheckboxData[target]);
+            // Update the checkbox data if the value has changed and invoke the onValueChanged action
+            if (newValue != formCheckboxData[target])
+            {
+                formCheckboxData[target] = newValue;
+                onValueChanged?.Invoke(newValue);
+            }
+
+            if (setting != null)
+            {
+                EditorGUILayout.LabelField("", GUILayout.Width(10));
+                // 配置按钮
+                if (GUILayout.Button(new GUIContent("设置"), GUILayout.Width(40), GUILayout.Height(18)))
+                {
+                    setting?.Invoke(true);
+                }
+                EditorGUILayout.LabelField("", GUILayout.MinWidth(10));
+            }
+
+            EditorGUI.EndDisabledGroup();
+
+            if (setting == null)
+                EditorGUILayout.LabelField(string.Empty);
+            GUILayout.EndHorizontal();
+        }
+
+        private void setData(string target, string value)
+        {
+            if (formInputData.ContainsKey(target))
+            {
+                formInputData[target] = value;
+            }
+            else
+            {
+                formInputData.Add(target, value);
+            }
+        }
+
+        private void setData(string target, bool value)
+        {
+            if (formCheckboxData.ContainsKey(target))
+            {
+                formCheckboxData[target] = value;
+            }
+            else
+            {
+                formCheckboxData.Add(target, value);
+            }
+        }
+
+        private void setData(string target, int value)
+        {
+            if (formIntPopupData.ContainsKey(target))
+            {
+                formIntPopupData[target] = value;
+            }
+            else
+            {
+                formIntPopupData.Add(target, value);
+            }
+        }
+
+        private void formInput(string target, string label, string help = null)
+        {
+            if (!formInputData.ContainsKey(target))
+            {
+                formInputData[target] = "";
+            }
+            GUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField(string.Empty, GUILayout.Width(10));
+            if (help == null)
+            {
+                GUILayout.Label(label, GUILayout.Width(140));
+            }
+            else
+            {
+                GUILayout.Label(new GUIContent(label, help), GUILayout.Width(140));
+            }
+            formInputData[target] = GUILayout.TextField(formInputData[target], GUILayout.MaxWidth(EditorGUIUtility.currentViewWidth - 195));
+            GUILayout.EndHorizontal();
+        }
+
+        private void formIntPopup(string target, string label, string[] options, int[] values)
+        {
+            if (!formIntPopupData.ContainsKey(target))
+            {
+                formIntPopupData[target] = 0;
+            }
+            GUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField(string.Empty, GUILayout.Width(10));
+            GUILayout.Label(label, GUILayout.Width(140));
+            formIntPopupData[target] = EditorGUILayout.IntPopup(formIntPopupData[target], options, values, GUILayout.MaxWidth(EditorGUIUtility.currentViewWidth - 195));
+            GUILayout.EndHorizontal();
+        }
+
+        public static bool IsAbsolutePath(string path)
+        {
+            // 检查是否为空或空白
+            if (string.IsNullOrWhiteSpace(path))
+            {
+                return false;
+            }
+
+            // 在 Windows 上，检查驱动器字母或网络路径
+            if (Application.platform == RuntimePlatform.WindowsEditor && Path.IsPathRooted(path))
+            {
+                return true;
+            }
+
+            // 在 Unix/Linux 和 macOS 上，检查是否以 '/' 开头
+            if (Application.platform == RuntimePlatform.OSXEditor && path.StartsWith("/"))
+            {
+                return true;
+            }
+
+            return false; // 否则为相对路径
+        }
+
+        public static string GetAbsolutePath(string path)
+        {
+            if (IsAbsolutePath(path))
+            {
+                return path;
+            }
+
+            return Path.Combine(projectRootPath, path);
+        }
+    }
+}

Assets/12.WeixinMinigame/Editor/Playable/WXPlayableEditorSettingHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b74b322f96dd0db42b1de748eca7aa87
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/Playable/WXPlayableWindow.cs

@@ -0,0 +1,46 @@
+using UnityEngine;
+using UnityEditor;
+using static WeChatWASM.WXConvertCore;
+
+namespace WeChatWASM
+{
+
+    public class WXPlayableWin : EditorWindow
+    {
+        [MenuItem("微信小游戏 / 转换小游戏试玩", false, 2)]
+        public static void Open()
+        {
+            var win = GetWindow(typeof(WXPlayableWin), false, "微信小游戏试玩转换工具面板");
+            win.minSize = new Vector2(350, 400);
+            win.position = new Rect(200, 200, 600, 300);
+            win.Show();
+        }
+
+        // 向前兼容，请使用 WXConvertCore.cs
+        public static WXExportError DoExport(bool buildWebGL = true)
+        {
+            return WXPlayableConvertCore.DoExport(buildWebGL);
+        }
+
+        public void OnFocus()
+        {
+            WXPlayableSettingsHelperInterface.helper.OnFocus();
+        }
+
+        public void OnLostFocus()
+        {
+            WXPlayableSettingsHelperInterface.helper.OnLostFocus();
+        }
+
+        public void OnDisable()
+        {
+            WXPlayableSettingsHelperInterface.helper.OnDisable();
+        }
+
+        public void OnGUI()
+        {
+            WXPlayableSettingsHelperInterface.helper.OnSettingsGUI(this);
+            WXPlayableSettingsHelperInterface.helper.OnBuildButtonGUI(this);
+        }
+    }
+}

Assets/12.WeixinMinigame/Editor/Playable/WXPlayableWindow.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5be96aedd3b97814f9ec6d3a44b8f3a7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/12.WeixinMinigame/Editor/TextureEditor.meta

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