Imported from hhhh124hhhh/godot-mcp (
.claude/skills/godot-skills/sub-skills/godot-performance-optimizer/SKILL.md). Install upstream withnpx skills add hhhh124hhhh/godot-mcp --skill godot-performance-optimizer. Copyright stays with the author.
Godot 性能优化专家技能
技能概述
godot-performance-optimizer 是专门用于 Godot 游戏性能优化和平台适配的智能化技能，能够根据用户的自然语言描述自动完成分辨率适配、性能分析、内存优化、帧率提升、平台适配等全面的性能优化工作。
核心功能
📱 分辨率适配系统
- 多分辨率支持：自动适配不同屏幕分辨率和比例
- DPI缩放：智能DPI检测和UI缩放
- 横竖屏切换：动态横竖屏布局适配
- 平台特定优化：针对不同平台的显示优化
⚡ 性能分析工具
- 帧率监控：实时FPS监控和分析
- 内存分析：内存使用情况追踪和优化建议
- 渲染分析：Draw call、Overdraw等渲染性能分析
- 瓶颈检测：自动检测性能瓶颈和热点代码
🧠 内存优化系统
- 对象池管理：智能对象池和内存回收
- 资源压缩：纹理、音频等资源的智能压缩
- 垃圾回收优化：GC策略优化和内存碎片整理
- 流式加载：大型资源的流式加载和卸载
🎮 渲染优化
- 批处理优化：减少Draw call和渲染批次
- LOD系统：细节层次距离优化
- 遮挡剔除：智能遮挡剔除和视锥剔除
- 着色器优化：GPU着色器性能优化
使用方法
分辨率适配优化
用户: "我的游戏在不同手机上显示不正常，需要适配各种屏幕尺寸"
系统: 自动实现：
- 检测目标设备分辨率范围
- 设计响应式布局系统
- 配置自动缩放和锚点
- 优化UI元素大小和间距
- 测试各种分辨率下的显示效果
性能分析和优化
用户: "游戏在低端设备上运行卡顿，需要优化到60FPS"
系统: 智能优化：
- 全面性能分析和瓶颈检测
- 优化渲染管线和Draw call
- 减少物理计算开销
- 优化脚本执行效率
- 调整画质设置和特效等级
内存使用优化
用户: "游戏内存占用过高，经常闪退，需要优化内存使用"
系统: 全面优化：
- 分析内存使用热点
- 实现智能对象池系统
- 优化资源加载和卸载策略
- 压缩纹理和音频资源
- 配置垃圾回收策略
平台性能适配
用户: "需要为PC、移动、主机三个平台优化性能"
系统: 多平台优化：
- 针对不同平台的性能策略
- 平台特定的渲染设置
- 输入和UI适配优化
- 性能分级和质量设置
工作流程
1. 性能分析阶段
# 全面性能检测
- 帧率和稳定性分析
- 内存使用情况检测
- 渲染性能瓶颈识别
- CPU和GPU使用率分析2. 优化策略制定
# 制定优化方案
- 确定优化优先级
- 选择合适的优化技术
- 平衡画质和性能
- 制定分阶段优化计划3. 自动优化实施
# 执行优化操作
- 自动调整渲染设置
- 优化代码和算法
- 配置资源压缩
- 实现内存管理策略4. 效果验证
# 验证优化效果
- 对比优化前后性能
- 测试不同设备表现
- 验证稳定性改善
- 生成优化报告MCP 工具集成
性能分析工具
get_performance_metrics- 获取性能指标analyze_memory_usage- 分析内存使用profile_render_performance- 分析渲染性能detect_performance_bottlenecks- 检测性能瓶颈
优化操作工具
optimize_render_settings- 优化渲染设置compress_textures- 压缩纹理资源configure_object_pools- 配置对象池adjust_quality_settings- 调整画质设置
平台适配工具
detect_platform_capabilities- 检测平台能力configure_platform_settings- 配置平台设置optimize_for_platform- 针对平台优化test_platform_performance- 测试平台性能
监控调试工具
create_performance_monitor- 创建性能监控器setup_debug_overlay- 设置调试界面log_performance_data- 记录性能数据generate_performance_report- 生成性能报告
分辨率适配系统
智能布局管理器
# 响应式布局管理器
class_name ResponsiveLayoutManager extends Control
@export var base_resolution: Vector2 = Vector2(1920, 1080)
@export var support_orientations: bool = true
var current_scale: float = 1.0
var current_resolution: Vector2
func _ready() -> void:
get_tree().get_window().size_changed.connect(_on_window_resized)
_on_window_resized()
func _on_window_resized() -> void:
var window_size = get_tree().get_window().size
current_resolution = window_size
current_scale = _calculate_scale_factor(window_size)
_apply_scaling()
func _calculate_scale_factor(window_size: Vector2) -> float:
var scale_x = window_size.x / base_resolution.x
var scale_y = window_size.y / base_resolution.y
# 使用最小缩放比例确保内容完全可见
return min(scale_x, scale_y)
func _apply_scaling() -> void:
# 应用缩放到所有子控件
for child in get_children():
if child is Control:
_scale_control_recursive(child, current_scale)DPI适配系统
# DPI适配管理器
class_name DPIAdapter extends Node
var base_dpi: float = 96.0 # 标准DPI
var current_dpi: float = 96.0
var scale_factor: float = 1.0
func _ready() -> void:
_detect_dpi()
_apply_dpi_scaling()
func _detect_dpi() -> void:
var screen = DisplayServer.screen_get_screen_rect()
var physical_size = DisplayServer.screen_get_size()
# 计算DPI
var diagonal_pixels = sqrt(physical_size.x^2 + physical_size.y^2)
var diagonal_inches = sqrt(screen.size.x^2 + screen.size.y^2) / base_dpi
current_dpi = diagonal_pixels / diagonal_inches
scale_factor = current_dpi / base_dpi
func _apply_dpi_scaling() -> void:
# 调整字体大小
var theme = get_tree().current_scene.get_theme()
if theme:
_scale_font_sizes(theme, scale_factor)
# 调整UI元素间距
_scale_ui_spacing(scale_factor)性能分析系统
实时性能监控器
# 性能监控器
class_name PerformanceMonitor extends Node
@export var monitoring_interval: float = 1.0
@export var enable_debug_overlay: bool = true
var fps_history: Array[float] = []
var memory_history: Array[float] = []
var draw_call_history: Array[int] = []
var debug_overlay: Control
func _ready() -> void:
if enable_debug_overlay:
_create_debug_overlay()
var timer = Timer.new()
timer.timeout.connect(_update_metrics)
timer.wait_time = monitoring_interval
timer.autostart = true
add_child(timer)
func _update_metrics() -> void:
# 收集性能指标
var current_fps = Engine.get_frames_per_second()
var memory_usage = OS.get_static_memory_usage_by_type()
var draw_calls = RenderingServer.get_rendering_info(RenderingServer.RENDERING_INFO_DRAW_CALLS_IN_FRAME)
# 更新历史数据
fps_history.append(current_fps)
memory_history.append(memory_usage[OS.MEMORY_TYPE_STATIC] / 1024.0 / 1024.0) # MB
draw_call_history.append(draw_calls)
# 保持历史数据在合理范围内
if fps_history.size() > 60:
fps_history.pop_front()
memory_history.pop_front()
draw_call_history.pop_front()
# 更新调试界面
if debug_overlay:
_update_debug_overlay()
func get_performance_summary() -> Dictionary:
var avg_fps = 0.0
if fps_history.size() > 0:
avg_fps = fps_history.reduce(func(sum, fps): return sum + fps, 0.0) / fps_history.size()
return {
"average_fps": avg_fps,
"min_fps": fps_history.min() if fps_history.size() > 0 else 0,
"max_fps": fps_history.max() if fps_history.size() > 0 else 0,
"memory_usage_mb": memory_history[-1] if memory_history.size() > 0 else 0,
"draw_calls": draw_calls[-1] if draw_calls.size() > 0 else 0
}性能瓶颈检测器
# 性能瓶颈检测器
class_name PerformanceBottleneckDetector extends Node
@export var analysis_duration: float = 5.0
@export var fps_threshold: float = 30.0
@export var memory_threshold_mb: float = 500.0
var analysis_active: bool = false
var analysis_start_time: float = 0.0
func start_analysis() -> void:
analysis_active = true
analysis_start_time = Time.get_time_dict_from_system().hour * 3600 + \
Time.get_time_dict_from_system().minute * 60 + \
Time.get_time_dict_from_system().second
func _process(delta: float) -> void:
if not analysis_active:
return
var current_time = Time.get_time_dict_from_system().hour * 3600 + \
Time.get_time_dict_from_system().minute * 60 + \
Time.get_time_dict_from_system().second
if current_time - analysis_start_time >= analysis_duration:
_analyze_and_report()
analysis_active = false
func _analyze_and_report() -> void:
var report = {}
# 检测FPS问题
var fps = Engine.get_frames_per_second()
if fps < fps_threshold:
report["fps_issue"] = {
"current_fps": fps,
"threshold": fps_threshold,
"suggestions": _get_fps_optimization_suggestions(fps)
}
# 检测内存问题
var memory_mb = OS.get_static_memory_usage_by_type()[OS.MEMORY_TYPE_STATIC] / 1024.0 / 1024.0
if memory_mb > memory_threshold_mb:
report["memory_issue"] = {
"current_memory_mb": memory_mb,
"threshold_mb": memory_threshold_mb,
"suggestions": _get_memory_optimization_suggestions(memory_mb)
}
# 输出报告
_output_performance_report(report)内存优化系统
智能对象池
# 智能对象池管理器
class_name SmartObjectPool extends Node
var pools: Dictionary = {}
@export var max_pool_size: int = 100
@export var cleanup_interval: float = 30.0
func _ready() -> void:
var cleanup_timer = Timer.new()
cleanup_timer.timeout.connect(_cleanup_unused_objects)
cleanup_timer.wait_time = cleanup_interval
cleanup_timer.autostart = true
add_child(cleanup_timer)
func get_object(object_scene: PackedScene) -> Node:
var scene_path = object_scene.resource_path
var pool = pools.get(scene_path)
if not pool:
pool = []
pools[scene_path] = pool
# 从池中获取对象
if pool.size() > 0:
var obj = pool.pop_back()
obj.visible = true
obj.set_process(true)
return obj
# 池中没有可用对象，创建新对象
return object_scene.instantiate()
func return_object(obj: Node) -> void:
var scene_path = obj.scene_file_path
var pool = pools.get(scene_path)
if not pool:
pool = []
pools[scene_path] = pool
# 如果池未满，将对象返回池中
if pool.size() < max_pool_size:
obj.visible = false
obj.set_process(false)
obj.get_parent().remove_child(obj)
pool.append(obj)
else:
# 池已满，直接删除对象
obj.queue_free()
func _cleanup_unused_objects() -> void:
for scene_path in pools.keys():
var pool = pools[scene_path]
# 清理池中一半的对象
var cleanup_count = pool.size() / 2
for i in range(cleanup_count):
pool.pop_front().queue_free()资源压缩优化器
# 资源压缩优化器
class_name AssetCompressionOptimizer extends Node
func optimize_textures_recursively(folder_path: String) -> void:
var dir = DirAccess.open(folder_path)
if not dir:
push_error("Cannot open folder: " + folder_path)
return
dir.list_dir_begin()
var file_name = dir.get_next()
while file_name != "":
var full_path = folder_path + "/" + file_name
if dir.current_is_dir():
# 递归处理子文件夹
optimize_textures_recursively(full_path)
elif file_name.ends_with(".png") or file_name.ends_with(".jpg"):
# 优化纹理文件
optimize_texture(full_path)
file_name = dir.get_next()
func optimize_texture(file_path: String) -> void:
var texture = load(file_path)
if not texture:
return
var image = texture.get_image()
if not image:
return
# 检测是否可以压缩
if image.get_format() != Image.FORMAT_DXT1 or image.get_format() != Image.FORMAT_DXT5:
# 转换为压缩格式
var compressed_format = _select_optimal_format(image)
image.compress(compressed_format, Image.COMPRESS_S3TC)
# 保存优化后的纹理
var optimized_texture = ImageTexture.new()
optimized_texture.set_image(image)
var save_path = file_path.get_basename() + "_optimized" + file_path.get_extension()
ResourceSaver.save(optimized_texture, save_path)
func _select_optimal_format(image: Image) -> Image.Format:
# 根据图像特征选择最佳压缩格式
if image.detect_alpha():
return Image.FORMAT_DXT5 # 带透明度
else:
return Image.FORMAT_DXT1 # 不带透明度渲染优化系统
批处理优化器
# 渲染批处理优化器
class_name RenderingBatchOptimizer extends Node
@export var batch_size: int = 100
@export var max_distance: float = 1000.0
var batch_groups: Dictionary = {}
func _ready() -> void:
# 注册到性能监控
var performance_monitor = PerformanceMonitor.new()
add_child(performance_monitor)
func optimize_rendering() -> void:
# 收集所有可批处理的对象
var renderable_objects = _get_renderable_objects()
# 按材质和纹理分组
var groups = _group_by_material(renderable_objects)
# 为每个组创建批处理
for group_key in groups.keys():
_create_render_batch(groups[group_key])
func _get_renderable_objects() -> Array[Node]:
var objects: Array[Node] = []
var tree = get_tree()
# 遍历场景树收集可渲染对象
_collect_renderable_objects_recursive(tree.current_scene, objects)
return objects
func _collect_renderable_objects_recursive(node: Node, objects: Array[Node]) -> void:
# 检查节点是否可批处理
if _can_be_batched(node):
objects.append(node)
# 递归处理子节点
for child in node.get_children():
_collect_renderable_objects_recursive(child, objects)
func _can_be_batched(node: Node) -> bool:
# 检查节点是否适合批处理
if not node is Sprite2D and not node is MeshInstance3D:
return false
# 检查是否使用相同的材质
# 检查是否在合理的距离范围内
# 检查其他批处理条件
return trueLOD系统管理器
# LOD（细节层次）系统管理器
class_name LODManager extends Node
@export var camera_path: NodePath
@export var lod_distances: Array[float] = [10.0, 25.0, 50.0, 100.0]
var camera: Camera3D
var lod_objects: Array[LODObject] = []
func _ready() -> void:
# ✅ 正确：添加节点存在性和类型检查
if camera_path and has_node(camera_path):
var node = get_node(camera_path)
if node is Camera3D:
camera = node
else:
push_warning("指定路径的节点不是 Camera3D 类型: " + camera_path)
elif camera_path:
push_warning("找不到指定的相机节点: " + camera_path)
else:
# 如果没有指定路径，尝试自动查找主相机
camera = get_viewport().get_camera_3d()
if not camera:
push_warning("场景中未找到相机，LOD 系统将无法工作")
func register_lod_object(obj: Node, lod_levels: Array[Mesh]) -> void:
var lod_obj = LODObject.new()
lod_obj.object = obj
lod_obj.lod_levels = lod_levels
lod_objects.append(lod_obj)
func _process(_delta: float) -> void:
if not camera:
return
var camera_pos = camera.global_position
# 更新所有LOD对象
for lod_obj in lod_objects:
var distance = camera_pos.distance_to(lod_obj.object.global_position)
var lod_level = _calculate_lod_level(distance)
_apply_lod_level(lod_obj, lod_level)
func _calculate_lod_level(distance: float) -> int:
for i in range(lod_distances.size()):
if distance < lod_distances[i]:
return i
return lod_distances.size() - 1
func _apply_lod_level(lod_obj: LODObject, level: int) -> void:
if level < lod_obj.lod_levels.size():
var mesh_instance = lod_obj.object as MeshInstance3D
if mesh_instance:
mesh_instance.mesh = lod_obj.lod_levels[level]
# LOD对象数据结构
class LODObject:
var object: Node
var lod_levels: Array[Mesh]
var current_level: int = 0智能特性
自适应优化
- 性能检测：实时检测设备性能表现
- 动态调整：根据性能自动调整画质
- 预测优化：预测性能瓶颈并提前优化
- 学习优化：基于使用数据优化策略
平台智能适配
- 设备识别：自动识别设备性能等级
- 配置优化：针对设备特点优化配置
- 资源适配：选择合适的资源质量
- 功能开关：智能开关高级功能
用户行为分析
- 使用模式：分析用户使用习惯
- 热点检测：识别性能热点场景
- 体验优化：基于用户体验优化
- 反馈收集：收集性能反馈数据
示例实现
完整性能优化系统
# 智能性能优化系统
class_name SmartPerformanceOptimizer extends Node
@export var target_fps: float = 60.0
@export var enable_adaptive_quality: bool = true
var performance_monitor: PerformanceMonitor
var object_pool: SmartObjectPool
var lod_manager: LODManager
var compression_optimizer: AssetCompressionOptimizer
func _ready() -> void:
_initialize_systems()
start_continuous_optimization()
func _initialize_systems() -> void:
# 初始化各个子系统
performance_monitor = PerformanceMonitor.new()
object_pool = SmartObjectPool.new()
lod_manager = LODManager.new()
compression_optimizer = AssetCompressionOptimizer.new()
add_child(performance_monitor)
add_child(object_pool)
add_child(lod_manager)
add_child(compression_optimizer)
func start_continuous_optimization() -> void:
var optimization_timer = Timer.new()
optimization_timer.timeout.connect(_continuous_optimization_check)
optimization_timer.wait_time = 5.0 # 每5秒检查一次
optimization_timer.autostart = true
add_child(optimization_timer)
func _continuous_optimization_check() -> void:
var metrics = performance_monitor.get_performance_summary()
if metrics.average_fps < target_fps:
_apply_performance_optimizations(metrics)
elif metrics.average_fps > target_fps * 1.2:
_can_increase_quality(metrics)
func _apply_performance_optimizations(metrics: Dictionary) -> void:
# FPS不足时应用优化
if metrics.average_fps < target_fps * 0.8:
_reduce_rendering_quality()
if metrics.memory_usage_mb > 300.0:
_optimize_memory_usage()
if metrics.draw_calls > 100:
_optimize_rendering_pipeline()
func _reduce_rendering_quality() -> void:
# 降低渲染质量
RenderingServer.camera_set_use_vertical_aspect(true)
get_viewport().msaa_3d = Viewport.MSAA_DISABLED
get_viewport().screen_space_aa = Viewport.SCREEN_SPACE_AA_DISABLED
func _optimize_memory_usage() -> void:
# 优化内存使用
object_pool._cleanup_unused_objects()
compression_optimizer.optimize_textures_recursively("res://assets/")质量保证
性能验证
- 基准测试：标准化的性能基准测试
- 压力测试：高负载下的稳定性测试
- 长时间测试：长时间运行的稳定性验证
- 多设备测试：不同设备上的性能验证
优化效果评估
- 量化指标：具体的性能提升数据
- 用户体验：主观体验改善评估
- 稳定性分析：优化后的稳定性分析
- 兼容性验证：确保优化不影响兼容性
回归测试
- 功能完整性：确保功能不受影响
- 视觉质量：验证视觉质量保持
- 音频同步：确保音画同步正常
- 交互响应：验证交互响应及时
使用限制和注意事项
技术限制
- 硬件限制：低端硬件的优化空间有限
- 功能权衡：某些优化可能影响功能
- 平台差异：不同平台的优化策略不同
最佳实践
- 渐进优化：逐步优化，避免激进改动
- 测试验证：每次优化后进行充分测试
- 用户反馈：重视用户的使用反馈
故障排除
常见问题
- 优化后性能下降：检查优化策略是否正确
- 视觉质量下降：平衡性能和画质
- 内存泄漏：检查对象池和资源管理
- 兼容性问题：验证不同平台的表现
调试技巧
- 使用性能监控工具
- 分析性能瓶颈报告
- 检查优化配置参数
- 对比优化前后的表现
更新日志
v1.0.0 (当前版本)
- 基础性能监控功能
- 分辨率适配系统
- 内存优化工具
- 渲染批处理优化
计划功能
- AI智能优化建议
- 云端性能数据分析
- 更多平台适配策略
- 高级性能诊断工具
技能状态: ✅ 可用 最后更新: 2025-11-09 兼容性: Godot 4.5+ 依赖: Godot MCP 工具集 + 性能优化知识