UniMCP4CC
by dsgarage
- UniMCP4CC
- Editor
UnityMcpHttpServer.cs•174 kB
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Text;
using System.Threading;
using UnityEngine;
#if UNITY_2021_2_OR_NEWER
using LocalMcp.UnityServer.UIToolkit;
using LocalMcp.UnityServer.UIToolkit.DI;
using LocalMcp.UnityServer.UIToolkit.Animation;
using LocalMcp.UnityServer.UIToolkit.Theme;
using LocalMcp.UnityServer.UIToolkit.Presets;
using LocalMcp.UnityServer.UIToolkit.Responsive;
using LocalMcp.UnityServer.UIToolkit.Accessibility;
using LocalMcp.UnityServer.UIToolkit.Localization;
using LocalMcp.UnityServer.UIToolkit.Debug;
using LocalMcp.UnityServer.UIToolkit.AssetDependencies;
#endif
namespace LocalMcp.UnityServer
{
/// <summary>
/// HTTP REST API server for MCP protocol bridge compatibility.
/// Runs alongside the WebSocket server on port 5051.
/// </summary>
public class UnityMcpHttpServer
{
private HttpListener httpListener;
private Thread listenerThread;
private bool isRunning = false;
private int port = 5051;
public static UnityMcpHttpServer Instance { get; private set; }
public UnityMcpHttpServer()
{
Instance = this;
}
/// <summary>
/// Starts the HTTP server.
/// </summary>
public void StartServer(int serverPort = 5051)
{
if (isRunning)
{
Debug.LogWarning("[MCP HTTP] Server is already running");
return;
}
port = serverPort;
isRunning = true;
listenerThread = new Thread(ServerLoop);
listenerThread.IsBackground = true;
listenerThread.Start();
Debug.Log($"[MCP HTTP] Server started on http://localhost:{port}");
}
/// <summary>
/// Stops the HTTP server.
/// </summary>
public void StopServer()
{
if (!isRunning)
{
return;
}
isRunning = false;
if (httpListener != null && httpListener.IsListening)
{
httpListener.Stop();
httpListener.Close();
httpListener = null;
}
if (listenerThread != null && listenerThread.IsAlive)
{
listenerThread.Join(1000);
listenerThread = null;
}
Debug.Log("[MCP HTTP] Server stopped");
}
private void ServerLoop()
{
try
{
httpListener = new HttpListener();
httpListener.Prefixes.Add($"http://localhost:{port}/");
httpListener.Start();
Debug.Log($"[MCP HTTP] Server listening on port {port}");
while (isRunning)
{
try
{
var context = httpListener.GetContext();
ThreadPool.QueueUserWorkItem((_) => HandleRequest(context));
}
catch (HttpListenerException)
{
// Expected when stopping
break;
}
}
}
catch (ThreadAbortException)
{
// Silently handle thread abort during domain reload
Thread.ResetAbort();
}
catch (Exception e)
{
// Only log unexpected errors
if (isRunning)
{
Debug.LogError($"[MCP HTTP] Server error: {e.Message}");
}
}
}
private void HandleRequest(HttpListenerContext context)
{
try
{
var request = context.Request;
var response = context.Response;
// Enable CORS
response.AddHeader("Access-Control-Allow-Origin", "*");
response.AddHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
response.AddHeader("Access-Control-Allow-Headers", "Content-Type");
// Handle preflight
if (request.HttpMethod == "OPTIONS")
{
response.StatusCode = 200;
response.Close();
return;
}
// Health check endpoint
if (request.HttpMethod == "GET" && request.Url.AbsolutePath == "/health")
{
// Get project info from main thread
string healthJson = UnityMainThreadDispatcher.EnqueueAndWait(() =>
{
return $"{{\"status\":\"ok\",\"projectName\":\"{Application.productName}\",\"unityVersion\":\"{Application.unityVersion}\",\"timestamp\":{DateTimeOffset.UtcNow.ToUnixTimeSeconds()}}}";
});
response.StatusCode = 200;
response.ContentType = "application/json";
byte[] healthBytes = Encoding.UTF8.GetBytes(healthJson);
response.ContentLength64 = healthBytes.Length;
response.OutputStream.Write(healthBytes, 0, healthBytes.Length);
response.Close();
return;
}
// Only accept POST requests to /api/mcp
if (request.HttpMethod != "POST" || !request.Url.AbsolutePath.StartsWith("/api/mcp"))
{
response.StatusCode = 404;
byte[] errorBytes = Encoding.UTF8.GetBytes("{\"error\":\"Not found\"}");
response.OutputStream.Write(errorBytes, 0, errorBytes.Length);
response.Close();
return;
}
// Read request body
string requestBody;
using (var reader = new StreamReader(request.InputStream, request.ContentEncoding))
{
requestBody = reader.ReadToEnd();
}
Debug.Log($"[MCP HTTP] Received: {requestBody}");
// Extract method and params from JSON manually
// (JsonUtility doesn't handle 'object' type fields properly)
string method = ExtractJsonField(requestBody, "method");
string paramsJson = ExtractJsonObject(requestBody, "params");
string idStr = ExtractJsonField(requestBody, "id");
object id = null;
if (!string.IsNullOrEmpty(idStr))
{
if (int.TryParse(idStr, out int intId))
id = intId;
else
id = idStr;
}
if (string.IsNullOrEmpty(method))
{
SendErrorResponse(response, "Invalid JSON-RPC request: method is required");
return;
}
Debug.Log($"[MCP HTTP] Method: {method}, Params: {paramsJson}, ID: {id}");
// Process request
string responseText = ProcessRequestDirect(method, paramsJson, id);
// Record success or failure based on response
if (responseText.Contains("\"error\""))
{
ConnectionHealthMonitor.RecordFailure();
}
else
{
ConnectionHealthMonitor.RecordSuccess();
}
// Send response
response.StatusCode = 200;
response.ContentType = "application/json";
byte[] responseBytes = Encoding.UTF8.GetBytes(responseText);
response.ContentLength64 = responseBytes.Length;
response.OutputStream.Write(responseBytes, 0, responseBytes.Length);
response.Close();
Debug.Log($"[MCP HTTP] Response sent");
}
catch (Exception e)
{
Debug.LogError($"[MCP HTTP] Error handling request: {e.Message}");
try
{
SendErrorResponse(context.Response, e.Message);
}
catch
{
// Ignore errors when sending error response
}
}
}
private void SendErrorResponse(HttpListenerResponse response, string message)
{
response.StatusCode = 500;
response.ContentType = "application/json";
string errorJson = JsonRpcResponseHelper.ErrorMessage(message, null);
byte[] errorBytes = Encoding.UTF8.GetBytes(errorJson);
response.ContentLength64 = errorBytes.Length;
response.OutputStream.Write(errorBytes, 0, errorBytes.Length);
response.Close();
}
private string ProcessRequestDirect(string method, string paramsJson, object id)
{
var stopwatch = System.Diagnostics.Stopwatch.StartNew();
string result = null;
try
{
// Execute on main thread using UnityMainThreadDispatcher
result = UnityMainThreadDispatcher.EnqueueAndWait(() => ProcessRequestOnMainThread(method, paramsJson, id));
stopwatch.Stop();
// ログ記録（エラーレスポンスかどうかを判定）
if (result != null && result.Contains("\"error\""))
{
// エラーメッセージを抽出
string errorMsg = ExtractJsonField(result, "message") ?? "Unknown error";
McpApiLogger.Instance.LogError(method, paramsJson, errorMsg, stopwatch.ElapsedMilliseconds);
}
else
{
McpApiLogger.Instance.LogSuccess(method, paramsJson, result, stopwatch.ElapsedMilliseconds);
}
return result;
}
catch (Exception e)
{
stopwatch.Stop();
McpApiLogger.Instance.LogError(method, paramsJson, e.Message, stopwatch.ElapsedMilliseconds);
throw;
}
}
private string ProcessRequestOnMainThread(string method, string paramsJson, object id)
{
Debug.Log($"[MCP HTTP] ProcessRequestOnMainThread called with method: '{method}'");
if (string.IsNullOrEmpty(paramsJson))
{
paramsJson = "{}";
}
// Route to appropriate handler (same as McpSession)
// MCP tools/list - API Discovery (Issue #73)
if (method == "tools/list")
{
return GetToolsList(paramsJson, id);
}
else if (method == "tools/categories")
{
return GetToolsCategories(id);
}
else if (method == "unity.log.stream")
{
// Note: HTTP doesn't support streaming, so this will just return status
return JsonRpcResponseHelper.SuccessMessage("Log streaming not supported over HTTP. Use WebSocket instead.", id);
}
else if (method == "unity.log.history")
{
// Initialize GlobalLogCapture if not already done
var logCapture = GlobalLogCapture.Instance;
// Parse parameters
int limit = ExtractIntParam(paramsJson, "limit", 50);
string level = ExtractJsonField(paramsJson, "level") ?? "all";
// Get logs
var logs = logCapture.GetLogs(limit, level);
var logsJson = new List<string>();
foreach (var log in logs)
{
string escapedMessage = log.message.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\n", "\\n").Replace("\r", "\\r");
string escapedStack = log.stackTrace.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\n", "\\n").Replace("\r", "\\r");
logsJson.Add($"{{\"message\":\"{escapedMessage}\",\"type\":\"{log.type}\",\"timestamp\":\"{log.timestamp}\",\"stackTrace\":\"{escapedStack}\"}}");
}
string result = $"{{\"logs\":[{string.Join(",", logsJson)}],\"total\":{logs.Count},\"totalCaptured\":{logCapture.GetTotalLogCount()}}}";
return JsonRpcResponseHelper.SuccessMessage(result, id);
}
else if (method == "unity.connection.status")
{
return ConnectionHealthMonitor.GetStatus(id);
}
else if (method == "unity.connection.ping")
{
return ConnectionHealthMonitor.Ping(id);
}
else if (method == "unity.connection.reset")
{
return ConnectionHealthMonitor.Reset(id);
}
else if (method == "unity.editor.play")
{
return EditorPlayModeControl.Play(id);
}
else if (method == "unity.editor.stop")
{
return EditorPlayModeControl.Stop(id);
}
else if (method == "unity.editor.pause")
{
return EditorPlayModeControl.Pause(id);
}
else if (method == "unity.editor.resume")
{
return EditorPlayModeControl.Resume(id);
}
else if (method == "unity.editor.step")
{
return EditorPlayModeControl.Step(id);
}
else if (method == "unity.editor.playModeStatus")
{
return EditorPlayModeControl.GetStatus(id);
}
else if (method == "unity.editor.playAndCaptureLogs")
{
return EditorPlayModeControl.PlayAndCaptureLogs(paramsJson, id);
}
else if (method == "unity.test.runAll")
{
return UnityTestRunnerControl.RunAllTests(paramsJson, id);
}
else if (method == "unity.test.runByCategory")
{
return UnityTestRunnerControl.RunTestsByCategory(paramsJson, id);
}
else if (method == "unity.test.runByAssembly")
{
return UnityTestRunnerControl.RunTestsByAssembly(paramsJson, id);
}
else if (method == "unity.test.runSpecific")
{
return UnityTestRunnerControl.RunSpecificTest(paramsJson, id);
}
else if (method == "unity.test.getResults")
{
return UnityTestRunnerControl.GetTestResults(id);
}
else if (method == "unity.test.list")
{
return UnityTestRunnerControl.ListTests(paramsJson, id);
}
else if (method == "unity.test.status")
{
return UnityTestRunnerControl.GetStatus(id);
}
else if (method == "unity.test.getFailedTests")
{
return UnityTestRunnerControl.GetFailedTests(id);
}
else if (method == "unity.test.saveResults")
{
return UnityTestRunnerControl.SaveResults(paramsJson, id);
}
else if (method == "unity.test.runWithLog")
{
return UnityTestRunnerControl.RunWithLog(paramsJson, id);
}
else if (method == "unity.test.exportResults")
{
return UnityTestRunnerControl.ExportResults(paramsJson, id);
}
else if (method == "unity.test.clearResults")
{
return UnityTestRunnerControl.ClearResults(id);
}
else if (method == "unity.test.runSelected")
{
return UnityTestRunnerControl.RunSelected(paramsJson, id);
}
else if (method == "unity.test.runFailed")
{
return UnityTestRunnerControl.RunFailed(paramsJson, id);
}
else if (method == "unity.test.runEditMode")
{
return UnityTestRunnerControl.RunEditMode(paramsJson, id);
}
else if (method == "unity.test.runPlayMode")
{
return UnityTestRunnerControl.RunPlayMode(paramsJson, id);
}
else if (method == "unity.scene.list")
{
return SceneSetupCommand.ListScene(paramsJson, id);
}
else if (method == "unity.scene.setup")
{
return SceneSetupCommand.SetupScene(paramsJson, id);
}
else if (method == "unity.scene.save")
{
return SceneSetupCommand.SaveScene(paramsJson, id);
}
else if (method == "unity.project.save")
{
return SceneSetupCommand.SaveProject(paramsJson, id);
}
else if (method == "unity.scene.open")
{
return SceneSetupCommand.OpenScene(paramsJson, id);
}
else if (method == "unity.create")
{
return SceneSetupCommand.CreateGameObject(paramsJson, id);
}
else if (method == "unity.debug.log")
{
return SceneSetupCommand.DebugLog(paramsJson, id);
}
else if (method == "unity.editor.executeMenuItem")
{
return SceneSetupCommand.ExecuteMenuItem(paramsJson, id);
}
else if (method == "unity.scene.findObjectOfType")
{
return SceneSetupCommand.FindObjectOfType(paramsJson, id);
}
else if (method == "unity.scene.setupArchitecture")
{
return SceneSetupCommand.SetupSceneArchitecture(paramsJson, id);
}
// GameObject operations
else if (method == "unity.gameObject.delete")
{
return SceneSetupCommand.DeleteGameObject(paramsJson, id);
}
else if (method == "unity.gameObject.setActive")
{
return SceneSetupCommand.SetGameObjectActive(paramsJson, id);
}
else if (method == "unity.gameObject.setParent")
{
return SceneSetupCommand.SetGameObjectParent(paramsJson, id);
}
else if (method == "unity.transform.setPosition")
{
return SceneSetupCommand.SetTransformPosition(paramsJson, id);
}
else if (method == "unity.transform.setRotation")
{
return SceneSetupCommand.SetTransformRotation(paramsJson, id);
}
else if (method == "unity.transform.setScale")
{
return SceneSetupCommand.SetTransformScale(paramsJson, id);
}
else if (method == "unity.gameobject.destroy")
{
return SceneSetupCommand.DestroyGameObject(paramsJson, id);
}
// Prefab operations
else if (method == "unity.prefab.instantiate")
{
return PrefabOperations.InstantiatePrefab(paramsJson, id);
}
else if (method == "unity.prefab.create")
{
return PrefabOperations.CreatePrefab(paramsJson, id);
}
else if (method == "unity.prefab.apply")
{
return PrefabOperations.ApplyPrefabChanges(paramsJson, id);
}
else if (method == "unity.prefab.revert")
{
return PrefabOperations.RevertPrefabChanges(paramsJson, id);
}
else if (method == "unity.prefab.unpack")
{
return PrefabOperations.UnpackPrefab(paramsJson, id);
}
else if (method == "unity.asset.list")
{
return AssetDatabaseProvider.ListAssets(paramsJson, id);
}
else if (method == "unity.asset.find")
{
return AssetDatabaseProvider.FindAsset(paramsJson, id);
}
else if (method == "unity.asset.refresh")
{
return AssetDatabaseProvider.RefreshAssetDatabase(paramsJson, id);
}
else if (method == "unity.asset.delete")
{
return AssetDatabaseProvider.DeleteAsset(paramsJson, id);
}
else if (method == "unity.asset.move")
{
return AssetDatabaseProvider.MoveAsset(paramsJson, id);
}
else if (method == "unity.asset.copy")
{
return AssetDatabaseProvider.CopyAsset(paramsJson, id);
}
else if (method == "unity.component.list")
{
return ComponentReflection.ListComponents(paramsJson, id);
}
else if (method == "unity.component.inspect")
{
return ComponentReflection.InspectComponent(paramsJson, id);
}
else if (method == "unity.component.set")
{
return ComponentReflection.SetField(paramsJson, id);
}
else if (method == "unity.component.setProperty")
{
return ComponentReflection.SetProperty(paramsJson, id);
}
else if (method == "unity.component.invoke")
{
return ComponentReflection.InvokeMethod(paramsJson, id);
}
else if (method == "unity.component.add")
{
return ComponentReflection.AddComponent(paramsJson, id);
}
else if (method == "unity.component.remove")
{
return ComponentReflection.RemoveComponent(paramsJson, id);
}
else if (method == "unity.component.setReference")
{
return ComponentReflection.SetReference(paramsJson, id);
}
else if (method == "unity.component.setSerializedProperty")
{
Debug.Log("[MCP HTTP] SerializedProperty method called!");
return SerializedPropertyWriter.SetSerializedProperty(paramsJson, id);
}
else if (method == "unity.compile.status")
{
return CompileWaitHelper.GetCompileStatus(id);
}
else if (method == "unity.compile.waitForCompile")
{
return CompileWaitHelper.WaitForCompile(paramsJson, id);
}
else if (method == "unity.project.getPlayerSettings")
{
return ProjectSettingsController.GetPlayerSettings(id);
}
else if (method == "unity.project.setPlayerSettings")
{
return ProjectSettingsController.SetPlayerSettings(paramsJson, id);
}
else if (method == "unity.project.getQualitySettings")
{
return ProjectSettingsController.GetQualitySettings(id);
}
else if (method == "unity.project.setQualitySettings")
{
return ProjectSettingsController.SetQualitySettings(paramsJson, id);
}
else if (method == "unity.project.getPhysicsSettings")
{
return ProjectSettingsController.GetPhysicsSettings(id);
}
else if (method == "unity.project.setPhysicsSettings")
{
return ProjectSettingsController.SetPhysicsSettings(paramsJson, id);
}
else if (method == "unity.project.getTimeSettings")
{
return ProjectSettingsController.GetTimeSettings(id);
}
else if (method == "unity.project.setTimeSettings")
{
return ProjectSettingsController.SetTimeSettings(paramsJson, id);
}
else if (method == "unity.component.setArrayElement")
{
return ComponentReflection.SetArrayElement(paramsJson, id);
}
else if (method == "unity.component.addArrayElement")
{
return ComponentReflection.AddArrayElement(paramsJson, id);
}
else if (method == "unity.component.removeArrayElement")
{
return ComponentReflection.RemoveArrayElement(paramsJson, id);
}
else if (method == "unity.animator.create")
{
return AnimatorBuilder.CreateController(paramsJson, id);
}
else if (method == "unity.animator.addState")
{
return AnimatorBuilder.AddState(paramsJson, id);
}
else if (method == "unity.animator.addTransition")
{
return AnimatorBuilder.AddTransition(paramsJson, id);
}
else if (method == "unity.animator.addParameter")
{
return AnimatorBuilder.AddParameter(paramsJson, id);
}
else if (method == "unity.animator.assignClip")
{
return AnimatorBuilder.AssignClip(paramsJson, id);
}
else if (method == "unity.animator.bind")
{
return AnimatorControl.BindController(paramsJson, id);
}
// AnimatorOverrideController APIs
else if (method == "unity.animator.createOverride")
{
return AnimatorOverrideBuilder.CreateOverride(paramsJson, id);
}
else if (method == "unity.animator.setOverrideController")
{
return AnimatorOverrideBuilder.SetOverrideController(paramsJson, id);
}
else if (method == "unity.animator.setOverrideClip")
{
return AnimatorOverrideBuilder.SetOverrideClip(paramsJson, id);
}
else if (method == "unity.animator.getOverrideClips")
{
return AnimatorOverrideBuilder.GetOverrideClips(paramsJson, id);
}
else if (method == "unity.animator.clearOverrideClip")
{
return AnimatorOverrideBuilder.ClearOverrideClip(paramsJson, id);
}
#if UNITY_2021_2_OR_NEWER
else if (method == "unity.uitoolkit.createUIDocument")
{
return UIToolkitAssetCreator.CreateUIDocument(paramsJson, id);
}
else if (method == "unity.uitoolkit.createStyleSheet")
{
return UIToolkitAssetCreator.CreateStyleSheet(paramsJson, id);
}
else if (method == "unity.uitoolkit.createPanelSettings")
{
return UIToolkitAssetCreator.CreatePanelSettings(paramsJson, id);
}
else if (method == "unity.uitoolkit.addUIDocumentComponent")
{
return UIToolkitAssetCreator.AddUIDocumentComponent(paramsJson, id);
}
#endif // UNITY_2021_2_OR_NEWER
// TextMeshPro APIs
else if (method == "unity.textmeshpro.create")
{
return TextMeshProController.Create(paramsJson, id);
}
else if (method == "unity.textmeshpro.setText")
{
return TextMeshProController.SetText(paramsJson, id);
}
else if (method == "unity.textmeshpro.setStyle")
{
return TextMeshProController.SetStyle(paramsJson, id);
}
else if (method == "unity.textmeshpro.setLayout")
{
return TextMeshProController.SetLayout(paramsJson, id);
}
else if (method == "unity.textmeshpro.setAutoSize")
{
return TextMeshProController.SetAutoSize(paramsJson, id);
}
else if (method == "unity.textmeshpro.setOverflow")
{
return TextMeshProController.SetOverflow(paramsJson, id);
}
else if (method == "unity.textmeshpro.setFont")
{
return TextMeshProController.SetFont(paramsJson, id);
}
else if (method == "unity.textmeshpro.getInfo")
{
return TextMeshProController.GetInfo(paramsJson, id);
}
else if (method == "unity.textmeshpro.createMultiple")
{
return TextMeshProController.CreateMultiple(paramsJson, id);
}
else if (method == "unity.textmeshpro.listFontAssets")
{
return TextMeshProController.ListFontAssets(paramsJson, id);
}
else if (method == "unity.textmeshpro.getFontAssetInfo")
{
return TextMeshProController.GetFontAssetInfo(paramsJson, id);
}
// Material APIs
else if (method == "unity.material.getInfo")
{
return MaterialController.GetInfo(paramsJson, id);
}
else if (method == "unity.material.getProperty")
{
return MaterialController.GetProperty(paramsJson, id);
}
else if (method == "unity.material.setProperty")
{
return MaterialController.SetProperty(paramsJson, id);
}
else if (method == "unity.material.setColor")
{
return MaterialController.SetColor(paramsJson, id);
}
else if (method == "unity.material.setFloat")
{
return MaterialController.SetFloat(paramsJson, id);
}
else if (method == "unity.material.setVector")
{
return MaterialController.SetVector(paramsJson, id);
}
else if (method == "unity.material.setTexture")
{
return MaterialController.SetTexture(paramsJson, id);
}
else if (method == "unity.material.setKeyword")
{
return MaterialController.SetKeyword(paramsJson, id);
}
else if (method == "unity.material.setRenderQueue")
{
return MaterialController.SetRenderQueue(paramsJson, id);
}
else if (method == "unity.material.listProperties")
{
return MaterialController.ListProperties(paramsJson, id);
}
else if (method == "unity.material.create")
{
return MaterialController.Create(paramsJson, id);
}
else if (method == "unity.material.copyProperties")
{
return MaterialController.CopyProperties(paramsJson, id);
}
else if (method == "unity.material.apply")
{
return MaterialController.Apply(paramsJson, id);
}
else if (method == "unity.material.getFromObject")
{
return MaterialController.GetFromObject(paramsJson, id);
}
else if (method == "unity.material.listFromObject")
{
return MaterialController.ListFromObject(paramsJson, id);
}
else if (method == "unity.material.setSharedMaterial")
{
return MaterialController.SetSharedMaterial(paramsJson, id);
}
// ============================================
// Renderer APIs
// ============================================
else if (method == "unity.renderer.setMaterial")
{
return MaterialController.SetRendererMaterial(paramsJson, id);
}
// ============================================
// Build Pipeline APIs (3)
// ============================================
else if (method == "unity.build.buildPlayer")
{
return BuildPipelineController.BuildPlayer(paramsJson, id);
}
else if (method == "unity.build.getSettings")
{
return BuildPipelineController.GetBuildSettings(id);
}
else if (method == "unity.build.setSettings")
{
return BuildPipelineController.SetBuildSettings(paramsJson, id);
}
#if UNITY_2022_1_OR_NEWER
// ============================================
// Build Profile APIs (5) - Unity 2022.1+
// ============================================
else if (method == "unity.buildProfile.list")
{
return BuildProfileController.ListProfiles(id);
}
else if (method == "unity.buildProfile.activate")
{
return BuildProfileController.ActivateProfile(paramsJson, id);
}
else if (method == "unity.buildProfile.create")
{
return BuildProfileController.CreateProfile(paramsJson, id);
}
else if (method == "unity.buildProfile.getSettings")
{
return BuildProfileController.GetProfileSettings(paramsJson, id);
}
else if (method == "unity.buildProfile.setSettings")
{
return BuildProfileController.SetProfileSettings(paramsJson, id);
}
#endif
// ============================================
// Package APIs (7)
// ============================================
else if (method == "unity.package.export")
{
return PackageController.ExportPackage(paramsJson, id);
}
else if (method == "unity.package.import")
{
return PackageController.ImportPackage(paramsJson, id);
}
else if (method == "unity.package.list")
{
return PackageController.ListPackages(paramsJson, id);
}
else if (method == "unity.package.add")
{
return PackageController.AddPackage(paramsJson, id);
}
else if (method == "unity.package.remove")
{
return PackageController.RemovePackage(paramsJson, id);
}
else if (method == "unity.package.embed")
{
return PackageController.EmbedPackage(paramsJson, id);
}
else if (method == "unity.package.pack")
{
return PackageController.PackPackage(paramsJson, id);
}
// ============================================
// uGUI - RectTransform APIs (6)
// ============================================
else if (method == "unity.rectTransform.setSize")
{
return uGUIController.SetSize(paramsJson, id);
}
else if (method == "unity.rectTransform.setPosition")
{
return uGUIController.SetPosition(paramsJson, id);
}
else if (method == "unity.rectTransform.setAnchors")
{
return uGUIController.SetAnchors(paramsJson, id);
}
else if (method == "unity.rectTransform.setPivot")
{
return uGUIController.SetPivot(paramsJson, id);
}
else if (method == "unity.rectTransform.setOffsets")
{
return uGUIController.SetOffsets(paramsJson, id);
}
else if (method == "unity.rectTransform.getInfo")
{
return uGUIController.GetInfo(paramsJson, id);
}
// ============================================
// uGUI - Canvas APIs (3)
// ============================================
else if (method == "unity.canvas.create")
{
return uGUIController.CreateCanvas(paramsJson, id);
}
else if (method == "unity.canvas.setScaler")
{
return uGUIController.SetScaler(paramsJson, id);
}
else if (method == "unity.canvas.getInfo")
{
return uGUIController.GetCanvasInfo(paramsJson, id);
}
// ============================================
// uGUI - UI Element Presets (4)
// ============================================
else if (method == "unity.ui.createButton")
{
return uGUIController.CreateButton(paramsJson, id);
}
else if (method == "unity.ui.createPanel")
{
return uGUIController.CreatePanel(paramsJson, id);
}
else if (method == "unity.ui.createImage")
{
return uGUIController.CreateImage(paramsJson, id);
}
else if (method == "unity.ui.createText")
{
return uGUIController.CreateText(paramsJson, id);
}
// Asset creation APIs
else if (method == "unity.asset.createMaterial")
{
return UnityAssetCreator.CreateMaterial(paramsJson, id);
}
else if (method == "unity.asset.createScene")
{
return UnityAssetCreator.CreateScene(paramsJson, id);
}
else if (method == "unity.asset.createFolder")
{
return UnityAssetCreator.CreateFolder(paramsJson, id);
}
else if (method == "unity.asset.createPhysicsMaterial")
{
return UnityAssetCreator.CreatePhysicsMaterial(paramsJson, id);
}
else if (method == "unity.asset.createPhysicsMaterial2D")
{
return UnityAssetCreator.CreatePhysicsMaterial2D(paramsJson, id);
}
else if (method == "unity.asset.createAudioMixer")
{
return UnityAssetCreator.CreateAudioMixer(paramsJson, id);
}
else if (method == "unity.asset.createAnimationClip")
{
return UnityAssetCreator.CreateAnimationClip(paramsJson, id);
}
else if (method == "unity.asset.createRenderTexture")
{
return UnityAssetCreator.CreateRenderTexture(paramsJson, id);
}
else if (method == "unity.asset.createAvatarMask")
{
return UnityAssetCreator.CreateAvatarMask(paramsJson, id);
}
else if (method == "unity.asset.createScriptableObject" || method == "unity.asset.create")
{
return UnityAssetCreator.CreateScriptableObject(paramsJson, id);
}
// SerializedObject inspection
else if (method == "unity.serialized.inspect")
{
return SerializedObjectInspector.InspectSerializedObject(paramsJson, id);
}
else if (method == "unity.serialized.validateMissingReferences")
{
return SerializedObjectInspector.ValidateMissingReferences(paramsJson, id);
}
else if (method == "unity.serialized.validateSceneMissingReferences")
{
return SerializedObjectInspector.ValidateSceneMissingReferences(paramsJson, id);
}
// Editor method invocation
else if (method == "unity.editor.executeMenuItem")
{
return EditorMethodInvoker.ExecuteMenuItem(paramsJson, id);
}
else if (method == "unity.editor.invokeStaticMethod")
{
return EditorMethodInvoker.InvokeStaticMethod(paramsJson, id);
}
else if (method == "unity.editor.listMenuItems")
{
return EditorMethodInvoker.ListMenuItems(paramsJson, id);
}
// ============================================
// Timeline APIs (Reflection-based)
// ============================================
// Timeline API - TimelineAsset管理 (6個)
else if (method == "unity.timeline.create")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineBuilder, "Create", paramsJson, id);
}
else if (method == "unity.timeline.delete")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineBuilder, "Delete", paramsJson, id);
}
else if (method == "unity.timeline.get")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineBuilder, "Get", paramsJson, id);
}
else if (method == "unity.timeline.list")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineBuilder, "List", paramsJson, id);
}
else if (method == "unity.timeline.setDuration")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineBuilder, "SetDuration", paramsJson, id);
}
else if (method == "unity.timeline.duplicate")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineBuilder, "Duplicate", paramsJson, id);
}
// Timeline API - PlayableDirector制御 (10個)
else if (method == "unity.timeline.director.bind")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "Bind", paramsJson, id);
}
else if (method == "unity.timeline.director.play")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "Play", paramsJson, id);
}
else if (method == "unity.timeline.director.stop")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "Stop", paramsJson, id);
}
else if (method == "unity.timeline.director.pause")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "Pause", paramsJson, id);
}
else if (method == "unity.timeline.director.resume")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "Resume", paramsJson, id);
}
else if (method == "unity.timeline.director.setTime")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "SetTime", paramsJson, id);
}
else if (method == "unity.timeline.director.evaluate")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "Evaluate", paramsJson, id);
}
else if (method == "unity.timeline.director.getState")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "GetState", paramsJson, id);
}
else if (method == "unity.timeline.director.setBinding")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "SetBinding", paramsJson, id);
}
else if (method == "unity.timeline.director.getBindings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "GetBindings", paramsJson, id);
}
// Timeline API - Track操作 (10個)
else if (method == "unity.timeline.track.create")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "Create", paramsJson, id);
}
else if (method == "unity.timeline.track.delete")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "Delete", paramsJson, id);
}
else if (method == "unity.timeline.track.get")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "Get", paramsJson, id);
}
else if (method == "unity.timeline.track.list")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "List", paramsJson, id);
}
else if (method == "unity.timeline.track.setMuted")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "SetMuted", paramsJson, id);
}
else if (method == "unity.timeline.track.setLocked")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "SetLocked", paramsJson, id);
}
else if (method == "unity.timeline.track.setParent")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "SetParent", paramsJson, id);
}
else if (method == "unity.timeline.track.reorder")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "Reorder", paramsJson, id);
}
else if (method == "unity.timeline.track.setAnimationTrackSettings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "SetAnimationTrackSettings", paramsJson, id);
}
else if (method == "unity.timeline.track.setActivationTrackSettings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "SetActivationTrackSettings", paramsJson, id);
}
// Timeline API - Clip操作 (12個)
else if (method == "unity.timeline.clip.create")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "Create", paramsJson, id);
}
else if (method == "unity.timeline.clip.delete")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "Delete", paramsJson, id);
}
else if (method == "unity.timeline.clip.get")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "Get", paramsJson, id);
}
else if (method == "unity.timeline.clip.list")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "List", paramsJson, id);
}
else if (method == "unity.timeline.clip.setTiming")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "SetTiming", paramsJson, id);
}
else if (method == "unity.timeline.clip.setBlend")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "SetBlend", paramsJson, id);
}
else if (method == "unity.timeline.clip.setEase")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "SetEase", paramsJson, id);
}
else if (method == "unity.timeline.clip.setDisplayName")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "SetDisplayName", paramsJson, id);
}
else if (method == "unity.timeline.clip.setAnimationClipSettings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "SetAnimationClipSettings", paramsJson, id);
}
else if (method == "unity.timeline.clip.setAudioClipSettings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "SetAudioClipSettings", paramsJson, id);
}
else if (method == "unity.timeline.clip.setControlClipSettings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "SetControlClipSettings", paramsJson, id);
}
else if (method == "unity.timeline.clip.duplicate")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "Duplicate", paramsJson, id);
}
// Timeline API - Marker操作 (4個)
else if (method == "unity.timeline.marker.create")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineMarkerBuilder, "Create", paramsJson, id);
}
else if (method == "unity.timeline.marker.delete")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineMarkerBuilder, "Delete", paramsJson, id);
}
else if (method == "unity.timeline.marker.list")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineMarkerBuilder, "List", paramsJson, id);
}
else if (method == "unity.timeline.marker.setSignalEmitterSettings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineMarkerBuilder, "SetSignalEmitterSettings", paramsJson, id);
}
// ============================================
// Recorder APIs (Reflection-based)
// ============================================
// Recorder APIs - Basic Operations
else if (method == "unity.recorder.createSession")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "CreateSession", paramsJson, id);
}
else if (method == "unity.recorder.prepareRecording")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "PrepareRecording", paramsJson, id);
}
else if (method == "unity.recorder.startRecording")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "StartRecording", paramsJson, id);
}
else if (method == "unity.recorder.stopRecording")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "StopRecording", paramsJson, id);
}
else if (method == "unity.recorder.isRecording")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "IsRecording", paramsJson, id);
}
else if (method == "unity.recorder.getStatus")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "GetStatus", paramsJson, id);
}
// Recorder APIs - Settings
else if (method == "unity.recorder.setFrameRate")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "SetFrameRate", paramsJson, id);
}
else if (method == "unity.recorder.setRecordModeManual")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "SetRecordModeManual", paramsJson, id);
}
else if (method == "unity.recorder.setRecordModeFrameInterval")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "SetRecordModeFrameInterval", paramsJson, id);
}
else if (method == "unity.recorder.setRecordModeTimeInterval")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "SetRecordModeTimeInterval", paramsJson, id);
}
else if (method == "unity.recorder.setRecordModeSingleFrame")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "SetRecordModeSingleFrame", paramsJson, id);
}
// Recorder APIs - Presets
else if (method == "unity.recorder.preset.qaTestVideo")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "PresetQaTestVideo", paramsJson, id);
}
else if (method == "unity.recorder.preset.gifCapture")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "PresetGifCapture", paramsJson, id);
}
else if (method == "unity.recorder.preset.thumbnailSequence")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "PresetThumbnailSequence", paramsJson, id);
}
else if (method == "unity.recorder.preset.cinematicExport")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "PresetCinematicExport", paramsJson, id);
}
else if (method == "unity.recorder.preset.motionCapture")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "PresetMotionCapture", paramsJson, id);
}
else if (method == "unity.recorder.preset.audioCapture")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "PresetAudioCapture", paramsJson, id);
}
// Recorder APIs - Detailed Recorders
else if (method == "unity.recorder.createMovieRecorder")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "CreateMovieRecorder", paramsJson, id);
}
else if (method == "unity.recorder.createImageRecorder")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "CreateImageRecorder", paramsJson, id);
}
else if (method == "unity.recorder.createAnimationRecorder")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "CreateAnimationRecorder", paramsJson, id);
}
// Recorder APIs - Management
else if (method == "unity.recorder.listRecorderSettings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "ListRecorderSettings", paramsJson, id);
}
else if (method == "unity.recorder.clearSession")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "ClearSession", paramsJson, id);
}
else if (method == "unity.recorder.setCapFrameRate")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "SetCapFrameRate", paramsJson, id);
}
// ============================================
// Cinemachine APIs (Reflection-based)
// ============================================
// Phase 1: Basic Virtual Camera
else if (method == "unity.cinemachine.createVirtualCamera")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineControl, "CreateVirtualCamera", paramsJson, id);
}
else if (method == "unity.cinemachine.deleteVirtualCamera")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineControl, "DeleteVirtualCamera", paramsJson, id);
}
else if (method == "unity.cinemachine.listVirtualCameras")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineControl, "ListVirtualCameras", paramsJson, id);
}
else if (method == "unity.cinemachine.setVirtualCameraTarget")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineControl, "SetVirtualCameraTarget", paramsJson, id);
}
else if (method == "unity.cinemachine.setVirtualCameraPriority")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineControl, "SetVirtualCameraPriority", paramsJson, id);
}
else if (method == "unity.cinemachine.getVirtualCameraInfo")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineControl, "GetVirtualCameraInfo", paramsJson, id);
}
// Phase 2: Body/Aim
else if (method == "unity.cinemachine.setBodyType")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineBodyAim, "SetBodyType", paramsJson, id);
}
else if (method == "unity.cinemachine.setAimType")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineBodyAim, "SetAimType", paramsJson, id);
}
else if (method == "unity.cinemachine.setFollowOffset")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineBodyAim, "SetFollowOffset", paramsJson, id);
}
else if (method == "unity.cinemachine.setDamping")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineBodyAim, "SetDamping", paramsJson, id);
}
else if (method == "unity.cinemachine.setDeadZone")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineBodyAim, "SetDeadZone", paramsJson, id);
}
else if (method == "unity.cinemachine.setSoftZone")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineBodyAim, "SetSoftZone", paramsJson, id);
}
// Phase 3: Advanced Cameras
else if (method == "unity.cinemachine.createFreeLookCamera")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineAdvanced, "CreateFreeLookCamera", paramsJson, id);
}
else if (method == "unity.cinemachine.setFreeLookRig")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineAdvanced, "SetFreeLookRig", paramsJson, id);
}
else if (method == "unity.cinemachine.createBlendListCamera")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineAdvanced, "CreateBlendListCamera", paramsJson, id);
}
else if (method == "unity.cinemachine.createClearShot")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineAdvanced, "CreateClearShot", paramsJson, id);
}
// Phase 4: Dolly System
else if (method == "unity.cinemachine.createDollyTrack")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineDolly, "CreateDollyTrack", paramsJson, id);
}
else if (method == "unity.cinemachine.addDollyWaypoint")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineDolly, "AddDollyWaypoint", paramsJson, id);
}
else if (method == "unity.cinemachine.updateDollyWaypoint")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineDolly, "UpdateDollyWaypoint", paramsJson, id);
}
else if (method == "unity.cinemachine.removeDollyWaypoint")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineDolly, "RemoveDollyWaypoint", paramsJson, id);
}
else if (method == "unity.cinemachine.getDollyTrackInfo")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineDolly, "GetDollyTrackInfo", paramsJson, id);
}
else if (method == "unity.cinemachine.createDollyCamera")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineDolly, "CreateDollyCamera", paramsJson, id);
}
else if (method == "unity.cinemachine.setDollyPathPosition")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineDolly, "SetDollyPathPosition", paramsJson, id);
}
else if (method == "unity.cinemachine.setDollyLoopMode")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineDolly, "SetDollyLoopMode", paramsJson, id);
}
// Phase 5: Transitions
else if (method == "unity.cinemachine.setBrainSettings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineTransition, "SetBrainSettings", paramsJson, id);
}
else if (method == "unity.cinemachine.setDefaultBlend")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineTransition, "SetDefaultBlend", paramsJson, id);
}
else if (method == "unity.cinemachine.setCustomBlend")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineTransition, "SetCustomBlend", paramsJson, id);
}
else if (method == "unity.cinemachine.triggerCameraSwitch")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineTransition, "TriggerCameraSwitch", paramsJson, id);
}
// Phase 6: Target Groups
else if (method == "unity.cinemachine.createTargetGroup")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "CreateTargetGroup", paramsJson, id);
}
else if (method == "unity.cinemachine.addTargetGroupMember")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "AddTargetGroupMember", paramsJson, id);
}
else if (method == "unity.cinemachine.removeTargetGroupMember")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "RemoveTargetGroupMember", paramsJson, id);
}
else if (method == "unity.cinemachine.updateTargetGroupMember")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "UpdateTargetGroupMember", paramsJson, id);
}
else if (method == "unity.cinemachine.getTargetGroupInfo")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "GetTargetGroupInfo", paramsJson, id);
}
else if (method == "unity.cinemachine.createGroupCamera")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "CreateGroupCamera", paramsJson, id);
}
else if (method == "unity.cinemachine.setGroupFramingMode")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "SetGroupFramingMode", paramsJson, id);
}
else if (method == "unity.cinemachine.setGroupFramingSize")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "SetGroupFramingSize", paramsJson, id);
}
else if (method == "unity.cinemachine.frameTargets")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "FrameTargets", paramsJson, id);
}
else if (method == "unity.cinemachine.frameAllTargets")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "FrameAllTargets", paramsJson, id);
}
// Phase 7: Effects
else if (method == "unity.cinemachine.createCameraShake")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineEffects, "CreateCameraShake", paramsJson, id);
}
else if (method == "unity.cinemachine.triggerImpulse")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineEffects, "TriggerImpulse", paramsJson, id);
}
else if (method == "unity.cinemachine.setNoiseProfile")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineEffects, "SetNoiseProfile", paramsJson, id);
}
else if (method == "unity.cinemachine.createConfiner")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineEffects, "CreateConfiner", paramsJson, id);
}
else if (method == "unity.cinemachine.setScreenComposition")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineEffects, "SetScreenComposition", paramsJson, id);
}
// Phase 8: Presets
else if (method == "unity.cinemachine.applyPreset")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachinePresets, "ApplyPreset", paramsJson, id);
}
else if (method == "unity.cinemachine.createCinematicShot")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachinePresets, "CreateCinematicShot", paramsJson, id);
}
else if (method == "unity.cinemachine.saveCameraState")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachinePresets, "SaveCameraState", paramsJson, id);
}
else if (method == "unity.cinemachine.loadCameraState")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachinePresets, "LoadCameraState", paramsJson, id);
}
// ============================================
// ShaderGraph APIs (Reflection-based)
// ============================================
else if (method == "unity.shaderGraph.create")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ShaderGraph, PackageTypes.ShaderGraphBuilder, "CreateShaderGraph", paramsJson, id);
}
else if (method == "unity.shaderGraph.getInfo")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ShaderGraph, PackageTypes.ShaderGraphBuilder, "GetShaderGraphInfo", paramsJson, id);
}
else if (method == "unity.shaderGraph.getNodes")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ShaderGraph, PackageTypes.ShaderGraphBuilder, "GetNodes", paramsJson, id);
}
else if (method == "unity.shaderGraph.getProperties")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ShaderGraph, PackageTypes.ShaderGraphBuilder, "GetProperties", paramsJson, id);
}
else if (method == "unity.shaderGraph.getConnections")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ShaderGraph, PackageTypes.ShaderGraphBuilder, "GetConnections", paramsJson, id);
}
// ============================================
// Shader APIs
// ============================================
// Core Shader APIs
else if (method == "unity.shader.getInfo")
{
return ShaderController.GetInfo(paramsJson, id);
}
else if (method == "unity.shader.reimport")
{
return ShaderController.Reimport(paramsJson, id);
}
else if (method == "unity.shader.getCompileErrors")
{
return ShaderController.GetCompileErrors(paramsJson, id);
}
else if (method == "unity.shader.listAll")
{
return ShaderController.ListAll(paramsJson, id);
}
else if (method == "unity.shader.find")
{
return ShaderController.Find(paramsJson, id);
}
// TextMeshPro Shader APIs
else if (method == "unity.shader.tmp.listPresets")
{
return ShaderController.TMPListPresets(paramsJson, id);
}
else if (method == "unity.shader.tmp.applyDistanceField")
{
return ShaderController.TMPApplyDistanceField(paramsJson, id);
}
else if (method == "unity.shader.tmp.setOutline")
{
return ShaderController.TMPSetOutline(paramsJson, id);
}
else if (method == "unity.shader.tmp.setGlow")
{
return ShaderController.TMPSetGlow(paramsJson, id);
}
else if (method == "unity.shader.tmp.setBevel")
{
return ShaderController.TMPSetBevel(paramsJson, id);
}
else if (method == "unity.shader.tmp.setUnderlay")
{
return ShaderController.TMPSetUnderlay(paramsJson, id);
}
// UI Shader APIs
else if (method == "unity.shader.ui.listPresets")
{
return ShaderController.UIListPresets(paramsJson, id);
}
else if (method == "unity.shader.ui.applyDefault")
{
return ShaderController.UIApplyDefault(paramsJson, id);
}
else if (method == "unity.shader.ui.setMask")
{
return ShaderController.UISetMask(paramsJson, id);
}
else if (method == "unity.shader.ui.setStencil")
{
return ShaderController.UISetStencil(paramsJson, id);
}
// Particle Shader APIs
else if (method == "unity.shader.particle.listPresets")
{
return ShaderController.ParticleListPresets(paramsJson, id);
}
else if (method == "unity.shader.particle.applyShader")
{
return ShaderController.ParticleApplyShader(paramsJson, id);
}
else if (method == "unity.shader.particle.setBlendMode")
{
return ShaderController.ParticleSetBlendMode(paramsJson, id);
}
// Skybox Shader APIs
else if (method == "unity.shader.skybox.listPresets")
{
return ShaderController.SkyboxListPresets(paramsJson, id);
}
else if (method == "unity.shader.skybox.applyProcedural")
{
return ShaderController.SkyboxApplyProcedural(paramsJson, id);
}
else if (method == "unity.shader.skybox.applyCubemap")
{
return ShaderController.SkyboxApplyCubemap(paramsJson, id);
}
else if (method == "unity.shader.skybox.applyPanoramic")
{
return ShaderController.SkyboxApplyPanoramic(paramsJson, id);
}
// Sprite Shader APIs
else if (method == "unity.shader.sprite.listPresets")
{
return ShaderController.SpriteListPresets(paramsJson, id);
}
else if (method == "unity.shader.sprite.applyShader")
{
return ShaderController.SpriteApplyShader(paramsJson, id);
}
// ============================================
// Camera APIs (Public Plan)
// ============================================
else if (method == "unity.camera.create")
{
return CameraController.CreateCamera(paramsJson, id);
}
else if (method == "unity.camera.delete")
{
return CameraController.DeleteCamera(paramsJson, id);
}
else if (method == "unity.camera.list")
{
return CameraController.ListCameras(paramsJson, id);
}
else if (method == "unity.camera.getInfo")
{
return CameraController.GetCameraInfo(paramsJson, id);
}
else if (method == "unity.camera.setProperty")
{
return CameraController.SetCameraProperty(paramsJson, id);
}
else if (method == "unity.camera.setViewport")
{
return CameraController.SetViewport(paramsJson, id);
}
else if (method == "unity.camera.setTargetDisplay")
{
return CameraController.SetTargetDisplay(paramsJson, id);
}
else if (method == "unity.camera.setCullingMask")
{
return CameraController.SetCullingMask(paramsJson, id);
}
else if (method == "unity.camera.setRenderingPath")
{
return CameraController.SetRenderingPath(paramsJson, id);
}
// ============================================
// Audio APIs (Direct call - Core Unity feature)
// ============================================
else if (method == "unity.audio.createSource")
{
return AudioController.CreateSource(paramsJson, id);
}
else if (method == "unity.audio.deleteSource")
{
return AudioController.DeleteSource(paramsJson, id);
}
else if (method == "unity.audio.play")
{
return AudioController.Play(paramsJson, id);
}
else if (method == "unity.audio.stop")
{
return AudioController.Stop(paramsJson, id);
}
else if (method == "unity.audio.pause")
{
return AudioController.Pause(paramsJson, id);
}
else if (method == "unity.audio.setClip")
{
return AudioController.SetClip(paramsJson, id);
}
else if (method == "unity.audio.setProperty")
{
return AudioController.SetProperty(paramsJson, id);
}
else if (method == "unity.audio.getInfo")
{
return AudioController.GetInfo(paramsJson, id);
}
else if (method == "unity.audio.list")
{
return AudioController.ListSources(paramsJson, id);
}
else if (method == "unity.audio.loadMixer")
{
return AudioController.LoadMixer(paramsJson, id);
}
else if (method == "unity.audio.setMixerFloat")
{
return AudioController.SetMixerFloat(paramsJson, id);
}
else if (method == "unity.audio.getMixerFloat")
{
return AudioController.GetMixerFloat(paramsJson, id);
}
else if (method == "unity.audio.listMixerGroups")
{
return AudioController.ListMixerGroups(paramsJson, id);
}
else if (method == "unity.audio.listClips")
{
return AudioController.ListClips(paramsJson, id);
}
else if (method == "unity.audio.getClipInfo")
{
return AudioController.GetClipInfo(paramsJson, id);
}
else if (method == "unity.audio.importClip")
{
return AudioController.ImportClip(paramsJson, id);
}
else if (method == "unity.audio.createListener")
{
return AudioController.CreateListener(paramsJson, id);
}
else if (method == "unity.audio.deleteListener")
{
return AudioController.DeleteListener(paramsJson, id);
}
else if (method == "unity.audio.listListeners")
{
return AudioController.ListListeners(paramsJson, id);
}
else if (method == "unity.audio.getListenerInfo")
{
return AudioController.GetListenerInfo(paramsJson, id);
}
else if (method == "unity.audio.setListenerProperty")
{
return AudioController.SetListenerProperty(paramsJson, id);
}
// AudioMixer Extended APIs - グループ操作
else if (method == "unity.audio.createMixerGroup")
{
return AudioController.CreateMixerGroup(paramsJson, id);
}
else if (method == "unity.audio.deleteMixerGroup")
{
return AudioController.DeleteMixerGroup(paramsJson, id);
}
else if (method == "unity.audio.renameMixerGroup")
{
return AudioController.RenameMixerGroup(paramsJson, id);
}
else if (method == "unity.audio.setGroupVolume")
{
return AudioController.SetGroupVolume(paramsJson, id);
}
else if (method == "unity.audio.setGroupOutput")
{
return AudioController.SetGroupOutput(paramsJson, id);
}
// AudioMixer Extended APIs - エフェクト操作
else if (method == "unity.audio.addEffect")
{
return AudioController.AddEffect(paramsJson, id);
}
else if (method == "unity.audio.removeEffect")
{
return AudioController.RemoveEffect(paramsJson, id);
}
else if (method == "unity.audio.moveEffect")
{
return AudioController.MoveEffect(paramsJson, id);
}
else if (method == "unity.audio.listEffects")
{
return AudioController.ListEffects(paramsJson, id);
}
else if (method == "unity.audio.setEffectParameter")
{
return AudioController.SetEffectParameter(paramsJson, id);
}
else if (method == "unity.audio.getEffectParameter")
{
return AudioController.GetEffectParameter(paramsJson, id);
}
else if (method == "unity.audio.listEffectTypes")
{
return AudioController.ListEffectTypes(paramsJson, id);
}
// AudioMixer Extended APIs - スナップショット操作
else if (method == "unity.audio.createSnapshot")
{
return AudioController.CreateSnapshot(paramsJson, id);
}
else if (method == "unity.audio.deleteSnapshot")
{
return AudioController.DeleteSnapshot(paramsJson, id);
}
else if (method == "unity.audio.listSnapshots")
{
return AudioController.ListSnapshots(paramsJson, id);
}
else if (method == "unity.audio.transitionToSnapshot")
{
return AudioController.TransitionToSnapshot(paramsJson, id);
}
// AudioMixer Extended APIs - センド操作
else if (method == "unity.audio.addSend")
{
return AudioController.AddSend(paramsJson, id);
}
else if (method == "unity.audio.setSendLevel")
{
return AudioController.SetSendLevel(paramsJson, id);
}
// ============================================
// Volume / Post Processing APIs (Reflection-based)
// Requires: com.unity.render-pipelines.universal
// ============================================
else if (method == "unity.volume.create")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "CreateVolume", paramsJson, id);
}
else if (method == "unity.volume.createProfile")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "CreateProfile", paramsJson, id);
}
else if (method == "unity.volume.assignProfile")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "AssignProfile", paramsJson, id);
}
else if (method == "unity.volume.delete")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "DeleteVolume", paramsJson, id);
}
else if (method == "unity.volume.list")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "ListVolumes", paramsJson, id);
}
else if (method == "unity.volume.getInfo")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "GetVolumeInfo", paramsJson, id);
}
else if (method == "unity.volume.setBloom")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetBloom", paramsJson, id);
}
else if (method == "unity.volume.setVignette")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetVignette", paramsJson, id);
}
else if (method == "unity.volume.setColorAdjustments")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetColorAdjustments", paramsJson, id);
}
else if (method == "unity.volume.setDepthOfField")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetDepthOfField", paramsJson, id);
}
else if (method == "unity.volume.setMotionBlur")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetMotionBlur", paramsJson, id);
}
else if (method == "unity.volume.setToneMapping")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetToneMapping", paramsJson, id);
}
else if (method == "unity.volume.setFilmGrain")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetFilmGrain", paramsJson, id);
}
else if (method == "unity.volume.setChromaticAberration")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetChromaticAberration", paramsJson, id);
}
else if (method == "unity.volume.setLensDistortion")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetLensDistortion", paramsJson, id);
}
else if (method == "unity.volume.setWhiteBalance")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetWhiteBalance", paramsJson, id);
}
else if (method == "unity.volume.applyPreset")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "ApplyPreset", paramsJson, id);
}
else if (method == "unity.volume.removeOverride")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "RemoveOverride", paramsJson, id);
}
// ============================================
// InputSystem APIs (Reflection-based)
// ============================================
// Asset APIs
else if (method == "unity.inputsystem.createAsset")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "CreateAsset", paramsJson, id);
}
else if (method == "unity.inputsystem.deleteAsset")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "DeleteAsset", paramsJson, id);
}
else if (method == "unity.inputsystem.getAsset")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "GetAsset", paramsJson, id);
}
else if (method == "unity.inputsystem.listAssets")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "ListAssets", paramsJson, id);
}
// ActionMap APIs
else if (method == "unity.inputsystem.addActionMap")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "AddActionMap", paramsJson, id);
}
else if (method == "unity.inputsystem.removeActionMap")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "RemoveActionMap", paramsJson, id);
}
else if (method == "unity.inputsystem.getActionMap")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "GetActionMap", paramsJson, id);
}
// Action APIs
else if (method == "unity.inputsystem.addAction")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "AddAction", paramsJson, id);
}
else if (method == "unity.inputsystem.removeAction")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "RemoveAction", paramsJson, id);
}
else if (method == "unity.inputsystem.getAction")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "GetAction", paramsJson, id);
}
// Binding APIs
else if (method == "unity.inputsystem.addBinding")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "AddBinding", paramsJson, id);
}
else if (method == "unity.inputsystem.removeBinding")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "RemoveBinding", paramsJson, id);
}
else if (method == "unity.inputsystem.addCompositeBinding")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "AddCompositeBinding", paramsJson, id);
}
// ControlScheme APIs
else if (method == "unity.inputsystem.addControlScheme")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "AddControlScheme", paramsJson, id);
}
else if (method == "unity.inputsystem.removeControlScheme")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "RemoveControlScheme", paramsJson, id);
}
else if (method == "unity.inputsystem.listControlSchemes")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "ListControlSchemes", paramsJson, id);
}
// Device APIs
else if (method == "unity.inputsystem.listDevices")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "ListDevices", paramsJson, id);
}
else if (method == "unity.inputsystem.listLayouts")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "ListLayouts", paramsJson, id);
}
// Utility APIs
else if (method == "unity.inputsystem.generateScript")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "GenerateScript", paramsJson, id);
}
else if (method == "unity.inputsystem.addPlayerInput")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "AddPlayerInput", paramsJson, id);
}
// InputSystem Setup APIs (Platform Presets)
else if (method == "unity.inputsystem.setup.desktop")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "SetupDesktop", paramsJson, id);
}
else if (method == "unity.inputsystem.setup.mobile")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "SetupMobile", paramsJson, id);
}
else if (method == "unity.inputsystem.setup.console")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "SetupConsole", paramsJson, id);
}
else if (method == "unity.inputsystem.setup.vr")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "SetupVR", paramsJson, id);
}
// InputSystem Game Genre Presets
else if (method == "unity.inputsystem.preset.fps")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "PresetFPS", paramsJson, id);
}
else if (method == "unity.inputsystem.preset.thirdPerson")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "PresetThirdPerson", paramsJson, id);
}
else if (method == "unity.inputsystem.preset.platformer")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "PresetPlatformer", paramsJson, id);
}
else if (method == "unity.inputsystem.preset.ui")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "PresetUI", paramsJson, id);
}
// InputSystem Settings Management
else if (method == "unity.inputsystem.settings.get")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "GetSettings", paramsJson, id);
}
else if (method == "unity.inputsystem.settings.set")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "SetSettings", paramsJson, id);
}
else if (method == "unity.inputsystem.settings.reset")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "ResetSettings", paramsJson, id);
}
else if (method == "unity.inputsystem.setInputHandling")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "SetInputHandling", paramsJson, id);
}
// ============================================
// ProBuilder APIs (Reflection-based)
// ============================================
// Mode Management APIs
else if (method == "unity.probuilder.mode.get")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderModeManager, "GetMode", paramsJson, id);
}
else if (method == "unity.probuilder.mode.set")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderModeManager, "SetMode", paramsJson, id);
}
else if (method == "unity.probuilder.selection.get")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderModeManager, "GetSelection", paramsJson, id);
}
else if (method == "unity.probuilder.selection.clear")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderModeManager, "ClearSelection", paramsJson, id);
}
// Object Mode APIs
else if (method == "unity.probuilder.object.createPrimitive")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderObjectOperations, "CreatePrimitive", paramsJson, id);
}
else if (method == "unity.probuilder.object.delete")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderObjectOperations, "DeleteObject", paramsJson, id);
}
else if (method == "unity.probuilder.object.getMeshInfo")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderObjectOperations, "GetMeshInfo", paramsJson, id);
}
else if (method == "unity.probuilder.object.list")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderObjectOperations, "ListObjects", paramsJson, id);
}
else if (method == "unity.probuilder.object.duplicate")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderObjectOperations, "Duplicate", paramsJson, id);
}
else if (method == "unity.probuilder.object.combineMeshes")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderObjectOperations, "CombineMeshes", paramsJson, id);
}
else if (method == "unity.probuilder.object.mirror")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderObjectOperations, "Mirror", paramsJson, id);
}
else if (method == "unity.probuilder.object.proBuilderize")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderObjectOperations, "ProBuilderize", paramsJson, id);
}
else if (method == "unity.probuilder.object.freezeTransform")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderObjectOperations, "FreezeTransform", paramsJson, id);
}
else if (method == "unity.probuilder.object.centerPivot")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderObjectOperations, "CenterPivot", paramsJson, id);
}
else if (method == "unity.probuilder.object.conformNormals")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderObjectOperations, "ConformNormals", paramsJson, id);
}
else if (method == "unity.probuilder.object.flipNormals")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderObjectOperations, "FlipNormals", paramsJson, id);
}
else if (method == "unity.probuilder.object.setCollider")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderObjectOperations, "SetCollider", paramsJson, id);
}
else if (method == "unity.probuilder.object.setTrigger")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderObjectOperations, "SetTrigger", paramsJson, id);
}
else if (method == "unity.probuilder.object.setVertexColors")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderObjectOperations, "SetVertexColors", paramsJson, id);
}
else if (method == "unity.probuilder.object.getVertexColors")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderObjectOperations, "GetVertexColors", paramsJson, id);
}
else if (method == "unity.probuilder.object.export")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderObjectOperations, "Export", paramsJson, id);
}
// Vertex Mode APIs
else if (method == "unity.probuilder.vertex.select")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderVertexOperations, "Select", paramsJson, id);
}
else if (method == "unity.probuilder.vertex.move")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderVertexOperations, "Move", paramsJson, id);
}
else if (method == "unity.probuilder.vertex.weld")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderVertexOperations, "Weld", paramsJson, id);
}
else if (method == "unity.probuilder.vertex.collapse")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderVertexOperations, "Collapse", paramsJson, id);
}
else if (method == "unity.probuilder.vertex.connect")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderVertexOperations, "Connect", paramsJson, id);
}
else if (method == "unity.probuilder.vertex.split")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderVertexOperations, "Split", paramsJson, id);
}
else if (method == "unity.probuilder.vertex.delete")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderVertexOperations, "Delete", paramsJson, id);
}
else if (method == "unity.probuilder.vertex.fillHole")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderVertexOperations, "FillHole", paramsJson, id);
}
else if (method == "unity.probuilder.vertex.getPositions")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderVertexOperations, "GetPositions", paramsJson, id);
}
else if (method == "unity.probuilder.vertex.setColor")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderVertexOperations, "SetColor", paramsJson, id);
}
// Edge Mode APIs
else if (method == "unity.probuilder.edge.select")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderEdgeOperations, "Select", paramsJson, id);
}
else if (method == "unity.probuilder.edge.extrude")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderEdgeOperations, "Extrude", paramsJson, id);
}
else if (method == "unity.probuilder.edge.subdivide")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderEdgeOperations, "Subdivide", paramsJson, id);
}
else if (method == "unity.probuilder.edge.bevel")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderEdgeOperations, "Bevel", paramsJson, id);
}
else if (method == "unity.probuilder.edge.bridge")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderEdgeOperations, "Bridge", paramsJson, id);
}
else if (method == "unity.probuilder.edge.delete")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderEdgeOperations, "Delete", paramsJson, id);
}
else if (method == "unity.probuilder.edge.loop")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderEdgeOperations, "Loop", paramsJson, id);
}
else if (method == "unity.probuilder.edge.ring")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderEdgeOperations, "Ring", paramsJson, id);
}
else if (method == "unity.probuilder.edge.connect")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderEdgeOperations, "Connect", paramsJson, id);
}
else if (method == "unity.probuilder.edge.insertLoop")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderEdgeOperations, "InsertLoop", paramsJson, id);
}
else if (method == "unity.probuilder.edge.fillHole")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderEdgeOperations, "FillHole", paramsJson, id);
}
else if (method == "unity.probuilder.edge.offset")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderEdgeOperations, "Offset", paramsJson, id);
}
// Face Mode APIs
else if (method == "unity.probuilder.face.select")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderFaceOperations, "Select", paramsJson, id);
}
else if (method == "unity.probuilder.face.extrude")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderFaceOperations, "Extrude", paramsJson, id);
}
else if (method == "unity.probuilder.face.inset")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderFaceOperations, "Inset", paramsJson, id);
}
else if (method == "unity.probuilder.face.detach")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderFaceOperations, "Detach", paramsJson, id);
}
else if (method == "unity.probuilder.face.delete")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderFaceOperations, "Delete", paramsJson, id);
}
else if (method == "unity.probuilder.face.duplicate")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderFaceOperations, "Duplicate", paramsJson, id);
}
else if (method == "unity.probuilder.face.merge")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderFaceOperations, "Merge", paramsJson, id);
}
else if (method == "unity.probuilder.face.subdivide")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderFaceOperations, "Subdivide", paramsJson, id);
}
else if (method == "unity.probuilder.face.triangulate")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderFaceOperations, "Triangulate", paramsJson, id);
}
else if (method == "unity.probuilder.face.flip")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderFaceOperations, "Flip", paramsJson, id);
}
else if (method == "unity.probuilder.face.conformNormals")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderFaceOperations, "ConformNormals", paramsJson, id);
}
else if (method == "unity.probuilder.face.loop")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderFaceOperations, "Loop", paramsJson, id);
}
else if (method == "unity.probuilder.face.ring")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderFaceOperations, "Ring", paramsJson, id);
}
else if (method == "unity.probuilder.face.setMaterial")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderFaceOperations, "SetMaterial", paramsJson, id);
}
else if (method == "unity.probuilder.face.setColor")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderFaceOperations, "SetColor", paramsJson, id);
}
else if (method == "unity.probuilder.face.offset")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderFaceOperations, "Offset", paramsJson, id);
}
else if (method == "unity.probuilder.face.flipEdge")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderFaceOperations, "FlipEdge", paramsJson, id);
}
// Boolean Operations APIs
else if (method == "unity.probuilder.boolean.union")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderBooleanOperations, "Union", paramsJson, id);
}
else if (method == "unity.probuilder.boolean.intersection")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderBooleanOperations, "Intersection", paramsJson, id);
}
else if (method == "unity.probuilder.boolean.subtraction")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderBooleanOperations, "Subtraction", paramsJson, id);
}
else if (method == "unity.probuilder.smoothing.set")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderBooleanOperations, "SetSmoothingGroup", paramsJson, id);
}
else if (method == "unity.probuilder.smoothing.get")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderBooleanOperations, "GetSmoothingGroups", paramsJson, id);
}
else if (method == "unity.probuilder.smoothing.clear")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderBooleanOperations, "ClearSmoothing", paramsJson, id);
}
// UV Operations APIs
else if (method == "unity.probuilder.uv.setAutoUV")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderUVOperations, "SetAutoUV", paramsJson, id);
}
else if (method == "unity.probuilder.uv.reset")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderUVOperations, "ResetUV", paramsJson, id);
}
else if (method == "unity.probuilder.uv.get")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderUVOperations, "GetUVs", paramsJson, id);
}
else if (method == "unity.probuilder.uv.set")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderUVOperations, "SetUVs", paramsJson, id);
}
else if (method == "unity.probuilder.uv.projectPlanar")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderUVOperations, "ProjectPlanar", paramsJson, id);
}
else if (method == "unity.probuilder.uv.projectBox")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderUVOperations, "ProjectBox", paramsJson, id);
}
// Selection Operations APIs
else if (method == "unity.probuilder.selection.grow")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderSelectionOperations, "Grow", paramsJson, id);
}
else if (method == "unity.probuilder.selection.shrink")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderSelectionOperations, "Shrink", paramsJson, id);
}
else if (method == "unity.probuilder.selection.byMaterial")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderSelectionOperations, "SelectByMaterial", paramsJson, id);
}
else if (method == "unity.probuilder.selection.byColor")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderSelectionOperations, "SelectByColor", paramsJson, id);
}
else if (method == "unity.probuilder.selection.holes")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderSelectionOperations, "SelectHoles", paramsJson, id);
}
else if (method == "unity.probuilder.selection.invert")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderSelectionOperations, "Invert", paramsJson, id);
}
// PolyShape Operations APIs
else if (method == "unity.probuilder.polyshape.create")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderPolyShapeOperations, "Create", paramsJson, id);
}
else if (method == "unity.probuilder.polyshape.setControlPoints")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderPolyShapeOperations, "SetControlPoints", paramsJson, id);
}
else if (method == "unity.probuilder.polyshape.getControlPoints")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderPolyShapeOperations, "GetControlPoints", paramsJson, id);
}
else if (method == "unity.probuilder.polyshape.setExtrusion")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderPolyShapeOperations, "SetExtrusion", paramsJson, id);
}
else if (method == "unity.probuilder.polyshape.setFlipNormals")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderPolyShapeOperations, "SetFlipNormals", paramsJson, id);
}
// Optimization Operations APIs
else if (method == "unity.probuilder.optimize.collapseSharedVertices")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderOptimizationOperations, "CollapseSharedVertices", paramsJson, id);
}
else if (method == "unity.probuilder.optimize.removeDegenerateTriangles")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderOptimizationOperations, "RemoveDegenerateTriangles", paramsJson, id);
}
else if (method == "unity.probuilder.optimize.rebuildMesh")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderOptimizationOperations, "RebuildMesh", paramsJson, id);
}
else if (method == "unity.probuilder.optimize.fitToSize")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderOptimizationOperations, "FitToSize", paramsJson, id);
}
else if (method == "unity.probuilder.optimize.getMeshStats")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderOptimizationOperations, "GetMeshStats", paramsJson, id);
}
else if (method == "unity.probuilder.optimize.analyzeMesh")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderOptimizationOperations, "AnalyzeMesh", paramsJson, id);
}
else if (method == "unity.probuilder.optimize.setTargetVertexCount")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderOptimizationOperations, "SetTargetVertexCount", paramsJson, id);
}
else if (method == "unity.probuilder.optimize.generateLOD")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderOptimizationOperations, "GenerateLOD", paramsJson, id);
}
else if (method == "unity.probuilder.optimize.setTextureSize")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderOptimizationOperations, "SetTextureSize", paramsJson, id);
}
else if (method == "unity.probuilder.optimize.setPlatformSettings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ProBuilder, PackageTypes.ProBuilderOptimizationOperations, "SetPlatformSettings", paramsJson, id);
}
// ============ Lighting Core APIs ============
else if (method == "unity.lighting.createLight")
{
return LightingCore.CreateLight(paramsJson, id);
}
else if (method == "unity.lighting.deleteLight")
{
return LightingCore.DeleteLight(paramsJson, id);
}
else if (method == "unity.lighting.listLights")
{
return LightingCore.ListLights(paramsJson, id);
}
else if (method == "unity.lighting.setLightProperties")
{
return LightingCore.SetLightProperties(paramsJson, id);
}
else if (method == "unity.lighting.setColorTemperature")
{
return LightingCore.SetColorTemperature(paramsJson, id);
}
else if (method == "unity.lighting.setLightMode")
{
return LightingCore.SetLightMode(paramsJson, id);
}
else if (method == "unity.lighting.getLightInfo")
{
return LightingCore.GetLightInfo(paramsJson, id);
}
// ============ Lighting Cinematic APIs ============
else if (method == "unity.lighting.createThreePointLighting")
{
return LightingCinematic.CreateThreePointLighting(paramsJson, id);
}
else if (method == "unity.lighting.setKeyLight")
{
return LightingCinematic.SetKeyLight(paramsJson, id);
}
else if (method == "unity.lighting.setFillLight")
{
return LightingCinematic.SetFillLight(paramsJson, id);
}
else if (method == "unity.lighting.setRimLight")
{
return LightingCinematic.SetRimLight(paramsJson, id);
}
else if (method == "unity.lighting.setLightingRatio")
{
return LightingCinematic.SetLightingRatio(paramsJson, id);
}
else if (method == "unity.lighting.createFourPointLighting")
{
return LightingCinematic.CreateFourPointLighting(paramsJson, id);
}
else if (method == "unity.lighting.setPracticalLight")
{
return LightingCinematic.SetPracticalLight(paramsJson, id);
}
// ============ Lighting Mood APIs ============
else if (method == "unity.lighting.applyMoodPreset")
{
return LightingMood.ApplyMoodPreset(paramsJson, id);
}
else if (method == "unity.lighting.setTimeOfDay")
{
return LightingMood.SetTimeOfDay(paramsJson, id);
}
else if (method == "unity.lighting.setColorHarmony")
{
return LightingMood.SetColorHarmony(paramsJson, id);
}
else if (method == "unity.lighting.setAmbientLight" || method == "unity.lighting.setAmbient")
{
return LightingMood.SetAmbientLight(paramsJson, id);
}
else if (method == "unity.lighting.setSkybox")
{
return LightingMood.SetSkybox(paramsJson, id);
}
else if (method == "unity.lighting.setFog")
{
return LightingMood.SetFog(paramsJson, id);
}
else if (method == "unity.lighting.listMoodPresets")
{
return LightingMood.ListMoodPresets(paramsJson, id);
}
// ============ Lighting GI APIs ============
else if (method == "unity.lighting.setGIMode")
{
return LightingGI.SetGIMode(paramsJson, id);
}
else if (method == "unity.lighting.bakeLighting" || method == "unity.lighting.bake")
{
return LightingGI.BakeLighting(paramsJson, id);
}
else if (method == "unity.lighting.clearBakedData")
{
return LightingGI.ClearBakedData(paramsJson, id);
}
else if (method == "unity.lighting.setLightmapSettings")
{
return LightingGI.SetLightmapSettings(paramsJson, id);
}
else if (method == "unity.lighting.createLightProbeGroup")
{
return LightingGI.CreateLightProbeGroup(paramsJson, id);
}
else if (method == "unity.lighting.autoPlaceLightProbes")
{
return LightingGI.AutoPlaceLightProbes(paramsJson, id);
}
else if (method == "unity.lighting.enableAPV")
{
return LightingGI.EnableAPV(paramsJson, id);
}
else if (method == "unity.lighting.getGIStatus")
{
return LightingGI.GetGIStatus(paramsJson, id);
}
else if (method == "unity.lighting.cancelBake")
{
return LightingGI.CancelBake(paramsJson, id);
}
// ============ Lighting Reflection APIs ============
else if (method == "unity.lighting.createReflectionProbe")
{
return LightingReflection.CreateReflectionProbe(paramsJson, id);
}
else if (method == "unity.lighting.setReflectionProbeType")
{
return LightingReflection.SetReflectionProbeType(paramsJson, id);
}
else if (method == "unity.lighting.setReflectionProbeSettings")
{
return LightingReflection.SetReflectionProbeSettings(paramsJson, id);
}
else if (method == "unity.lighting.bakeReflectionProbes")
{
return LightingReflection.BakeReflectionProbes(paramsJson, id);
}
else if (method == "unity.lighting.autoPlaceReflectionProbes")
{
return LightingReflection.AutoPlaceReflectionProbes(paramsJson, id);
}
else if (method == "unity.lighting.setReflectionIntensity")
{
return LightingReflection.SetReflectionIntensity(paramsJson, id);
}
else if (method == "unity.lighting.listReflectionProbes")
{
return LightingReflection.ListReflectionProbes(paramsJson, id);
}
// ============ Lighting Project Settings APIs ============
else if (method == "unity.lighting.detectRenderPipeline")
{
return LightingProjectSettings.DetectRenderPipeline(paramsJson, id);
}
else if (method == "unity.lighting.optimizeForScale")
{
return LightingProjectSettings.OptimizeForScale(paramsJson, id);
}
else if (method == "unity.lighting.setQualityPreset")
{
return LightingProjectSettings.SetQualityPreset(paramsJson, id);
}
else if (method == "unity.lighting.analyzeScene")
{
return LightingProjectSettings.AnalyzeScene(paramsJson, id);
}
else if (method == "unity.lighting.getOptimizationSuggestions")
{
return LightingProjectSettings.GetOptimizationSuggestions(paramsJson, id);
}
else if (method == "unity.lighting.listScalePresets")
{
return LightingProjectSettings.ListScalePresets(paramsJson, id);
}
// ============ API Logger APIs ============
else if (method == "unity.apilog.getLogs")
{
return McpApiLogger.GetLogs(paramsJson, id);
}
else if (method == "unity.apilog.getErrors")
{
return McpApiLogger.GetErrors(paramsJson, id);
}
else if (method == "unity.apilog.getStats")
{
return McpApiLogger.GetStats(paramsJson, id);
}
else if (method == "unity.apilog.clear")
{
return McpApiLogger.ClearLogs(paramsJson, id);
}
else if (method == "unity.apilog.configure")
{
return McpApiLogger.Configure(paramsJson, id);
}
else if (method == "unity.apilog.getFilePath")
{
return McpApiLogger.GetLogFilePath(paramsJson, id);
}
#if UNITY_2021_2_OR_NEWER
// ============ UIToolkit Asset Management APIs ============
else if (method == "unity.uitoolkit.asset.createUxml")
{
return UIToolkitAssetManager.CreateUxml(paramsJson, id);
}
else if (method == "unity.uitoolkit.asset.getUxmlContent")
{
return UIToolkitAssetManager.GetUxmlContent(paramsJson, id);
}
else if (method == "unity.uitoolkit.asset.updateUxml")
{
return UIToolkitAssetManager.UpdateUxml(paramsJson, id);
}
else if (method == "unity.uitoolkit.asset.createUss")
{
return UIToolkitAssetManager.CreateUss(paramsJson, id);
}
else if (method == "unity.uitoolkit.asset.getUssContent")
{
return UIToolkitAssetManager.GetUssContent(paramsJson, id);
}
else if (method == "unity.uitoolkit.asset.updateUss")
{
return UIToolkitAssetManager.UpdateUss(paramsJson, id);
}
else if (method == "unity.uitoolkit.asset.linkStyleSheet")
{
return UIToolkitAssetManager.LinkStyleSheet(paramsJson, id);
}
else if (method == "unity.uitoolkit.asset.createPanelSettings")
{
return UIToolkitAssetManager.CreatePanelSettings(paramsJson, id);
}
else if (method == "unity.uitoolkit.asset.getPanelSettings")
{
return UIToolkitAssetManager.GetPanelSettings(paramsJson, id);
}
else if (method == "unity.uitoolkit.asset.updatePanelSettings")
{
return UIToolkitAssetManager.UpdatePanelSettings(paramsJson, id);
}
// ============ UIToolkit Element Builder APIs ============
else if (method == "unity.uitoolkit.element.add")
{
return UIToolkitElementBuilder.AddElement(paramsJson, id);
}
else if (method == "unity.uitoolkit.element.remove")
{
return UIToolkitElementBuilder.RemoveElement(paramsJson, id);
}
else if (method == "unity.uitoolkit.element.update")
{
return UIToolkitElementBuilder.UpdateElement(paramsJson, id);
}
else if (method == "unity.uitoolkit.element.query")
{
return UIToolkitElementBuilder.QueryElement(paramsJson, id);
}
else if (method == "unity.uitoolkit.element.getHierarchy")
{
return UIToolkitElementBuilder.GetHierarchy(paramsJson, id);
}
else if (method == "unity.uitoolkit.element.move")
{
return UIToolkitElementBuilder.MoveElement(paramsJson, id);
}
else if (method == "unity.uitoolkit.element.duplicate")
{
return UIToolkitElementBuilder.DuplicateElement(paramsJson, id);
}
// ============ UIToolkit ViewModel Generator APIs (Phase 8.2) ============
else if (method == "unity.uitoolkit.viewmodel.create")
{
return UIToolkitViewModelGenerator.CreateViewModel(paramsJson, id);
}
else if (method == "unity.uitoolkit.viewmodel.addProperty")
{
return UIToolkitViewModelGenerator.AddProperty(paramsJson, id);
}
else if (method == "unity.uitoolkit.viewmodel.addCommand")
{
return UIToolkitViewModelGenerator.AddCommand(paramsJson, id);
}
else if (method == "unity.uitoolkit.viewmodel.createFromInterface")
{
return UIToolkitViewModelGenerator.CreateFromInterface(paramsJson, id);
}
else if (method == "unity.uitoolkit.viewmodel.generateScript")
{
return UIToolkitViewModelGenerator.GenerateScript(paramsJson, id);
}
else if (method == "unity.uitoolkit.viewmodel.list")
{
return UIToolkitViewModelGenerator.ListViewModels(paramsJson, id);
}
// ============ UIToolkit Binding Builder APIs (Phase 8.3) ============
else if (method == "unity.uitoolkit.binding.create")
{
return UIToolkitBindingBuilder.CreateBinding(paramsJson, id);
}
else if (method == "unity.uitoolkit.binding.add")
{
return UIToolkitBindingBuilder.AddBinding(paramsJson, id);
}
else if (method == "unity.uitoolkit.binding.bindCommand")
{
return UIToolkitBindingBuilder.BindCommand(paramsJson, id);
}
else if (method == "unity.uitoolkit.binding.bindTwoWay")
{
return UIToolkitBindingBuilder.BindTwoWay(paramsJson, id);
}
else if (method == "unity.uitoolkit.binding.bindVisibility")
{
return UIToolkitBindingBuilder.BindVisibility(paramsJson, id);
}
else if (method == "unity.uitoolkit.binding.bindEnabled")
{
return UIToolkitBindingBuilder.BindEnabled(paramsJson, id);
}
else if (method == "unity.uitoolkit.binding.unbind")
{
return UIToolkitBindingBuilder.Unbind(paramsJson, id);
}
else if (method == "unity.uitoolkit.binding.generateScript")
{
return UIToolkitBindingBuilder.GenerateBindingScript(paramsJson, id);
}
else if (method == "unity.uitoolkit.binding.list")
{
return UIToolkitBindingBuilder.ListBindings(paramsJson, id);
}
// ============ UIToolkit Style Operations APIs (Phase 3) ============
else if (method == "unity.uitoolkit.style.addRule")
{
return UIToolkitStyleOperations.AddRule(paramsJson, id);
}
else if (method == "unity.uitoolkit.style.updateRule")
{
return UIToolkitStyleOperations.UpdateRule(paramsJson, id);
}
else if (method == "unity.uitoolkit.style.removeRule")
{
return UIToolkitStyleOperations.RemoveRule(paramsJson, id);
}
else if (method == "unity.uitoolkit.style.getRule")
{
return UIToolkitStyleOperations.GetRule(paramsJson, id);
}
else if (method == "unity.uitoolkit.style.setProperty")
{
return UIToolkitStyleOperations.SetProperty(paramsJson, id);
}
else if (method == "unity.uitoolkit.style.removeProperty")
{
return UIToolkitStyleOperations.RemoveProperty(paramsJson, id);
}
else if (method == "unity.uitoolkit.style.setVariable")
{
return UIToolkitStyleOperations.SetVariable(paramsJson, id);
}
else if (method == "unity.uitoolkit.style.getVariables")
{
return UIToolkitStyleOperations.GetVariables(paramsJson, id);
}
else if (method == "unity.uitoolkit.style.setInlineStyle")
{
return UIToolkitStyleOperations.SetInlineStyle(paramsJson, id);
}
else if (method == "unity.uitoolkit.style.addClass")
{
return UIToolkitStyleOperations.AddClass(paramsJson, id);
}
else if (method == "unity.uitoolkit.style.removeClass")
{
return UIToolkitStyleOperations.RemoveClass(paramsJson, id);
}
// ============ UIToolkit Component Templates APIs (Phase 4) ============
else if (method == "unity.uitoolkit.template.createTextField")
{
return UIToolkitComponentTemplates.CreateTextField(paramsJson, id);
}
else if (method == "unity.uitoolkit.template.createButton")
{
return UIToolkitComponentTemplates.CreateButton(paramsJson, id);
}
else if (method == "unity.uitoolkit.template.createToggle")
{
return UIToolkitComponentTemplates.CreateToggle(paramsJson, id);
}
else if (method == "unity.uitoolkit.template.createSlider")
{
return UIToolkitComponentTemplates.CreateSlider(paramsJson, id);
}
else if (method == "unity.uitoolkit.template.createDropdown")
{
return UIToolkitComponentTemplates.CreateDropdown(paramsJson, id);
}
else if (method == "unity.uitoolkit.template.createCard")
{
return UIToolkitComponentTemplates.CreateCard(paramsJson, id);
}
else if (method == "unity.uitoolkit.template.createScrollView")
{
return UIToolkitComponentTemplates.CreateScrollView(paramsJson, id);
}
else if (method == "unity.uitoolkit.template.createFoldout")
{
return UIToolkitComponentTemplates.CreateFoldout(paramsJson, id);
}
else if (method == "unity.uitoolkit.template.createTabView")
{
return UIToolkitComponentTemplates.CreateTabView(paramsJson, id);
}
else if (method == "unity.uitoolkit.template.createListView")
{
return UIToolkitComponentTemplates.CreateListView(paramsJson, id);
}
else if (method == "unity.uitoolkit.template.createTreeView")
{
return UIToolkitComponentTemplates.CreateTreeView(paramsJson, id);
}
else if (method == "unity.uitoolkit.template.createProgressBar")
{
return UIToolkitComponentTemplates.CreateProgressBar(paramsJson, id);
}
else if (method == "unity.uitoolkit.template.createForm")
{
return UIToolkitComponentTemplates.CreateForm(paramsJson, id);
}
// ============ UIToolkit Layout Helpers APIs (Phase 5) ============
else if (method == "unity.uitoolkit.layout.createFlexContainer")
{
return UIToolkitLayoutHelpers.CreateFlexContainer(paramsJson, id);
}
else if (method == "unity.uitoolkit.layout.createFlexRow")
{
return UIToolkitLayoutHelpers.CreateFlexRow(paramsJson, id);
}
else if (method == "unity.uitoolkit.layout.createFlexColumn")
{
return UIToolkitLayoutHelpers.CreateFlexColumn(paramsJson, id);
}
else if (method == "unity.uitoolkit.layout.createCenter")
{
return UIToolkitLayoutHelpers.CreateCenter(paramsJson, id);
}
else if (method == "unity.uitoolkit.layout.createSpacer")
{
return UIToolkitLayoutHelpers.CreateSpacer(paramsJson, id);
}
else if (method == "unity.uitoolkit.layout.createGrid")
{
return UIToolkitLayoutHelpers.CreateGrid(paramsJson, id);
}
else if (method == "unity.uitoolkit.layout.createGridItem")
{
return UIToolkitLayoutHelpers.CreateGridItem(paramsJson, id);
}
else if (method == "unity.uitoolkit.layout.createScreenLayout")
{
return UIToolkitLayoutHelpers.CreateScreenLayout(paramsJson, id);
}
else if (method == "unity.uitoolkit.layout.createAbsolutePosition")
{
return UIToolkitLayoutHelpers.CreateAbsolutePosition(paramsJson, id);
}
else if (method == "unity.uitoolkit.layout.generateLayoutStyles")
{
return UIToolkitLayoutHelpers.GenerateLayoutStyles(paramsJson, id);
}
// ============ UIToolkit Runtime Operations APIs (Phase 6) ============
else if (method == "unity.uitoolkit.runtime.createUIDocument")
{
return UIToolkitRuntimeOperations.CreateUIDocument(paramsJson, id);
}
else if (method == "unity.uitoolkit.runtime.getUIDocument")
{
return UIToolkitRuntimeOperations.GetUIDocument(paramsJson, id);
}
else if (method == "unity.uitoolkit.runtime.listUIDocuments")
{
return UIToolkitRuntimeOperations.ListUIDocuments(paramsJson, id);
}
else if (method == "unity.uitoolkit.runtime.queryElement")
{
return UIToolkitRuntimeOperations.QueryElement(paramsJson, id);
}
else if (method == "unity.uitoolkit.runtime.getHierarchy")
{
return UIToolkitRuntimeOperations.GetRuntimeHierarchy(paramsJson, id);
}
else if (method == "unity.uitoolkit.runtime.setElementText")
{
return UIToolkitRuntimeOperations.SetElementText(paramsJson, id);
}
else if (method == "unity.uitoolkit.runtime.setElementValue")
{
return UIToolkitRuntimeOperations.SetElementValue(paramsJson, id);
}
else if (method == "unity.uitoolkit.runtime.setElementVisibility")
{
return UIToolkitRuntimeOperations.SetElementVisibility(paramsJson, id);
}
else if (method == "unity.uitoolkit.runtime.setElementEnabled")
{
return UIToolkitRuntimeOperations.SetElementEnabled(paramsJson, id);
}
else if (method == "unity.uitoolkit.runtime.addRuntimeClass")
{
return UIToolkitRuntimeOperations.AddRuntimeClass(paramsJson, id);
}
else if (method == "unity.uitoolkit.runtime.removeRuntimeClass")
{
return UIToolkitRuntimeOperations.RemoveRuntimeClass(paramsJson, id);
}
// ============ UIToolkit Scene Setup APIs ============
else if (method == "unity.uitoolkit.scene.setupComplete")
{
return UIToolkit.SceneSetup.UIToolkitSceneSetup.SetupComplete(paramsJson, id);
}
else if (method == "unity.uitoolkit.scene.setTargetScene")
{
return UIToolkit.SceneSetup.UIToolkitSceneSetup.SetTargetSceneApi(paramsJson, id);
}
else if (method == "unity.uitoolkit.scene.getLoadedScenes")
{
return UIToolkit.SceneSetup.UIToolkitSceneSetup.GetLoadedScenes(paramsJson, id);
}
else if (method == "unity.uitoolkit.scene.createUIGameObject")
{
return UIToolkit.SceneSetup.UIToolkitSceneSetup.CreateUIGameObject(paramsJson, id);
}
else if (method == "unity.uitoolkit.scene.configureUIDocument")
{
return UIToolkit.SceneSetup.UIToolkitSceneSetup.ConfigureUIDocument(paramsJson, id);
}
else if (method == "unity.uitoolkit.scene.saveAsPrefab")
{
return UIToolkit.SceneSetup.UIToolkitSceneSetup.SaveAsPrefab(paramsJson, id);
}
else if (method == "unity.uitoolkit.scene.instantiateUIPrefab")
{
return UIToolkit.SceneSetup.UIToolkitSceneSetup.InstantiateUIPrefab(paramsJson, id);
}
else if (method == "unity.uitoolkit.scene.getUIDocumentsInScene")
{
return UIToolkit.SceneSetup.UIToolkitSceneSetup.GetUIDocumentsInScene(paramsJson, id);
}
// ============ UIToolkit Game Presets APIs (Phase 7) ============
else if (method == "unity.uitoolkit.preset.createHUD")
{
return UIToolkitGamePresets.CreateHUD(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createHealthBar")
{
return UIToolkitGamePresets.CreateHealthBar(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createInventory")
{
return UIToolkitGamePresets.CreateInventory(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createQuickSlots")
{
return UIToolkitGamePresets.CreateQuickSlots(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createSkillBar")
{
return UIToolkitGamePresets.CreateSkillBar(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createDialogBox")
{
return UIToolkitGamePresets.CreateDialogBox(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createVirtualJoystick")
{
return UIToolkitGamePresets.CreateVirtualJoystick(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createDPad")
{
return UIToolkitGamePresets.CreateDPad(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createActionButtons")
{
return UIToolkitGamePresets.CreateActionButtons(paramsJson, id);
}
// ============ UIToolkit Navigation Presets APIs (Phase 7) ============
else if (method == "unity.uitoolkit.preset.createTabBar")
{
return UIToolkitNavigationPresets.CreateTabBar(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createBottomNavigation")
{
return UIToolkitNavigationPresets.CreateBottomNavigation(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createSidebar")
{
return UIToolkitNavigationPresets.CreateSidebar(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createBreadcrumb")
{
return UIToolkitNavigationPresets.CreateBreadcrumb(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createPagination")
{
return UIToolkitNavigationPresets.CreatePagination(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createContextMenu")
{
return UIToolkitNavigationPresets.CreateContextMenu(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createDropdownMenu")
{
return UIToolkitNavigationPresets.CreateDropdownMenu(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createNavbar")
{
return UIToolkitNavigationPresets.CreateNavbar(paramsJson, id);
}
// ============ UIToolkit Notification Presets APIs (Phase 7) ============
else if (method == "unity.uitoolkit.preset.createPopup")
{
return UIToolkitNotificationPresets.CreatePopup(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createConfirmDialog")
{
return UIToolkitNotificationPresets.CreateConfirmDialog(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createBanner")
{
return UIToolkitNotificationPresets.CreateBanner(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createToast")
{
return UIToolkitNotificationPresets.CreateToast(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createToastContainer")
{
return UIToolkitNotificationPresets.CreateToastContainer(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createAlertBar")
{
return UIToolkitNotificationPresets.CreateAlertBar(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createTooltip")
{
return UIToolkitNotificationPresets.CreateTooltip(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createBadge")
{
return UIToolkitNotificationPresets.CreateBadge(paramsJson, id);
}
else if (method == "unity.uitoolkit.preset.createLoadingOverlay")
{
return UIToolkitNotificationPresets.CreateLoadingOverlay(paramsJson, id);
}
// ============ UIToolkit DI Container APIs (Phase 8.1) ============
else if (method == "unity.uitoolkit.di.createContainer")
{
return UIToolkitDIContainer.CreateContainer(paramsJson, id);
}
else if (method == "unity.uitoolkit.di.registerService")
{
return UIToolkitDIContainer.RegisterService(paramsJson, id);
}
else if (method == "unity.uitoolkit.di.unregisterService")
{
return UIToolkitDIContainer.UnregisterService(paramsJson, id);
}
else if (method == "unity.uitoolkit.di.listServices")
{
return UIToolkitDIContainer.ListServices(paramsJson, id);
}
else if (method == "unity.uitoolkit.di.generateContainerScript")
{
return UIToolkitDIContainer.GenerateContainerScript(paramsJson, id);
}
// ============ UIToolkit Event Bus APIs (Phase 8.4) ============
else if (method == "unity.uitoolkit.eventbus.create")
{
return UIToolkitEventBus.CreateEventBus(paramsJson, id);
}
else if (method == "unity.uitoolkit.eventbus.defineEvent")
{
return UIToolkitEventBus.DefineEvent(paramsJson, id);
}
else if (method == "unity.uitoolkit.eventbus.removeEvent")
{
return UIToolkitEventBus.RemoveEvent(paramsJson, id);
}
else if (method == "unity.uitoolkit.eventbus.listEvents")
{
return UIToolkitEventBus.ListEvents(paramsJson, id);
}
else if (method == "unity.uitoolkit.eventbus.generateScript")
{
return UIToolkitEventBus.GenerateScript(paramsJson, id);
}
// ============ UIToolkit State Manager APIs (Phase 8.5) ============
else if (method == "unity.uitoolkit.state.createStore")
{
return UIToolkitStateManager.CreateStore(paramsJson, id);
}
else if (method == "unity.uitoolkit.state.addSlice")
{
return UIToolkitStateManager.AddSlice(paramsJson, id);
}
else if (method == "unity.uitoolkit.state.addAction")
{
return UIToolkitStateManager.AddAction(paramsJson, id);
}
else if (method == "unity.uitoolkit.state.removeSlice")
{
return UIToolkitStateManager.RemoveSlice(paramsJson, id);
}
else if (method == "unity.uitoolkit.state.listSlices")
{
return UIToolkitStateManager.ListSlices(paramsJson, id);
}
else if (method == "unity.uitoolkit.state.generateStoreScript")
{
return UIToolkitStateManager.GenerateStoreScript(paramsJson, id);
}
else if (method == "unity.uitoolkit.state.createSelector")
{
return UIToolkitStateManager.CreateSelector(paramsJson, id);
}
// ============ UIToolkit Animation APIs (Phase 9) ============
else if (method == "unity.uitoolkit.animation.define")
{
return UIToolkitAnimationController.DefineAnimation(paramsJson, id);
}
else if (method == "unity.uitoolkit.animation.addKeyframe")
{
return UIToolkitAnimationController.AddKeyframe(paramsJson, id);
}
else if (method == "unity.uitoolkit.animation.remove")
{
return UIToolkitAnimationController.RemoveAnimation(paramsJson, id);
}
else if (method == "unity.uitoolkit.animation.list")
{
return UIToolkitAnimationController.ListAnimations(paramsJson, id);
}
else if (method == "unity.uitoolkit.animation.generateTransitionUSS")
{
return UIToolkitAnimationController.GenerateTransitionUSS(paramsJson, id);
}
else if (method == "unity.uitoolkit.animation.createFade")
{
return UIToolkitAnimationController.CreateFadeAnimation(paramsJson, id);
}
else if (method == "unity.uitoolkit.animation.createSlide")
{
return UIToolkitAnimationController.CreateSlideAnimation(paramsJson, id);
}
else if (method == "unity.uitoolkit.animation.createScale")
{
return UIToolkitAnimationController.CreateScaleAnimation(paramsJson, id);
}
else if (method == "unity.uitoolkit.animation.createRotate")
{
return UIToolkitAnimationController.CreateRotateAnimation(paramsJson, id);
}
else if (method == "unity.uitoolkit.animation.applyToElement")
{
return UIToolkitAnimationController.ApplyToElement(paramsJson, id);
}
// ============ UIToolkit Theme Manager APIs (Phase 10) ============
else if (method == "unity.uitoolkit.theme.create")
{
return UIToolkitThemeManager.CreateTheme(paramsJson, id);
}
else if (method == "unity.uitoolkit.theme.setColor")
{
return UIToolkitThemeManager.SetColor(paramsJson, id);
}
else if (method == "unity.uitoolkit.theme.setSpacing")
{
return UIToolkitThemeManager.SetSpacing(paramsJson, id);
}
else if (method == "unity.uitoolkit.theme.get")
{
return UIToolkitThemeManager.GetTheme(paramsJson, id);
}
else if (method == "unity.uitoolkit.theme.list")
{
return UIToolkitThemeManager.ListThemes(paramsJson, id);
}
else if (method == "unity.uitoolkit.theme.delete")
{
return UIToolkitThemeManager.DeleteTheme(paramsJson, id);
}
else if (method == "unity.uitoolkit.theme.generateUSS")
{
return UIToolkitThemeManager.GenerateUSS(paramsJson, id);
}
else if (method == "unity.uitoolkit.theme.generateDarkModeUSS")
{
return UIToolkitThemeManager.GenerateDarkModeUSS(paramsJson, id);
}
// ============ UIToolkit Responsive Manager APIs (Phase 11) ============
else if (method == "unity.uitoolkit.responsive.setBreakpoint")
{
return UIToolkitResponsiveManager.SetBreakpoint(paramsJson, id);
}
else if (method == "unity.uitoolkit.responsive.getBreakpoints")
{
return UIToolkitResponsiveManager.GetBreakpoints(paramsJson, id);
}
else if (method == "unity.uitoolkit.responsive.removeBreakpoint")
{
return UIToolkitResponsiveManager.RemoveBreakpoint(paramsJson, id);
}
else if (method == "unity.uitoolkit.responsive.createRuleSet")
{
return UIToolkitResponsiveManager.CreateRuleSet(paramsJson, id);
}
else if (method == "unity.uitoolkit.responsive.addBreakpointStyle")
{
return UIToolkitResponsiveManager.AddBreakpointStyle(paramsJson, id);
}
else if (method == "unity.uitoolkit.responsive.generateUSS")
{
return UIToolkitResponsiveManager.GenerateUSS(paramsJson, id);
}
else if (method == "unity.uitoolkit.responsive.generateHelperScript")
{
return UIToolkitResponsiveManager.GenerateHelperScript(paramsJson, id);
}
// ============ UIToolkit Accessibility Manager APIs (Phase 12) ============
else if (method == "unity.uitoolkit.accessibility.setAriaLabel")
{
return UIToolkitAccessibilityManager.SetAriaLabel(paramsJson, id);
}
else if (method == "unity.uitoolkit.accessibility.setTabIndex")
{
return UIToolkitAccessibilityManager.SetTabIndex(paramsJson, id);
}
else if (method == "unity.uitoolkit.accessibility.setRole")
{
return UIToolkitAccessibilityManager.SetRole(paramsJson, id);
}
else if (method == "unity.uitoolkit.accessibility.generateFocusStyles")
{
return UIToolkitAccessibilityManager.GenerateFocusStyles(paramsJson, id);
}
else if (method == "unity.uitoolkit.accessibility.checkColorContrast")
{
return UIToolkitAccessibilityManager.CheckColorContrast(paramsJson, id);
}
else if (method == "unity.uitoolkit.accessibility.generateScreenReaderHelper")
{
return UIToolkitAccessibilityManager.GenerateScreenReaderHelper(paramsJson, id);
}
else if (method == "unity.uitoolkit.accessibility.generateHighContrastUSS")
{
return UIToolkitAccessibilityManager.GenerateHighContrastUSS(paramsJson, id);
}
// ============ UIToolkit Localization Manager APIs (Phase 13) ============
else if (method == "unity.uitoolkit.localization.addLocale")
{
return UIToolkitLocalizationManager.AddLocale(paramsJson, id);
}
else if (method == "unity.uitoolkit.localization.removeLocale")
{
return UIToolkitLocalizationManager.RemoveLocale(paramsJson, id);
}
else if (method == "unity.uitoolkit.localization.listLocales")
{
return UIToolkitLocalizationManager.ListLocales(paramsJson, id);
}
else if (method == "unity.uitoolkit.localization.setCurrentLocale")
{
return UIToolkitLocalizationManager.SetCurrentLocale(paramsJson, id);
}
else if (method == "unity.uitoolkit.localization.addTranslation")
{
return UIToolkitLocalizationManager.AddTranslation(paramsJson, id);
}
else if (method == "unity.uitoolkit.localization.addTranslations")
{
return UIToolkitLocalizationManager.AddTranslations(paramsJson, id);
}
else if (method == "unity.uitoolkit.localization.getTranslation")
{
return UIToolkitLocalizationManager.GetTranslation(paramsJson, id);
}
else if (method == "unity.uitoolkit.localization.generateScript")
{
return UIToolkitLocalizationManager.GenerateLocalizationScript(paramsJson, id);
}
else if (method == "unity.uitoolkit.localization.exportToJson")
{
return UIToolkitLocalizationManager.ExportToJson(paramsJson, id);
}
else if (method == "unity.uitoolkit.localization.importFromJson")
{
return UIToolkitLocalizationManager.ImportFromJson(paramsJson, id);
}
else if (method == "unity.uitoolkit.localization.generateRTLStyles")
{
return UIToolkitLocalizationManager.GenerateRTLStyles(paramsJson, id);
}
// ============ UIToolkit Debug Tools APIs (Phase 14) ============
else if (method == "unity.uitoolkit.debug.analyzeUXML")
{
return UIToolkitDebugTools.AnalyzeUXML(paramsJson, id);
}
else if (method == "unity.uitoolkit.debug.analyzeUSS")
{
return UIToolkitDebugTools.AnalyzeUSS(paramsJson, id);
}
else if (method == "unity.uitoolkit.debug.validateUXML")
{
return UIToolkitDebugTools.ValidateUXML(paramsJson, id);
}
else if (method == "unity.uitoolkit.debug.validateUSS")
{
return UIToolkitDebugTools.ValidateUSS(paramsJson, id);
}
else if (method == "unity.uitoolkit.debug.generateDebugOverlay")
{
return UIToolkitDebugTools.GenerateDebugOverlay(paramsJson, id);
}
else if (method == "unity.uitoolkit.debug.generateDebugScript")
{
return UIToolkitDebugTools.GenerateDebugScript(paramsJson, id);
}
else if (method == "unity.uitoolkit.debug.profileUI")
{
return UIToolkitDebugTools.ProfileUI(paramsJson, id);
}
// ============ UIToolkit Asset Dependencies APIs (Phase 15) ============
else if (method == "unity.uitoolkit.dependencies.analyze")
{
return UIToolkitAssetDependencyManager.AnalyzeDependencies(paramsJson, id);
}
else if (method == "unity.uitoolkit.dependencies.findReferences")
{
return UIToolkitAssetDependencyManager.FindReferences(paramsJson, id);
}
else if (method == "unity.uitoolkit.dependencies.findUnused")
{
return UIToolkitAssetDependencyManager.FindUnusedAssets(paramsJson, id);
}
else if (method == "unity.uitoolkit.dependencies.generateGraph")
{
return UIToolkitAssetDependencyManager.GenerateDependencyGraph(paramsJson, id);
}
else if (method == "unity.uitoolkit.dependencies.analyzeBundle")
{
return UIToolkitAssetDependencyManager.AnalyzeBundle(paramsJson, id);
}
#endif // UNITY_2021_2_OR_NEWER
// ============ Compositing APIs (Reflection-based) ============
else if (method == "unity.compositing.setLook")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Compositing, PackageTypes.CompositingController, "SetLook", paramsJson, id);
}
else if (method == "unity.compositing.setMood")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Compositing, PackageTypes.CompositingController, "SetMood", paramsJson, id);
}
else if (method == "unity.compositing.lockExposure")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Compositing, PackageTypes.CompositingController, "LockExposure", paramsJson, id);
}
else if (method == "unity.compositing.getLook")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Compositing, PackageTypes.CompositingController, "GetLook", paramsJson, id);
}
// ============================================
// Asset Import APIs (Reflection-based)
// TextureImporter, AudioImporter, ModelImporter, VideoClipImporter
// ============================================
else if (method.StartsWith("unity.import."))
{
return PackageApiInvoker.InvokeWithParams(PackageAssemblies.AssetImport, PackageTypes.AssetImportController, "HandleRequest", method, paramsJson, id);
}
else
{
return JsonRpcResponseHelper.MethodNotFound(method, id);
}
}
// Helper methods to extract JSON fields
private int ExtractIntParam(string paramsJson, string paramName, int defaultValue)
{
try
{
string pattern = $"\"{paramName}\"\\s*:\\s*(\\d+)";
var match = System.Text.RegularExpressions.Regex.Match(paramsJson, pattern);
if (match.Success && int.TryParse(match.Groups[1].Value, out int value))
{
return value;
}
}
catch (System.Exception e)
{
Debug.LogError($"Error extracting parameter '{paramName}': {e.Message}");
}
return defaultValue;
}
private string ExtractJsonField(string json, string fieldName)
{
try
{
string pattern = $"\"{fieldName}\"\\s*:\\s*\"([^\"]+)\"";
var match = System.Text.RegularExpressions.Regex.Match(json, pattern);
if (match.Success)
{
return match.Groups[1].Value;
}
// Try without quotes (for numbers)
pattern = $"\"{fieldName}\"\\s*:\\s*([^,}}]+)";
match = System.Text.RegularExpressions.Regex.Match(json, pattern);
if (match.Success)
{
return match.Groups[1].Value.Trim();
}
}
catch (Exception e)
{
Debug.LogError($"[MCP HTTP] Error extracting field '{fieldName}': {e.Message}");
}
return null;
}
private string ExtractJsonObject(string json, string fieldName)
{
try
{
int fieldIndex = json.IndexOf($"\"{fieldName}\"");
if (fieldIndex == -1) return null;
int colonIndex = json.IndexOf(':', fieldIndex);
if (colonIndex == -1) return null;
// Skip whitespace after colon
int startIndex = colonIndex + 1;
while (startIndex < json.Length && char.IsWhiteSpace(json[startIndex]))
{
startIndex++;
}
if (startIndex >= json.Length) return null;
// Check if it's an object or array
char startChar = json[startIndex];
if (startChar == '{')
{
// Find matching closing brace
int braceCount = 1;
int endIndex = startIndex + 1;
while (endIndex < json.Length && braceCount > 0)
{
if (json[endIndex] == '{') braceCount++;
else if (json[endIndex] == '}') braceCount--;
endIndex++;
}
return json.Substring(startIndex, endIndex - startIndex);
}
}
catch (Exception e)
{
Debug.LogError($"[MCP HTTP] Error extracting object '{fieldName}': {e.Message}");
}
return null;
}
/// <summary>
/// Cleanup method to be called when shutting down.
/// </summary>
public void Cleanup()
{
StopServer();
}
#region API Discovery (tools/list)
/// <summary>
/// MCP仕様準拠のtools/listエンドポイント
/// </summary>
private static string GetToolsList(string paramsJson, object id)
{
try
{
string category = null;
string search = null;
if (!string.IsNullOrEmpty(paramsJson) && paramsJson != "{}")
{
var categoryMatch = System.Text.RegularExpressions.Regex.Match(paramsJson, "\"category\"\\s*:\\s*\"([^\"]+)\"");
if (categoryMatch.Success)
{
category = categoryMatch.Groups[1].Value;
}
var searchMatch = System.Text.RegularExpressions.Regex.Match(paramsJson, "\"search\"\\s*:\\s*\"([^\"]+)\"");
if (searchMatch.Success)
{
search = searchMatch.Groups[1].Value;
}
}
List<ApiDefinition> apis;
if (!string.IsNullOrEmpty(search))
{
apis = ApiRegistry.SearchApis(search);
}
else if (!string.IsNullOrEmpty(category))
{
apis = ApiRegistry.GetApisByCategory(category);
}
else
{
apis = ApiRegistry.GetAllApis();
}
var sb = new System.Text.StringBuilder();
sb.Append("{\"tools\":[");
for (int i = 0; i < apis.Count; i++)
{
if (i > 0) sb.Append(",");
sb.Append(FormatToolDefinition(apis[i]));
}
sb.Append("],\"totalCount\":");
sb.Append(apis.Count);
sb.Append(",\"categories\":[");
var categories = ApiRegistry.GetCategories();
for (int i = 0; i < categories.Count; i++)
{
if (i > 0) sb.Append(",");
sb.Append("\"");
sb.Append(categories[i]);
sb.Append("\"");
}
sb.Append("]");
// エディション情報を追加
var editionSummary = ApiRegistry.GetEditionSummary();
sb.Append(",\"edition\":{");
sb.Append("\"current\":\"");
sb.Append(editionSummary.currentEdition);
sb.Append("\",\"availableApis\":");
sb.Append(editionSummary.totalApis);
sb.Append(",\"publicApis\":");
sb.Append(editionSummary.publicApis);
sb.Append(",\"standardApis\":");
sb.Append(editionSummary.standardApis);
sb.Append(",\"proApis\":");
sb.Append(editionSummary.proApis);
sb.Append("}}");
return JsonRpcResponseHelper.SuccessJson(sb.ToString(), id);
}
catch (Exception e)
{
return JsonRpcResponseHelper.ErrorMessage($"Failed to get tools list: {e.Message}", id);
}
}
private static string GetToolsCategories(object id)
{
try
{
var categories = ApiRegistry.GetCategories();
var categoryInfos = new List<string>();
foreach (var cat in categories)
{
var apis = ApiRegistry.GetApisByCategory(cat);
categoryInfos.Add($"{{\"name\":\"{cat}\",\"count\":{apis.Count}}}");
}
var result = "{\"categories\":[" + string.Join(",", categoryInfos) + "]}";
return JsonRpcResponseHelper.SuccessJson(result, id);
}
catch (Exception e)
{
return JsonRpcResponseHelper.ErrorMessage($"Failed to get categories: {e.Message}", id);
}
}
private static string FormatToolDefinition(ApiDefinition api)
{
var sb = new System.Text.StringBuilder();
sb.Append("{");
sb.Append($"\"name\":\"{EscapeJsonString(api.name)}\",");
sb.Append($"\"description\":\"{EscapeJsonString(api.description)}\",");
sb.Append($"\"category\":\"{EscapeJsonString(api.category)}\"");
if (api.inputSchema != null)
{
sb.Append(",\"inputSchema\":{");
sb.Append($"\"type\":\"{api.inputSchema.type}\"");
if (api.inputSchema.properties != null && api.inputSchema.properties.Count > 0)
{
sb.Append(",\"properties\":{");
bool first = true;
foreach (var prop in api.inputSchema.properties)
{
if (!first) sb.Append(",");
first = false;
sb.Append($"\"{prop.Key}\":{{\"type\":\"{prop.Value.type}\",\"description\":\"{EscapeJsonString(prop.Value.description)}\"}}");
}
sb.Append("}");
}
if (api.inputSchema.required != null && api.inputSchema.required.Length > 0)
{
sb.Append(",\"required\":[");
for (int i = 0; i < api.inputSchema.required.Length; i++)
{
if (i > 0) sb.Append(",");
sb.Append($"\"{api.inputSchema.required[i]}\"");
}
sb.Append("]");
}
sb.Append("}");
}
if (api.useCases != null && api.useCases.Length > 0)
{
sb.Append(",\"useCases\":[");
for (int i = 0; i < api.useCases.Length; i++)
{
if (i > 0) sb.Append(",");
sb.Append($"\"{EscapeJsonString(api.useCases[i])}\"");
}
sb.Append("]");
}
if (api.relatedApis != null && api.relatedApis.Length > 0)
{
sb.Append(",\"relatedApis\":[");
for (int i = 0; i < api.relatedApis.Length; i++)
{
if (i > 0) sb.Append(",");
sb.Append($"\"{api.relatedApis[i]}\"");
}
sb.Append("]");
}
sb.Append("}");
return sb.ToString();
}
private static string EscapeJsonString(string s)
{
if (string.IsNullOrEmpty(s)) return "";
return s.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\n", "\\n").Replace("\r", "\\r").Replace("\t", "\\t");
}
#endregion
}
}
Latest Blog Posts
- MCP Moves to the Linux Foundation: Neutral Stewardship for Agentic InfrastructureBy Om-Shree-0709 on .mcpanthropicLinux Foundation
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/dsgarage/UniMCP4CC'
If you have feedback or need assistance with the MCP directory API, please join our Discord server