Better way to handle serialization/deserialization with custom resource formats?

Help Programming
,
1

Godot Version

4.7.stable.mono.official [5b4e0cb0f]

Question

I’m trying to create a custom resource format with ResourceFormatLoader and ResourceFormatSaver that allows me to save Godot resources into a binary format I’ve designed. So far, I have a base Resource class that I use:

[Tool, GlobalClass]
public partial class MyPropertyListResource: Resource {
    private Dictionary<string, Variant> _propertyList;

    public MyPropertyListResource(): base() {
        _propertyList = {
            { "_GDClassName", GetType().AssemblyQualifiedName },
        };
    }
    
    public void InstantiateWithPropertyList(...);
    public Dictionary<string, Variant> SerializePropertyList(...);
}

Where I also have loaders/savers that create this resource type. However, in order for me to expose properties, I often need to write my properties like this, which is a tad unwieldy (GetValue and SetValue are methods I have written to handle different types when serializing/deserializing data, backfilling in any properties that might be missing in the dictionary):

[Tool, GlobalClass]
public partial class PuzzleGraphData: MyPropertyListResource {
    [Export] public string Name {
        get => GetValue(nameof(Name), "");
        set => SetValue(value, nameof(Name));
    }

    [Export] public string BasePath {
        get => GetValue(nameof(BasePath), "");
        set => SetValue(value, nameof(BasePath));
    }
}

Ideally, I’d like to avoid this entirely by having some custom attribute, say ResourceExportable, to simplify the code:

[Tool, GlobalClass]
public partial class PuzzleGraphData: MyPropertyListResource {
    [ResourceExportable] public string Name = "";
    [ResourceExportable] public string BasePath = "";
}

Or, alternatively, I’d like to have a solution that can automagically surface properties to be exposed in the Godot inspector, without me needing to write any additional attributes or boilerplate code. However, I’m not sure how to accomplish either of those. What’s the best way to handle this type of serialization for Godot resources?

What I’ve tried

  • Hooking into _get_property_list(): Admittedly, I tried looking at the docs to see how to best accomplish it, and I didn’t see anything helpful.
  • Looking at other custom resource implementations: I looked at some I found for safe resource loading and some older ones for JSON with Godot 3, but I got pretty confused and didn’t understand what was going on.
  • Writing a custom C# attribute: I know very little about C# attributes. My background is mostly in Swift, so I wouldn’t know where to start. Also, researching it didn’t yield anything useful for me.

Context

  • Why am I making a custom format? I needed a format that could be represented in binary that I could easily parse, as the resources will be shared with another game project for the Playdate console.
  • Why binary and not something like JSON? Because JSON parsing is a pain on the Playdate (also I’d prefer it to be smaller in file size).
  • What’s with _GDClassName in the default dictionary? In order for me to know what resource type I’m instantiating, I’ve added that metadata into the property list itself. When loading the resource with my custom ResourceFormatLoader, I use reflection to find the corresponding type and instantiate it, assuming that the assembly exists.
2

You don’t need to do anything special. Just use Object.get_property_list() to get the @exported properties and Object.get() / Object.set() to get / set their values.

4

I’m not sure I understand. Could you elaborate on how I can use these to better handle serialization? (As aforementioned, I tried with _get_property_list but that failed on me, as there weren’t any good examples or documentation I could follow to understand what was going on).

5

Check the example:

@tool
extends EditorScript


func _run() -> void:
	var saver = MySaver.new()
	var loader = MyLoader.new()
	ResourceSaver.add_resource_format_saver(saver)
	ResourceLoader.add_resource_format_loader(loader)

	var my_res = MyResource.new()
	my_res.name = "John"
	my_res.age = 30

	ResourceSaver.save(my_res, "user://save01.save")

	var res2 = load("user://save01.save")

	printt(res2.name, res2.age)


class MyResource extends Resource:

	@export var name: String
	@export var age: int


class MySaver extends ResourceFormatSaver:


	func _get_recognized_extensions(resource: Resource) -> PackedStringArray:
		if resource is MyResource:
			return ["save"]

		return []


	func _recognize(resource: Resource) -> bool:
		return resource is MyResource


	func _save(resource: Resource, path: String, flags: int) -> Error:
		# Open the file to save
		var file = FileAccess.open(path, FileAccess.WRITE)
		var err = FileAccess.get_open_error()
		if err != OK:
			return err

		# Gather the properties to save
		var save_props = {}
		for prop in resource.get_property_list():
			if prop.name == "script":
				# SKIP script
				continue
			if prop.usage & PROPERTY_USAGE_STORAGE == PROPERTY_USAGE_STORAGE:
				# Only get the ones marked as PROPERTY_USAGE_STORAGE
				save_props.set(prop.name, resource.get(prop.name))

		# Save them
		var json = JSON.stringify(save_props)
		file.store_string(json)

		return OK


class MyLoader extends ResourceFormatLoader:


	func _get_recognized_extensions() -> PackedStringArray:
		return ["save"]


	func _handles_type(type: StringName) -> bool:
		return type == "MyResource"


	func _load(path: String, original_path: String, use_sub_threads: bool, cache_mode: int) -> Variant:
		# Open and parse the file to load
		var file = FileAccess.get_file_as_string(path)
		var json = JSON.parse_string(file)
		
		# Create a MyResource
		var res = MyResource.new()

		# For each entry in the json set the value in the resource
		for prop in json.keys():
			res.set(prop, json.get(prop))

		return res
6

Ahh, I see where I went wrong! I was trying to use this inside the base resource class itself instead of the loader and saver. Thanks for the clarification.