Godot Performance Optimization

# custom_monitor_profiler.gd
# Monitoring performance bottlenecks in real-time
extends Label

# EXPERT NOTE: Use Performance.get_monitor to create 
# custom debug overlays that catch regression during play.

func _process(_delta):
	text = "FPS: %d\n" % Engine.get_frames_per_second()
	text += "Draw Calls: %d\n" % Performance.get_monitor(Performance.RENDER_TOTAL_DRAW_CALLS_IN_FRAME)
	text += "Static Memory: %s\n" % String.humanize_size(Performance.get_monitor(Performance.MEMORY_STATIC))
	text += "Objects: %d\n" % Performance.get_monitor(Performance.OBJECT_COUNT)

# skills/performance-optimization/scripts/custom_performance_monitor.gd
extends Node

## Custom Performance Monitor Expert Pattern
## Adds game-specific metrics to the Godot Debugger > Monitors tab.

class_name CustomPerformanceMonitor

enum MonitorType {
	ENEMY_COUNT,
	ACTIVE_PROJECTILES,
	PATHFINDING_TIME_MS,
	CHUNK_LOAD_TIME_MS
}

# Map enum to readable names
var _monitor_names = {
	MonitorType.ENEMY_COUNT: "Game/Enemy Count",
	MonitorType.ACTIVE_PROJECTILES: "Game/Active Projectiles",
	MonitorType.PATHFINDING_TIME_MS: "Game/Pathfinding (ms)",
	MonitorType.CHUNK_LOAD_TIME_MS: "Game/Chunk Load (ms)"
}

var _monitor_values = {}

func _ready() -> void:
	# Only run in debug builds
	if not OS.is_debug_build():
		queue_free()
		return
		
	# Register monitors
	for type in _monitor_names:
		var path = _monitor_names[type]
		if not Performance.has_custom_monitor(path):
			Performance.add_custom_monitor(path, _get_monitor_value.bind(type))
			_monitor_values[type] = 0.0

func update_monitor(type: MonitorType, value: float) -> void:
	if OS.is_debug_build():
		_monitor_values[type] = value

func increment_monitor(type: MonitorType, amount: float = 1.0) -> void:
	if OS.is_debug_build():
		if type in _monitor_values:
			_monitor_values[type] += amount
		else:
			_monitor_values[type] = amount

func _get_monitor_value(type: MonitorType) -> float:
	return _monitor_values.get(type, 0.0)

## EXPERT USAGE:
## CustomPerformanceMonitor.update_monitor(CustomPerformanceMonitor.MonitorType.ENEMY_COUNT, enemies.size())

# low_level_physics_query.gd
# Direct PhysicsServer queries for high performance
extends Node3D

# EXPERT NOTE: Direct space queries via DirectSpaceState 
# are faster than RayCast nodes when doing hundreds of checks 
# per frame (e.g. for AI vision or custom particles).

func _physics_process(_delta):
	var space_state = get_world_3d().direct_space_state
	var query = PhysicsRayQueryParameters3D.create(global_position, global_position + Vector3.FORWARD * 10)
	query.exclude = [get_rid()]
	
	var result = space_state.intersect_ray(query)
	if result:
		# Handle hit
		pass

# manual_culling_logic.gd
# Disabling off-screen logic manually
extends VisibleOnScreenNotifier2D

# EXPERT NOTE: VisibilityNotifiers are the most efficient 
# way to cull heavy _process or _physics_process logic 
# when nodes are not visible to the camera.

func _ready():
	screen_entered.connect(_on_screen_entered)
	screen_exited.connect(_on_screen_exited)

func _on_screen_entered():
	set_process(true)
	set_physics_process(true)

func _on_screen_exited():
	set_process(false)
	set_physics_process(false)

# skills/performance-optimization/code/multimesh_foliage_manager.gd
extends MultiMeshInstance3D

## MultiMesh Foliage Manager Expert Pattern
## Efficiently renders 10,000s of objects in 1 draw call.

@export var instance_count: int = 10000
@export var area_size: float = 50.0

func _ready() -> void:
    # 1. MultiMesh Initialization
    # Expert logic: Use 'MultiMeshInterface' to batch geometry.
    multimesh = MultiMesh.new()
    multimesh.transform_format = MultiMesh.TRANSFORM_3D
    multimesh.instance_count = instance_count
    multimesh.mesh = _get_standard_grass_mesh()
    
    _populate_instances()

func _populate_instances() -> void:
    # 2. Bulk Transform Assignment
    # Professional games set all transforms at once to minimize state changes.
    for i in instance_count:
        var pos = Vector3(
            randf_range(-area_size, area_size),
            0,
            randf_range(-area_size, area_size)
        )
        var basis = Basis().rotated(Vector3.UP, randf() * PI)
        multimesh.set_instance_transform(i, Transform3D(basis, pos))

func _get_standard_grass_mesh() -> Mesh:
    # Placeholder for a simple QuadMesh with a grass texture
    return QuadMesh.new()

## EXPERT NOTE:
## Use 'Draw Call Batching': MultiMesh reduces 10,000 individual nodes 
## into a SINGLE draw call, drastically reducing CPU/GPU overhead.
## For 'performance-optimization', implement 'VisibilityNotifier' to 
## hide the entire MultiMesh node when off-screen.
## NEVER call 'get_node()' or 'find_child()' in '_process'; always 
## cache references in '@onready' or unique instance IDs.

# multimesh_optimizer.gd
# Rendering thousands of instances with MultiMeshInstance
extends MultiMeshInstance3D

# EXPERT NOTE: MultiMesh uses hardware instancing. It is 
# significantly faster than spawning thousands of 
# individual nodes for grass, debris, or particles.

func setup(count: int):
	multimesh.instance_count = count
	for i in range(count):
		var trans = Transform3D(Basis(), Vector3(randf(), 0, randf()) * 10)
		multimesh.set_instance_transform(i, trans)
		multimesh.set_instance_color(i, Color(randf(), randf(), randf()))

# navigation_agent_optimization.gd
# Staggering paths for massive AI crowds
extends NavigationAgent3D

# EXPERT NOTE: Recalculating hundreds of paths per frame 
# kills performance. Stagger updates using a global counter.

static var global_update_tick: int = 0

func _process(_delta):
	global_update_tick += 1
	# Only update path every 10 frames, staggered by this agent's ID
	if (global_update_tick + get_instance_id()) % 10 == 0:
		# target_position = ...
		pass

# object_pool_system.gd
# Minimal allocation strategy for high-frequency objects
extends Node

# EXPERT NOTE: Instantiating nodes is expensive. Pooling 
# avoids the hit by toggling visibility and process mode 
# instead of calling .instantiate() and .queue_free().

@export var pool_size: int = 100
@export var bullet_scene: PackedScene

var pool: Array[Node] = []

func _ready():
	for i in pool_size:
		var node = bullet_scene.instantiate()
		_deactivate_node(node)
		add_child(node)
		pool.append(node)

func spawn():
	for node in pool:
		if not node.visible:
			_activate_node(node)
			return node
	return null

func _activate_node(node):
	node.visible = true
	node.set_process(true)
	node.set_physics_process(true)

func _deactivate_node(node):
	node.visible = false
	node.set_process(false)
	node.set_physics_process(false)

# rendering_server_direct.gd
# Bypassing the Node tree for massive item rendering
extends Node2D

# EXPERT NOTE: The RenderingServer allows you to draw 
# millions of items by avoiding the overhead of the Node 
# hierarchy. Each canvas item is just an RID in the server.

var items: Array[RID] = []

func _ready():
	var canvas = get_canvas_item()
	for i in range(1000):
		var item = RenderingServer.canvas_item_create()
		RenderingServer.canvas_item_set_parent(item, canvas)
		RenderingServer.canvas_item_add_rect(item, Rect2(i, i, 10, 10), Color.RED)
		items.append(item)

func _exit_tree():
	for item in items:
		RenderingServer.free_rid(item)

# shared_resource_strategy.gd
# Using Local-To-Scene vs Shared resources
extends Sprite2D

# EXPERT NOTE: By default, Resources are shared. If you change 
# a property in one instance, it changes for all. Toggle 
# "Local to Scene" for unique instances or use .duplicate() 
# for performance-balanced unique states.

@export var data: Resource

func _ready():
	# If we need a unique instance for this node:
	if not data.resource_local_to_scene:
		data = data.duplicate()

# texture_array_batching.gd
# Reducing state changes with TextureArrays
extends Node

# EXPERT NOTE: Switching textures is a slow "state change" 
# for GPUs. Using Texture2DArray or Atlases allows 
# the RenderingServer to batch multiple draw calls into one.

@export var tex_array: Texture2DArray

func apply_material_index(sprite: Sprite2D, index: int):
	sprite.material.set_shader_parameter("layer_index", index)
	# Shader then pulls from tex_array[index]
	pass

# worker_thread_pool_manager.gd
# Offloading heavy computation to worker threads
extends Node

# EXPERT NOTE: WorkerThreadPool is superior to Thread.new() in 
# Godot 4 as it reuses a pool of system threads, avoiding 
# the overhead of spawning new OS threads intermittently.

func process_massive_dataset(data: Array):
	var task_id = WorkerThreadPool.add_task(_do_heavy_work.bind(data))
	# task_id can be used to check completion or wait
	# WorkerThreadPool.is_task_completed(task_id)

func _do_heavy_work(data: Array):
	for i in data:
		# Process locally without touching the SceneTree directly
		pass