@satelliteoflove/godot-mcp 2.3.0 → 2.4.1

package/addon/commands/resource_commands.gd

@@ -0,0 +1,293 @@
+@tool
+extends MCPBaseCommand
+class_name MCPResourceCommands
+
+
+const MAX_ARRAY_PREVIEW := 100
+const BINARY_ARRAY_TYPES := [
+	TYPE_PACKED_BYTE_ARRAY,
+	TYPE_PACKED_INT32_ARRAY,
+	TYPE_PACKED_INT64_ARRAY,
+	TYPE_PACKED_FLOAT32_ARRAY,
+	TYPE_PACKED_FLOAT64_ARRAY,
+]
+
+
+func get_commands() -> Dictionary:
+	return {
+		"get_resource_info": get_resource_info
+	}
+
+
+func get_resource_info(params: Dictionary) -> Dictionary:
+	var resource_path: String = params.get("resource_path", "")
+	var max_depth: int = params.get("max_depth", 1)
+	var include_internal: bool = params.get("include_internal", false)
+
+	if resource_path.is_empty():
+		return _error("INVALID_PARAMS", "resource_path is required")
+
+	if not ResourceLoader.exists(resource_path):
+		return _error("RESOURCE_NOT_FOUND", "Resource not found: %s" % resource_path)
+
+	var resource := load(resource_path)
+	if not resource:
+		return _error("LOAD_FAILED", "Failed to load resource: %s" % resource_path)
+
+	var result := {
+		"resource_path": resource_path,
+		"resource_type": resource.get_class()
+	}
+
+	var type_specific := _get_type_specific_info(resource, max_depth)
+	if not type_specific.is_empty():
+		result["type_specific"] = type_specific
+	else:
+		var properties := _get_generic_properties(resource, max_depth, include_internal)
+		if not properties.is_empty():
+			result["properties"] = properties
+
+	return _success(result)
+
+
+func _get_type_specific_info(resource: Resource, max_depth: int) -> Dictionary:
+	if resource is SpriteFrames:
+		return _format_sprite_frames(resource, max_depth)
+	elif resource is TileSet:
+		return _format_tileset(resource, max_depth)
+	elif resource is ShaderMaterial:
+		return _format_shader_material(resource, max_depth)
+	elif resource is StandardMaterial3D or resource is ORMMaterial3D:
+		return _format_standard_material(resource, max_depth)
+	elif resource is Texture2D:
+		return _format_texture2d(resource)
+	return {}
+
+
+func _format_sprite_frames(sf: SpriteFrames, max_depth: int) -> Dictionary:
+	var animations := []
+
+	for anim_name in sf.get_animation_names():
+		var anim_info := {
+			"name": str(anim_name),
+			"frame_count": sf.get_frame_count(anim_name),
+			"fps": sf.get_animation_speed(anim_name),
+			"loop": sf.get_animation_loop(anim_name),
+		}
+
+		if max_depth >= 1:
+			var frames := []
+			for i in range(sf.get_frame_count(anim_name)):
+				var texture := sf.get_frame_texture(anim_name, i)
+				var frame_info := {
+					"index": i,
+					"duration": sf.get_frame_duration(anim_name, i),
+				}
+
+				if texture:
+					frame_info["texture_type"] = texture.get_class()
+
+					if texture is AtlasTexture:
+						var atlas := texture as AtlasTexture
+						if atlas.atlas:
+							frame_info["atlas_source"] = atlas.atlas.resource_path
+						frame_info["region"] = _serialize_rect2(atlas.region)
+						if atlas.margin != Rect2():
+							frame_info["margin"] = _serialize_rect2(atlas.margin)
+					elif texture.resource_path:
+						frame_info["texture_path"] = texture.resource_path
+
+				frames.append(frame_info)
+			anim_info["frames"] = frames
+
+		animations.append(anim_info)
+
+	return {"animations": animations}
+
+
+func _format_tileset(ts: TileSet, max_depth: int) -> Dictionary:
+	var sources := []
+
+	for i in range(ts.get_source_count()):
+		var source_id := ts.get_source_id(i)
+		var source := ts.get_source(source_id)
+		var source_info := {
+			"source_id": source_id,
+			"source_type": source.get_class(),
+		}
+
+		if source is TileSetAtlasSource:
+			var atlas := source as TileSetAtlasSource
+			if atlas.texture:
+				source_info["texture_path"] = atlas.texture.resource_path
+			source_info["texture_region_size"] = _serialize_vector2i(atlas.texture_region_size)
+			source_info["tile_count"] = atlas.get_tiles_count()
+
+			if max_depth >= 2:
+				var tiles := []
+				for j in range(atlas.get_tiles_count()):
+					var coords := atlas.get_tile_id(j)
+					tiles.append({
+						"atlas_coords": _serialize_vector2i(coords),
+						"size": _serialize_vector2i(atlas.get_tile_size_in_atlas(coords))
+					})
+				source_info["tiles"] = _truncate_array(tiles)
+
+		elif source is TileSetScenesCollectionSource:
+			var scenes := source as TileSetScenesCollectionSource
+			source_info["scene_count"] = scenes.get_scene_tiles_count()
+
+		sources.append(source_info)
+
+	return {
+		"tile_size": _serialize_vector2i(ts.tile_size),
+		"source_count": ts.get_source_count(),
+		"physics_layers_count": ts.get_physics_layers_count(),
+		"navigation_layers_count": ts.get_navigation_layers_count(),
+		"custom_data_layers_count": ts.get_custom_data_layers_count(),
+		"terrain_sets_count": ts.get_terrain_sets_count(),
+		"sources": sources
+	}
+
+
+func _format_shader_material(mat: ShaderMaterial, max_depth: int) -> Dictionary:
+	var result := {
+		"shader_path": mat.shader.resource_path if mat.shader else ""
+	}
+
+	if mat.shader and max_depth >= 1:
+		var params := {}
+		for prop in mat.get_property_list():
+			var prop_name: String = prop["name"]
+			if prop_name.begins_with("shader_parameter/"):
+				var param_name := prop_name.substr(len("shader_parameter/"))
+				var value = mat.get_shader_parameter(param_name)
+				params[param_name] = _serialize_property_value(value, max_depth - 1)
+		if not params.is_empty():
+			result["shader_parameters"] = params
+
+	return result
+
+
+func _format_standard_material(mat: BaseMaterial3D, max_depth: int) -> Dictionary:
+	var result := {
+		"albedo_color": _serialize_color(mat.albedo_color),
+		"metallic": mat.metallic,
+		"roughness": mat.roughness,
+		"emission_enabled": mat.emission_enabled,
+		"transparency": mat.transparency,
+		"cull_mode": mat.cull_mode,
+		"shading_mode": mat.shading_mode
+	}
+
+	if mat.albedo_texture:
+		result["albedo_texture"] = mat.albedo_texture.resource_path
+
+	if mat.emission_enabled and mat.emission_texture:
+		result["emission_texture"] = mat.emission_texture.resource_path
+
+	if mat.normal_enabled and mat.normal_texture:
+		result["normal_texture"] = mat.normal_texture.resource_path
+
+	return result
+
+
+func _format_texture2d(tex: Texture2D) -> Dictionary:
+	var result := {
+		"width": tex.get_width(),
+		"height": tex.get_height(),
+		"texture_type": tex.get_class()
+	}
+
+	if tex is CompressedTexture2D:
+		var ct := tex as CompressedTexture2D
+		result["load_path"] = ct.load_path
+
+	if tex is AtlasTexture:
+		var at := tex as AtlasTexture
+		if at.atlas:
+			result["atlas_source"] = at.atlas.resource_path
+		result["region"] = _serialize_rect2(at.region)
+		if at.margin != Rect2():
+			result["margin"] = _serialize_rect2(at.margin)
+
+	return result
+
+
+func _get_generic_properties(resource: Resource, max_depth: int, include_internal: bool) -> Dictionary:
+	var properties := {}
+
+	for prop in resource.get_property_list():
+		var prop_name: String = prop["name"]
+
+		if prop_name.begins_with("_") and not include_internal:
+			continue
+		if prop["usage"] & PROPERTY_USAGE_EDITOR == 0:
+			continue
+		if prop_name in ["resource_local_to_scene", "resource_path", "resource_name", "script"]:
+			continue
+
+		var value = resource.get(prop_name)
+		properties[prop_name] = _serialize_property_value(value, max_depth)
+
+	return properties
+
+
+func _serialize_property_value(value: Variant, depth: int) -> Variant:
+	var value_type := typeof(value)
+
+	if value_type in BINARY_ARRAY_TYPES:
+		return {"_binary_array": true, "size": value.size(), "type": type_string(value_type)}
+
+	if value_type == TYPE_ARRAY:
+		if value.size() > MAX_ARRAY_PREVIEW:
+			var preview := []
+			for i in range(MAX_ARRAY_PREVIEW):
+				preview.append(_serialize_property_value(value[i], depth - 1) if depth > 0 else str(value[i]))
+			return {"_truncated": true, "size": value.size(), "preview": preview}
+		else:
+			var result := []
+			for item in value:
+				result.append(_serialize_property_value(item, depth - 1) if depth > 0 else str(item))
+			return result
+
+	if value_type == TYPE_DICTIONARY:
+		var result := {}
+		for key in value:
+			result[str(key)] = _serialize_property_value(value[key], depth - 1) if depth > 0 else str(value[key])
+		return result
+
+	if value_type == TYPE_OBJECT:
+		if value == null:
+			return null
+		if value is Resource:
+			if value.resource_path and not value.resource_path.is_empty():
+				return {"_resource_ref": value.resource_path, "type": value.get_class()}
+			elif depth > 0:
+				return {"_inline_resource": true, "type": value.get_class()}
+			return str(value)
+		return str(value)
+
+	return _serialize_value(value)
+
+
+func _serialize_rect2(r: Rect2) -> Dictionary:
+	return {"x": r.position.x, "y": r.position.y, "width": r.size.x, "height": r.size.y}
+
+
+func _serialize_vector2i(v: Vector2i) -> Dictionary:
+	return {"x": v.x, "y": v.y}
+
+
+func _serialize_color(c: Color) -> Dictionary:
+	return {"r": c.r, "g": c.g, "b": c.b, "a": c.a}
+
+
+func _truncate_array(arr: Array, limit: int = MAX_ARRAY_PREVIEW) -> Variant:
+	if arr.size() <= limit:
+		return arr
+	return {
+		"_truncated": true,
+		"size": arr.size(),
+		"preview": arr.slice(0, limit)
+	}

package/addon/commands/resource_commands.gd.uid

@@ -0,0 +1 @@
+uid://tg6qm22o8jlf

package/addon/commands/scene3d_commands.gd

@@ -0,0 +1,162 @@
+@tool
+extends MCPBaseCommand
+class_name MCPScene3DCommands
+
+
+func get_commands() -> Dictionary:
+	return {
+		"get_spatial_info": get_spatial_info,
+		"get_scene_bounds": get_scene_bounds,
+	}
+
+
+func get_spatial_info(params: Dictionary) -> Dictionary:
+	var scene_check := _require_scene_open()
+	if not scene_check.is_empty():
+		return scene_check
+
+	var node_path: String = params.get("node_path", "")
+	var include_children: bool = params.get("include_children", false)
+	var type_filter: String = params.get("type_filter", "")
+	var max_results: int = params.get("max_results", 0)
+	var within_aabb: Dictionary = params.get("within_aabb", {})
+
+	if node_path.is_empty():
+		return _error("INVALID_PARAMS", "node_path is required")
+
+	var node := _get_node(node_path)
+	if not node:
+		return _error("NODE_NOT_FOUND", "Node not found: %s" % node_path)
+
+	if not node is Node3D:
+		return _error("NOT_NODE3D", "Node is not a Node3D: %s" % node_path)
+
+	var filter_aabb: AABB = AABB()
+	var use_aabb_filter := false
+	if not within_aabb.is_empty():
+		var pos: Dictionary = within_aabb.get("position", {})
+		var size: Dictionary = within_aabb.get("size", {})
+		if pos.has("x") and size.has("x"):
+			filter_aabb = AABB(
+				Vector3(pos.get("x", 0), pos.get("y", 0), pos.get("z", 0)),
+				Vector3(size.get("x", 0), size.get("y", 0), size.get("z", 0))
+			)
+			use_aabb_filter = true
+
+	var nodes: Array[Dictionary] = []
+	var state := {"max": max_results, "count": 0, "stopped": false}
+	_collect_spatial_info(node, nodes, type_filter, include_children, use_aabb_filter, filter_aabb, state)
+
+	var result := {"nodes": nodes, "count": nodes.size()}
+	if state.stopped:
+		result["truncated"] = true
+		result["max_results"] = max_results
+	return _success(result)
+
+
+func _collect_spatial_info(node: Node, results: Array[Dictionary], type_filter: String, include_children: bool, use_aabb_filter: bool, filter_aabb: AABB, state: Dictionary) -> void:
+	if state.max > 0 and state.count >= state.max:
+		state.stopped = true
+		return
+
+	if node is Node3D:
+		var node3d := node as Node3D
+		var type_matches := type_filter.is_empty() or node.is_class(type_filter)
+		var aabb_matches := true
+		if use_aabb_filter:
+			aabb_matches = filter_aabb.has_point(node3d.global_position)
+		if type_matches and aabb_matches:
+			results.append(_get_node3d_info(node3d))
+			state.count += 1
+
+	if include_children and not state.stopped:
+		for child in node.get_children():
+			_collect_spatial_info(child, results, type_filter, true, use_aabb_filter, filter_aabb, state)
+			if state.stopped:
+				break
+
+
+func _get_node3d_info(node: Node3D) -> Dictionary:
+	var scene_root := EditorInterface.get_edited_scene_root()
+	var relative_path := scene_root.get_path_to(node)
+	var usable_path := "/root/" + scene_root.name
+	if relative_path != NodePath("."):
+		usable_path += "/" + str(relative_path)
+
+	var gpos: Vector3 = node.global_position
+	var grot: Vector3 = node.global_rotation
+	var gscale: Vector3 = node.global_transform.basis.get_scale()
+
+	var info := {
+		"path": usable_path,
+		"type": node.get_class(),
+		"global_position": {"x": gpos.x, "y": gpos.y, "z": gpos.z},
+		"global_rotation": {"x": grot.x, "y": grot.y, "z": grot.z},
+		"global_scale": {"x": gscale.x, "y": gscale.y, "z": gscale.z},
+		"visible": node.visible,
+	}
+
+	if node is VisualInstance3D:
+		var aabb := (node as VisualInstance3D).get_aabb()
+		var global_aabb := node.global_transform * aabb
+		info["aabb"] = _serialize_aabb(aabb)
+		info["global_aabb"] = _serialize_aabb(global_aabb)
+
+	return info
+
+
+func _serialize_aabb(aabb: AABB) -> Dictionary:
+	return {
+		"position": _serialize_value(aabb.position),
+		"size": _serialize_value(aabb.size),
+		"end": _serialize_value(aabb.end),
+	}
+
+
+func get_scene_bounds(params: Dictionary) -> Dictionary:
+	var scene_check := _require_scene_open()
+	if not scene_check.is_empty():
+		return scene_check
+
+	var root_path: String = params.get("root_path", "")
+	var scene_root := EditorInterface.get_edited_scene_root()
+
+	var search_root: Node = scene_root
+	if not root_path.is_empty():
+		search_root = _get_node(root_path)
+		if not search_root:
+			return _error("NODE_NOT_FOUND", "Root node not found: %s" % root_path)
+
+	var state := {"aabb": AABB(), "count": 0, "first": true}
+	_collect_bounds(search_root, state)
+
+	if state.count == 0:
+		return _error("NO_GEOMETRY", "No VisualInstance3D nodes found under: %s" % (root_path if not root_path.is_empty() else "scene root"))
+
+	var usable_path := "/root/" + scene_root.name
+	if search_root != scene_root:
+		var relative_path := scene_root.get_path_to(search_root)
+		usable_path += "/" + str(relative_path)
+
+	return _success({
+		"root_path": usable_path,
+		"node_count": state.count,
+		"combined_aabb": _serialize_aabb(state.aabb),
+	})
+
+
+func _collect_bounds(node: Node, state: Dictionary) -> void:
+	if node is VisualInstance3D:
+		var visual := node as VisualInstance3D
+		var local_aabb := visual.get_aabb()
+		var global_aabb := visual.global_transform * local_aabb
+
+		if state.first:
+			state.aabb = global_aabb
+			state.first = false
+		else:
+			state.aabb = state.aabb.merge(global_aabb)
+		state.count += 1
+
+	for child in node.get_children():
+		_collect_bounds(child, state)

package/addon/commands/scene3d_commands.gd.uid

@@ -0,0 +1 @@
+uid://dt8hadn4m25l8

package/addon/commands/scene_commands.gd

@@ -0,0 +1,131 @@
+@tool
+extends MCPBaseCommand
+class_name MCPSceneCommands
+
+
+func get_commands() -> Dictionary:
+	return {
+		"get_current_scene": get_current_scene,
+		"get_scene_tree": get_scene_tree,
+		"open_scene": open_scene,
+		"save_scene": save_scene,
+		"create_scene": create_scene
+	}
+
+
+func get_current_scene(_params: Dictionary) -> Dictionary:
+	var root := EditorInterface.get_edited_scene_root()
+	if not root:
+		return _success({
+			"path": null,
+			"root_name": null,
+			"root_type": null
+		})
+
+	return _success({
+		"path": root.scene_file_path,
+		"root_name": root.name,
+		"root_type": root.get_class()
+	})
+
+
+func get_scene_tree(_params: Dictionary) -> Dictionary:
+	var root := EditorInterface.get_edited_scene_root()
+	if not root:
+		return _error("NO_SCENE", "No scene is currently open")
+
+	return _success({"tree": _build_tree(root)})
+
+
+func _build_tree(node: Node) -> Dictionary:
+	var result := {
+		"name": node.name,
+		"type": node.get_class(),
+	}
+
+	if node is Node2D:
+		var pos: Vector2 = node.position
+		result["position"] = {"x": pos.x, "y": pos.y}
+	elif node is Node3D:
+		var pos: Vector3 = node.position
+		result["position"] = {"x": pos.x, "y": pos.y, "z": pos.z}
+
+	var children: Array[Dictionary] = []
+	for child in node.get_children():
+		children.append(_build_tree(child))
+
+	if not children.is_empty():
+		result["children"] = children
+
+	return result
+
+
+func open_scene(params: Dictionary) -> Dictionary:
+	var scene_path: String = params.get("scene_path", "")
+	if scene_path.is_empty():
+		return _error("INVALID_PARAMS", "scene_path is required")
+
+	if not FileAccess.file_exists(scene_path):
+		return _error("FILE_NOT_FOUND", "Scene file not found: %s" % scene_path)
+
+	EditorInterface.open_scene_from_path(scene_path)
+	return _success({"path": scene_path})
+
+
+func save_scene(params: Dictionary) -> Dictionary:
+	var root := EditorInterface.get_edited_scene_root()
+	if not root:
+		return _error("NO_SCENE", "No scene is currently open")
+
+	var path: String = params.get("path", "")
+	if path.is_empty():
+		path = root.scene_file_path
+
+	if path.is_empty():
+		return _error("NO_PATH", "Scene has no path and none was provided")
+
+	var packed_scene := PackedScene.new()
+	var err := packed_scene.pack(root)
+	if err != OK:
+		return _error("PACK_FAILED", "Failed to pack scene: %s" % error_string(err))
+
+	err = ResourceSaver.save(packed_scene, path)
+	if err != OK:
+		return _error("SAVE_FAILED", "Failed to save scene: %s" % error_string(err))
+
+	return _success({"path": path})
+
+
+func create_scene(params: Dictionary) -> Dictionary:
+	var root_type: String = params.get("root_type", "")
+	var root_name: String = params.get("root_name", root_type)
+	var scene_path: String = params.get("scene_path", "")
+
+	if root_type.is_empty():
+		return _error("INVALID_PARAMS", "root_type is required")
+	if scene_path.is_empty():
+		return _error("INVALID_PARAMS", "scene_path is required")
+
+	if not ClassDB.class_exists(root_type):
+		return _error("INVALID_TYPE", "Unknown node type: %s" % root_type)
+
+	var root: Node = ClassDB.instantiate(root_type)
+	if not root:
+		return _error("CREATE_FAILED", "Failed to create node of type: %s" % root_type)
+
+	root.name = root_name
+
+	var packed_scene := PackedScene.new()
+	var err := packed_scene.pack(root)
+	root.free()
+
+	if err != OK:
+		return _error("PACK_FAILED", "Failed to pack scene: %s" % error_string(err))
+
+	err = ResourceSaver.save(packed_scene, scene_path)
+	if err != OK:
+		return _error("SAVE_FAILED", "Failed to save scene: %s" % error_string(err))
+
+	EditorInterface.open_scene_from_path(scene_path)
+	return _success({"path": scene_path})
+

package/addon/commands/scene_commands.gd.uid

@@ -0,0 +1 @@
+uid://odetea75q17p