UniMCP4CC
by dsgarage
- UniMCP4CC
- Editor
McpSession.cs•163 kB
using System;
using System.IO;
using System.Net.Sockets;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
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>
/// Manages a single WebSocket connection and handles JSON-RPC requests.
/// </summary>
public class McpSession
{
private TcpClient client;
private NetworkStream stream;
private bool isConnected = false;
private bool isWebSocketHandshakeComplete = false;
private McpLogStream logStream;
public McpSession(TcpClient tcpClient)
{
client = tcpClient;
stream = client.GetStream();
isConnected = true;
logStream = new McpLogStream(this);
}
/// <summary>
/// Main client handling loop. Performs WebSocket handshake and processes messages.
/// </summary>
public void HandleClient()
{
try
{
// Perform WebSocket handshake
if (!PerformWebSocketHandshake())
{
Debug.LogError("[MCP] WebSocket handshake failed");
Close();
return;
}
Debug.Log("[MCP] WebSocket handshake complete");
isWebSocketHandshakeComplete = true;
// Main message loop
while (isConnected && client.Connected)
{
if (stream.DataAvailable)
{
string message = ReceiveWebSocketMessage();
if (!string.IsNullOrEmpty(message))
{
ProcessMessage(message);
}
}
else
{
System.Threading.Thread.Sleep(10);
}
}
}
catch (System.Threading.ThreadAbortException)
{
// Silently handle thread abort during domain reload
System.Threading.Thread.ResetAbort();
}
catch (Exception e)
{
// Only log errors if connection is still expected
if (isConnected)
{
Debug.LogError($"[MCP] Session error: {e.Message}\n{e.StackTrace}");
}
}
finally
{
Close();
if (UnityMcpServer.Instance != null)
{
UnityMcpServer.Instance.RemoveSession(this);
}
}
}
/// <summary>
/// Performs the WebSocket handshake with the client.
/// </summary>
private bool PerformWebSocketHandshake()
{
try
{
// Read the handshake request
byte[] buffer = new byte[4096];
int bytesRead = stream.Read(buffer, 0, buffer.Length);
string request = Encoding.UTF8.GetString(buffer, 0, bytesRead);
// Extract the WebSocket key
Match keyMatch = Regex.Match(request, @"Sec-WebSocket-Key: (.*)");
if (!keyMatch.Success)
{
return false;
}
string key = keyMatch.Groups[1].Value.Trim();
string acceptKey = ComputeWebSocketAcceptKey(key);
// Send the handshake response
string response = "HTTP/1.1 101 Switching Protocols\r\n" +
"Connection: Upgrade\r\n" +
"Upgrade: websocket\r\n" +
$"Sec-WebSocket-Accept: {acceptKey}\r\n\r\n";
byte[] responseBytes = Encoding.UTF8.GetBytes(response);
stream.Write(responseBytes, 0, responseBytes.Length);
stream.Flush();
return true;
}
catch (Exception e)
{
Debug.LogError($"[MCP] Handshake error: {e.Message}");
return false;
}
}
/// <summary>
/// Computes the Sec-WebSocket-Accept key for the handshake response.
/// </summary>
private string ComputeWebSocketAcceptKey(string key)
{
string combined = key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
byte[] hash = SHA1.Create().ComputeHash(Encoding.UTF8.GetBytes(combined));
return Convert.ToBase64String(hash);
}
/// <summary>
/// Receives and decodes a WebSocket message.
/// </summary>
private string ReceiveWebSocketMessage()
{
try
{
// Read first two bytes
byte[] header = new byte[2];
int bytesRead = stream.Read(header, 0, 2);
if (bytesRead < 2)
{
return null;
}
bool fin = (header[0] & 0b10000000) != 0;
int opcode = header[0] & 0b00001111;
bool mask = (header[1] & 0b10000000) != 0;
int payloadLength = header[1] & 0b01111111;
// Handle extended payload length
if (payloadLength == 126)
{
byte[] extendedLength = new byte[2];
stream.Read(extendedLength, 0, 2);
payloadLength = (extendedLength[0] << 8) | extendedLength[1];
}
else if (payloadLength == 127)
{
byte[] extendedLength = new byte[8];
stream.Read(extendedLength, 0, 8);
// For simplicity, we'll only use the lower 32 bits
payloadLength = (extendedLength[4] << 24) | (extendedLength[5] << 16) |
(extendedLength[6] << 8) | extendedLength[7];
}
// Read masking key
byte[] maskingKey = new byte[4];
if (mask)
{
stream.Read(maskingKey, 0, 4);
}
// Read payload
byte[] payload = new byte[payloadLength];
int totalRead = 0;
while (totalRead < payloadLength)
{
int read = stream.Read(payload, totalRead, payloadLength - totalRead);
if (read == 0) break;
totalRead += read;
}
// Unmask payload
if (mask)
{
for (int i = 0; i < payload.Length; i++)
{
payload[i] = (byte)(payload[i] ^ maskingKey[i % 4]);
}
}
// Handle close frame
if (opcode == 0x8)
{
isConnected = false;
return null;
}
return Encoding.UTF8.GetString(payload);
}
catch (Exception e)
{
Debug.LogError($"[MCP] Error receiving message: {e.Message}");
return null;
}
}
/// <summary>
/// Sends a message through the WebSocket connection.
/// </summary>
public void SendMessage(string message)
{
if (!isConnected || !isWebSocketHandshakeComplete || stream == null)
{
return;
}
try
{
byte[] payload = Encoding.UTF8.GetBytes(message);
byte[] frame = EncodeWebSocketFrame(payload);
stream.Write(frame, 0, frame.Length);
stream.Flush();
}
catch (Exception e)
{
Debug.LogError($"[MCP] Error sending message: {e.Message}");
isConnected = false;
}
}
/// <summary>
/// Encodes a payload into a WebSocket frame.
/// </summary>
private byte[] EncodeWebSocketFrame(byte[] payload)
{
int payloadLength = payload.Length;
int headerLength = 2;
if (payloadLength > 125)
{
if (payloadLength <= 65535)
headerLength += 2;
else
headerLength += 8;
}
byte[] frame = new byte[headerLength + payloadLength];
// First byte: FIN + opcode (text frame = 0x1)
frame[0] = 0b10000001;
// Payload length
if (payloadLength <= 125)
{
frame[1] = (byte)payloadLength;
}
else if (payloadLength <= 65535)
{
frame[1] = 126;
frame[2] = (byte)(payloadLength >> 8);
frame[3] = (byte)(payloadLength & 0xFF);
}
else
{
frame[1] = 127;
// Write 64-bit length (simplified for lower 32 bits)
frame[6] = (byte)(payloadLength >> 24);
frame[7] = (byte)(payloadLength >> 16);
frame[8] = (byte)(payloadLength >> 8);
frame[9] = (byte)(payloadLength & 0xFF);
}
// Copy payload
Array.Copy(payload, 0, frame, headerLength, payloadLength);
return frame;
}
/// <summary>
/// Processes a received JSON-RPC message.
/// </summary>
private void ProcessMessage(string message)
{
try
{
Debug.Log($"[MCP] Received: {message}");
JsonRpcRequest request = JsonRpcRequest.Parse(message);
if (request == null)
{
SendMessage(JsonRpcResponseHelper.ErrorMessage("Invalid JSON-RPC request", null));
return;
}
string response = ProcessRequest(request);
// Record success or failure based on response
if (response.Contains("\"error\""))
{
ConnectionHealthMonitor.RecordFailure();
}
else
{
ConnectionHealthMonitor.RecordSuccess();
}
SendMessage(response);
}
catch (Exception e)
{
Debug.LogError($"[MCP] Error processing message: {e.Message}\n{e.StackTrace}");
SendMessage(JsonRpcResponseHelper.ErrorMessage(e.Message, null));
}
}
/// <summary>
/// Processes a JSON-RPC request and returns the response.
/// </summary>
private string ProcessRequest(JsonRpcRequest request)
{
string method = request.method;
string paramsJson = request.@params != null ? request.@params.ToString() : "{}";
Debug.Log($"[MCP] Method: {method}, Params: {paramsJson}");
var stopwatch = System.Diagnostics.Stopwatch.StartNew();
string result = null;
try
{
result = ProcessRequestInternal(request, method, paramsJson);
stopwatch.Stop();
// ログ記録（エラーレスポンスかどうかを判定）
if (result != null && result.Contains("\"error\""))
{
string errorMsg = ExtractErrorMessage(result);
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 ExtractErrorMessage(string result)
{
try
{
string pattern = "\"message\"\\s*:\\s*\"([^\"]+)\"";
var match = System.Text.RegularExpressions.Regex.Match(result, pattern);
if (match.Success) return match.Groups[1].Value;
}
catch { }
return "Unknown error";
}
private string ProcessRequestInternal(JsonRpcRequest request, string method, string paramsJson)
{
// Route to appropriate handler based on method name
// MCP tools/list - API Discovery (Issue #73)
if (method == "tools/list")
{
return GetToolsList(paramsJson, request.id);
}
else if (method == "tools/categories")
{
return GetToolsCategories(request.id);
}
else if (method == "unity.log.stream")
{
return logStream.EnableStream(paramsJson, request.id);
}
else if (method == "unity.log.history")
{
return logStream.GetHistory(paramsJson, request.id);
}
else if (method == "unity.connection.status")
{
return ConnectionHealthMonitor.GetStatus(request.id);
}
else if (method == "unity.connection.ping")
{
return ConnectionHealthMonitor.Ping(request.id);
}
else if (method == "unity.connection.reset")
{
return ConnectionHealthMonitor.Reset(request.id);
}
else if (method == "unity.editor.play")
{
return EditorPlayModeControl.Play(request.id);
}
else if (method == "unity.editor.stop")
{
return EditorPlayModeControl.Stop(request.id);
}
else if (method == "unity.editor.pause")
{
return EditorPlayModeControl.Pause(request.id);
}
else if (method == "unity.editor.resume")
{
return EditorPlayModeControl.Resume(request.id);
}
else if (method == "unity.editor.step")
{
return EditorPlayModeControl.Step(request.id);
}
else if (method == "unity.editor.playModeStatus")
{
return EditorPlayModeControl.GetStatus(request.id);
}
else if (method == "unity.editor.playAndCaptureLogs")
{
return EditorPlayModeControl.PlayAndCaptureLogs(paramsJson, request.id);
}
else if (method == "unity.test.runAll")
{
return UnityTestRunnerControl.RunAllTests(paramsJson, request.id);
}
else if (method == "unity.test.runByCategory")
{
return UnityTestRunnerControl.RunTestsByCategory(paramsJson, request.id);
}
else if (method == "unity.test.runByAssembly")
{
return UnityTestRunnerControl.RunTestsByAssembly(paramsJson, request.id);
}
else if (method == "unity.test.runSpecific")
{
return UnityTestRunnerControl.RunSpecificTest(paramsJson, request.id);
}
else if (method == "unity.test.getResults")
{
return UnityTestRunnerControl.GetTestResults(request.id);
}
else if (method == "unity.test.list")
{
return UnityTestRunnerControl.ListTests(paramsJson, request.id);
}
else if (method == "unity.test.status")
{
return UnityTestRunnerControl.GetStatus(request.id);
}
else if (method == "unity.test.getFailedTests")
{
return UnityTestRunnerControl.GetFailedTests(request.id);
}
else if (method == "unity.test.saveResults")
{
return UnityTestRunnerControl.SaveResults(paramsJson, request.id);
}
else if (method == "unity.test.runWithLog")
{
return UnityTestRunnerControl.RunWithLog(paramsJson, request.id);
}
else if (method == "unity.test.exportResults")
{
return UnityTestRunnerControl.ExportResults(paramsJson, request.id);
}
else if (method == "unity.test.clearResults")
{
return UnityTestRunnerControl.ClearResults(request.id);
}
else if (method == "unity.test.runSelected")
{
return UnityTestRunnerControl.RunSelected(paramsJson, request.id);
}
else if (method == "unity.test.runFailed")
{
return UnityTestRunnerControl.RunFailed(paramsJson, request.id);
}
else if (method == "unity.test.runEditMode")
{
return UnityTestRunnerControl.RunEditMode(paramsJson, request.id);
}
else if (method == "unity.test.runPlayMode")
{
return UnityTestRunnerControl.RunPlayMode(paramsJson, request.id);
}
else if (method == "unity.scene.list")
{
return SceneSetupCommand.ListScene(paramsJson, request.id);
}
else if (method == "unity.scene.setup")
{
return SceneSetupCommand.SetupScene(paramsJson, request.id);
}
else if (method == "unity.scene.save")
{
return SceneSetupCommand.SaveScene(paramsJson, request.id);
}
else if (method == "unity.project.save")
{
return SceneSetupCommand.SaveProject(paramsJson, request.id);
}
else if (method == "unity.scene.open")
{
return SceneSetupCommand.OpenScene(paramsJson, request.id);
}
else if (method == "unity.create")
{
return SceneSetupCommand.CreateGameObject(paramsJson, request.id);
}
else if (method == "unity.debug.log")
{
return SceneSetupCommand.DebugLog(paramsJson, request.id);
}
else if (method == "unity.editor.executeMenuItem")
{
return SceneSetupCommand.ExecuteMenuItem(paramsJson, request.id);
}
else if (method == "unity.scene.findObjectOfType")
{
return SceneSetupCommand.FindObjectOfType(paramsJson, request.id);
}
else if (method == "unity.scene.setupArchitecture")
{
return SceneSetupCommand.SetupSceneArchitecture(paramsJson, request.id);
}
// GameObject operations
else if (method == "unity.gameObject.delete")
{
return SceneSetupCommand.DeleteGameObject(paramsJson, request.id);
}
else if (method == "unity.gameObject.setActive")
{
return SceneSetupCommand.SetGameObjectActive(paramsJson, request.id);
}
else if (method == "unity.gameObject.setParent")
{
return SceneSetupCommand.SetGameObjectParent(paramsJson, request.id);
}
else if (method == "unity.transform.setPosition")
{
return SceneSetupCommand.SetTransformPosition(paramsJson, request.id);
}
else if (method == "unity.transform.setRotation")
{
return SceneSetupCommand.SetTransformRotation(paramsJson, request.id);
}
else if (method == "unity.transform.setScale")
{
return SceneSetupCommand.SetTransformScale(paramsJson, request.id);
}
else if (method == "unity.gameobject.destroy")
{
return SceneSetupCommand.DestroyGameObject(paramsJson, request.id);
}
// Prefab operations
else if (method == "unity.prefab.instantiate")
{
return PrefabOperations.InstantiatePrefab(paramsJson, request.id);
}
else if (method == "unity.prefab.create")
{
return PrefabOperations.CreatePrefab(paramsJson, request.id);
}
else if (method == "unity.prefab.apply")
{
return PrefabOperations.ApplyPrefabChanges(paramsJson, request.id);
}
else if (method == "unity.prefab.revert")
{
return PrefabOperations.RevertPrefabChanges(paramsJson, request.id);
}
else if (method == "unity.prefab.unpack")
{
return PrefabOperations.UnpackPrefab(paramsJson, request.id);
}
else if (method == "unity.asset.list")
{
return AssetDatabaseProvider.ListAssets(paramsJson, request.id);
}
else if (method == "unity.asset.find")
{
return AssetDatabaseProvider.FindAsset(paramsJson, request.id);
}
else if (method == "unity.asset.refresh")
{
return AssetDatabaseProvider.RefreshAssetDatabase(paramsJson, request.id);
}
else if (method == "unity.asset.delete")
{
return AssetDatabaseProvider.DeleteAsset(paramsJson, request.id);
}
else if (method == "unity.asset.move")
{
return AssetDatabaseProvider.MoveAsset(paramsJson, request.id);
}
else if (method == "unity.asset.copy")
{
return AssetDatabaseProvider.CopyAsset(paramsJson, request.id);
}
else if (method == "unity.component.list")
{
return ComponentReflection.ListComponents(paramsJson, request.id);
}
else if (method == "unity.component.inspect")
{
return ComponentReflection.InspectComponent(paramsJson, request.id);
}
else if (method == "unity.component.set")
{
return ComponentReflection.SetField(paramsJson, request.id);
}
else if (method == "unity.component.setProperty")
{
return ComponentReflection.SetProperty(paramsJson, request.id);
}
else if (method == "unity.component.invoke")
{
return ComponentReflection.InvokeMethod(paramsJson, request.id);
}
else if (method == "unity.component.add")
{
return ComponentReflection.AddComponent(paramsJson, request.id);
}
else if (method == "unity.component.remove")
{
return ComponentReflection.RemoveComponent(paramsJson, request.id);
}
else if (method == "unity.component.setReference")
{
return ComponentReflection.SetReference(paramsJson, request.id);
}
else if (method == "unity.component.setSerializedProperty")
{
return SerializedPropertyWriter.SetSerializedProperty(paramsJson, request.id);
}
else if (method == "unity.compile.status")
{
return CompileWaitHelper.GetCompileStatus(request.id);
}
else if (method == "unity.compile.waitForCompile")
{
return CompileWaitHelper.WaitForCompile(paramsJson, request.id);
}
else if (method == "unity.project.getPlayerSettings")
{
return ProjectSettingsController.GetPlayerSettings(request.id);
}
else if (method == "unity.project.setPlayerSettings")
{
return ProjectSettingsController.SetPlayerSettings(paramsJson, request.id);
}
else if (method == "unity.project.getQualitySettings")
{
return ProjectSettingsController.GetQualitySettings(request.id);
}
else if (method == "unity.project.setQualitySettings")
{
return ProjectSettingsController.SetQualitySettings(paramsJson, request.id);
}
else if (method == "unity.project.getPhysicsSettings")
{
return ProjectSettingsController.GetPhysicsSettings(request.id);
}
else if (method == "unity.project.setPhysicsSettings")
{
return ProjectSettingsController.SetPhysicsSettings(paramsJson, request.id);
}
else if (method == "unity.project.getTimeSettings")
{
return ProjectSettingsController.GetTimeSettings(request.id);
}
else if (method == "unity.project.setTimeSettings")
{
return ProjectSettingsController.SetTimeSettings(paramsJson, request.id);
}
// Build Pipeline APIs
else if (method == "unity.build.player")
{
return BuildPipelineController.BuildPlayer(paramsJson, request.id);
}
else if (method == "unity.build.getSettings")
{
return BuildPipelineController.GetBuildSettings(request.id);
}
else if (method == "unity.build.setSettings")
{
return BuildPipelineController.SetBuildSettings(paramsJson, request.id);
}
// Package Management APIs
else if (method == "unity.package.export")
{
return PackageController.ExportPackage(paramsJson, request.id);
}
else if (method == "unity.package.import")
{
return PackageController.ImportPackage(paramsJson, request.id);
}
else if (method == "unity.package.list")
{
return PackageController.ListPackages(paramsJson, request.id);
}
else if (method == "unity.package.add")
{
return PackageController.AddPackage(paramsJson, request.id);
}
else if (method == "unity.package.remove")
{
return PackageController.RemovePackage(paramsJson, request.id);
}
else if (method == "unity.package.embed")
{
return PackageController.EmbedPackage(paramsJson, request.id);
}
else if (method == "unity.package.pack")
{
return PackageController.PackPackage(paramsJson, request.id);
}
// iOS Build Settings APIs
else if (method == "unity.build.ios.setPlist")
{
return iOSBuildSettings.SetPlist(paramsJson, request.id);
}
else if (method == "unity.build.ios.setXcodeSettings")
{
return iOSBuildSettings.SetXcodeSettings(paramsJson, request.id);
}
else if (method == "unity.build.ios.setEntitlements")
{
return iOSBuildSettings.SetEntitlements(paramsJson, request.id);
}
else if (method == "unity.build.ios.setBuildNumber")
{
return iOSBuildSettings.SetBuildNumber(paramsJson, request.id);
}
else if (method == "unity.build.ios.getSettings")
{
return iOSBuildSettings.GetSettings(request.id);
}
// Android Build Settings APIs
else if (method == "unity.build.android.setKeystore")
{
return AndroidBuildSettings.SetKeystore(paramsJson, request.id);
}
else if (method == "unity.build.android.setGradleProperties")
{
return AndroidBuildSettings.SetGradleProperties(paramsJson, request.id);
}
else if (method == "unity.build.android.setManifest")
{
return AndroidBuildSettings.SetManifest(paramsJson, request.id);
}
else if (method == "unity.build.android.setBundleVersionCode")
{
return AndroidBuildSettings.SetBundleVersionCode(paramsJson, request.id);
}
else if (method == "unity.build.android.getSettings")
{
return AndroidBuildSettings.GetSettings(request.id);
}
// BuildProfile APIs (Unity 2022+)
else if (method == "unity.buildProfile.list")
{
return BuildProfileController.ListProfiles(request.id);
}
else if (method == "unity.buildProfile.activate")
{
return BuildProfileController.ActivateProfile(paramsJson, request.id);
}
else if (method == "unity.buildProfile.create")
{
return BuildProfileController.CreateProfile(paramsJson, request.id);
}
else if (method == "unity.buildProfile.getSettings")
{
return BuildProfileController.GetProfileSettings(paramsJson, request.id);
}
else if (method == "unity.buildProfile.setSettings")
{
return BuildProfileController.SetProfileSettings(paramsJson, request.id);
}
else if (method == "unity.component.setArrayElement")
{
return ComponentReflection.SetArrayElement(paramsJson, request.id);
}
else if (method == "unity.component.addArrayElement")
{
return ComponentReflection.AddArrayElement(paramsJson, request.id);
}
else if (method == "unity.component.removeArrayElement")
{
return ComponentReflection.RemoveArrayElement(paramsJson, request.id);
}
else if (method == "unity.animator.create")
{
return AnimatorBuilder.CreateController(paramsJson, request.id);
}
else if (method == "unity.animator.addState")
{
return AnimatorBuilder.AddState(paramsJson, request.id);
}
else if (method == "unity.animator.addTransition")
{
return AnimatorBuilder.AddTransition(paramsJson, request.id);
}
else if (method == "unity.animator.addParameter")
{
return AnimatorBuilder.AddParameter(paramsJson, request.id);
}
else if (method == "unity.animator.assignClip")
{
return AnimatorBuilder.AssignClip(paramsJson, request.id);
}
else if (method == "unity.animator.bind")
{
return AnimatorControl.BindController(paramsJson, request.id);
}
// AnimatorOverrideController APIs
else if (method == "unity.animator.createOverride")
{
return AnimatorOverrideBuilder.CreateOverride(paramsJson, request.id);
}
else if (method == "unity.animator.setOverrideController")
{
return AnimatorOverrideBuilder.SetOverrideController(paramsJson, request.id);
}
else if (method == "unity.animator.setOverrideClip")
{
return AnimatorOverrideBuilder.SetOverrideClip(paramsJson, request.id);
}
else if (method == "unity.animator.getOverrideClips")
{
return AnimatorOverrideBuilder.GetOverrideClips(paramsJson, request.id);
}
else if (method == "unity.animator.clearOverrideClip")
{
return AnimatorOverrideBuilder.ClearOverrideClip(paramsJson, request.id);
}
// Asset creation APIs
else if (method == "unity.asset.createMaterial")
{
return UnityAssetCreator.CreateMaterial(paramsJson, request.id);
}
else if (method == "unity.asset.createScene")
{
return UnityAssetCreator.CreateScene(paramsJson, request.id);
}
else if (method == "unity.asset.createFolder")
{
return UnityAssetCreator.CreateFolder(paramsJson, request.id);
}
else if (method == "unity.asset.createPhysicsMaterial")
{
return UnityAssetCreator.CreatePhysicsMaterial(paramsJson, request.id);
}
else if (method == "unity.asset.createPhysicsMaterial2D")
{
return UnityAssetCreator.CreatePhysicsMaterial2D(paramsJson, request.id);
}
else if (method == "unity.asset.createAudioMixer")
{
return UnityAssetCreator.CreateAudioMixer(paramsJson, request.id);
}
else if (method == "unity.asset.createAnimationClip")
{
return UnityAssetCreator.CreateAnimationClip(paramsJson, request.id);
}
else if (method == "unity.asset.createRenderTexture")
{
return UnityAssetCreator.CreateRenderTexture(paramsJson, request.id);
}
else if (method == "unity.asset.createAvatarMask")
{
return UnityAssetCreator.CreateAvatarMask(paramsJson, request.id);
}
else if (method == "unity.asset.createScriptableObject" || method == "unity.asset.create")
{
return UnityAssetCreator.CreateScriptableObject(paramsJson, request.id);
}
// SerializedObject inspection
else if (method == "unity.serialized.inspect")
{
return SerializedObjectInspector.InspectSerializedObject(paramsJson, request.id);
}
else if (method == "unity.serialized.validateMissingReferences")
{
return SerializedObjectInspector.ValidateMissingReferences(paramsJson, request.id);
}
else if (method == "unity.serialized.validateSceneMissingReferences")
{
return SerializedObjectInspector.ValidateSceneMissingReferences(paramsJson, request.id);
}
// Editor method invocation
else if (method == "unity.editor.executeMenuItem")
{
return EditorMethodInvoker.ExecuteMenuItem(paramsJson, request.id);
}
else if (method == "unity.editor.invokeStaticMethod")
{
return EditorMethodInvoker.InvokeStaticMethod(paramsJson, request.id);
}
else if (method == "unity.editor.listMenuItems")
{
return EditorMethodInvoker.ListMenuItems(paramsJson, request.id);
}
// Build Pipeline APIs
else if (method == "unity.build.player")
{
return BuildPipelineController.BuildPlayer(paramsJson, request.id);
}
else if (method == "unity.build.getSettings")
{
return BuildPipelineController.GetBuildSettings(request.id);
}
else if (method == "unity.build.setSettings")
{
return BuildPipelineController.SetBuildSettings(paramsJson, request.id);
}
// Package Management APIs
else if (method == "unity.package.export")
{
return PackageController.ExportPackage(paramsJson, request.id);
}
else if (method == "unity.package.import")
{
return PackageController.ImportPackage(paramsJson, request.id);
}
else if (method == "unity.package.list")
{
return PackageController.ListPackages(paramsJson, request.id);
}
else if (method == "unity.package.add")
{
return PackageController.AddPackage(paramsJson, request.id);
}
else if (method == "unity.package.remove")
{
return PackageController.RemovePackage(paramsJson, request.id);
}
else if (method == "unity.package.embed")
{
return PackageController.EmbedPackage(paramsJson, request.id);
}
else if (method == "unity.package.pack")
{
return PackageController.PackPackage(paramsJson, request.id);
}
// iOS Build Settings APIs
else if (method == "unity.build.ios.setPlist")
{
return iOSBuildSettings.SetPlist(paramsJson, request.id);
}
else if (method == "unity.build.ios.setXcodeSettings")
{
return iOSBuildSettings.SetXcodeSettings(paramsJson, request.id);
}
else if (method == "unity.build.ios.setEntitlements")
{
return iOSBuildSettings.SetEntitlements(paramsJson, request.id);
}
else if (method == "unity.build.ios.setBuildNumber")
{
return iOSBuildSettings.SetBuildNumber(paramsJson, request.id);
}
else if (method == "unity.build.ios.getSettings")
{
return iOSBuildSettings.GetSettings(request.id);
}
// Android Build Settings APIs
else if (method == "unity.build.android.setKeystore")
{
return AndroidBuildSettings.SetKeystore(paramsJson, request.id);
}
else if (method == "unity.build.android.setGradleProperties")
{
return AndroidBuildSettings.SetGradleProperties(paramsJson, request.id);
}
else if (method == "unity.build.android.setManifest")
{
return AndroidBuildSettings.SetManifest(paramsJson, request.id);
}
else if (method == "unity.build.android.setBundleVersionCode")
{
return AndroidBuildSettings.SetBundleVersionCode(paramsJson, request.id);
}
else if (method == "unity.build.android.getSettings")
{
return AndroidBuildSettings.GetSettings(request.id);
}
// BuildProfile APIs (Unity 2022+)
else if (method == "unity.build.profile.list")
{
return BuildProfileController.ListProfiles(request.id);
}
else if (method == "unity.build.profile.activate")
{
return BuildProfileController.ActivateProfile(paramsJson, request.id);
}
else if (method == "unity.build.profile.create")
{
return BuildProfileController.CreateProfile(paramsJson, request.id);
}
else if (method == "unity.build.profile.getSettings")
{
return BuildProfileController.GetProfileSettings(paramsJson, request.id);
}
else if (method == "unity.build.profile.setSettings")
{
return BuildProfileController.SetProfileSettings(paramsJson, request.id);
}
// Build Processor Management APIs
else if (method == "unity.build.addPreprocessor")
{
return BuildProcessorManager.AddPreprocessor(paramsJson, request.id);
}
else if (method == "unity.build.addPostprocessor")
{
return BuildProcessorManager.AddPostprocessor(paramsJson, request.id);
}
else if (method == "unity.build.removePreprocessor")
{
return BuildProcessorManager.RemovePreprocessor(paramsJson, request.id);
}
else if (method == "unity.build.removePostprocessor")
{
return BuildProcessorManager.RemovePostprocessor(paramsJson, request.id);
}
else if (method == "unity.build.listProcessors")
{
return BuildProcessorManager.ListProcessors(request.id);
}
else if (method == "unity.build.executeProcessor")
{
return BuildProcessorManager.ExecuteProcessor(paramsJson, request.id);
}
// Platform Build Settings APIs
else if (method == "unity.build.platform.getSettings")
{
return PlatformBuildSettings.GetSettings(paramsJson, request.id);
}
else if (method == "unity.build.platform.setSettings")
{
return PlatformBuildSettings.SetSettings(paramsJson, request.id);
}
// Timeline APIs (Reflection-based)
else if (method == "unity.timeline.create")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineBuilder, "Create", paramsJson, request.id);
}
else if (method == "unity.timeline.delete")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineBuilder, "Delete", paramsJson, request.id);
}
else if (method == "unity.timeline.get")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineBuilder, "Get", paramsJson, request.id);
}
else if (method == "unity.timeline.list")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineBuilder, "List", paramsJson, request.id);
}
else if (method == "unity.timeline.setDuration")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineBuilder, "SetDuration", paramsJson, request.id);
}
else if (method == "unity.timeline.duplicate")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineBuilder, "Duplicate", paramsJson, request.id);
}
// Timeline Director APIs
else if (method == "unity.timeline.director.bind")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "Bind", paramsJson, request.id);
}
else if (method == "unity.timeline.director.play")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "Play", paramsJson, request.id);
}
else if (method == "unity.timeline.director.stop")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "Stop", paramsJson, request.id);
}
else if (method == "unity.timeline.director.pause")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "Pause", paramsJson, request.id);
}
else if (method == "unity.timeline.director.resume")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "Resume", paramsJson, request.id);
}
else if (method == "unity.timeline.director.setTime")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "SetTime", paramsJson, request.id);
}
else if (method == "unity.timeline.director.evaluate")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "Evaluate", paramsJson, request.id);
}
else if (method == "unity.timeline.director.getState")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "GetState", paramsJson, request.id);
}
else if (method == "unity.timeline.director.setBinding")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "SetBinding", paramsJson, request.id);
}
else if (method == "unity.timeline.director.getBindings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineDirectorControl, "GetBindings", paramsJson, request.id);
}
// Timeline Track APIs
else if (method == "unity.timeline.track.create")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "Create", paramsJson, request.id);
}
else if (method == "unity.timeline.track.delete")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "Delete", paramsJson, request.id);
}
else if (method == "unity.timeline.track.get")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "Get", paramsJson, request.id);
}
else if (method == "unity.timeline.track.list")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "List", paramsJson, request.id);
}
else if (method == "unity.timeline.track.setMuted")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "SetMuted", paramsJson, request.id);
}
else if (method == "unity.timeline.track.setLocked")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "SetLocked", paramsJson, request.id);
}
else if (method == "unity.timeline.track.setParent")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "SetParent", paramsJson, request.id);
}
else if (method == "unity.timeline.track.reorder")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "Reorder", paramsJson, request.id);
}
else if (method == "unity.timeline.track.setAnimationTrackSettings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "SetAnimationTrackSettings", paramsJson, request.id);
}
else if (method == "unity.timeline.track.setActivationTrackSettings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineTrackBuilder, "SetActivationTrackSettings", paramsJson, request.id);
}
// Timeline Clip APIs
else if (method == "unity.timeline.clip.create")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "Create", paramsJson, request.id);
}
else if (method == "unity.timeline.clip.delete")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "Delete", paramsJson, request.id);
}
else if (method == "unity.timeline.clip.get")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "Get", paramsJson, request.id);
}
else if (method == "unity.timeline.clip.list")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "List", paramsJson, request.id);
}
else if (method == "unity.timeline.clip.setTiming")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "SetTiming", paramsJson, request.id);
}
else if (method == "unity.timeline.clip.setBlend")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "SetBlend", paramsJson, request.id);
}
else if (method == "unity.timeline.clip.setEase")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "SetEase", paramsJson, request.id);
}
else if (method == "unity.timeline.clip.setDisplayName")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "SetDisplayName", paramsJson, request.id);
}
else if (method == "unity.timeline.clip.setAnimationClipSettings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "SetAnimationClipSettings", paramsJson, request.id);
}
else if (method == "unity.timeline.clip.setAudioClipSettings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "SetAudioClipSettings", paramsJson, request.id);
}
else if (method == "unity.timeline.clip.setControlClipSettings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "SetControlClipSettings", paramsJson, request.id);
}
else if (method == "unity.timeline.clip.duplicate")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineClipBuilder, "Duplicate", paramsJson, request.id);
}
// Timeline Marker APIs
else if (method == "unity.timeline.marker.create")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineMarkerBuilder, "Create", paramsJson, request.id);
}
else if (method == "unity.timeline.marker.delete")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineMarkerBuilder, "Delete", paramsJson, request.id);
}
else if (method == "unity.timeline.marker.list")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineMarkerBuilder, "List", paramsJson, request.id);
}
else if (method == "unity.timeline.marker.setSignalEmitterSettings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Timeline, PackageTypes.TimelineMarkerBuilder, "SetSignalEmitterSettings", paramsJson, request.id);
}
// ============================================
// Lighting APIs (Phase 1-7)
// ============================================
// Phase 1: Basic Light Operations
else if (method == "unity.lighting.createLight")
{
return LightingCore.CreateLight(paramsJson, request.id);
}
else if (method == "unity.lighting.deleteLight")
{
return LightingCore.DeleteLight(paramsJson, request.id);
}
else if (method == "unity.lighting.listLights")
{
return LightingCore.ListLights(paramsJson, request.id);
}
else if (method == "unity.lighting.setLightProperties")
{
return LightingCore.SetLightProperties(paramsJson, request.id);
}
else if (method == "unity.lighting.setColorTemperature")
{
return LightingCore.SetColorTemperature(paramsJson, request.id);
}
else if (method == "unity.lighting.setLightMode")
{
return LightingCore.SetLightMode(paramsJson, request.id);
}
else if (method == "unity.lighting.getLightInfo")
{
return LightingCore.GetLightInfo(paramsJson, request.id);
}
// Phase 2: Cinematic Lighting (Three-Point, Four-Point)
else if (method == "unity.lighting.createThreePointLighting")
{
return LightingCinematic.CreateThreePointLighting(paramsJson, request.id);
}
else if (method == "unity.lighting.setKeyLight")
{
return LightingCinematic.SetKeyLight(paramsJson, request.id);
}
else if (method == "unity.lighting.setFillLight")
{
return LightingCinematic.SetFillLight(paramsJson, request.id);
}
else if (method == "unity.lighting.setRimLight")
{
return LightingCinematic.SetRimLight(paramsJson, request.id);
}
else if (method == "unity.lighting.setLightingRatio")
{
return LightingCinematic.SetLightingRatio(paramsJson, request.id);
}
else if (method == "unity.lighting.createFourPointLighting")
{
return LightingCinematic.CreateFourPointLighting(paramsJson, request.id);
}
else if (method == "unity.lighting.setPracticalLight")
{
return LightingCinematic.SetPracticalLight(paramsJson, request.id);
}
// Phase 3: Mood & Color Settings
else if (method == "unity.lighting.applyMoodPreset")
{
return LightingMood.ApplyMoodPreset(paramsJson, request.id);
}
else if (method == "unity.lighting.setTimeOfDay")
{
return LightingMood.SetTimeOfDay(paramsJson, request.id);
}
else if (method == "unity.lighting.setColorHarmony")
{
return LightingMood.SetColorHarmony(paramsJson, request.id);
}
else if (method == "unity.lighting.setAmbientLight" || method == "unity.lighting.setAmbient")
{
return LightingMood.SetAmbientLight(paramsJson, request.id);
}
else if (method == "unity.lighting.setSkybox")
{
return LightingMood.SetSkybox(paramsJson, request.id);
}
else if (method == "unity.lighting.setFog")
{
return LightingMood.SetFog(paramsJson, request.id);
}
else if (method == "unity.lighting.listMoodPresets")
{
return LightingMood.ListMoodPresets(paramsJson, request.id);
}
// Phase 4: Global Illumination
else if (method == "unity.lighting.setGIMode")
{
return LightingGI.SetGIMode(paramsJson, request.id);
}
else if (method == "unity.lighting.bakeLighting" || method == "unity.lighting.bake")
{
return LightingGI.BakeLighting(paramsJson, request.id);
}
else if (method == "unity.lighting.clearBakedData")
{
return LightingGI.ClearBakedData(paramsJson, request.id);
}
else if (method == "unity.lighting.setLightmapSettings")
{
return LightingGI.SetLightmapSettings(paramsJson, request.id);
}
else if (method == "unity.lighting.createLightProbeGroup")
{
return LightingGI.CreateLightProbeGroup(paramsJson, request.id);
}
else if (method == "unity.lighting.autoPlaceLightProbes")
{
return LightingGI.AutoPlaceLightProbes(paramsJson, request.id);
}
else if (method == "unity.lighting.enableAPV")
{
return LightingGI.EnableAPV(paramsJson, request.id);
}
else if (method == "unity.lighting.getGIStatus")
{
return LightingGI.GetGIStatus(paramsJson, request.id);
}
else if (method == "unity.lighting.cancelBake")
{
return LightingGI.CancelBake(paramsJson, request.id);
}
// Phase 5: Reflection Probes
else if (method == "unity.lighting.createReflectionProbe")
{
return LightingReflection.CreateReflectionProbe(paramsJson, request.id);
}
else if (method == "unity.lighting.setReflectionProbeType")
{
return LightingReflection.SetReflectionProbeType(paramsJson, request.id);
}
else if (method == "unity.lighting.setReflectionProbeSettings")
{
return LightingReflection.SetReflectionProbeSettings(paramsJson, request.id);
}
else if (method == "unity.lighting.bakeReflectionProbes")
{
return LightingReflection.BakeReflectionProbes(paramsJson, request.id);
}
else if (method == "unity.lighting.autoPlaceReflectionProbes")
{
return LightingReflection.AutoPlaceReflectionProbes(paramsJson, request.id);
}
else if (method == "unity.lighting.setReflectionIntensity")
{
return LightingReflection.SetReflectionIntensity(paramsJson, request.id);
}
else if (method == "unity.lighting.listReflectionProbes")
{
return LightingReflection.ListReflectionProbes(paramsJson, request.id);
}
// Phase 7: Project Settings Optimization
else if (method == "unity.lighting.detectRenderPipeline")
{
return LightingProjectSettings.DetectRenderPipeline(paramsJson, request.id);
}
else if (method == "unity.lighting.optimizeForScale")
{
return LightingProjectSettings.OptimizeForScale(paramsJson, request.id);
}
else if (method == "unity.lighting.setQualityPreset")
{
return LightingProjectSettings.SetQualityPreset(paramsJson, request.id);
}
else if (method == "unity.lighting.analyzeScene")
{
return LightingProjectSettings.AnalyzeScene(paramsJson, request.id);
}
else if (method == "unity.lighting.getOptimizationSuggestions")
{
return LightingProjectSettings.GetOptimizationSuggestions(paramsJson, request.id);
}
else if (method == "unity.lighting.listScalePresets")
{
return LightingProjectSettings.ListScalePresets(paramsJson, request.id);
}
// ShaderGraph APIs (Reflection-based)
else if (method == "unity.shaderGraph.create")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ShaderGraph, PackageTypes.ShaderGraphBuilder, "CreateShaderGraph", paramsJson, request.id);
}
else if (method == "unity.shaderGraph.getInfo")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ShaderGraph, PackageTypes.ShaderGraphBuilder, "GetShaderGraphInfo", paramsJson, request.id);
}
else if (method == "unity.shaderGraph.getNodes")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ShaderGraph, PackageTypes.ShaderGraphBuilder, "GetNodes", paramsJson, request.id);
}
else if (method == "unity.shaderGraph.getProperties")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ShaderGraph, PackageTypes.ShaderGraphBuilder, "GetProperties", paramsJson, request.id);
}
else if (method == "unity.shaderGraph.getConnections")
{
return PackageApiInvoker.Invoke(PackageAssemblies.ShaderGraph, PackageTypes.ShaderGraphBuilder, "GetConnections", paramsJson, request.id);
}
// ============================================
// Debug Diagnostics APIs
// ============================================
else if (method == "unity.debug.diagnose")
{
return DebugDiagnostics.Diagnose(paramsJson, request.id);
}
else if (method == "unity.debug.findProblematicObjects")
{
return DebugDiagnostics.FindProblematicObjects(paramsJson, request.id);
}
else if (method == "unity.debug.inspectObject")
{
return DebugDiagnostics.InspectObject(paramsJson, request.id);
}
else if (method == "unity.debug.analyzeErrorLogs")
{
return ErrorLogAnalyzer.AnalyzeErrorLogs(paramsJson, request.id);
}
else if (method == "unity.debug.generateReport")
{
return DiagnosticReportGenerator.GenerateReport(paramsJson, request.id);
}
// ============================================
// TextMeshPro APIs
// ============================================
else if (method == "unity.textmeshpro.create")
{
return TextMeshProController.Create(paramsJson, request.id);
}
else if (method == "unity.textmeshpro.setText")
{
return TextMeshProController.SetText(paramsJson, request.id);
}
else if (method == "unity.textmeshpro.setStyle")
{
return TextMeshProController.SetStyle(paramsJson, request.id);
}
else if (method == "unity.textmeshpro.setLayout")
{
return TextMeshProController.SetLayout(paramsJson, request.id);
}
else if (method == "unity.textmeshpro.setAutoSize")
{
return TextMeshProController.SetAutoSize(paramsJson, request.id);
}
else if (method == "unity.textmeshpro.setOverflow")
{
return TextMeshProController.SetOverflow(paramsJson, request.id);
}
else if (method == "unity.textmeshpro.setFont")
{
return TextMeshProController.SetFont(paramsJson, request.id);
}
else if (method == "unity.textmeshpro.getInfo")
{
return TextMeshProController.GetInfo(paramsJson, request.id);
}
else if (method == "unity.textmeshpro.getFontAssetInfo")
{
return TextMeshProController.GetFontAssetInfo(paramsJson, request.id);
}
else if (method == "unity.textmeshpro.listFontAssets")
{
return TextMeshProController.ListFontAssets(paramsJson, request.id);
}
else if (method == "unity.textmeshpro.createMultiple")
{
return TextMeshProController.CreateMultiple(paramsJson, request.id);
}
// TextMeshPro Presets
else if (method == "unity.textmeshpro.preset.title")
{
return TextMeshProPresets.PresetTitle(paramsJson, request.id);
}
else if (method == "unity.textmeshpro.preset.body")
{
return TextMeshProPresets.PresetBody(paramsJson, request.id);
}
else if (method == "unity.textmeshpro.preset.button")
{
return TextMeshProPresets.PresetButton(paramsJson, request.id);
}
else if (method == "unity.textmeshpro.preset.hud")
{
return TextMeshProPresets.PresetHud(paramsJson, request.id);
}
// uGUI - RectTransform APIs
else if (method == "unity.rectTransform.setSize")
{
return uGUIController.SetSize(paramsJson, request.id);
}
else if (method == "unity.rectTransform.setPosition")
{
return uGUIController.SetPosition(paramsJson, request.id);
}
else if (method == "unity.rectTransform.setAnchors")
{
return uGUIController.SetAnchors(paramsJson, request.id);
}
else if (method == "unity.rectTransform.setPivot")
{
return uGUIController.SetPivot(paramsJson, request.id);
}
else if (method == "unity.rectTransform.setOffsets")
{
return uGUIController.SetOffsets(paramsJson, request.id);
}
else if (method == "unity.rectTransform.getInfo")
{
return uGUIController.GetInfo(paramsJson, request.id);
}
// uGUI - Canvas APIs
else if (method == "unity.canvas.create")
{
return uGUIController.CreateCanvas(paramsJson, request.id);
}
else if (method == "unity.canvas.setScaler")
{
return uGUIController.SetScaler(paramsJson, request.id);
}
else if (method == "unity.canvas.getInfo")
{
return uGUIController.GetCanvasInfo(paramsJson, request.id);
}
// uGUI - UI Element Presets
else if (method == "unity.ui.createButton")
{
return uGUIController.CreateButton(paramsJson, request.id);
}
else if (method == "unity.ui.createPanel")
{
return uGUIController.CreatePanel(paramsJson, request.id);
}
else if (method == "unity.ui.createImage")
{
return uGUIController.CreateImage(paramsJson, request.id);
}
else if (method == "unity.ui.createText")
{
return uGUIController.CreateText(paramsJson, request.id);
}
// ============================================
// Material APIs
// ============================================
else if (method == "unity.material.getInfo")
{
return MaterialController.GetInfo(paramsJson, request.id);
}
else if (method == "unity.material.getProperty")
{
return MaterialController.GetProperty(paramsJson, request.id);
}
else if (method == "unity.material.setProperty")
{
return MaterialController.SetProperty(paramsJson, request.id);
}
else if (method == "unity.material.setColor")
{
return MaterialController.SetColor(paramsJson, request.id);
}
else if (method == "unity.material.setFloat")
{
return MaterialController.SetFloat(paramsJson, request.id);
}
else if (method == "unity.material.setVector")
{
return MaterialController.SetVector(paramsJson, request.id);
}
else if (method == "unity.material.setTexture")
{
return MaterialController.SetTexture(paramsJson, request.id);
}
else if (method == "unity.material.setKeyword")
{
return MaterialController.SetKeyword(paramsJson, request.id);
}
else if (method == "unity.material.setRenderQueue")
{
return MaterialController.SetRenderQueue(paramsJson, request.id);
}
else if (method == "unity.material.listProperties")
{
return MaterialController.ListProperties(paramsJson, request.id);
}
else if (method == "unity.material.create")
{
return MaterialController.Create(paramsJson, request.id);
}
else if (method == "unity.material.copyProperties")
{
return MaterialController.CopyProperties(paramsJson, request.id);
}
// ============================================
// Shader APIs
// ============================================
// Core Shader APIs
else if (method == "unity.shader.getInfo")
{
return ShaderController.GetInfo(paramsJson, request.id);
}
else if (method == "unity.shader.reimport")
{
return ShaderController.Reimport(paramsJson, request.id);
}
else if (method == "unity.shader.getCompileErrors")
{
return ShaderController.GetCompileErrors(paramsJson, request.id);
}
else if (method == "unity.shader.listAll")
{
return ShaderController.ListAll(paramsJson, request.id);
}
else if (method == "unity.shader.find")
{
return ShaderController.Find(paramsJson, request.id);
}
// TextMeshPro Shader APIs
else if (method == "unity.shader.tmp.listPresets")
{
return ShaderController.TMPListPresets(paramsJson, request.id);
}
else if (method == "unity.shader.tmp.applyDistanceField")
{
return ShaderController.TMPApplyDistanceField(paramsJson, request.id);
}
else if (method == "unity.shader.tmp.setOutline")
{
return ShaderController.TMPSetOutline(paramsJson, request.id);
}
else if (method == "unity.shader.tmp.setGlow")
{
return ShaderController.TMPSetGlow(paramsJson, request.id);
}
else if (method == "unity.shader.tmp.setBevel")
{
return ShaderController.TMPSetBevel(paramsJson, request.id);
}
else if (method == "unity.shader.tmp.setUnderlay")
{
return ShaderController.TMPSetUnderlay(paramsJson, request.id);
}
// UI Shader APIs
else if (method == "unity.shader.ui.listPresets")
{
return ShaderController.UIListPresets(paramsJson, request.id);
}
else if (method == "unity.shader.ui.applyDefault")
{
return ShaderController.UIApplyDefault(paramsJson, request.id);
}
else if (method == "unity.shader.ui.setMask")
{
return ShaderController.UISetMask(paramsJson, request.id);
}
else if (method == "unity.shader.ui.setStencil")
{
return ShaderController.UISetStencil(paramsJson, request.id);
}
// Particle Shader APIs
else if (method == "unity.shader.particle.listPresets")
{
return ShaderController.ParticleListPresets(paramsJson, request.id);
}
else if (method == "unity.shader.particle.applyShader")
{
return ShaderController.ParticleApplyShader(paramsJson, request.id);
}
else if (method == "unity.shader.particle.setBlendMode")
{
return ShaderController.ParticleSetBlendMode(paramsJson, request.id);
}
// Skybox Shader APIs
else if (method == "unity.shader.skybox.listPresets")
{
return ShaderController.SkyboxListPresets(paramsJson, request.id);
}
else if (method == "unity.shader.skybox.applyProcedural")
{
return ShaderController.SkyboxApplyProcedural(paramsJson, request.id);
}
else if (method == "unity.shader.skybox.applyCubemap")
{
return ShaderController.SkyboxApplyCubemap(paramsJson, request.id);
}
else if (method == "unity.shader.skybox.applyPanoramic")
{
return ShaderController.SkyboxApplyPanoramic(paramsJson, request.id);
}
// Sprite Shader APIs
else if (method == "unity.shader.sprite.listPresets")
{
return ShaderController.SpriteListPresets(paramsJson, request.id);
}
else if (method == "unity.shader.sprite.applyShader")
{
return ShaderController.SpriteApplyShader(paramsJson, request.id);
}
// ============ Camera APIs ============
else if (method == "unity.camera.create")
{
return CameraController.CreateCamera(paramsJson, request.id);
}
else if (method == "unity.camera.delete")
{
return CameraController.DeleteCamera(paramsJson, request.id);
}
else if (method == "unity.camera.list")
{
return CameraController.ListCameras(paramsJson, request.id);
}
else if (method == "unity.camera.getInfo")
{
return CameraController.GetCameraInfo(paramsJson, request.id);
}
else if (method == "unity.camera.setProperty")
{
return CameraController.SetCameraProperty(paramsJson, request.id);
}
else if (method == "unity.camera.setViewport")
{
return CameraController.SetViewport(paramsJson, request.id);
}
else if (method == "unity.camera.setTargetDisplay")
{
return CameraController.SetTargetDisplay(paramsJson, request.id);
}
else if (method == "unity.camera.setCullingMask")
{
return CameraController.SetCullingMask(paramsJson, request.id);
}
else if (method == "unity.camera.setRenderingPath")
{
return CameraController.SetRenderingPath(paramsJson, request.id);
}
// ============================================
// Audio APIs (Direct call - Core Unity feature)
// ============================================
// AudioSource APIs
else if (method == "unity.audio.createSource")
{
return AudioController.CreateSource(paramsJson, request.id);
}
else if (method == "unity.audio.deleteSource")
{
return AudioController.DeleteSource(paramsJson, request.id);
}
else if (method == "unity.audio.play")
{
return AudioController.Play(paramsJson, request.id);
}
else if (method == "unity.audio.stop")
{
return AudioController.Stop(paramsJson, request.id);
}
else if (method == "unity.audio.pause")
{
return AudioController.Pause(paramsJson, request.id);
}
else if (method == "unity.audio.setClip")
{
return AudioController.SetClip(paramsJson, request.id);
}
else if (method == "unity.audio.setProperty")
{
return AudioController.SetProperty(paramsJson, request.id);
}
else if (method == "unity.audio.getInfo")
{
return AudioController.GetInfo(paramsJson, request.id);
}
else if (method == "unity.audio.list")
{
return AudioController.ListSources(paramsJson, request.id);
}
// AudioMixer APIs
else if (method == "unity.audio.loadMixer")
{
return AudioController.LoadMixer(paramsJson, request.id);
}
else if (method == "unity.audio.setMixerFloat")
{
return AudioController.SetMixerFloat(paramsJson, request.id);
}
else if (method == "unity.audio.getMixerFloat")
{
return AudioController.GetMixerFloat(paramsJson, request.id);
}
else if (method == "unity.audio.listMixerGroups")
{
return AudioController.ListMixerGroups(paramsJson, request.id);
}
// AudioClip APIs
else if (method == "unity.audio.listClips")
{
return AudioController.ListClips(paramsJson, request.id);
}
else if (method == "unity.audio.getClipInfo")
{
return AudioController.GetClipInfo(paramsJson, request.id);
}
else if (method == "unity.audio.importClip")
{
return AudioController.ImportClip(paramsJson, request.id);
}
// AudioListener APIs
else if (method == "unity.audio.createListener")
{
return AudioController.CreateListener(paramsJson, request.id);
}
else if (method == "unity.audio.deleteListener")
{
return AudioController.DeleteListener(paramsJson, request.id);
}
else if (method == "unity.audio.listListeners")
{
return AudioController.ListListeners(paramsJson, request.id);
}
else if (method == "unity.audio.getListenerInfo")
{
return AudioController.GetListenerInfo(paramsJson, request.id);
}
else if (method == "unity.audio.setListenerProperty")
{
return AudioController.SetListenerProperty(paramsJson, request.id);
}
// AudioMixer Extended APIs - グループ操作
else if (method == "unity.audio.createMixerGroup")
{
return AudioController.CreateMixerGroup(paramsJson, request.id);
}
else if (method == "unity.audio.deleteMixerGroup")
{
return AudioController.DeleteMixerGroup(paramsJson, request.id);
}
else if (method == "unity.audio.renameMixerGroup")
{
return AudioController.RenameMixerGroup(paramsJson, request.id);
}
else if (method == "unity.audio.setGroupVolume")
{
return AudioController.SetGroupVolume(paramsJson, request.id);
}
else if (method == "unity.audio.setGroupOutput")
{
return AudioController.SetGroupOutput(paramsJson, request.id);
}
// AudioMixer Extended APIs - エフェクト操作
else if (method == "unity.audio.addEffect")
{
return AudioController.AddEffect(paramsJson, request.id);
}
else if (method == "unity.audio.removeEffect")
{
return AudioController.RemoveEffect(paramsJson, request.id);
}
else if (method == "unity.audio.moveEffect")
{
return AudioController.MoveEffect(paramsJson, request.id);
}
else if (method == "unity.audio.listEffects")
{
return AudioController.ListEffects(paramsJson, request.id);
}
else if (method == "unity.audio.setEffectParameter")
{
return AudioController.SetEffectParameter(paramsJson, request.id);
}
else if (method == "unity.audio.getEffectParameter")
{
return AudioController.GetEffectParameter(paramsJson, request.id);
}
else if (method == "unity.audio.listEffectTypes")
{
return AudioController.ListEffectTypes(paramsJson, request.id);
}
// AudioMixer Extended APIs - スナップショット操作
else if (method == "unity.audio.createSnapshot")
{
return AudioController.CreateSnapshot(paramsJson, request.id);
}
else if (method == "unity.audio.deleteSnapshot")
{
return AudioController.DeleteSnapshot(paramsJson, request.id);
}
else if (method == "unity.audio.listSnapshots")
{
return AudioController.ListSnapshots(paramsJson, request.id);
}
else if (method == "unity.audio.transitionToSnapshot")
{
return AudioController.TransitionToSnapshot(paramsJson, request.id);
}
// AudioMixer Extended APIs - センド操作
else if (method == "unity.audio.addSend")
{
return AudioController.AddSend(paramsJson, request.id);
}
else if (method == "unity.audio.setSendLevel")
{
return AudioController.SetSendLevel(paramsJson, request.id);
}
// ============ Material Apply APIs ============
else if (method == "unity.material.apply")
{
return MaterialController.Apply(paramsJson, request.id);
}
else if (method == "unity.material.getFromObject")
{
return MaterialController.GetFromObject(paramsJson, request.id);
}
else if (method == "unity.material.listFromObject")
{
return MaterialController.ListFromObject(paramsJson, request.id);
}
else if (method == "unity.material.setSharedMaterial")
{
return MaterialController.SetSharedMaterial(paramsJson, request.id);
}
// ============ Renderer APIs ============
else if (method == "unity.renderer.setMaterial")
{
return MaterialController.SetRendererMaterial(paramsJson, request.id);
}
#if UNITY_2021_2_OR_NEWER
// ============ UIToolkit APIs ============
else if (method == "unity.uitoolkit.createUIDocument")
{
return UIToolkitAssetCreator.CreateUIDocument(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.createStyleSheet")
{
return UIToolkitAssetCreator.CreateStyleSheet(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.createPanelSettings")
{
return UIToolkitAssetCreator.CreatePanelSettings(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.addUIDocumentComponent")
{
return UIToolkitAssetCreator.AddUIDocumentComponent(paramsJson, request.id);
}
#endif // UNITY_2021_2_OR_NEWER
// ============ Build API ============
else if (method == "unity.build.buildPlayer")
{
return BuildPipelineController.BuildPlayer(paramsJson, request.id);
}
// ============ Volume APIs (Reflection-based) ============
else if (method == "unity.volume.create")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "CreateVolume", paramsJson, request.id);
}
else if (method == "unity.volume.createProfile")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "CreateProfile", paramsJson, request.id);
}
else if (method == "unity.volume.assignProfile")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "AssignProfile", paramsJson, request.id);
}
else if (method == "unity.volume.delete")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "DeleteVolume", paramsJson, request.id);
}
else if (method == "unity.volume.list")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "ListVolumes", paramsJson, request.id);
}
else if (method == "unity.volume.getInfo")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "GetVolumeInfo", paramsJson, request.id);
}
else if (method == "unity.volume.setBloom")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetBloom", paramsJson, request.id);
}
else if (method == "unity.volume.setVignette")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetVignette", paramsJson, request.id);
}
else if (method == "unity.volume.setColorAdjustments")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetColorAdjustments", paramsJson, request.id);
}
else if (method == "unity.volume.setDepthOfField")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetDepthOfField", paramsJson, request.id);
}
else if (method == "unity.volume.setMotionBlur")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetMotionBlur", paramsJson, request.id);
}
else if (method == "unity.volume.setToneMapping")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetToneMapping", paramsJson, request.id);
}
else if (method == "unity.volume.setFilmGrain")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetFilmGrain", paramsJson, request.id);
}
else if (method == "unity.volume.setChromaticAberration")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetChromaticAberration", paramsJson, request.id);
}
else if (method == "unity.volume.setLensDistortion")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetLensDistortion", paramsJson, request.id);
}
else if (method == "unity.volume.setWhiteBalance")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "SetWhiteBalance", paramsJson, request.id);
}
else if (method == "unity.volume.applyPreset")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "ApplyPreset", paramsJson, request.id);
}
else if (method == "unity.volume.removeOverride")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Volume, PackageTypes.VolumeController, "RemoveOverride", paramsJson, request.id);
}
// ============ InputSystem APIs (Reflection-based) ============
// Asset APIs
else if (method == "unity.inputsystem.createAsset")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "CreateAsset", paramsJson, request.id);
}
else if (method == "unity.inputsystem.deleteAsset")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "DeleteAsset", paramsJson, request.id);
}
else if (method == "unity.inputsystem.getAsset")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "GetAsset", paramsJson, request.id);
}
else if (method == "unity.inputsystem.listAssets")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "ListAssets", paramsJson, request.id);
}
// ActionMap APIs
else if (method == "unity.inputsystem.addActionMap")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "AddActionMap", paramsJson, request.id);
}
else if (method == "unity.inputsystem.removeActionMap")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "RemoveActionMap", paramsJson, request.id);
}
else if (method == "unity.inputsystem.getActionMap")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "GetActionMap", paramsJson, request.id);
}
// Action APIs
else if (method == "unity.inputsystem.addAction")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "AddAction", paramsJson, request.id);
}
else if (method == "unity.inputsystem.removeAction")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "RemoveAction", paramsJson, request.id);
}
else if (method == "unity.inputsystem.getAction")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "GetAction", paramsJson, request.id);
}
// Binding APIs
else if (method == "unity.inputsystem.addBinding")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "AddBinding", paramsJson, request.id);
}
else if (method == "unity.inputsystem.removeBinding")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "RemoveBinding", paramsJson, request.id);
}
else if (method == "unity.inputsystem.addCompositeBinding")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "AddCompositeBinding", paramsJson, request.id);
}
// ControlScheme APIs
else if (method == "unity.inputsystem.addControlScheme")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "AddControlScheme", paramsJson, request.id);
}
else if (method == "unity.inputsystem.removeControlScheme")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "RemoveControlScheme", paramsJson, request.id);
}
else if (method == "unity.inputsystem.listControlSchemes")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "ListControlSchemes", paramsJson, request.id);
}
// Device APIs
else if (method == "unity.inputsystem.listDevices")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "ListDevices", paramsJson, request.id);
}
else if (method == "unity.inputsystem.listLayouts")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "ListLayouts", paramsJson, request.id);
}
// Utility APIs
else if (method == "unity.inputsystem.generateScript")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "GenerateScript", paramsJson, request.id);
}
else if (method == "unity.inputsystem.addPlayerInput")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemControl, "AddPlayerInput", paramsJson, request.id);
}
// InputSystem Setup APIs (Platform Presets)
else if (method == "unity.inputsystem.setup.desktop")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "SetupDesktop", paramsJson, request.id);
}
else if (method == "unity.inputsystem.setup.mobile")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "SetupMobile", paramsJson, request.id);
}
else if (method == "unity.inputsystem.setup.console")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "SetupConsole", paramsJson, request.id);
}
else if (method == "unity.inputsystem.setup.vr")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "SetupVR", paramsJson, request.id);
}
// InputSystem Game Genre Presets
else if (method == "unity.inputsystem.preset.fps")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "PresetFPS", paramsJson, request.id);
}
else if (method == "unity.inputsystem.preset.thirdPerson")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "PresetThirdPerson", paramsJson, request.id);
}
else if (method == "unity.inputsystem.preset.platformer")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "PresetPlatformer", paramsJson, request.id);
}
else if (method == "unity.inputsystem.preset.ui")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "PresetUI", paramsJson, request.id);
}
// InputSystem Settings Management
else if (method == "unity.inputsystem.settings.get")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "GetSettings", paramsJson, request.id);
}
else if (method == "unity.inputsystem.settings.set")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "SetSettings", paramsJson, request.id);
}
else if (method == "unity.inputsystem.settings.reset")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "ResetSettings", paramsJson, request.id);
}
else if (method == "unity.inputsystem.setInputHandling")
{
return PackageApiInvoker.Invoke(PackageAssemblies.InputSystem, PackageTypes.InputSystemSetup, "SetInputHandling", paramsJson, request.id);
}
// ============ Recorder APIs (Reflection-based) ============
else if (method == "unity.recorder.createSession")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "CreateSession", paramsJson, request.id);
}
else if (method == "unity.recorder.prepareRecording")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "PrepareRecording", paramsJson, request.id);
}
else if (method == "unity.recorder.startRecording")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "StartRecording", paramsJson, request.id);
}
else if (method == "unity.recorder.stopRecording")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "StopRecording", paramsJson, request.id);
}
else if (method == "unity.recorder.isRecording")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "IsRecording", paramsJson, request.id);
}
else if (method == "unity.recorder.getStatus")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "GetStatus", paramsJson, request.id);
}
else if (method == "unity.recorder.setFrameRate")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "SetFrameRate", paramsJson, request.id);
}
else if (method == "unity.recorder.setRecordModeManual")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "SetRecordModeManual", paramsJson, request.id);
}
else if (method == "unity.recorder.setRecordModeFrameInterval")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "SetRecordModeFrameInterval", paramsJson, request.id);
}
else if (method == "unity.recorder.setRecordModeTimeInterval")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "SetRecordModeTimeInterval", paramsJson, request.id);
}
else if (method == "unity.recorder.setRecordModeSingleFrame")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "SetRecordModeSingleFrame", paramsJson, request.id);
}
else if (method == "unity.recorder.createMovieRecorder")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "CreateMovieRecorder", paramsJson, request.id);
}
else if (method == "unity.recorder.createImageRecorder")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "CreateImageRecorder", paramsJson, request.id);
}
else if (method == "unity.recorder.createAnimationRecorder")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "CreateAnimationRecorder", paramsJson, request.id);
}
else if (method == "unity.recorder.listRecorderSettings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "ListRecorderSettings", paramsJson, request.id);
}
else if (method == "unity.recorder.clearSession")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "ClearSession", paramsJson, request.id);
}
else if (method == "unity.recorder.setCapFrameRate")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "SetCapFrameRate", paramsJson, request.id);
}
// Recorder Preset APIs
else if (method == "unity.recorder.preset.qaTestVideo")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "PresetQaTestVideo", paramsJson, request.id);
}
else if (method == "unity.recorder.preset.gifCapture")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "PresetGifCapture", paramsJson, request.id);
}
else if (method == "unity.recorder.preset.thumbnailSequence")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "PresetThumbnailSequence", paramsJson, request.id);
}
else if (method == "unity.recorder.preset.cinematicExport")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "PresetCinematicExport", paramsJson, request.id);
}
else if (method == "unity.recorder.preset.motionCapture")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "PresetMotionCapture", paramsJson, request.id);
}
else if (method == "unity.recorder.preset.audioCapture")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Recorder, PackageTypes.RecorderController, "PresetAudioCapture", paramsJson, request.id);
}
// ============ Cinemachine APIs (Reflection-based) ============
else if (method == "unity.cinemachine.createVirtualCamera")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineControl, "CreateVirtualCamera", paramsJson, request.id);
}
else if (method == "unity.cinemachine.deleteVirtualCamera")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineControl, "DeleteVirtualCamera", paramsJson, request.id);
}
else if (method == "unity.cinemachine.listVirtualCameras")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineControl, "ListVirtualCameras", paramsJson, request.id);
}
else if (method == "unity.cinemachine.setVirtualCameraTarget")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineControl, "SetVirtualCameraTarget", paramsJson, request.id);
}
else if (method == "unity.cinemachine.setVirtualCameraPriority")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineControl, "SetVirtualCameraPriority", paramsJson, request.id);
}
else if (method == "unity.cinemachine.getVirtualCameraInfo")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineControl, "GetVirtualCameraInfo", paramsJson, request.id);
}
// Cinemachine Body/Aim APIs
else if (method == "unity.cinemachine.setBodyType")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineBodyAim, "SetBodyType", paramsJson, request.id);
}
else if (method == "unity.cinemachine.setAimType")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineBodyAim, "SetAimType", paramsJson, request.id);
}
else if (method == "unity.cinemachine.setFollowOffset")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineBodyAim, "SetFollowOffset", paramsJson, request.id);
}
else if (method == "unity.cinemachine.setDamping")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineBodyAim, "SetDamping", paramsJson, request.id);
}
else if (method == "unity.cinemachine.setDeadZone")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineBodyAim, "SetDeadZone", paramsJson, request.id);
}
else if (method == "unity.cinemachine.setSoftZone")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineBodyAim, "SetSoftZone", paramsJson, request.id);
}
// Cinemachine Advanced APIs
else if (method == "unity.cinemachine.createFreeLookCamera")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineAdvanced, "CreateFreeLookCamera", paramsJson, request.id);
}
else if (method == "unity.cinemachine.setFreeLookRig")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineAdvanced, "SetFreeLookRig", paramsJson, request.id);
}
else if (method == "unity.cinemachine.createBlendListCamera")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineAdvanced, "CreateBlendListCamera", paramsJson, request.id);
}
else if (method == "unity.cinemachine.createClearShot")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineAdvanced, "CreateClearShot", paramsJson, request.id);
}
// Cinemachine Dolly APIs
else if (method == "unity.cinemachine.createDollyTrack")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineDolly, "CreateDollyTrack", paramsJson, request.id);
}
else if (method == "unity.cinemachine.addDollyWaypoint")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineDolly, "AddDollyWaypoint", paramsJson, request.id);
}
else if (method == "unity.cinemachine.updateDollyWaypoint")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineDolly, "UpdateDollyWaypoint", paramsJson, request.id);
}
else if (method == "unity.cinemachine.removeDollyWaypoint")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineDolly, "RemoveDollyWaypoint", paramsJson, request.id);
}
else if (method == "unity.cinemachine.getDollyTrackInfo")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineDolly, "GetDollyTrackInfo", paramsJson, request.id);
}
else if (method == "unity.cinemachine.createDollyCamera")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineDolly, "CreateDollyCamera", paramsJson, request.id);
}
else if (method == "unity.cinemachine.setDollyPathPosition")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineDolly, "SetDollyPathPosition", paramsJson, request.id);
}
else if (method == "unity.cinemachine.setDollyLoopMode")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineDolly, "SetDollyLoopMode", paramsJson, request.id);
}
// Cinemachine Transition APIs
else if (method == "unity.cinemachine.setBrainSettings")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineTransition, "SetBrainSettings", paramsJson, request.id);
}
else if (method == "unity.cinemachine.setDefaultBlend")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineTransition, "SetDefaultBlend", paramsJson, request.id);
}
else if (method == "unity.cinemachine.setCustomBlend")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineTransition, "SetCustomBlend", paramsJson, request.id);
}
else if (method == "unity.cinemachine.triggerCameraSwitch")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineTransition, "TriggerCameraSwitch", paramsJson, request.id);
}
// Cinemachine Group APIs
else if (method == "unity.cinemachine.createTargetGroup")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "CreateTargetGroup", paramsJson, request.id);
}
else if (method == "unity.cinemachine.addTargetGroupMember")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "AddTargetGroupMember", paramsJson, request.id);
}
else if (method == "unity.cinemachine.removeTargetGroupMember")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "RemoveTargetGroupMember", paramsJson, request.id);
}
else if (method == "unity.cinemachine.updateTargetGroupMember")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "UpdateTargetGroupMember", paramsJson, request.id);
}
else if (method == "unity.cinemachine.getTargetGroupInfo")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "GetTargetGroupInfo", paramsJson, request.id);
}
else if (method == "unity.cinemachine.createGroupCamera")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "CreateGroupCamera", paramsJson, request.id);
}
else if (method == "unity.cinemachine.setGroupFramingMode")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "SetGroupFramingMode", paramsJson, request.id);
}
else if (method == "unity.cinemachine.setGroupFramingSize")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "SetGroupFramingSize", paramsJson, request.id);
}
else if (method == "unity.cinemachine.frameTargets")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "FrameTargets", paramsJson, request.id);
}
else if (method == "unity.cinemachine.frameAllTargets")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineGroup, "FrameAllTargets", paramsJson, request.id);
}
// Cinemachine Effects APIs
else if (method == "unity.cinemachine.createCameraShake")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineEffects, "CreateCameraShake", paramsJson, request.id);
}
else if (method == "unity.cinemachine.triggerImpulse")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineEffects, "TriggerImpulse", paramsJson, request.id);
}
else if (method == "unity.cinemachine.setNoiseProfile")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineEffects, "SetNoiseProfile", paramsJson, request.id);
}
else if (method == "unity.cinemachine.createConfiner")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineEffects, "CreateConfiner", paramsJson, request.id);
}
else if (method == "unity.cinemachine.setScreenComposition")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachineEffects, "SetScreenComposition", paramsJson, request.id);
}
// Cinemachine Presets APIs
else if (method == "unity.cinemachine.applyPreset")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachinePresets, "ApplyPreset", paramsJson, request.id);
}
else if (method == "unity.cinemachine.createCinematicShot")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachinePresets, "CreateCinematicShot", paramsJson, request.id);
}
else if (method == "unity.cinemachine.saveCameraState")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachinePresets, "SaveCameraState", paramsJson, request.id);
}
else if (method == "unity.cinemachine.loadCameraState")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Cinemachine, PackageTypes.CinemachinePresets, "LoadCameraState", paramsJson, request.id);
}
// ============ API Logger APIs ============
else if (method == "unity.apilog.getLogs")
{
return McpApiLogger.GetLogs(paramsJson, request.id);
}
else if (method == "unity.apilog.getErrors")
{
return McpApiLogger.GetErrors(paramsJson, request.id);
}
else if (method == "unity.apilog.getStats")
{
return McpApiLogger.GetStats(paramsJson, request.id);
}
else if (method == "unity.apilog.clear")
{
return McpApiLogger.ClearLogs(paramsJson, request.id);
}
else if (method == "unity.apilog.configure")
{
return McpApiLogger.Configure(paramsJson, request.id);
}
else if (method == "unity.apilog.getFilePath")
{
return McpApiLogger.GetLogFilePath(paramsJson, request.id);
}
#if UNITY_2021_2_OR_NEWER
// ============ UIToolkit Asset Management APIs ============
else if (method == "unity.uitoolkit.asset.createUxml")
{
return UIToolkitAssetManager.CreateUxml(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.asset.getUxmlContent")
{
return UIToolkitAssetManager.GetUxmlContent(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.asset.updateUxml")
{
return UIToolkitAssetManager.UpdateUxml(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.asset.createUss")
{
return UIToolkitAssetManager.CreateUss(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.asset.getUssContent")
{
return UIToolkitAssetManager.GetUssContent(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.asset.updateUss")
{
return UIToolkitAssetManager.UpdateUss(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.asset.linkStyleSheet")
{
return UIToolkitAssetManager.LinkStyleSheet(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.asset.createPanelSettings")
{
return UIToolkitAssetManager.CreatePanelSettings(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.asset.getPanelSettings")
{
return UIToolkitAssetManager.GetPanelSettings(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.asset.updatePanelSettings")
{
return UIToolkitAssetManager.UpdatePanelSettings(paramsJson, request.id);
}
// ============ UIToolkit Element Builder APIs (Reflection-based) ============
else if (method == "unity.uitoolkit.element.add")
{
return UIToolkitElementBuilder.AddElement(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.element.remove")
{
return UIToolkitElementBuilder.RemoveElement(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.element.update")
{
return UIToolkitElementBuilder.UpdateElement(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.element.query")
{
return UIToolkitElementBuilder.QueryElement(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.element.getHierarchy")
{
return UIToolkitElementBuilder.GetHierarchy(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.element.move")
{
return UIToolkitElementBuilder.MoveElement(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.element.duplicate")
{
return UIToolkitElementBuilder.DuplicateElement(paramsJson, request.id);
}
// ============ UIToolkit ViewModel Generator APIs (Phase 8.2) ============
else if (method == "unity.uitoolkit.viewmodel.create")
{
return UIToolkitViewModelGenerator.CreateViewModel(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.viewmodel.addProperty")
{
return UIToolkitViewModelGenerator.AddProperty(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.viewmodel.addCommand")
{
return UIToolkitViewModelGenerator.AddCommand(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.viewmodel.createFromInterface")
{
return UIToolkitViewModelGenerator.CreateFromInterface(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.viewmodel.generateScript")
{
return UIToolkitViewModelGenerator.GenerateScript(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.viewmodel.list")
{
return UIToolkitViewModelGenerator.ListViewModels(paramsJson, request.id);
}
// ============ UIToolkit Binding Builder APIs (Phase 8.3) ============
else if (method == "unity.uitoolkit.binding.create")
{
return UIToolkitBindingBuilder.CreateBinding(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.binding.add")
{
return UIToolkitBindingBuilder.AddBinding(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.binding.bindCommand")
{
return UIToolkitBindingBuilder.BindCommand(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.binding.bindTwoWay")
{
return UIToolkitBindingBuilder.BindTwoWay(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.binding.bindVisibility")
{
return UIToolkitBindingBuilder.BindVisibility(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.binding.bindEnabled")
{
return UIToolkitBindingBuilder.BindEnabled(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.binding.unbind")
{
return UIToolkitBindingBuilder.Unbind(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.binding.generateScript")
{
return UIToolkitBindingBuilder.GenerateBindingScript(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.binding.list")
{
return UIToolkitBindingBuilder.ListBindings(paramsJson, request.id);
}
// ============ UIToolkit Style Operations APIs (Phase 3) ============
else if (method == "unity.uitoolkit.style.addRule")
{
return UIToolkitStyleOperations.AddRule(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.style.updateRule")
{
return UIToolkitStyleOperations.UpdateRule(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.style.removeRule")
{
return UIToolkitStyleOperations.RemoveRule(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.style.getRule")
{
return UIToolkitStyleOperations.GetRule(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.style.setProperty")
{
return UIToolkitStyleOperations.SetProperty(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.style.removeProperty")
{
return UIToolkitStyleOperations.RemoveProperty(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.style.setVariable")
{
return UIToolkitStyleOperations.SetVariable(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.style.getVariables")
{
return UIToolkitStyleOperations.GetVariables(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.style.setInlineStyle")
{
return UIToolkitStyleOperations.SetInlineStyle(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.style.addClass")
{
return UIToolkitStyleOperations.AddClass(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.style.removeClass")
{
return UIToolkitStyleOperations.RemoveClass(paramsJson, request.id);
}
// ============ UIToolkit Component Templates APIs (Phase 4) ============
else if (method == "unity.uitoolkit.template.createTextField")
{
return UIToolkitComponentTemplates.CreateTextField(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.template.createButton")
{
return UIToolkitComponentTemplates.CreateButton(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.template.createToggle")
{
return UIToolkitComponentTemplates.CreateToggle(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.template.createSlider")
{
return UIToolkitComponentTemplates.CreateSlider(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.template.createDropdown")
{
return UIToolkitComponentTemplates.CreateDropdown(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.template.createCard")
{
return UIToolkitComponentTemplates.CreateCard(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.template.createScrollView")
{
return UIToolkitComponentTemplates.CreateScrollView(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.template.createFoldout")
{
return UIToolkitComponentTemplates.CreateFoldout(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.template.createTabView")
{
return UIToolkitComponentTemplates.CreateTabView(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.template.createListView")
{
return UIToolkitComponentTemplates.CreateListView(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.template.createTreeView")
{
return UIToolkitComponentTemplates.CreateTreeView(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.template.createProgressBar")
{
return UIToolkitComponentTemplates.CreateProgressBar(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.template.createForm")
{
return UIToolkitComponentTemplates.CreateForm(paramsJson, request.id);
}
// ============ UIToolkit Layout Helpers APIs (Phase 5) ============
else if (method == "unity.uitoolkit.layout.createFlexContainer")
{
return UIToolkitLayoutHelpers.CreateFlexContainer(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.layout.createFlexRow")
{
return UIToolkitLayoutHelpers.CreateFlexRow(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.layout.createFlexColumn")
{
return UIToolkitLayoutHelpers.CreateFlexColumn(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.layout.createCenter")
{
return UIToolkitLayoutHelpers.CreateCenter(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.layout.createSpacer")
{
return UIToolkitLayoutHelpers.CreateSpacer(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.layout.createGrid")
{
return UIToolkitLayoutHelpers.CreateGrid(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.layout.createGridItem")
{
return UIToolkitLayoutHelpers.CreateGridItem(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.layout.createScreenLayout")
{
return UIToolkitLayoutHelpers.CreateScreenLayout(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.layout.createAbsolutePosition")
{
return UIToolkitLayoutHelpers.CreateAbsolutePosition(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.layout.generateLayoutStyles")
{
return UIToolkitLayoutHelpers.GenerateLayoutStyles(paramsJson, request.id);
}
// ============ UIToolkit Runtime Operations APIs (Phase 6) ============
else if (method == "unity.uitoolkit.runtime.createUIDocument")
{
return UIToolkitRuntimeOperations.CreateUIDocument(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.runtime.getUIDocument")
{
return UIToolkitRuntimeOperations.GetUIDocument(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.runtime.listUIDocuments")
{
return UIToolkitRuntimeOperations.ListUIDocuments(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.runtime.queryElement")
{
return UIToolkitRuntimeOperations.QueryElement(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.runtime.getHierarchy")
{
return UIToolkitRuntimeOperations.GetRuntimeHierarchy(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.runtime.setElementText")
{
return UIToolkitRuntimeOperations.SetElementText(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.runtime.setElementValue")
{
return UIToolkitRuntimeOperations.SetElementValue(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.runtime.setElementVisibility")
{
return UIToolkitRuntimeOperations.SetElementVisibility(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.runtime.setElementEnabled")
{
return UIToolkitRuntimeOperations.SetElementEnabled(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.runtime.addRuntimeClass")
{
return UIToolkitRuntimeOperations.AddRuntimeClass(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.runtime.removeRuntimeClass")
{
return UIToolkitRuntimeOperations.RemoveRuntimeClass(paramsJson, request.id);
}
// ============ UIToolkit Scene Setup APIs ============
else if (method == "unity.uitoolkit.scene.setupComplete")
{
return UIToolkit.SceneSetup.UIToolkitSceneSetup.SetupComplete(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.scene.setTargetScene")
{
return UIToolkit.SceneSetup.UIToolkitSceneSetup.SetTargetSceneApi(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.scene.getLoadedScenes")
{
return UIToolkit.SceneSetup.UIToolkitSceneSetup.GetLoadedScenes(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.scene.createUIGameObject")
{
return UIToolkit.SceneSetup.UIToolkitSceneSetup.CreateUIGameObject(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.scene.configureUIDocument")
{
return UIToolkit.SceneSetup.UIToolkitSceneSetup.ConfigureUIDocument(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.scene.saveAsPrefab")
{
return UIToolkit.SceneSetup.UIToolkitSceneSetup.SaveAsPrefab(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.scene.instantiateUIPrefab")
{
return UIToolkit.SceneSetup.UIToolkitSceneSetup.InstantiateUIPrefab(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.scene.getUIDocumentsInScene")
{
return UIToolkit.SceneSetup.UIToolkitSceneSetup.GetUIDocumentsInScene(paramsJson, request.id);
}
// ============ UIToolkit Game Presets APIs (Phase 7) ============
else if (method == "unity.uitoolkit.preset.createHUD")
{
return UIToolkitGamePresets.CreateHUD(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createHealthBar")
{
return UIToolkitGamePresets.CreateHealthBar(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createInventory")
{
return UIToolkitGamePresets.CreateInventory(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createQuickSlots")
{
return UIToolkitGamePresets.CreateQuickSlots(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createSkillBar")
{
return UIToolkitGamePresets.CreateSkillBar(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createDialogBox")
{
return UIToolkitGamePresets.CreateDialogBox(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createVirtualJoystick")
{
return UIToolkitGamePresets.CreateVirtualJoystick(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createDPad")
{
return UIToolkitGamePresets.CreateDPad(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createActionButtons")
{
return UIToolkitGamePresets.CreateActionButtons(paramsJson, request.id);
}
// ============ UIToolkit Navigation Presets APIs (Phase 7) ============
else if (method == "unity.uitoolkit.preset.createTabBar")
{
return UIToolkitNavigationPresets.CreateTabBar(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createBottomNavigation")
{
return UIToolkitNavigationPresets.CreateBottomNavigation(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createSidebar")
{
return UIToolkitNavigationPresets.CreateSidebar(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createBreadcrumb")
{
return UIToolkitNavigationPresets.CreateBreadcrumb(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createPagination")
{
return UIToolkitNavigationPresets.CreatePagination(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createContextMenu")
{
return UIToolkitNavigationPresets.CreateContextMenu(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createDropdownMenu")
{
return UIToolkitNavigationPresets.CreateDropdownMenu(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createNavbar")
{
return UIToolkitNavigationPresets.CreateNavbar(paramsJson, request.id);
}
// ============ UIToolkit Notification Presets APIs (Phase 7) ============
else if (method == "unity.uitoolkit.preset.createPopup")
{
return UIToolkitNotificationPresets.CreatePopup(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createConfirmDialog")
{
return UIToolkitNotificationPresets.CreateConfirmDialog(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createBanner")
{
return UIToolkitNotificationPresets.CreateBanner(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createToast")
{
return UIToolkitNotificationPresets.CreateToast(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createToastContainer")
{
return UIToolkitNotificationPresets.CreateToastContainer(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createAlertBar")
{
return UIToolkitNotificationPresets.CreateAlertBar(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createTooltip")
{
return UIToolkitNotificationPresets.CreateTooltip(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createBadge")
{
return UIToolkitNotificationPresets.CreateBadge(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.preset.createLoadingOverlay")
{
return UIToolkitNotificationPresets.CreateLoadingOverlay(paramsJson, request.id);
}
// ============ UIToolkit DI Container APIs (Phase 8.1) ============
else if (method == "unity.uitoolkit.di.createContainer")
{
return UIToolkitDIContainer.CreateContainer(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.di.registerService")
{
return UIToolkitDIContainer.RegisterService(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.di.unregisterService")
{
return UIToolkitDIContainer.UnregisterService(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.di.listServices")
{
return UIToolkitDIContainer.ListServices(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.di.generateContainerScript")
{
return UIToolkitDIContainer.GenerateContainerScript(paramsJson, request.id);
}
// ============ UIToolkit Event Bus APIs (Phase 8.4) ============
else if (method == "unity.uitoolkit.eventbus.create")
{
return UIToolkitEventBus.CreateEventBus(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.eventbus.defineEvent")
{
return UIToolkitEventBus.DefineEvent(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.eventbus.removeEvent")
{
return UIToolkitEventBus.RemoveEvent(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.eventbus.listEvents")
{
return UIToolkitEventBus.ListEvents(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.eventbus.generateScript")
{
return UIToolkitEventBus.GenerateScript(paramsJson, request.id);
}
// ============ UIToolkit State Manager APIs (Phase 8.5) ============
else if (method == "unity.uitoolkit.state.createStore")
{
return UIToolkitStateManager.CreateStore(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.state.addSlice")
{
return UIToolkitStateManager.AddSlice(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.state.addAction")
{
return UIToolkitStateManager.AddAction(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.state.removeSlice")
{
return UIToolkitStateManager.RemoveSlice(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.state.listSlices")
{
return UIToolkitStateManager.ListSlices(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.state.generateStoreScript")
{
return UIToolkitStateManager.GenerateStoreScript(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.state.createSelector")
{
return UIToolkitStateManager.CreateSelector(paramsJson, request.id);
}
// ============ UIToolkit Animation APIs (Phase 9) ============
else if (method == "unity.uitoolkit.animation.define")
{
return UIToolkitAnimationController.DefineAnimation(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.animation.addKeyframe")
{
return UIToolkitAnimationController.AddKeyframe(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.animation.remove")
{
return UIToolkitAnimationController.RemoveAnimation(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.animation.list")
{
return UIToolkitAnimationController.ListAnimations(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.animation.generateTransitionUSS")
{
return UIToolkitAnimationController.GenerateTransitionUSS(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.animation.createFade")
{
return UIToolkitAnimationController.CreateFadeAnimation(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.animation.createSlide")
{
return UIToolkitAnimationController.CreateSlideAnimation(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.animation.createScale")
{
return UIToolkitAnimationController.CreateScaleAnimation(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.animation.createRotate")
{
return UIToolkitAnimationController.CreateRotateAnimation(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.animation.applyToElement")
{
return UIToolkitAnimationController.ApplyToElement(paramsJson, request.id);
}
// ============ UIToolkit Theme Manager APIs (Phase 10) ============
else if (method == "unity.uitoolkit.theme.create")
{
return UIToolkitThemeManager.CreateTheme(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.theme.setColor")
{
return UIToolkitThemeManager.SetColor(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.theme.setSpacing")
{
return UIToolkitThemeManager.SetSpacing(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.theme.get")
{
return UIToolkitThemeManager.GetTheme(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.theme.list")
{
return UIToolkitThemeManager.ListThemes(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.theme.delete")
{
return UIToolkitThemeManager.DeleteTheme(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.theme.generateUSS")
{
return UIToolkitThemeManager.GenerateUSS(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.theme.generateDarkModeUSS")
{
return UIToolkitThemeManager.GenerateDarkModeUSS(paramsJson, request.id);
}
// ============ UIToolkit Responsive Manager APIs (Phase 11) ============
else if (method == "unity.uitoolkit.responsive.setBreakpoint")
{
return UIToolkitResponsiveManager.SetBreakpoint(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.responsive.getBreakpoints")
{
return UIToolkitResponsiveManager.GetBreakpoints(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.responsive.removeBreakpoint")
{
return UIToolkitResponsiveManager.RemoveBreakpoint(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.responsive.createRuleSet")
{
return UIToolkitResponsiveManager.CreateRuleSet(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.responsive.addBreakpointStyle")
{
return UIToolkitResponsiveManager.AddBreakpointStyle(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.responsive.generateUSS")
{
return UIToolkitResponsiveManager.GenerateUSS(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.responsive.generateHelperScript")
{
return UIToolkitResponsiveManager.GenerateHelperScript(paramsJson, request.id);
}
// ============ UIToolkit Accessibility Manager APIs (Phase 12) ============
else if (method == "unity.uitoolkit.accessibility.setAriaLabel")
{
return UIToolkitAccessibilityManager.SetAriaLabel(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.accessibility.setTabIndex")
{
return UIToolkitAccessibilityManager.SetTabIndex(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.accessibility.setRole")
{
return UIToolkitAccessibilityManager.SetRole(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.accessibility.generateFocusStyles")
{
return UIToolkitAccessibilityManager.GenerateFocusStyles(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.accessibility.checkColorContrast")
{
return UIToolkitAccessibilityManager.CheckColorContrast(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.accessibility.generateScreenReaderHelper")
{
return UIToolkitAccessibilityManager.GenerateScreenReaderHelper(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.accessibility.generateHighContrastUSS")
{
return UIToolkitAccessibilityManager.GenerateHighContrastUSS(paramsJson, request.id);
}
// ============ UIToolkit Localization Manager APIs (Phase 13) ============
else if (method == "unity.uitoolkit.localization.addLocale")
{
return UIToolkitLocalizationManager.AddLocale(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.localization.removeLocale")
{
return UIToolkitLocalizationManager.RemoveLocale(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.localization.listLocales")
{
return UIToolkitLocalizationManager.ListLocales(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.localization.setCurrentLocale")
{
return UIToolkitLocalizationManager.SetCurrentLocale(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.localization.addTranslation")
{
return UIToolkitLocalizationManager.AddTranslation(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.localization.addTranslations")
{
return UIToolkitLocalizationManager.AddTranslations(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.localization.getTranslation")
{
return UIToolkitLocalizationManager.GetTranslation(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.localization.generateScript")
{
return UIToolkitLocalizationManager.GenerateLocalizationScript(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.localization.exportToJson")
{
return UIToolkitLocalizationManager.ExportToJson(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.localization.importFromJson")
{
return UIToolkitLocalizationManager.ImportFromJson(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.localization.generateRTLStyles")
{
return UIToolkitLocalizationManager.GenerateRTLStyles(paramsJson, request.id);
}
// ============ UIToolkit Debug Tools APIs (Phase 14) ============
else if (method == "unity.uitoolkit.debug.analyzeUXML")
{
return UIToolkitDebugTools.AnalyzeUXML(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.debug.analyzeUSS")
{
return UIToolkitDebugTools.AnalyzeUSS(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.debug.validateUXML")
{
return UIToolkitDebugTools.ValidateUXML(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.debug.validateUSS")
{
return UIToolkitDebugTools.ValidateUSS(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.debug.generateDebugOverlay")
{
return UIToolkitDebugTools.GenerateDebugOverlay(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.debug.generateDebugScript")
{
return UIToolkitDebugTools.GenerateDebugScript(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.debug.profileUI")
{
return UIToolkitDebugTools.ProfileUI(paramsJson, request.id);
}
// ============ UIToolkit Asset Dependencies APIs (Phase 15) ============
else if (method == "unity.uitoolkit.dependencies.analyze")
{
return UIToolkitAssetDependencyManager.AnalyzeDependencies(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.dependencies.findReferences")
{
return UIToolkitAssetDependencyManager.FindReferences(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.dependencies.findUnused")
{
return UIToolkitAssetDependencyManager.FindUnusedAssets(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.dependencies.generateGraph")
{
return UIToolkitAssetDependencyManager.GenerateDependencyGraph(paramsJson, request.id);
}
else if (method == "unity.uitoolkit.dependencies.analyzeBundle")
{
return UIToolkitAssetDependencyManager.AnalyzeBundle(paramsJson, request.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, request.id);
}
else if (method == "unity.compositing.setMood")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Compositing, PackageTypes.CompositingController, "SetMood", paramsJson, request.id);
}
else if (method == "unity.compositing.lockExposure")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Compositing, PackageTypes.CompositingController, "LockExposure", paramsJson, request.id);
}
else if (method == "unity.compositing.getLook")
{
return PackageApiInvoker.Invoke(PackageAssemblies.Compositing, PackageTypes.CompositingController, "GetLook", paramsJson, request.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, request.id);
}
else
{
return JsonRpcResponseHelper.MethodNotFound(method, request.id);
}
}
/// <summary>
/// Closes the connection.
/// </summary>
public void Close()
{
if (logStream != null)
{
logStream.Dispose();
logStream = null;
}
isConnected = false;
try
{
if (stream != null)
{
stream.Close();
stream = null;
}
if (client != null)
{
client.Close();
client = null;
}
}
catch (Exception e)
{
Debug.LogError($"[MCP] Error closing session: {e.Message}");
}
Debug.Log("[MCP] Session closed");
}
#region API Discovery (tools/list)
/// <summary>
/// MCP仕様準拠のtools/listエンドポイント
/// 利用可能なAPIの一覧をメタデータ付きで返す
/// </summary>
private string GetToolsList(string paramsJson, object id)
{
try
{
string category = null;
string search = null;
// パラメータ解析
if (!string.IsNullOrEmpty(paramsJson) && paramsJson != "{}")
{
var categoryMatch = Regex.Match(paramsJson, "\"category\"\\s*:\\s*\"([^\"]+)\"");
if (categoryMatch.Success)
{
category = categoryMatch.Groups[1].Value;
}
var searchMatch = Regex.Match(paramsJson, "\"search\"\\s*:\\s*\"([^\"]+)\"");
if (searchMatch.Success)
{
search = searchMatch.Groups[1].Value;
}
}
System.Collections.Generic.List<ApiDefinition> apis;
if (!string.IsNullOrEmpty(search))
{
apis = ApiRegistry.SearchApis(search);
}
else if (!string.IsNullOrEmpty(category))
{
apis = ApiRegistry.GetApisByCategory(category);
}
else
{
apis = ApiRegistry.GetAllApis();
}
// MCP仕様形式でレスポンス構築
var sb = new 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)
{
Debug.LogError($"[MCP] GetToolsList error: {e.Message}");
return JsonRpcResponseHelper.ErrorMessage($"Failed to get tools list: {e.Message}", id);
}
}
/// <summary>
/// 利用可能なカテゴリ一覧を返す
/// </summary>
private string GetToolsCategories(object id)
{
try
{
var categories = ApiRegistry.GetCategories();
var categoryInfos = new System.Collections.Generic.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)
{
Debug.LogError($"[MCP] GetToolsCategories error: {e.Message}");
return JsonRpcResponseHelper.ErrorMessage($"Failed to get categories: {e.Message}", id);
}
}
/// <summary>
/// API定義をMCP仕様のJSON形式に変換
/// </summary>
private string FormatToolDefinition(ApiDefinition api)
{
var sb = new StringBuilder();
sb.Append("{");
sb.Append($"\"name\":\"{EscapeJson(api.name)}\",");
sb.Append($"\"description\":\"{EscapeJson(api.description)}\",");
sb.Append($"\"category\":\"{EscapeJson(api.category)}\"");
// inputSchema
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\":\"{EscapeJson(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("}");
}
// useCases
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($"\"{EscapeJson(api.useCases[i])}\"");
}
sb.Append("]");
}
// relatedApis
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 string EscapeJson(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