# Structure for addons/godot_mcp/command_handler.gd
@tool
extends RefCounted
var editor_plugin: EditorPlugin = null
# Initialize with reference to the editor plugin
func set_editor_plugin(plugin):
editor_plugin = plugin
# Main command handling function
func handle_command(command_type, params):
match command_type:
"GET_SCENE_INFO":
return handle_get_scene_info()
"OPEN_SCENE":
return handle_open_scene(params)
"SAVE_SCENE":
return handle_save_scene()
"CREATE_CHILD_OBJECT":
return handle_create_child_object(params)
"NEW_SCENE":
return handle_new_scene(params)
"CREATE_OBJECT":
return handle_create_object(params)
"DELETE_OBJECT":
return handle_delete_object(params)
"FIND_OBJECTS_BY_NAME":
return handle_find_objects_by_name(params)
"GET_OBJECT_PROPERTIES":
return handle_get_object_properties(params)
"SET_PROPERTY":
return handle_set_property(params)
"SET_COLLISION_SHAPE":
return handle_set_collision_shape(params)
"SET_OBJECT_TRANSFORM":
return handle_set_object_transform(params)
"CREATE_CHILD_OBJECT":
return handle_create_child_object(params)
"GET_ASSET_LIST":
return handle_get_asset_list(params)
"VIEW_SCRIPT":
return handle_view_script(params)
"SET_NESTED_PROPERTY":
return handle_set_nested_property(params)
"SET_PARENT":
return handle_set_parent(params)
"CREATE_SCRIPT":
return handle_create_script(params)
"UPDATE_SCRIPT":
return handle_update_script(params)
"LIST_SCRIPTS":
return handle_list_scripts(params)
"DELETE_SCRIPT":
return handle_delete_script(params)
"DELETE_FILE":
return handle_delete_file(params)
"EDITOR_CONTROL":
return handle_editor_control(params)
"SET_MATERIAL":
return handle_set_material(params)
"IMPORT_ASSET":
return handle_import_asset(params)
"SET_MESH":
return handle_set_mesh(params)
"CREATE_PREFAB":
return handle_create_packed_scene(params)
"INSTANTIATE_PREFAB":
return handle_instantiate_prefab(params)
"SHOW_MESSAGE":
return handle_show_message(params)
"REIMPORT_ASSET":
return handle_reimport_asset(params)
"IMPORT_GLB_SCENE":
return handle_import_glb_scene(params)
_:
return {"error": "Unknown command type: " + command_type}
# Scene commands
func handle_get_scene_info():
var editor_interface = editor_plugin.get_editor_interface()
var current_scene = editor_interface.get_edited_scene_root()
if current_scene == null:
return {"error": "No scene is currently open"}
var scene_info = {
"name": current_scene.name,
"path": current_scene.scene_file_path,
"hierarchy": _get_hierarchy_recursive(current_scene),
"root_objects": []
}
# Get root-level nodes
for child in current_scene.get_children():
scene_info.root_objects.append({
"name": child.name,
"type": child.get_class()
})
return scene_info
# Helper function to recursively build hierarchy
func _get_hierarchy_recursive(node):
var hierarchy = {
"name": node.name,
"type": node.get_class(),
"children": []
}
# Add transform info for spatial nodes
if node is Node3D:
hierarchy["transform"] = {
"position": [node.position.x, node.position.y, node.position.z],
"rotation": [node.rotation_degrees.x, node.rotation_degrees.y, node.rotation_degrees.z],
"scale": [node.scale.x, node.scale.y, node.scale.z]
}
elif node is Node2D:
hierarchy["transform"] = {
"position": [node.position.x, node.position.y],
"rotation": node.rotation_degrees,
"scale": [node.scale.x, node.scale.y]
}
# Add script info if available
if node.get_script():
hierarchy["script"] = node.get_script().resource_path
# Add all child nodes recursively
for child in node.get_children():
hierarchy["children"].append(_get_hierarchy_recursive(child))
return hierarchy
func handle_open_scene(params):
if not params.has("scene_path"):
return {"error": "Missing required parameter: scene_path"}
var scene_path = params.scene_path
var editor_interface = editor_plugin.get_editor_interface()
# Check if file exists
if not FileAccess.file_exists(scene_path):
return {"error": "Scene file does not exist: " + scene_path}
# Save current scene if needed
if params.get("save_current", false):
editor_interface.save_scene()
# Open the scene
editor_interface.open_scene_from_path(scene_path)
return {"message": "Scene opened successfully: " + scene_path}
func handle_save_scene():
var editor_interface = editor_plugin.get_editor_interface()
var current_scene = editor_interface.get_edited_scene_root()
if current_scene == null:
return {"error": "No scene is currently open"}
editor_interface.save_scene()
return {"message": "Scene saved successfully: " + current_scene.scene_file_path}
func handle_new_scene(params):
if not params.has("scene_path"):
return {"error": "Missing required parameter: scene_path"}
var scene_path = params.scene_path
var editor_interface = editor_plugin.get_editor_interface()
# Check if file exists and handle overwrite
if FileAccess.file_exists(scene_path) and not params.get("overwrite", false):
return {"error": "Scene file already exists. Use overwrite=true to replace it."}
# Create directory if needed
var directory = scene_path.get_base_dir()
if not DirAccess.dir_exists_absolute(directory):
var error = DirAccess.make_dir_recursive_absolute(directory)
if error != OK:
return {"error": "Failed to create directory: " + directory}
# Create a new scene with a Node as root
var root_node = Node.new()
root_node.name = scene_path.get_file().get_basename()
# Create a packed scene and save it
var packed_scene = PackedScene.new()
var result = packed_scene.pack(root_node)
if result != OK:
return {"error": "Failed to pack scene: " + str(result)}
var error = ResourceSaver.save(packed_scene, scene_path)
if error != OK:
return {"error": "Failed to save new scene: " + str(error)}
# Open the newly created scene
editor_interface.open_scene_from_path(scene_path)
return {"message": "New scene created successfully: " + scene_path}
# Object commands
func handle_create_object(params):
var type = params.get("type", "EMPTY")
var name = params.get("name", "")
var location = params.get("location", [0, 0, 0])
var rotation = params.get("rotation", [0, 0, 0])
var scale = params.get("scale", [1, 1, 1])
var replace_if_exists = params.get("replace_if_exists", false)
var editor_interface = editor_plugin.get_editor_interface()
var current_scene = editor_interface.get_edited_scene_root()
if current_scene == null:
return {"error": "No scene is currently open"}
# Check if name already exists and handle replacement
if name != "":
var existing_node = current_scene.find_child(name, true, false)
if existing_node and not replace_if_exists:
return {"error": "Node with name '" + name + "' already exists. Use replace_if_exists=true to replace it."}
elif existing_node and replace_if_exists:
existing_node.queue_free()
# Create the node based on type (case-insensitive)
var node
var upper_type = type.to_upper()
# Handle common 3D node types
match upper_type:
"NODE", "EMPTY":
node = Node3D.new()
"NODE3D":
node = Node3D.new()
"SPATIAL": # For compatibility with Godot 3.x terminology
node = Node3D.new()
"MESH", "MESHINSTANCE3D":
node = MeshInstance3D.new()
"CUBE", "BOX":
node = MeshInstance3D.new()
node.mesh = BoxMesh.new()
"SPHERE":
node = MeshInstance3D.new()
node.mesh = SphereMesh.new()
"CYLINDER":
node = MeshInstance3D.new()
node.mesh = CylinderMesh.new()
"PLANE":
node = MeshInstance3D.new()
node.mesh = PlaneMesh.new()
"CAMERA", "CAMERA3D":
node = Camera3D.new()
"LIGHT", "DIRECTIONALLIGHT", "DIRECTIONALLIGHT3D":
node = DirectionalLight3D.new()
"SPOTLIGHT", "SPOTLIGHT3D":
node = SpotLight3D.new()
"OMNILIGHT", "OMNILIGHT3D":
node = OmniLight3D.new()
"RIGIDBODY", "RIGIDBODY3D":
node = RigidBody3D.new()
"STATICBODY", "STATICBODY3D":
node = StaticBody3D.new()
"CHARACTERBODY", "CHARACTERBODY3D":
node = CharacterBody3D.new()
"AREA", "AREA3D":
node = Area3D.new()
"COLLISION", "COLLISIONSHAPE3D":
node = CollisionShape3D.new()
# Add a default sphere shape
node.shape = SphereShape3D.new()
# Handle common 2D node types
"NODE2D":
node = Node2D.new()
"SPRITE", "SPRITE2D":
node = Sprite2D.new()
"CAMERA2D":
node = Camera2D.new()
"AREA2D":
node = Area2D.new()
"COLLISION2D", "COLLISIONSHAPE2D":
node = CollisionShape2D.new()
# Add a default circle shape
node.shape = CircleShape2D.new()
"RIGIDBODY2D":
node = RigidBody2D.new()
"STATICBODY2D":
node = StaticBody2D.new()
"CHARACTERBODY2D":
node = CharacterBody2D.new()
# Handle UI node types
"CONTROL":
node = Control.new()
"PANEL":
node = Panel.new()
"BUTTON":
node = Button.new()
"LABEL":
node = Label.new()
"LINEEDIT":
node = LineEdit.new()
"TEXTEDIT":
node = TextEdit.new()
"CONTAINER":
node = Container.new()
"VBOX", "VBOXCONTAINER":
node = VBoxContainer.new()
"HBOX", "HBOXCONTAINER":
node = HBoxContainer.new()
_:
# Try to create the node directly by class name using ClassDB
if ClassDB.class_exists(type) and ClassDB.can_instantiate(type):
node = ClassDB.instantiate(type)
else:
return {"error": "Unsupported object type: " + type}
# Set node name if provided
if name != "":
node.name = name
# Add to scene
current_scene.add_child(node)
node.owner = current_scene
# Set transform for Node3D or Node2D objects
if node is Node3D:
node.position = Vector3(location[0], location[1], location[2])
node.rotation_degrees = Vector3(rotation[0], rotation[1], rotation[2])
node.scale = Vector3(scale[0], scale[1], scale[2])
elif node is Node2D:
node.position = Vector2(location[0], location[1])
node.rotation_degrees = rotation[0]
node.scale = Vector2(scale[0], scale[1])
return {
"name": node.name,
"type": node.get_class(),
"path": current_scene.get_path_to(node)
}
func handle_delete_object(params):
if not params.has("name"):
return {"error": "Missing required parameter: name"}
var name_or_path = params.name
var editor_interface = editor_plugin.get_editor_interface()
var current_scene = editor_interface.get_edited_scene_root()
if current_scene == null:
return {"error": "No scene is currently open"}
# Find node by name or path
var node = null
# Check if it's a path (contains /)
if "/" in name_or_path:
# Try direct path lookup first
node = current_scene.get_node_or_null(name_or_path)
# If that fails, try with leading slash
if not node and not name_or_path.begins_with("/"):
node = current_scene.get_node_or_null("/" + name_or_path)
# If still not found, try parsing the path components
if not node:
var parts = name_or_path.split("/")
var current = current_scene
for part in parts:
if part == "":
continue
var found = false
for child in current.get_children():
if child.name == part:
current = child
found = true
break
if not found:
# Try searching recursively for this part
var found_node = current.find_child(part, true, false)
if found_node:
current = found_node
else:
# Part not found, path is invalid
return {"error": "Could not find part '" + part + "' in path: " + name_or_path}
node = current
else:
# Simple name lookup for non-path names
node = current_scene.find_child(name_or_path, true, false)
if not node:
return {"error": "Node not found: " + name_or_path}
# Store the node's path for the response before deleting
var node_path = current_scene.get_path_to(node)
var node_type = node.get_class()
# Delete the node
node.queue_free()
return {
"message": "Node deleted: " + name_or_path,
"path": node_path,
"type": node_type
}
#func handle_delete_object(params):
#if not params.has("name"):
#return {"error": "Missing required parameter: name"}
#
#var name = params.name
#var editor_interface = editor_plugin.get_editor_interface()
#var current_scene = editor_interface.get_edited_scene_root()
#
#if current_scene == null:
#return {"error": "No scene is currently open"}
#
## Find node by name
#var node = current_scene.find_child(name, true, false)
#if not node:
#return {"error": "Node not found: " + name}
#
## Delete the node
#node.queue_free()
#return {"message": "Node deleted: " + name}
func handle_find_objects_by_name(params):
if not params.has("name"):
return {"error": "Missing required parameter: name"}
var search_name = params.name
var editor_interface = editor_plugin.get_editor_interface()
var current_scene = editor_interface.get_edited_scene_root()
if current_scene == null:
return {"error": "No scene is currently open"}
var objects = []
var nodes = _find_nodes_by_name(current_scene, search_name)
for node in nodes:
objects.append({
"name": node.name,
"path": _get_node_path(node),
"type": node.get_class()
})
return {"objects": objects}
# Helper function to find nodes recursively
func _find_nodes_by_name(root, search_name):
var result = []
if search_name in root.name:
result.append(root)
for child in root.get_children():
result.append_array(_find_nodes_by_name(child, search_name))
return result
# Helper function to get a node's path relative to the scene root
func _get_node_path(node):
var current_scene = editor_plugin.get_editor_interface().get_edited_scene_root()
if current_scene:
return current_scene.get_path_to(node)
return node.get_path()
func handle_get_object_properties(params):
if not params.has("name"):
return {"error": "Missing required parameter: name"}
var name_or_path = params.name
var editor_interface = editor_plugin.get_editor_interface()
var current_scene = editor_interface.get_edited_scene_root()
if current_scene == null:
return {"error": "No scene is currently open"}
var node
# Check if we're dealing with a path or just a name
if "/" in name_or_path:
# It's a path, try to get the node using get_node
node = current_scene.get_node_or_null(name_or_path)
# If that fails, try with NodePath
if not node:
var node_path = NodePath(name_or_path)
node = current_scene.get_node_or_null(node_path)
# Try finding from root with a leading slash
if not node and not name_or_path.begins_with("/"):
node = current_scene.get_node_or_null("/" + name_or_path)
else:
# It's just a name, use find_child (which searches recursively)
node = current_scene.find_child(name_or_path, true, false)
if not node:
return {"error": "Node not found: " + name_or_path}
# Get properties
var properties = {
"name": node.name,
"type": node.get_class(),
"path": current_scene.get_path_to(node),
"visible": node.visible if "visible" in node else true,
"components": []
}
# Handle transform properties for 3D nodes
if node is Node3D:
properties["transform"] = {
"position": [node.position.x, node.position.y, node.position.z],
"rotation": [node.rotation_degrees.x, node.rotation_degrees.y, node.rotation_degrees.z],
"scale": [node.scale.x, node.scale.y, node.scale.z]
}
elif node is Node2D:
properties["transform"] = {
"position": [node.position.x, node.position.y],
"rotation": node.rotation_degrees,
"scale": [node.scale.x, node.scale.y]
}
# Get node properties and components
if node.get_script():
properties["components"].append({
"type": "Script",
"path": node.get_script().resource_path
})
# Get children information
properties["children"] = []
for child in node.get_children():
properties["children"].append({
"name": child.name,
"type": child.get_class(),
"path": current_scene.get_path_to(child)
})
# Get parent information
var parent = node.get_parent()
if parent and parent != current_scene:
properties["parent"] = {
"name": parent.name,
"type": parent.get_class(),
"path": current_scene.get_path_to(parent)
}
return properties
func handle_set_object_transform(params):
if not params.has("name"):
return {"error": "Missing required parameter: name"}
var name = params.name
var editor_interface = editor_plugin.get_editor_interface()
var current_scene = editor_interface.get_edited_scene_root()
if current_scene == null:
return {"error": "No scene is currently open"}
# Find node by name
var node = current_scene.find_child(name, true, false)
if not node:
return {"error": "Node not found: " + name}
# Check if node is 3D
if not node is Node3D:
return {"error": "Node is not a 3D node: " + name}
# Set transform properties
if params.has("location"):
var loc = params.location
node.position = Vector3(loc[0], loc[1], loc[2])
if params.has("rotation"):
var rot = params.rotation
node.rotation_degrees = Vector3(rot[0], rot[1], rot[2])
if params.has("scale"):
var scale = params.scale
node.scale = Vector3(scale[0], scale[1], scale[2])
return {"message": "Transform updated for node: " + name}
# Asset commands
func handle_get_asset_list(params):
var type = params.get("type", "")
var search_pattern = params.get("search_pattern", "*")
var folder = params.get("folder", "res://")
var assets = []
var dir = DirAccess.open(folder)
if dir == null:
return {"error": "Unable to access directory: " + folder}
dir.list_dir_begin()
var file_name = dir.get_next()
while file_name != "":
var full_path = folder.path_join(file_name)
if dir.current_is_dir():
# Handle directories if needed
pass
else:
# Check if it matches the search pattern
if search_pattern == "*" or search_pattern in file_name:
# Check type if specified
var add_file = true
if type != "":
# Determine file type based on extension
var extension = file_name.get_extension().to_lower()
match type.to_lower():
"scene":
add_file = extension == "tscn" or extension == "scn"
"script":
add_file = extension == "gd" or extension == "cs"
"texture":
add_file = extension in ["png", "jpg", "jpeg", "webp"]
"material":
add_file = extension == "material" or extension == "tres"
"prefab", "packedscene":
add_file = extension == "tscn" or extension == "scn"
if add_file:
assets.append({
"name": file_name,
"path": full_path,
"type": _get_resource_type(full_path)
})
file_name = dir.get_next()
dir.list_dir_end()
return {"assets": assets}
# Helper function to determine resource type
func _get_resource_type(path):
var extension = path.get_extension().to_lower()
match extension:
"tscn", "scn":
return "PackedScene"
"gd":
return "GDScript"
"cs":
return "CSharpScript"
"png", "jpg", "jpeg", "webp":
return "Texture"
"material", "tres":
return "Material"
"wav", "mp3", "ogg":
return "AudioStream"
_:
return "Resource"
# Script commands
func handle_view_script(params):
if not params.has("script_path"):
return {"error": "Missing required parameter: script_path"}
var script_path = params.script_path
var require_exists = params.get("require_exists", true)
if not FileAccess.file_exists(script_path):
if require_exists:
return {"error": "Script file does not exist: " + script_path}
else:
return {"exists": false, "message": "Script file does not exist: " + script_path}
var file = FileAccess.open(script_path, FileAccess.READ)
if file == null:
return {"error": "Failed to open script file: " + script_path}
var content = file.get_as_text()
return {"exists": true, "content": content}
func handle_create_script(params):
if not params.has("script_name"):
return {"error": "Missing required parameter: script_name"}
var script_name = params.script_name
var script_type = params.get("script_type", "Node")
var nam = params.get("namespace", "")
var script_folder = params.get("script_folder", "res://scripts")
var overwrite = params.get("overwrite", false)
var content = params.get("content", "")
# Ensure script has .gd extension
if not script_name.ends_with(".gd"):
script_name += ".gd"
# Create full script path
var script_path = script_folder.path_join(script_name)
# Check if directory exists, create if needed
if not DirAccess.dir_exists_absolute(script_folder):
var error = DirAccess.make_dir_recursive_absolute(script_folder)
if error != OK:
return {"error": "Failed to create script directory: " + script_folder}
# Check if script already exists
if FileAccess.file_exists(script_path) and not overwrite:
return {"error": "Script already exists. Use overwrite=true to replace it."}
# Create script content if not provided
if content == "":
content = _generate_script_template(script_type, nam)
# Write script file
var file = FileAccess.open(script_path, FileAccess.WRITE)
if file == null:
return {"error": "Failed to create script file: " + script_path}
file.store_string(content)
return {"message": "Script created successfully: " + script_path}
# Helper function to generate script template
func _generate_script_template(node_type, nam):
var template = ""
# Add class_name if namespace is provided
if nam != "":
template += "class_name " + nam + "\n\n"
# Add extends
template += "extends " + node_type + "\n\n"
# Add basic structure
template += "# Properties\n\n"
template += "# Called when the node enters the scene tree\n"
template += "func _ready():\n"
template += "\tpass\n\n"
template += "# Called every frame\n"
template += "func _process(delta):\n"
template += "\tpass\n"
return template
func handle_update_script(params):
if not params.has("script_path") or not params.has("content"):
return {"error": "Missing required parameters: script_path and content"}
var script_path = params.script_path
var content = params.content
var create_if_missing = params.get("create_if_missing", false)
var create_folder_if_missing = params.get("create_folder_if_missing", false)
# Check if script exists
if not FileAccess.file_exists(script_path):
if not create_if_missing:
return {"error": "Script file does not exist: " + script_path}
# Create directory if needed
var directory = script_path.get_base_dir()
if create_folder_if_missing and not DirAccess.dir_exists_absolute(directory):
var dir_error = DirAccess.make_dir_recursive_absolute(directory)
if dir_error != OK:
return {"error": "Failed to create directory: " + directory}
# Write script content
var file = FileAccess.open(script_path, FileAccess.WRITE)
if file == null:
return {"error": "Failed to open script file for writing: " + script_path}
file.store_string(content)
return {"message": "Script updated successfully: " + script_path}
func handle_list_scripts(params):
var folder_path = params.get("folder_path", "res://")
var scripts = []
var dir = DirAccess.open(folder_path)
if dir == null:
return {"error": "Unable to access directory: " + folder_path}
dir.list_dir_begin()
var file_name = dir.get_next()
while file_name != "":
if not dir.current_is_dir():
var extension = file_name.get_extension().to_lower()
if extension == "gd" or extension == "cs":
scripts.append(folder_path.path_join(file_name))
file_name = dir.get_next()
dir.list_dir_end()
return {"scripts": scripts}
# Editor control commands
func handle_editor_control(params):
if not params.has("command"):
return {"error": "Missing required parameter: command"}
var command = params.command
var editor_interface = editor_plugin.get_editor_interface()
match command:
"PLAY":
editor_interface.play_main_scene()
return {"message": "Started playing the main scene"}
"STOP":
editor_interface.stop_playing_scene()
return {"message": "Stopped playing the scene"}
"SAVE":
editor_interface.save_scene()
return {"message": "Scene saved"}
"READ_CONSOLE":
# Godot doesn't have a direct API for reading console output
return {"message": "Console reading not implemented in Godot"}
_:
return {"error": "Unknown editor command: " + command}
# Material commands
func handle_set_material(params):
if not params.has("object_name"):
return {"error": "Missing required parameter: object_name"}
var object_name = params.object_name
var material_name = params.get("material_name", "")
var color = params.get("color", [1.0, 1.0, 1.0, 1.0])
var create_if_missing = params.get("create_if_missing", true)
print("handle_set_material called for node: ", object_name, " color: ", color)
var editor_interface = editor_plugin.get_editor_interface()
var current_scene = editor_interface.get_edited_scene_root()
if current_scene == null:
return {"error": "No scene is currently open"}
# Find node using the improved node lookup
var node = _find_node(current_scene, object_name)
if not node:
return {"error": "Node not found: " + object_name}
print("Node found: ", node.name, " type: ", node.get_class())
# Check if node can have materials
if not (node is MeshInstance3D or node is CSGShape3D):
return {"error": "Node does not support materials: " + object_name}
var material
# Create or load material
if material_name != "":
var material_path = "res://materials/" + material_name + ".material"
if FileAccess.file_exists(material_path):
# Load existing material
material = load(material_path)
elif create_if_missing:
# Create directory if needed
if not DirAccess.dir_exists_absolute("res://materials"):
DirAccess.make_dir_recursive_absolute("res://materials")
# Create new material
material = StandardMaterial3D.new()
# Set color
if color.size() >= 3:
var albedo_color = Color(color[0], color[1], color[2])
if color.size() >= 4:
albedo_color.a = color[3]
material.albedo_color = albedo_color
# Save material
var error = ResourceSaver.save(material, material_path)
if error != OK:
return {"error": "Failed to save material: " + str(error)}
else:
return {"error": "Material not found and create_if_missing is false"}
else:
# Create instance material
material = StandardMaterial3D.new()
# Set color
if color.size() >= 3:
var albedo_color = Color(color[0], color[1], color[2])
if color.size() >= 4:
albedo_color.a = color[3]
material.albedo_color = albedo_color
# Apply material
if node is MeshInstance3D:
node.material_override = material
elif node is CSGShape3D:
node.material = material
if material_name != "":
return {
"material_name": material_name,
"path": "res://materials/" + material_name + ".material",
"message": "Applied shared material to " + object_name
}
else:
return {
"material_name": "instance_material",
"message": "Applied instance material to " + object_name
}
# Asset import
func handle_import_asset(params):
if not params.has("source_path") or not params.has("target_path"):
return {"error": "Missing required parameters: source_path and target_path"}
var source_path = params.source_path
var target_path = params.target_path
var overwrite = params.get("overwrite", false)
# Ensure target_path starts with res://
if not target_path.begins_with("res://"):
target_path = "res://" + target_path
# Check if source file exists
if not FileAccess.file_exists(source_path):
return {"error": "Source file does not exist: " + source_path}
# Check if target file exists
if FileAccess.file_exists(target_path) and not overwrite:
return {"error": "Target file already exists. Use overwrite=true to replace it."}
# Create target directory if needed
var target_dir = target_path.get_base_dir()
if not DirAccess.dir_exists_absolute(target_dir):
var dir_error = DirAccess.make_dir_recursive_absolute(target_dir)
if dir_error != OK:
return {"error": "Failed to create target directory: " + target_dir}
# Copy the file
var source_file = FileAccess.open(source_path, FileAccess.READ)
if source_file == null:
return {"error": "Failed to open source file: " + source_path}
var target_file = FileAccess.open(target_path, FileAccess.WRITE)
if target_file == null:
return {"error": "Failed to create target file: " + target_path}
target_file.store_buffer(source_file.get_buffer(source_file.get_length()))
return {
"success": true,
"message": "Asset imported successfully: " + target_path
}
func handle_create_packed_scene(params):
"""Create a packed scene (prefab) from an existing node."""
if not params.has("object_name") or not params.has("prefab_path"):
return {"error": "Missing required parameters: object_name and prefab_path"}
var object_name = params.object_name
var prefab_path = params.prefab_path
var overwrite = params.get("overwrite", false)
# Ensure prefab_path starts with res://
if not prefab_path.begins_with("res://"):
prefab_path = "res://" + prefab_path
# Ensure it has .tscn extension
if not prefab_path.ends_with(".tscn"):
prefab_path += ".tscn"
# Check if file exists and handle overwrite
if FileAccess.file_exists(prefab_path) and not overwrite:
return {"error": "Packed scene file already exists. Use overwrite=true to replace it."}
var editor_interface = editor_plugin.get_editor_interface()
var current_scene = editor_interface.get_edited_scene_root()
if current_scene == null:
return {"error": "No scene is currently open"}
# Find node by name
var node = current_scene.find_child(object_name, true, false)
if not node:
return {"error": "Node not found: " + object_name}
# Create directory if needed
var directory = prefab_path.get_base_dir()
if not DirAccess.dir_exists_absolute(directory):
var dir_error = DirAccess.make_dir_recursive_absolute(directory)
if dir_error != OK:
return {"error": "Failed to create directory: " + directory}
# Create packed scene
var packed_scene = PackedScene.new()
var result = packed_scene.pack(node)
if result != OK:
return {"error": "Failed to pack scene: " + str(result)}
# Save packed scene
result = ResourceSaver.save(packed_scene, prefab_path)
if result != OK:
return {"error": "Failed to save packed scene: " + str(result)}
return {
"success": true,
"path": prefab_path,
"message": "Packed scene created successfully from " + object_name
}
func handle_instantiate_prefab(params):
"""Instantiate a packed scene (prefab) into the current scene."""
if not params.has("prefab_path"):
return {"error": "Missing required parameter: prefab_path"}
var prefab_path = params.prefab_path
var position_x = params.get("position_x", 0.0)
var position_y = params.get("position_y", 0.0)
var position_z = params.get("position_z", 0.0)
var rotation_x = params.get("rotation_x", 0.0)
var rotation_y = params.get("rotation_y", 0.0)
var rotation_z = params.get("rotation_z", 0.0)
# Ensure prefab_path starts with res://
if not prefab_path.begins_with("res://"):
prefab_path = "res://" + prefab_path
# Check if file exists
if not FileAccess.file_exists(prefab_path):
return {"error": "Packed scene file does not exist: " + prefab_path}
var editor_interface = editor_plugin.get_editor_interface()
var current_scene = editor_interface.get_edited_scene_root()
if current_scene == null:
return {"error": "No scene is currently open"}
# Load the packed scene
var scene_resource = load(prefab_path)
if not scene_resource is PackedScene:
return {"error": "Failed to load packed scene: " + prefab_path}
# Instantiate the scene
var instance = scene_resource.instantiate()
if not instance:
return {"error": "Failed to instantiate packed scene"}
# Add to the current scene
current_scene.add_child(instance)
instance.owner = current_scene
# Set transform if it's a spatial node
if instance is Node3D:
instance.position = Vector3(position_x, position_y, position_z)
instance.rotation_degrees = Vector3(rotation_x, rotation_y, rotation_z)
return {
"success": true,
"instance_name": instance.name,
"message": "Packed scene instantiated successfully"
}
func handle_set_property(params):
if not params.has("node_name") or not params.has("property_name") or not params.has("value"):
return {"error": "Missing required parameters: node_name, property_name, and value"}
var node_name = params.node_name
var property_name = params.property_name
var value = params.value
var force_type = params.get("force_type", "")
print("handle_set_property called with node_name: ", node_name, " property_name: ", property_name, " value: ", value)
var editor_interface = editor_plugin.get_editor_interface()
var current_scene = editor_interface.get_edited_scene_root()
if current_scene == null:
return {"error": "No scene is currently open"}
# Find node by name or path
var node = null
# Check if it's a path (contains /)
if "/" in node_name:
# Try direct path lookup first
node = current_scene.get_node_or_null(node_name)
if not node:
# Try as relative path
if not node_name.begins_with("/"):
node = current_scene.get_node_or_null("/" + node_name)
else:
# Simple name lookup
node = current_scene.find_child(node_name, true, false)
if node:
print("Node found: ", node.name, " of type: ", node.get_class())
else:
print("Node not found: ", node_name)
return {"error": "Node not found: " + node_name}
# Handle special properties
if property_name == "script":
# Check if script file exists
if not FileAccess.file_exists(value):
return {"error": "Script file not found: " + value}
# Try to load the script
var script_resource = load(value)
if not script_resource:
return {"error": "Failed to load script: " + value}
if not script_resource is GDScript:
return {"error": "Resource is not a GDScript: " + value}
# Set the script
node.set_script(script_resource)
return {"message": "Script set on node '" + node_name + "': " + value}
# Handle other special properties
if property_name == "visible":
node.visible = bool(value)
return {"message": "Property set: visible = " + str(bool(value))}
if property_name == "name":
# Check if name is already taken
var existing = current_scene.find_child(str(value), true, false)
if existing != null and existing != node:
return {"error": "Name already in use by another node"}
node.name = str(value)
return {"message": "Node renamed to: " + str(value)}
# Handle property paths (e.g., "position:x")
var parts = property_name.split(":")
if parts.size() == 2:
var base_property = parts[0]
var sub_property = parts[1]
if base_property in node:
var base_value = node.get(base_property)
# Handle different vector types
if base_value is Vector2 or base_value is Vector3 or base_value is Color:
if sub_property in ["x", "y", "z", "r", "g", "b", "a"]:
# Safety check for Vector2 which doesn't have z
if base_value is Vector2 and sub_property == "z":
return {"error": "Vector2 doesn't have a z component"}
# Safety check for components that don't exist
if sub_property == "z" and not (base_value is Vector3):
return {"error": "Property doesn't have a z component"}
if sub_property in ["r", "g", "b", "a"] and not (base_value is Color):
return {"error": "Only Color has r, g, b, a components"}
# Convert value to float for vector components
var float_value
if typeof(value) == TYPE_STRING:
float_value = float(value)
else:
float_value = float(value)
# Set the appropriate component
match sub_property:
"x":
base_value.x = float_value
"y":
base_value.y = float_value
"z":
base_value.z = float_value
"r":
base_value.r = float_value
"g":
base_value.g = float_value
"b":
base_value.b = float_value
"a":
base_value.a = float_value
# Set the modified vector back to the node
node.set(base_property, base_value)
return {"message": "Property set: " + property_name + " = " + str(float_value)}
return {"error": "Unable to set sub-property: " + property_name}
# Handle regular properties
if not property_name in node:
return {"error": "Property not found on node: " + property_name}
# Get the current property value to determine its type
var current_value = node.get(property_name)
print("Current value type: ", typeof(current_value))
var converted_value = value
# If force_type is specified, use that for conversion
if force_type != "":
match force_type:
"bool":
if typeof(value) == TYPE_STRING:
converted_value = (value.to_lower() == "true")
else:
converted_value = bool(value)
"int":
converted_value = int(value)
"float":
converted_value = float(value)
"string":
converted_value = str(value)
"Vector2":
if typeof(value) == TYPE_ARRAY and value.size() >= 2:
converted_value = Vector2(float(value[0]), float(value[1]))
"Vector3":
if typeof(value) == TYPE_ARRAY and value.size() >= 3:
converted_value = Vector3(float(value[0]), float(value[1]), float(value[2]))
"Color":
if typeof(value) == TYPE_ARRAY:
if value.size() >= 4:
converted_value = Color(float(value[0]), float(value[1]), float(value[2]), float(value[3]))
elif value.size() >= 3:
converted_value = Color(float(value[0]), float(value[1]), float(value[2]))
else:
# Try to convert the value to match the current property type
match typeof(current_value):
TYPE_BOOL:
if typeof(value) == TYPE_STRING:
converted_value = (value.to_lower() == "true")
else:
converted_value = bool(value)
TYPE_INT:
converted_value = int(value)
TYPE_FLOAT:
converted_value = float(value)
TYPE_STRING:
converted_value = str(value)
TYPE_VECTOR2:
if typeof(value) == TYPE_ARRAY and value.size() >= 2:
converted_value = Vector2(float(value[0]), float(value[1]))
TYPE_VECTOR3:
if typeof(value) == TYPE_ARRAY and value.size() >= 3:
converted_value = Vector3(float(value[0]), float(value[1]), float(value[2]))
TYPE_COLOR:
if typeof(value) == TYPE_ARRAY:
if value.size() >= 4:
converted_value = Color(float(value[0]), float(value[1]), float(value[2]), float(value[3]))
elif value.size() >= 3:
converted_value = Color(float(value[0]), float(value[1]), float(value[2]))
print("Converted value: ", converted_value, " of type: ", typeof(converted_value))
# Try to set the property
var previous_value = node.get(property_name)
# Use set to safely call the setter
var error = null
node.set(property_name, converted_value)
# Check if the property actually changed
var new_value = node.get(property_name)
# Handle type-safe comparison - don't compare different types directly
var values_different = false
if typeof(new_value) == typeof(converted_value):
values_different = (new_value != converted_value)
else:
# Different types means they're different values
values_different = true
if new_value == previous_value and values_different:
return {"warning": "Property might be read-only or conversion failed: " + property_name, "previous_value": previous_value, "attempted_value": converted_value}
return {"message": "Property set: " + property_name + " = " + str(converted_value)}
#func handle_set_property(params):
#if not params.has("node_name") or not params.has("property_name") or not params.has("value"):
#return {"error": "Missing required parameters: node_name, property_name, and value"}
#
#var node_name = params.node_name
#var property_name = params.property_name
#var value = params.value
#var force_type = params.get("force_type", "")
#
#var editor_interface = editor_plugin.get_editor_interface()
#var current_scene = editor_interface.get_edited_scene_root()
#
#if current_scene == null:
#return {"error": "No scene is currently open"}
#
## Find node by name
#var node = current_scene.find_child(node_name, true, false)
#if not node:
#return {"error": "Node not found: " + node_name}
#
## Handle special properties
#if property_name == "script":
## Check if script file exists
#if not FileAccess.file_exists(value):
#return {"error": "Script file not found: " + value}
#
## Try to load the script
#var script_resource = load(value)
#if not script_resource:
#return {"error": "Failed to load script: " + value}
#
#if not script_resource is GDScript:
#return {"error": "Resource is not a GDScript: " + value}
#
## Set the script
#node.set_script(script_resource)
#return {"message": "Script set on node '" + node_name + "': " + value}
#
## Handle other special properties
#if property_name == "visible":
#node.visible = bool(value)
#return {"message": "Property set: visible = " + str(bool(value))}
#
#if property_name == "name":
## Check if name is already taken
#var existing = current_scene.find_child(str(value), true, false)
#if existing != null and existing != node:
#return {"error": "Name already in use by another node"}
#node.name = str(value)
#return {"message": "Node renamed to: " + str(value)}
#
## Handle property paths (e.g., "position:x")
#var parts = property_name.split(":")
#if parts.size() == 2:
#var base_property = parts[0]
#var sub_property = parts[1]
#
#if base_property in node:
#var base_value = node.get(base_property)
#
## Handle different vector types
#if base_value is Vector2 or base_value is Vector3 or base_value is Color:
#if sub_property in ["x", "y", "z", "r", "g", "b", "a"]:
## Safety check for Vector2 which doesn't have z
#if base_value is Vector2 and sub_property == "z":
#return {"error": "Vector2 doesn't have a z component"}
#
## Safety check for components that don't exist
#if sub_property == "z" and not (base_value is Vector3):
#return {"error": "Property doesn't have a z component"}
#
#if sub_property in ["r", "g", "b", "a"] and not (base_value is Color):
#return {"error": "Only Color has r, g, b, a components"}
#
## Convert value to float for vector components
#var float_value
#if typeof(value) == TYPE_STRING:
#float_value = float(value)
#else:
#float_value = float(value)
#
## Set the appropriate component
#match sub_property:
#"x": base_value.x = float_value
#"y": base_value.y = float_value
#"z": base_value.z = float_value
#"r": base_value.r = float_value
#"g": base_value.g = float_value
#"b": base_value.b = float_value
#"a": base_value.a = float_value
#
## Set the modified vector back to the node
#node.set(base_property, base_value)
#return {"message": "Property set: " + property_name + " = " + str(float_value)}
#
#return {"error": "Unable to set sub-property: " + property_name}
#
## Handle regular properties
#if not property_name in node:
#return {"error": "Property not found on node: " + property_name}
#
## Get the current property value to determine its type
#var current_value = node.get(property_name)
#var converted_value = value
#
## If force_type is specified, use that for conversion
#if force_type != "":
#match force_type:
#"bool":
#if typeof(value) == TYPE_STRING:
#converted_value = (value.to_lower() == "true")
#else:
#converted_value = bool(value)
#"int":
#converted_value = int(value)
#"float":
#converted_value = float(value)
#"string":
#converted_value = str(value)
#"Vector2":
#if typeof(value) == TYPE_ARRAY and value.size() >= 2:
#converted_value = Vector2(float(value[0]), float(value[1]))
#"Vector3":
#if typeof(value) == TYPE_ARRAY and value.size() >= 3:
#converted_value = Vector3(float(value[0]), float(value[1]), float(value[2]))
#"Color":
#if typeof(value) == TYPE_ARRAY:
#if value.size() >= 4:
#converted_value = Color(float(value[0]), float(value[1]), float(value[2]), float(value[3]))
#elif value.size() >= 3:
#converted_value = Color(float(value[0]), float(value[1]), float(value[2]))
#else:
## Try to convert the value to match the current property type
#match typeof(current_value):
#TYPE_BOOL:
#if typeof(value) == TYPE_STRING:
#converted_value = (value.to_lower() == "true")
#else:
#converted_value = bool(value)
#TYPE_INT:
#converted_value = int(value)
#TYPE_FLOAT:
#converted_value = float(value)
#TYPE_STRING:
#converted_value = str(value)
#TYPE_VECTOR2:
#if typeof(value) == TYPE_ARRAY and value.size() >= 2:
#converted_value = Vector2(float(value[0]), float(value[1]))
#TYPE_VECTOR3:
#if typeof(value) == TYPE_ARRAY and value.size() >= 3:
#converted_value = Vector3(float(value[0]), float(value[1]), float(value[2]))
#TYPE_COLOR:
#if typeof(value) == TYPE_ARRAY:
#if value.size() >= 4:
#converted_value = Color(float(value[0]), float(value[1]), float(value[2]), float(value[3]))
#elif value.size() >= 3:
#converted_value = Color(float(value[0]), float(value[1]), float(value[2]))
#
## Try to set the property
#var previous_value = node.get(property_name)
#
## Use callv to safely call the setter
#node.set(property_name, converted_value)
#
## Check if the property actually changed
#var new_value = node.get(property_name)
#if new_value == previous_value and new_value != converted_value:
#return {"warning": "Property might be read-only or conversion failed: " + property_name, "previous_value": previous_value, "attempted_value": converted_value}
#
#return {"message": "Property set: " + property_name + " = " + str(converted_value)}
func handle_set_parent(params):
if not params.has("child_name") or not params.has("parent_name"):
return {"error": "Missing required parameters: child_name and parent_name"}
var child_name = params.child_name
var parent_name = params.parent_name
var keep_global_transform = params.get("keep_global_transform", true)
var editor_interface = editor_plugin.get_editor_interface()
var current_scene = editor_interface.get_edited_scene_root()
if current_scene == null:
return {"error": "No scene is currently open"}
# Find child node (search the entire scene)
var child_node = current_scene.find_child(child_name, true, false)
if not child_node:
return {"error": "Child node not found: " + child_name}
# Find parent node (search the entire scene)
var parent_node
if parent_name == "root":
parent_node = current_scene
else:
parent_node = current_scene.find_child(parent_name, true, false)
if not parent_node:
return {"error": "Parent node not found: " + parent_name}
# Store the global transform if needed
var global_transform = null
if child_node is Node3D and keep_global_transform:
global_transform = child_node.global_transform
elif child_node is Node2D and keep_global_transform:
global_transform = child_node.global_transform
# Get the original parent
var original_parent = child_node.get_parent()
if original_parent:
# Remove from original parent
original_parent.remove_child(child_node)
# Add to new parent
parent_node.add_child(child_node)
# Ensure ownership is set correctly
child_node.owner = current_scene
# Set all children's owner recursively
_set_owner_recursive(child_node, current_scene)
# Restore global transform if needed
if child_node is Node3D and global_transform and keep_global_transform:
child_node.global_transform = global_transform
elif child_node is Node2D and global_transform and keep_global_transform:
child_node.global_transform = global_transform
return {"message": "Set parent of '" + child_name + "' to '" + parent_name + "'"}
# Helper function to set owner recursively
func _set_owner_recursive(node, owner):
for child in node.get_children():
child.owner = owner
_set_owner_recursive(child, owner)
func handle_create_child_object(params):
"""Create a new object as a child of an existing node."""
if not params.has("parent_name"):
return {"error": "Missing required parameter: parent_name"}
var parent_name = params.parent_name
var type = params.get("type", "EMPTY")
var name = params.get("name", "")
var location = params.get("location", [0, 0, 0])
var rotation = params.get("rotation", [0, 0, 0])
var scale = params.get("scale", [1, 1, 1])
var replace_if_exists = params.get("replace_if_exists", false)
var editor_interface = editor_plugin.get_editor_interface()
var current_scene = editor_interface.get_edited_scene_root()
if current_scene == null:
return {"error": "No scene is currently open"}
# Find parent node with proper path handling
var parent_node = null
if parent_name == "root":
parent_node = current_scene
else:
# Check if it's a path (contains /)
if "/" in parent_name:
# Try direct path lookup first
parent_node = current_scene.get_node_or_null(parent_name)
# If that fails, try with leading slash
if not parent_node and not parent_name.begins_with("/"):
parent_node = current_scene.get_node_or_null("/" + parent_name)
# If still not found, try parsing the path components
if not parent_node:
var parts = parent_name.split("/")
var current = current_scene
for part in parts:
if part == "":
continue
var found = false
for child in current.get_children():
if child.name == part:
current = child
found = true
break
if not found:
# Try searching recursively for this part
var found_node = current.find_child(part, true, false)
if found_node:
current = found_node
else:
# Part not found, path is invalid
return {"error": "Could not find part '" + part + "' in path: " + parent_name}
parent_node = current
else:
# Simple name lookup for non-path names
parent_node = current_scene.find_child(parent_name, true, false)
if not parent_node:
return {"error": "Parent node not found: " + parent_name}
# Check if name already exists and handle replacement
if name != "":
var existing_node = current_scene.find_child(name, true, false)
if existing_node and not replace_if_exists:
return {"error": "Node with name '" + name + "' already exists. Use replace_if_exists=true to replace it."}
elif existing_node and replace_if_exists:
existing_node.queue_free()
# Create the node based on type
var node
var upper_type = type.to_upper()
# Handle common 3D node types
match upper_type:
"NODE", "EMPTY":
node = Node3D.new()
"NODE3D":
node = Node3D.new()
"SPATIAL": # For compatibility with Godot 3.x terminology
node = Node3D.new()
"MESH", "MESHINSTANCE3D":
node = MeshInstance3D.new()
"CUBE", "BOX":
node = MeshInstance3D.new()
node.mesh = BoxMesh.new()
"SPHERE":
node = MeshInstance3D.new()
node.mesh = SphereMesh.new()
"CYLINDER":
node = MeshInstance3D.new()
node.mesh = CylinderMesh.new()
"PLANE":
node = MeshInstance3D.new()
node.mesh = PlaneMesh.new()
"CAMERA", "CAMERA3D":
node = Camera3D.new()
"LIGHT", "DIRECTIONALLIGHT", "DIRECTIONALLIGHT3D":
node = DirectionalLight3D.new()
"SPOTLIGHT", "SPOTLIGHT3D":
node = SpotLight3D.new()
"OMNILIGHT", "OMNILIGHT3D":
node = OmniLight3D.new()
"RIGIDBODY", "RIGIDBODY3D":
node = RigidBody3D.new()
"STATICBODY", "STATICBODY3D":
node = StaticBody3D.new()
"CHARACTERBODY", "CHARACTERBODY3D":
node = CharacterBody3D.new()
"AREA", "AREA3D":
node = Area3D.new()
"COLLISION", "COLLISIONSHAPE3D":
node = CollisionShape3D.new()
# Add a default sphere shape
node.shape = SphereShape3D.new()
# Handle common 2D node types
"NODE2D":
node = Node2D.new()
"SPRITE", "SPRITE2D":
node = Sprite2D.new()
"CAMERA2D":
node = Camera2D.new()
"AREA2D":
node = Area2D.new()
"COLLISION2D", "COLLISIONSHAPE2D":
node = CollisionShape2D.new()
# Add a default circle shape
node.shape = CircleShape2D.new()
"RIGIDBODY2D":
node = RigidBody2D.new()
"STATICBODY2D":
node = StaticBody2D.new()
"CHARACTERBODY2D":
node = CharacterBody2D.new()
# Handle UI node types
"CONTROL":
node = Control.new()
"PANEL":
node = Panel.new()
"BUTTON":
node = Button.new()
"LABEL":
node = Label.new()
"LINEEDIT":
node = LineEdit.new()
"TEXTEDIT":
node = TextEdit.new()
"CONTAINER":
node = Container.new()
"VBOX", "VBOXCONTAINER":
node = VBoxContainer.new()
"HBOX", "HBOXCONTAINER":
node = HBoxContainer.new()
_:
# Try to create the node directly by class name using ClassDB
if ClassDB.class_exists(type) and ClassDB.can_instantiate(type):
node = ClassDB.instantiate(type)
else:
return {"error": "Unsupported object type: " + type}
# Set node name if provided
if name != "":
node.name = name
# Add to parent node directly
parent_node.add_child(node)
node.owner = current_scene
# Recursively set ownership for all children
_set_owner_recursive(node, current_scene)
# Set transform for Node3D or Node2D objects
if node is Node3D:
node.position = Vector3(location[0], location[1], location[2])
node.rotation_degrees = Vector3(rotation[0], rotation[1], rotation[2])
node.scale = Vector3(scale[0], scale[1], scale[2])
elif node is Node2D:
node.position = Vector2(location[0], location[1])
node.rotation_degrees = rotation[0]
node.scale = Vector2(scale[0], scale[1])
# In the JSON output, include the full path to the parent to help with debugging
var parent_path = current_scene.get_path_to(parent_node)
return {
"name": node.name,
"type": node.get_class(),
"path": current_scene.get_path_to(node),
"parent": parent_node.name,
"parent_path": parent_path
}
#func handle_create_child_object(params):
#"""Create a new object as a child of an existing node."""
#if not params.has("parent_name"):
#return {"error": "Missing required parameter: parent_name"}
#
#var parent_name = params.parent_name
#var type = params.get("type", "EMPTY")
#var name = params.get("name", "")
#var location = params.get("location", [0, 0, 0])
#var rotation = params.get("rotation", [0, 0, 0])
#var scale = params.get("scale", [1, 1, 1])
#var replace_if_exists = params.get("replace_if_exists", false)
#
#var editor_interface = editor_plugin.get_editor_interface()
#var current_scene = editor_interface.get_edited_scene_root()
#
#if current_scene == null:
#return {"error": "No scene is currently open"}
#
## Find parent node
#var parent_node
#if parent_name == "root":
#parent_node = current_scene
#else:
#parent_node = current_scene.find_child(parent_name, true, false)
#
#if not parent_node:
#return {"error": "Parent node not found: " + parent_name}
#
## Check if name already exists and handle replacement
#if name != "":
#var existing_node = current_scene.find_child(name, true, false)
#if existing_node and not replace_if_exists:
#return {"error": "Node with name '" + name + "' already exists. Use replace_if_exists=true to replace it."}
#elif existing_node and replace_if_exists:
#existing_node.queue_free()
#
## Create the node based on type (same logic as handle_create_object)
#var node
#var upper_type = type.to_upper()
#
## Handle common 3D node types
#match upper_type:
#"NODE", "EMPTY":
#node = Node3D.new()
## (rest of the type matching code from handle_create_object)
## ...
#_:
## Try to create the node directly by class name using ClassDB
#if ClassDB.class_exists(type) and ClassDB.can_instantiate(type):
#node = ClassDB.instantiate(type)
#else:
#return {"error": "Unsupported object type: " + type}
#
## Set node name if provided
#if name != "":
#node.name = name
#
## Add to parent node directly
#parent_node.add_child(node)
#node.owner = current_scene
#
## Set transform for Node3D or Node2D objects
#if node is Node3D:
#node.position = Vector3(location[0], location[1], location[2])
#node.rotation_degrees = Vector3(rotation[0], rotation[1], rotation[2])
#node.scale = Vector3(scale[0], scale[1], scale[2])
#elif node is Node2D:
#node.position = Vector2(location[0], location[1])
#node.rotation_degrees = rotation[0]
#node.scale = Vector2(scale[0], scale[1])
#
#return {
#"name": node.name,
#"type": node.get_class(),
#"path": current_scene.get_path_to(node),
#"parent": parent_name
#}
func handle_set_mesh(params):
"""Create and set a mesh on a MeshInstance3D node."""
if not params.has("node_name") or not params.has("mesh_type"):
return {"error": "Missing required parameters: node_name and mesh_type"}
var node_name = params.node_name
var mesh_type = params.mesh_type
print("handle_set_mesh called for node: ", node_name, " mesh_type: ", mesh_type)
var editor_interface = editor_plugin.get_editor_interface()
var current_scene = editor_interface.get_edited_scene_root()
if current_scene == null:
return {"error": "No scene is currently open"}
# Find node using the improved node lookup
var node = _find_node(current_scene, node_name)
if not node:
return {"error": "Node not found: " + node_name}
print("Node found: ", node.name, " type: ", node.get_class())
# Check if the node can have a mesh property
if not node is MeshInstance3D:
return {"error": "Node is not a MeshInstance3D: " + node_name}
# Create mesh based on type
var mesh
match mesh_type.to_upper():
"CAPSULEMESH":
mesh = CapsuleMesh.new()
if params.has("radius"):
mesh.radius = float(params.radius)
if params.has("height"):
mesh.height = float(params.height)
"BOXMESH":
mesh = BoxMesh.new()
if params.has("size"):
var size = params.size
mesh.size = Vector3(float(size[0]), float(size[1]), float(size[2]))
"SPHEREMESH":
mesh = SphereMesh.new()
if params.has("radius"):
mesh.radius = float(params.radius)
"CYLINDERMESH":
mesh = CylinderMesh.new()
if params.has("radius"):
mesh.radius = float(params.radius)
if params.has("height"):
mesh.height = float(params.height)
"PLANEMESH":
mesh = PlaneMesh.new()
if params.has("size"):
var size = params.size
mesh.size = Vector2(float(size[0]), float(size[1]))
_:
return {"error": "Unsupported mesh type: " + mesh_type}
# Set the mesh
node.mesh = mesh
return {"message": "Set " + mesh_type + " on " + node_name}
func _find_node(root, name_or_path):
# Check if it's a path (contains /)
if "/" in name_or_path:
# Try direct path lookup first
var node = root.get_node_or_null(name_or_path)
if node:
return node
# Try as relative path
if not name_or_path.begins_with("/"):
node = root.get_node_or_null("/" + name_or_path)
if node:
return node
# Try all combinations of path separators
var parts = name_or_path.split("/")
var current = root
for part in parts:
# Look for the next part in current node's children
var found = false
for child in current.get_children():
if child.name == part:
current = child
found = true
break
if not found:
# Try searching recursively
var found_node = current.find_child(part, true, false)
if found_node:
current = found_node
else:
return null
return current
else:
# Simple name lookup
return root.find_child(name_or_path, true, false)
func handle_set_collision_shape(params):
"""Create and set a collision shape on a CollisionShape3D or CollisionShape2D node."""
if not params.has("node_name") or not params.has("shape_type"):
return {"error": "Missing required parameters: node_name and shape_type"}
var node_name = params.node_name
var shape_type = params.shape_type
var shape_params = params.get("shape_params", {})
var editor_interface = editor_plugin.get_editor_interface()
var current_scene = editor_interface.get_edited_scene_root()
if current_scene == null:
return {"error": "No scene is currently open"}
# Find node by name or path
var node = _find_node(current_scene, node_name)
if not node:
return {"error": "Node not found: " + node_name}
# Check if the node can have a shape property
if not (node is CollisionShape3D or node is CollisionShape2D):
return {"error": "Node is not a CollisionShape: " + node_name}
# Create shape based on type
var shape
match shape_type.to_upper():
"CAPSULESHAPE3D":
shape = CapsuleShape3D.new()
if shape_params.has("radius"):
shape.radius = float(shape_params.radius)
if shape_params.has("height"):
shape.height = float(shape_params.height)
"BOXSHAPE3D":
shape = BoxShape3D.new()
if shape_params.has("size"):
var size = shape_params.size
shape.size = Vector3(float(size[0]), float(size[1]), float(size[2]))
"SPHERESHAPE3D":
shape = SphereShape3D.new()
if shape_params.has("radius"):
shape.radius = float(shape_params.radius)
"CYLINDERSHAPE3D":
shape = CylinderShape3D.new()
if shape_params.has("radius"):
shape.radius = float(shape_params.radius)
if shape_params.has("height"):
shape.height = float(shape_params.height)
"WORLDBOUNDARYSHAPE3D":
shape = WorldBoundaryShape3D.new()
# 2D Shapes
"CIRCLESHAPE2D":
shape = CircleShape2D.new()
if shape_params.has("radius"):
shape.radius = float(shape_params.radius)
"RECTANGLESHAPE2D":
shape = RectangleShape2D.new()
if shape_params.has("size"):
var size = shape_params.size
shape.size = Vector2(float(size[0]), float(size[1]))
"CAPSULESHAPE2D":
shape = CapsuleShape2D.new()
if shape_params.has("radius"):
shape.radius = float(shape_params.radius)
if shape_params.has("height"):
shape.height = float(shape_params.height)
_:
return {"error": "Unsupported shape type: " + shape_type}
# Set the shape
node.shape = shape
return {"message": "Set " + shape_type + " on " + node_name}
#func handle_set_nested_property(params):
#"""Set a nested property like environment/sky/sky_material on a node."""
#if not params.has("node_name") or not params.has("property_name") or not params.has("value"):
#return {"error": "Missing required parameters: node_name, property_name, and value"}
#
#var node_name = params.node_name
#var property_path = params.property_name
#var value = params.value
#var value_type = params.get("value_type", "")
#
#var editor_interface = editor_plugin.get_editor_interface()
#var current_scene = editor_interface.get_edited_scene_root()
#
#if current_scene == null:
#return {"error": "No scene is currently open"}
#
## Find node by name or path
#var node = null
#
## Check if it's a path (contains /)
#if "/" in node_name:
## Try direct path lookup first
#node = current_scene.get_node_or_null(node_name)
#
## If that fails, try with leading slash
#if not node and not node_name.begins_with("/"):
#node = current_scene.get_node_or_null("/" + node_name)
#
## Try other lookup methods if needed...
#else:
## Simple name lookup for non-path names
#node = current_scene.find_child(node_name, true, false)
#
#if not node:
#return {"error": "Node not found: " + node_name}
#
## Split the property path
#var property_parts = property_path.split("/")
#
## Handle special cases for common node types
#if node is WorldEnvironment:
## Make sure the environment exists
#if not node.environment:
#node.environment = Environment.new()
#
## Handle environment properties
#if property_parts.size() >= 1 and property_parts[0] == "environment":
#var env = node.environment
#
## Handle special case for sky material
#if property_parts.size() >= 3 and property_parts[1] == "sky" and property_parts[2] == "sky_material":
## Make sure sky exists
#if not env.sky:
#env.sky = Sky.new()
#
#if property_parts.size() == 3:
## Create the material based on type
#var material = null
#if value == "ProceduralSkyMaterial":
#material = ProceduralSkyMaterial.new()
#elif value == "PanoramaSkyMaterial":
#material = PanoramaSkyMaterial.new()
#elif value == "PhysicalSkyMaterial":
#material = PhysicalSkyMaterial.new()
#else:
#return {"error": "Unknown sky material type: " + str(value)}
#
## Set the sky material
#env.sky.sky_material = material
#return {"message": "Set sky material to " + str(value)}
#
## Handle sky material properties (e.g., environment/sky/sky_material/sky_top_color)
#elif property_parts.size() >= 4 and env.sky.sky_material:
#var material = env.sky.sky_material
#var mat_prop = property_parts[3]
#
## Verify property exists on the material
#if not mat_prop in material:
#return {"error": "Property not found on sky material: " + mat_prop}
#
## Handle color properties
#if typeof(material.get(mat_prop)) == TYPE_COLOR:
#if typeof(value) == TYPE_ARRAY and value.size() >= 3:
#if value.size() >= 4:
#material.set(mat_prop, Color(value[0], value[1], value[2], value[3]))
#else:
#material.set(mat_prop, Color(value[0], value[1], value[2]))
#return {"message": "Set sky material property " + mat_prop + " to " + str(value)}
#else:
## Set other property types
#material.set(mat_prop, value)
#return {"message": "Set sky material property " + mat_prop + " to " + str(value)}
#
## Handle direct environment properties
#elif property_parts.size() == 2:
#var prop = property_parts[1]
#
## Map common property names to actual Godot property names
#match prop:
#"background_color":
#prop = "background_color"
#"ambient_light_color":
#prop = "ambient_light_color"
#"fog_color":
#prop = "fog_color"
#"background_mode":
#prop = "background_mode"
## Add more mappings as needed
#
## Verify property exists
#if not prop in env:
#var available_props = []
#for p in ["background_color", "ambient_light_color", "fog_color", "background_mode",
#"fog_enabled", "fog_density", "glow_enabled", "glow_intensity",
#"adjustment_enabled", "tonemap_mode"]:
#if p in env:
#available_props.append(p)
#return {"error": "Property not found on environment: " + prop +
#". Available properties include: " + str(available_props)}
#
## Convert value based on property type
#var converted_value = value
#var current_value = env.get(prop)
#
## Handle different types
#if typeof(current_value) == TYPE_COLOR:
#if typeof(value) == TYPE_ARRAY and value.size() >= 3:
#if value.size() >= 4:
#converted_value = Color(value[0], value[1], value[2], value[3])
#else:
#converted_value = Color(value[0], value[1], value[2])
#elif typeof(current_value) == TYPE_BOOL:
#if typeof(value) == TYPE_STRING:
#converted_value = (value.to_lower() == "true")
#else:
#converted_value = bool(value)
#elif typeof(current_value) == TYPE_INT:
#converted_value = int(value)
#elif typeof(current_value) == TYPE_FLOAT:
#converted_value = float(value)
#
## Set the property
#env.set(prop, converted_value)
#return {"message": "Set environment property " + prop + " to " + str(converted_value)}
#
## Handle environment sub-objects (e.g., environment/fog/enabled)
#elif property_parts.size() == 3:
#var sub_obj = property_parts[1]
#var sub_prop = property_parts[2]
#
## Map common property paths
#if sub_obj == "fog" and sub_prop == "enabled":
#env.fog_enabled = bool(value)
#return {"message": "Set fog_enabled to " + str(bool(value))}
#elif sub_obj == "glow" and sub_prop == "enabled":
#env.glow_enabled = bool(value)
#return {"message": "Set glow_enabled to " + str(bool(value))}
#elif sub_obj == "ambient_light" and sub_prop == "color":
#if typeof(value) == TYPE_ARRAY and value.size() >= 3:
#env.ambient_light_color = Color(value[0], value[1], value[2])
#return {"message": "Set ambient_light_color to " + str(value)}
#
## Generic property mapping attempt
#var full_prop = sub_obj + "_" + sub_prop
#if full_prop in env:
#env.set(full_prop, value)
#return {"message": "Set " + full_prop + " to " + str(value)}
#
#return {"error": "Unsupported environment property path: " + property_path}
#
## Handle other node types here
## ...
#
#return {"error": "Unsupported nested property path: " + property_path}
func handle_set_nested_property(params):
"""Set a nested property like environment/sky/sky_material on a node."""
if not params.has("node_name") or not params.has("property_name") or not params.has("value"):
return {"error": "Missing required parameters: node_name, property_name, and value"}
var node_name = params.node_name
var property_path = params.property_name
var value = params.value
var value_type = params.get("value_type", "")
print("Setting nested property: ", property_path, " to ", value, " on ", node_name)
var editor_interface = editor_plugin.get_editor_interface()
var current_scene = editor_interface.get_edited_scene_root()
if current_scene == null:
return {"error": "No scene is currently open"}
# Find node by name or path
var node = null
# Check if it's a path (contains /)
if "/" in node_name:
# Try direct path lookup first
node = current_scene.get_node_or_null(node_name)
# If that fails, try with leading slash
if not node and not node_name.begins_with("/"):
node = current_scene.get_node_or_null("/" + node_name)
# Try parsing the path manually if needed
if not node:
# Try other path resolution methods...
pass
else:
# Simple name lookup for non-path names
node = current_scene.find_child(node_name, true, false)
if not node:
return {"error": "Node not found: " + node_name}
# Split the property path
var property_parts = property_path.split("/")
# Handle WorldEnvironment properties
if node is WorldEnvironment:
return _handle_worldenvironment_properties(node, property_parts, value)
# Add other node type handlers here
# Default case for simple properties
return {"error": "Unsupported node type for nested properties: " + node.get_class()}
func _handle_worldenvironment_properties(node, property_parts, value):
"""Handle nested properties for WorldEnvironment nodes."""
# Make sure the environment exists
if not node.environment:
node.environment = Environment.new()
# Get environment resource for easier access
var env = node.environment
# First level should be "environment"
if property_parts.size() < 1 or property_parts[0] != "environment":
return {"error": "WorldEnvironment properties must start with 'environment/'"}
# Handle sky material properties (4-part paths)
if property_parts.size() == 4 and property_parts[1] == "sky" and property_parts[2] == "sky_material":
# Make sure sky exists
if not env.sky:
env.sky = Sky.new()
# Make sure sky material exists
if not env.sky.sky_material:
env.sky.sky_material = ProceduralSkyMaterial.new()
var material = env.sky.sky_material
var property_name = property_parts[3]
# Debug info
print("Trying to set sky material property: ", property_name)
print("Material class: ", material.get_class())
# Direct property handling for cloud properties
if property_name == "use_clouds" or property_name == "clouds_enabled":
# Enable/disable clouds directly
material.use_clouds = bool(value)
return {"message": "Set use_clouds to " + str(bool(value))}
elif property_name == "cloud_color":
# Set cloud color directly
if typeof(value) == TYPE_ARRAY and value.size() >= 3:
material.cloud_color = Color(float(value[0]), float(value[1]), float(value[2]))
return {"message": "Set cloud_color to " + str(material.cloud_color)}
elif property_name == "cloud_coverage":
# Set cloud coverage directly
material.cloud_coverage = float(value)
return {"message": "Set cloud_coverage to " + str(float(value))}
elif property_name == "cloud_size":
# Set cloud size directly
material.cloud_size = float(value)
return {"message": "Set cloud_size to " + str(float(value))}
# Handle other properties with the property map
var property_map = {
# Sky colors
"sky_top_color": "sky_top_color",
"sky_horizon_color": "sky_horizon_color",
"sky_curve": "sky_curve",
"ground_horizon_color": "ground_horizon_color",
"ground_bottom_color": "ground_bottom_color",
"ground_curve": "ground_curve",
# Sun properties
"sun_angle_max": "sun_angle_max",
"sun_curve": "sun_curve"
}
# Check if property name needs to be mapped
if property_name in property_map:
property_name = property_map[property_name]
# Try to set the property with property-specific type conversion
var current_value = material.get(property_name)
var converted_value = value
# Handle different property types
match typeof(current_value):
TYPE_BOOL:
converted_value = bool(value)
TYPE_INT:
converted_value = int(value)
TYPE_FLOAT:
converted_value = float(value)
TYPE_COLOR:
if typeof(value) == TYPE_ARRAY and value.size() >= 3:
if value.size() >= 4:
converted_value = Color(float(value[0]), float(value[1]), float(value[2]), float(value[3]))
else:
converted_value = Color(float(value[0]), float(value[1]), float(value[2]))
# Set the property
material.set(property_name, converted_value)
return {"message": "Set sky material property " + property_name + " to " + str(converted_value)}
return {"error": "Unknown sky material property: " + property_name + ". Available cloud properties: use_clouds, cloud_color, cloud_coverage, cloud_size"}
# Handle sky material type (3-part paths)
elif property_parts.size() == 3 and property_parts[1] == "sky" and property_parts[2] == "sky_material":
# Make sure sky exists
if not env.sky:
env.sky = Sky.new()
# Create the material based on type
var material = null
if value == "ProceduralSkyMaterial":
material = ProceduralSkyMaterial.new()
elif value == "PanoramaSkyMaterial":
material = PanoramaSkyMaterial.new()
elif value == "PhysicalSkyMaterial":
material = PhysicalSkyMaterial.new()
else:
return {"error": "Unknown sky material type: " + str(value)}
# Set the sky material
env.sky.sky_material = material
return {"message": "Set sky material to " + str(value)}
# Handle direct environment properties (2-part paths)
elif property_parts.size() == 2:
var property_name = property_parts[1]
# Map common property name variations to actual property names
var property_map = {
"background": "background_mode",
"ambient_light_color": "ambient_light_color",
"background_color": "background_color",
"fog_enabled": "fog_enabled",
"glow_enabled": "glow_enabled",
"glow_intensity": "glow_intensity",
"fog_density": "fog_density",
"fog_color": "fog_color",
"volumetric_fog_enabled": "volumetric_fog_enabled",
"volumetric_fog_density": "volumetric_fog_density",
"volumetric_fog_albedo": "volumetric_fog_albedo"
}
# Check if we need to map the property name
if property_name in property_map:
property_name = property_map[property_name]
# Verify property exists
if not property_name in env:
return {"error": "Property not found on environment: " + property_name}
# Convert value based on property type
var converted_value = value
var current_value = env.get(property_name)
# Handle different property types
match typeof(current_value):
TYPE_BOOL:
converted_value = bool(value)
TYPE_INT:
converted_value = int(value)
TYPE_FLOAT:
converted_value = float(value)
TYPE_COLOR:
if typeof(value) == TYPE_ARRAY and value.size() >= 3:
if value.size() >= 4:
converted_value = Color(float(value[0]), float(value[1]), float(value[2]), float(value[3]))
else:
converted_value = Color(float(value[0]), float(value[1]), float(value[2]))
# Set the property
env.set(property_name, converted_value)
return {"message": "Set environment property " + property_name + " to " + str(converted_value)}
# Handle fog properties (3-part paths)
elif property_parts.size() == 3 and property_parts[1] == "fog":
var prop = property_parts[2]
if prop == "enabled":
env.fog_enabled = bool(value)
return {"message": "Set fog_enabled to " + str(bool(value))}
elif prop == "density":
env.fog_density = float(value)
return {"message": "Set fog_density to " + str(float(value))}
elif prop == "color":
if typeof(value) == TYPE_ARRAY and value.size() >= 3:
env.fog_color = Color(float(value[0]), float(value[1]), float(value[2]))
return {"message": "Set fog_color to " + str(env.fog_color)}
else:
# Try a direct combined property name
var combined_prop = "fog_" + prop
if combined_prop in env:
env.set(combined_prop, value)
return {"message": "Set " + combined_prop + " to " + str(value)}
return {"error": "Unknown fog property: " + prop}
# Handle volumetric fog properties (3-part paths)
elif property_parts.size() == 3 and property_parts[1] == "volumetric_fog":
var prop = property_parts[2]
if prop == "enabled":
env.volumetric_fog_enabled = bool(value)
return {"message": "Set volumetric_fog_enabled to " + str(bool(value))}
elif prop == "density":
env.volumetric_fog_density = float(value)
return {"message": "Set volumetric_fog_density to " + str(float(value))}
elif prop == "albedo":
if typeof(value) == TYPE_ARRAY and value.size() >= 3:
env.volumetric_fog_albedo = Color(float(value[0]), float(value[1]), float(value[2]))
return {"message": "Set volumetric_fog_albedo to " + str(env.volumetric_fog_albedo)}
else:
# Try a direct combined property name
var combined_prop = "volumetric_fog_" + prop
if combined_prop in env:
env.set(combined_prop, value)
return {"message": "Set " + combined_prop + " to " + str(value)}
return {"error": "Unknown volumetric fog property: " + prop}
# Other environment properties can be added here
return {"error": "Unsupported property path: " + property_parts.join("/")}
# Add the following function:
func handle_delete_script(params):
if not params.has("script_path"):
return {"error": "Missing required parameter: script_path"}
var script_path = params.script_path
# Check if file exists
if not FileAccess.file_exists(script_path):
return {"error": "Script file does not exist: " + script_path}
# Delete the file
var error = DirAccess.remove_absolute(script_path)
if error != OK:
return {"error": "Failed to delete script file: " + script_path + " (Error code: " + str(error) + ")"}
return {
"message": "Script deleted successfully: " + script_path
}
# Add the following function near the handle_delete_script function:
func handle_delete_file(params):
if not params.has("file_path"):
return {"error": "Missing required parameter: file_path"}
var file_path = params.file_path
# Check if file exists
if not FileAccess.file_exists(file_path):
return {"error": "File does not exist: " + file_path}
# Delete the file
var error = DirAccess.remove_absolute(file_path)
if error != OK:
return {"error": "Failed to delete file: " + file_path + " (Error code: " + str(error) + ")"}
return {
"message": "File deleted successfully: " + file_path
}
func handle_show_message(params):
if not params.has("message"):
return {"error": "Missing required parameter: message"}
var message = params.message
# Show a message dialog
editor_plugin.get_editor_interface().show_message_notification(message)
return {"message": "Message shown successfully"}
func handle_reimport_asset(params):
if not params.has("asset_path"):
return {"error": "Missing required parameter: asset_path"}
var asset_path = params.asset_path
# Force a filesystem scan to detect the new file
var editor_filesystem = editor_plugin.get_editor_interface().get_resource_filesystem()
if editor_filesystem:
editor_filesystem.scan()
# Also scan the specific directory
var dir_path = asset_path.get_base_dir()
editor_filesystem.scan_sources()
return {
"message": "Triggered filesystem scan for: " + asset_path
}
else:
return {"error": "Could not access editor filesystem"}
func handle_import_glb_scene(params):
if not params.has("glb_path"):
return {"error": "Missing required parameter: glb_path"}
var glb_path = params.glb_path
var name = params.get("name", "")
var position = params.get("position", [0, 0, 0])
var rotation = params.get("rotation", [0, 0, 0])
var scale = params.get("scale", [1, 1, 1])
var editor_interface = editor_plugin.get_editor_interface()
var current_scene = editor_interface.get_edited_scene_root()
if current_scene == null:
return {"error": "No scene is currently open"}
# Check if the GLB file exists
if not FileAccess.file_exists(glb_path):
return {"error": "GLB file not found: " + glb_path}
# Try to load the GLB as a PackedScene
var glb_scene = load(glb_path)
if not glb_scene:
return {"error": "Failed to load GLB file: " + glb_path}
# Check if it's a PackedScene
if glb_scene is PackedScene:
# Instantiate the packed scene
var instance = glb_scene.instantiate()
if not instance:
return {"error": "Failed to instantiate GLB scene"}
# Set the name
if name != "":
instance.name = name
else:
# Use filename without extension
var filename = glb_path.get_file().get_basename()
instance.name = filename
# Add to current scene
current_scene.add_child(instance)
instance.owner = current_scene
# Set ownership recursively for all children
_set_owner_recursive(instance, current_scene)
# Set transform if it's a 3D node
if instance is Node3D:
instance.position = Vector3(position[0], position[1], position[2])
instance.rotation_degrees = Vector3(rotation[0], rotation[1], rotation[2])
instance.scale = Vector3(scale[0], scale[1], scale[2])
return {
"success": true,
"instance_name": instance.name,
"message": "GLB scene imported successfully as: " + instance.name
}
else:
# If it's not a PackedScene, try to create a MeshInstance3D
var node_name = name if name != "" else glb_path.get_file().get_basename()
# Create a MeshInstance3D
var mesh_instance = MeshInstance3D.new()
mesh_instance.name = node_name
# Try to set the mesh
if glb_scene is Mesh:
mesh_instance.mesh = glb_scene
else:
# Try loading it differently
return {"error": "GLB file is not a PackedScene or Mesh resource"}
# Add to scene
current_scene.add_child(mesh_instance)
mesh_instance.owner = current_scene
# Set transform
mesh_instance.position = Vector3(position[0], position[1], position[2])
mesh_instance.rotation_degrees = Vector3(rotation[0], rotation[1], rotation[2])
mesh_instance.scale = Vector3(scale[0], scale[1], scale[2])
return {
"success": true,
"instance_name": mesh_instance.name,
"message": "GLB imported as MeshInstance3D: " + mesh_instance.name
}
