Optimize finalized surface artwork

tests/surface_drawing_performance_validation.gd

@@ -0,0 +1,178 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+extends SceneTree
+
+const CANVAS_COUNT: int = 10
+const GRID_SIZE: int = 128
+const MAX_SETUP_MSEC: float = 2500.0
+const MAX_STATIC_MEMORY_MIB: float = 32.0
+const FINGERPRINT_A := (
+	"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+)
+const FINGERPRINT_B := (
+	"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+)
+
+
+func _initialize() -> void:
+	call_deferred("_run")
+
+
+func _run() -> void:
+	_validate_finalized_capacity()
+	_validate_dense_cells_and_author_index()
+	var drawing_root := Node3D.new()
+	root.add_child(drawing_root)
+	var colors := PackedByteArray()
+	colors.resize(GRID_SIZE * GRID_SIZE)
+	colors.fill(1)
+	var authors := PackedInt32Array()
+	authors.resize(GRID_SIZE * GRID_SIZE)
+	authors.fill(1)
+	var memory_before: int = OS.get_static_memory_usage()
+	var started_usec: int = Time.get_ticks_usec()
+	for canvas_index: int in CANVAS_COUNT:
+		var canvas := SurfaceDrawingCanvas.new()
+		drawing_root.add_child(canvas)
+		var state: Dictionary = _compact_state(
+			"canvas-%d" % canvas_index,
+			canvas_index,
+			colors,
+			authors,
+		)
+		assert(SurfaceDrawingProtocol.validate_canvas_state(state))
+		assert(canvas.setup(state, null))
+		assert(canvas.get_rendered_pixel_count() == GRID_SIZE * GRID_SIZE)
+		var artwork := canvas.get("_pixel_instance") as MeshInstance3D
+		var arrays: Array = artwork.mesh.surface_get_arrays(0)
+		var vertices: PackedVector3Array = arrays[Mesh.ARRAY_VERTEX]
+		assert(
+			vertices.size()
+			<= (SurfaceDrawingCanvas.FINALIZED_MAX_SUBDIVISIONS + 1) ** 2
+		)
+	var setup_msec: float = (
+		float(Time.get_ticks_usec() - started_usec) / 1000.0
+	)
+	var memory_mib: float = (
+		float(OS.get_static_memory_usage() - memory_before) / 1048576.0
+	)
+	assert(
+		setup_msec <= MAX_SETUP_MSEC,
+		"finalized artwork setup took %.2f ms" % setup_msec,
+	)
+	assert(
+		memory_mib <= MAX_STATIC_MEMORY_MIB,
+		"finalized artwork retained %.2f MiB" % memory_mib,
+	)
+	print(
+		"Surface drawing performance validation: PASS (%.2f ms, %.2f MiB)"
+		% [setup_msec, memory_mib]
+	)
+	drawing_root.queue_free()
+	await process_frame
+	quit()
+
+
+func _validate_finalized_capacity() -> void:
+	var world_scene := load(
+		"res://world/generation/generated_world_region.tscn"
+	) as PackedScene
+	assert(world_scene != null)
+	var world_region: Node = world_scene.instantiate()
+	var generator := world_region.get_node(
+		"Terrain/TerrainChunkGenerator"
+	) as TerrainChunkGenerator
+	assert(generator != null and generator.catalog != null)
+	var canvas_extent: float = (
+		float(SurfaceDrawingProtocol.MAX_GRID_SIZE)
+		* SurfaceDrawingProtocol.CELL_SIZE
+	)
+	var required_columns: int = ceili(
+		float(generator.grid_size.x) * generator.catalog.chunk_size
+		/ canvas_extent
+	)
+	var required_rows: int = ceili(
+		float(generator.grid_size.y) * generator.catalog.chunk_size
+		/ canvas_extent
+	)
+	var required_canvases: int = required_columns * required_rows
+	var cells_per_canvas: int = (
+		SurfaceDrawingProtocol.MAX_GRID_SIZE
+		* SurfaceDrawingProtocol.MAX_GRID_SIZE
+	)
+	assert(
+		SurfaceDrawingProtocol.MAX_FINALIZED_CANVASES >= required_canvases,
+		"finalized canvas budget cannot tile the generated world",
+	)
+	assert(
+		SurfaceDrawingProtocol.MAX_FINALIZED_GRID_CELLS
+		>= required_canvases * cells_per_canvas,
+		"finalized cell budget cannot tile the generated world",
+	)
+	world_region.free()
+
+
+func _validate_dense_cells_and_author_index() -> void:
+	var state: Dictionary = {
+		"session_id": "dense-cell-test",
+		"canvas_id": "dense-cell-canvas",
+		"origin": [0.0, 0.0, 0.0],
+		"normal": [0.0, 1.0, 0.0],
+		"tangent": [1.0, 0.0, 0.0],
+		"width": 16,
+		"height": 16,
+		"cell_size": SurfaceDrawingProtocol.CELL_SIZE,
+		"revision": 1,
+		"guide_visible": false,
+		"finalized": true,
+		"layer": 1,
+		"creator_fingerprint": FINGERPRINT_A,
+		"participant_fingerprints": [FINGERPRINT_A, FINGERPRINT_B],
+		"cells": [
+			{"x": 1, "y": 2, "color_id": "coral", "author_fingerprint": FINGERPRINT_A},
+			{"x": 3, "y": 4, "color_id": "blue", "author_fingerprint": FINGERPRINT_B},
+		],
+	}
+	var buffer := SurfaceDrawingCellBuffer.new()
+	assert(buffer.configure_from_state(state))
+	assert(buffer.get_painted_count() == 2)
+	assert(buffer.get_author_cell_keys(FINGERPRINT_A) == PackedInt32Array([33]))
+	assert(buffer.get_author_cell_keys(FINGERPRINT_B) == PackedInt32Array([67]))
+	var compact: Dictionary = state.duplicate(true)
+	compact.erase("cells")
+	compact.merge(buffer.to_compact_fields(), true)
+	assert(SurfaceDrawingProtocol.validate_canvas_state(compact))
+	var restored := SurfaceDrawingCellBuffer.new()
+	assert(restored.configure_from_state(compact))
+	assert(restored.to_cells() == buffer.to_cells())
+	assert(restored.apply_edits([
+		{"x": 1, "y": 2, "color_id": "", "author_fingerprint": ""},
+	]))
+	assert(restored.get_author_cell_keys(FINGERPRINT_A).is_empty())
+	assert(restored.get_painted_count() == 1)
+
+
+func _compact_state(
+	canvas_id: String,
+	layer: int,
+	colors: PackedByteArray,
+	authors: PackedInt32Array,
+) -> Dictionary:
+	return {
+		"session_id": "performance-test",
+		"canvas_id": canvas_id,
+		"origin": [float(layer) * 12.0, 0.0, 0.0],
+		"normal": [0.0, 1.0, 0.0],
+		"tangent": [1.0, 0.0, 0.0],
+		"width": GRID_SIZE,
+		"height": GRID_SIZE,
+		"cell_size": SurfaceDrawingProtocol.CELL_SIZE,
+		"revision": 1,
+		"guide_visible": false,
+		"finalized": true,
+		"layer": layer,
+		"creator_fingerprint": FINGERPRINT_A,
+		"participant_fingerprints": [FINGERPRINT_A],
+		"cell_encoding": SurfaceDrawingProtocol.CELL_ENCODING,
+		"cell_colors": colors,
+		"cell_authors": authors,
+	}