mcpforunityserver 9.0.8__py3-none-any.whl → 9.2.0__py3-none-any.whl

cli/commands/lighting.py

@@ -0,0 +1,128 @@
+"""Lighting CLI commands."""
+
+import sys
+import click
+from typing import Optional, Tuple
+
+from cli.utils.config import get_config
+from cli.utils.output import format_output, print_error, print_success
+from cli.utils.connection import run_command, UnityConnectionError
+
+
+@click.group()
+def lighting():
+    """Lighting operations - create, modify lights and lighting settings."""
+    pass
+
+
+@lighting.command("create")
+@click.argument("name")
+@click.option(
+    "--type", "-t",
+    "light_type",
+    type=click.Choice(["Directional", "Point", "Spot", "Area"]),
+    default="Point",
+    help="Type of light to create."
+)
+@click.option(
+    "--position", "-pos",
+    nargs=3,
+    type=float,
+    default=(0, 3, 0),
+    help="Position as X Y Z."
+)
+@click.option(
+    "--color", "-c",
+    nargs=3,
+    type=float,
+    default=None,
+    help="Color as R G B (0-1)."
+)
+@click.option(
+    "--intensity", "-i",
+    default=None,
+    type=float,
+    help="Light intensity."
+)
+def create(name: str, light_type: str, position: Tuple[float, float, float], color: Optional[Tuple[float, float, float]], intensity: Optional[float]):
+    """Create a new light.
+
+    \b
+    Examples:
+        unity-mcp lighting create "MainLight" --type Directional
+        unity-mcp lighting create "PointLight1" --position 0 5 0 --intensity 2
+        unity-mcp lighting create "RedLight" --type Spot --color 1 0 0
+    """
+    config = get_config()
+
+    try:
+        # Step 1: Create empty GameObject with position
+        create_result = run_command("manage_gameobject", {
+            "action": "create",
+            "name": name,
+            "position": list(position),
+        }, config)
+
+        if not (create_result.get("success")):
+            click.echo(format_output(create_result, config.format))
+            return
+
+        # Step 2: Add Light component using manage_components
+        add_result = run_command("manage_components", {
+            "action": "add",
+            "target": name,
+            "componentType": "Light",
+        }, config)
+
+        if not add_result.get("success"):
+            click.echo(format_output(add_result, config.format))
+            return
+
+        # Step 3: Set light type using manage_components set_property
+        type_result = run_command("manage_components", {
+            "action": "set_property",
+            "target": name,
+            "componentType": "Light",
+            "property": "type",
+            "value": light_type,
+        }, config)
+
+        if not type_result.get("success"):
+            click.echo(format_output(type_result, config.format))
+            return
+
+        # Step 4: Set color if provided
+        if color:
+            color_result = run_command("manage_components", {
+                "action": "set_property",
+                "target": name,
+                "componentType": "Light",
+                "property": "color",
+                "value": {"r": color[0], "g": color[1], "b": color[2], "a": 1},
+            }, config)
+
+            if not color_result.get("success"):
+                click.echo(format_output(color_result, config.format))
+                return
+
+        # Step 5: Set intensity if provided
+        if intensity is not None:
+            intensity_result = run_command("manage_components", {
+                "action": "set_property",
+                "target": name,
+                "componentType": "Light",
+                "property": "intensity",
+                "value": intensity,
+            }, config)
+
+            if not intensity_result.get("success"):
+                click.echo(format_output(intensity_result, config.format))
+                return
+
+        # Output the result
+        click.echo(format_output(create_result, config.format))
+        print_success(f"Created {light_type} light: {name}")
+
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)

cli/commands/material.py

@@ -0,0 +1,268 @@
+"""Material CLI commands."""
+
+import sys
+import json
+import click
+from typing import Optional, Any, Tuple
+
+from cli.utils.config import get_config
+from cli.utils.output import format_output, print_error, print_success
+from cli.utils.connection import run_command, UnityConnectionError
+
+
+@click.group()
+def material():
+    """Material operations - create, modify, assign materials."""
+    pass
+
+
+@material.command("info")
+@click.argument("path")
+def info(path: str):
+    """Get information about a material.
+
+    \b
+    Examples:
+        unity-mcp material info "Assets/Materials/Red.mat"
+    """
+    config = get_config()
+
+    try:
+        result = run_command("manage_material", {
+            "action": "get_material_info",
+            "materialPath": path,
+        }, config)
+        click.echo(format_output(result, config.format))
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@material.command("create")
+@click.argument("path")
+@click.option(
+    "--shader", "-s",
+    default="Standard",
+    help="Shader to use (default: Standard)."
+)
+@click.option(
+    "--properties", "-p",
+    default=None,
+    help='Initial properties as JSON.'
+)
+def create(path: str, shader: str, properties: Optional[str]):
+    """Create a new material.
+
+    \b
+    Examples:
+        unity-mcp material create "Assets/Materials/NewMat.mat"
+        unity-mcp material create "Assets/Materials/Red.mat" --shader "Universal Render Pipeline/Lit"
+        unity-mcp material create "Assets/Materials/Blue.mat" --properties '{"_Color": [0,0,1,1]}'
+    """
+    config = get_config()
+
+    params: dict[str, Any] = {
+        "action": "create",
+        "materialPath": path,
+        "shader": shader,
+    }
+
+    if properties:
+        try:
+            params["properties"] = json.loads(properties)
+        except json.JSONDecodeError as e:
+            print_error(f"Invalid JSON for properties: {e}")
+            sys.exit(1)
+
+    try:
+        result = run_command("manage_material", params, config)
+        click.echo(format_output(result, config.format))
+        if result.get("success"):
+            print_success(f"Created material: {path}")
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@material.command("set-color")
+@click.argument("path")
+@click.argument("r", type=float)
+@click.argument("g", type=float)
+@click.argument("b", type=float)
+@click.argument("a", type=float, default=1.0)
+@click.option(
+    "--property", "-p",
+    default="_Color",
+    help="Color property name (default: _Color)."
+)
+def set_color(path: str, r: float, g: float, b: float, a: float, property: str):
+    """Set a material's color.
+
+    \b
+    Examples:
+        unity-mcp material set-color "Assets/Materials/Red.mat" 1 0 0
+        unity-mcp material set-color "Assets/Materials/Blue.mat" 0 0 1 0.5
+        unity-mcp material set-color "Assets/Materials/Mat.mat" 1 1 0 --property "_BaseColor"
+    """
+    config = get_config()
+
+    params: dict[str, Any] = {
+        "action": "set_material_color",
+        "materialPath": path,
+        "property": property,
+        "color": [r, g, b, a],
+    }
+
+    try:
+        result = run_command("manage_material", params, config)
+        click.echo(format_output(result, config.format))
+        if result.get("success"):
+            print_success(f"Set color on: {path}")
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@material.command("set-property")
+@click.argument("path")
+@click.argument("property_name")
+@click.argument("value")
+def set_property(path: str, property_name: str, value: str):
+    """Set a shader property on a material.
+
+    \b
+    Examples:
+        unity-mcp material set-property "Assets/Materials/Mat.mat" _Metallic 0.5
+        unity-mcp material set-property "Assets/Materials/Mat.mat" _Smoothness 0.8
+        unity-mcp material set-property "Assets/Materials/Mat.mat" _MainTex "Assets/Textures/Tex.png"
+    """
+    config = get_config()
+
+    # Try to parse value as JSON for complex types
+    try:
+        parsed_value = json.loads(value)
+    except json.JSONDecodeError:
+        # Try to parse as number
+        try:
+            parsed_value = float(value)
+        except ValueError:
+            parsed_value = value
+
+    params: dict[str, Any] = {
+        "action": "set_material_shader_property",
+        "materialPath": path,
+        "property": property_name,
+        "value": parsed_value,
+    }
+
+    try:
+        result = run_command("manage_material", params, config)
+        click.echo(format_output(result, config.format))
+        if result.get("success"):
+            print_success(f"Set {property_name} on: {path}")
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@material.command("assign")
+@click.argument("material_path")
+@click.argument("target")
+@click.option(
+    "--search-method",
+    type=click.Choice(["by_name", "by_path", "by_tag",
+                      "by_layer", "by_component"]),
+    default=None,
+    help="How to find the target GameObject."
+)
+@click.option(
+    "--slot", "-s",
+    default=0,
+    type=int,
+    help="Material slot index (default: 0)."
+)
+@click.option(
+    "--mode", "-m",
+    type=click.Choice(["shared", "instance", "property_block"]),
+    default="shared",
+    help="Assignment mode."
+)
+def assign(material_path: str, target: str, search_method: Optional[str], slot: int, mode: str):
+    """Assign a material to a GameObject's renderer.
+
+    \b
+    Examples:
+        unity-mcp material assign "Assets/Materials/Red.mat" "Cube"
+        unity-mcp material assign "Assets/Materials/Blue.mat" "Player" --mode instance
+        unity-mcp material assign "Assets/Materials/Mat.mat" "-81840" --search-method by_id --slot 1
+    """
+    config = get_config()
+
+    params: dict[str, Any] = {
+        "action": "assign_material_to_renderer",
+        "materialPath": material_path,
+        "target": target,
+        "slot": slot,
+        "mode": mode,
+    }
+
+    if search_method:
+        params["searchMethod"] = search_method
+
+    try:
+        result = run_command("manage_material", params, config)
+        click.echo(format_output(result, config.format))
+        if result.get("success"):
+            print_success(f"Assigned material to: {target}")
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@material.command("set-renderer-color")
+@click.argument("target")
+@click.argument("r", type=float)
+@click.argument("g", type=float)
+@click.argument("b", type=float)
+@click.argument("a", type=float, default=1.0)
+@click.option(
+    "--search-method",
+    type=click.Choice(["by_name", "by_path", "by_tag",
+                      "by_layer", "by_component"]),
+    default=None,
+    help="How to find the target GameObject."
+)
+@click.option(
+    "--mode", "-m",
+    type=click.Choice(["shared", "instance", "property_block"]),
+    default="property_block",
+    help="Modification mode."
+)
+def set_renderer_color(target: str, r: float, g: float, b: float, a: float, search_method: Optional[str], mode: str):
+    """Set a renderer's material color directly.
+
+    \b
+    Examples:
+        unity-mcp material set-renderer-color "Cube" 1 0 0
+        unity-mcp material set-renderer-color "Player" 0 1 0 --mode instance
+    """
+    config = get_config()
+
+    params: dict[str, Any] = {
+        "action": "set_renderer_color",
+        "target": target,
+        "color": [r, g, b, a],
+        "mode": mode,
+    }
+
+    if search_method:
+        params["searchMethod"] = search_method
+
+    try:
+        result = run_command("manage_material", params, config)
+        click.echo(format_output(result, config.format))
+        if result.get("success"):
+            print_success(f"Set renderer color on: {target}")
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)

cli/commands/prefab.py

@@ -0,0 +1,144 @@
+"""Prefab CLI commands."""
+
+import sys
+import click
+from typing import Optional, Any
+
+from cli.utils.config import get_config
+from cli.utils.output import format_output, print_error, print_success
+from cli.utils.connection import run_command, UnityConnectionError
+
+
+@click.group()
+def prefab():
+    """Prefab operations - open, save, create prefabs."""
+    pass
+
+
+@prefab.command("open")
+@click.argument("path")
+@click.option(
+    "--mode", "-m",
+    default="InIsolation",
+    help="Prefab stage mode (InIsolation)."
+)
+def open_stage(path: str, mode: str):
+    """Open a prefab in the prefab stage for editing.
+
+    \b
+    Examples:
+        unity-mcp prefab open "Assets/Prefabs/Player.prefab"
+    """
+    config = get_config()
+
+    params: dict[str, Any] = {
+        "action": "open_stage",
+        "prefabPath": path,
+        "mode": mode,
+    }
+
+    try:
+        result = run_command("manage_prefabs", params, config)
+        click.echo(format_output(result, config.format))
+        if result.get("success"):
+            print_success(f"Opened prefab: {path}")
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@prefab.command("close")
+@click.option(
+    "--save", "-s",
+    is_flag=True,
+    help="Save the prefab before closing."
+)
+def close_stage(save: bool):
+    """Close the current prefab stage.
+
+    \b
+    Examples:
+        unity-mcp prefab close
+        unity-mcp prefab close --save
+    """
+    config = get_config()
+
+    params: dict[str, Any] = {
+        "action": "close_stage",
+    }
+    if save:
+        params["saveBeforeClose"] = True
+
+    try:
+        result = run_command("manage_prefabs", params, config)
+        click.echo(format_output(result, config.format))
+        if result.get("success"):
+            print_success("Closed prefab stage")
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@prefab.command("save")
+def save_stage():
+    """Save the currently open prefab stage.
+
+    \b
+    Examples:
+        unity-mcp prefab save
+    """
+    config = get_config()
+
+    try:
+        result = run_command("manage_prefabs", {
+                             "action": "save_open_stage"}, config)
+        click.echo(format_output(result, config.format))
+        if result.get("success"):
+            print_success("Saved prefab")
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@prefab.command("create")
+@click.argument("target")
+@click.argument("path")
+@click.option(
+    "--overwrite",
+    is_flag=True,
+    help="Overwrite existing prefab at path."
+)
+@click.option(
+    "--include-inactive",
+    is_flag=True,
+    help="Include inactive objects when finding target."
+)
+def create(target: str, path: str, overwrite: bool, include_inactive: bool):
+    """Create a prefab from a scene GameObject.
+
+    \b
+    Examples:
+        unity-mcp prefab create "Player" "Assets/Prefabs/Player.prefab"
+        unity-mcp prefab create "Enemy" "Assets/Prefabs/Enemy.prefab" --overwrite
+    """
+    config = get_config()
+
+    params: dict[str, Any] = {
+        "action": "create_from_gameobject",
+        "target": target,
+        "prefabPath": path,
+    }
+
+    if overwrite:
+        params["allowOverwrite"] = True
+    if include_inactive:
+        params["searchInactive"] = True
+
+    try:
+        result = run_command("manage_prefabs", params, config)
+        click.echo(format_output(result, config.format))
+        if result.get("success"):
+            print_success(f"Created prefab: {path}")
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)