Provide a way for Editor Import Plugins to save images as compressed textures (.ctex)

[viniciusgerevini]

It would be great to have a way for Editor Import Plugins to save images as compressed textures (.ctex)

The same way there is an Image.save_png(path), is there a way to expose the method to save a compressed texture programmatically? This way import plugins could save textures directly to the .godot folder instead of relying on texture importers to kick in for the new files generated.

Use-case

I maintain Aseprite Wizard, which helps users to import animations from Aseprite to Godot in a few different ways.

Besides some manual import strategies, it also adds a few custom importers to use .aseprite files as SpriteFrames or texture resources.

To illustrate, here is how the custom importer for SpriteFrames works at the moment:

1. The spritesheet (png) and metadata (json) files are generated externally using the Aseprite CLI.
2. If it's the first time the import is happening, call append_import_external_resource to trigger the png import, otherwise schedule a scan for after all imports so the cache is updated.
3. Create the SpriteFrames resource using the metadata and link to the newly generated texture.

Throughout the years I've tried a few different approaches to deal with the externally generated png, but this has been the most reliable / consistent so far. However, I don't think it provides a good user experience.

The main issue is not being able to store these generated files inside .godot, as this would not trigger the built-in importer. This means that the generated spritesheet is visible to the user, and unless there is a file pattern they ignored, they end including them in the source control.

Also, triggering a scan just after the import (to update the cache) can be jarring.

For now, in my plugin, imports only generate one spritesheet, but there are feature requests to break the spritesheet's further to workaround the texture 16384px size limitation. This would make the import process quite noisy as all generated pngs would have to be visible to the user.

I don't know anything about Godot internals. Does this make sense? Is there another workaround I'm missing?

[huwpascoe]

This came up in dev-chat, turns out there is a way.

Incomplete example of an EditorImportPlugin

func _test_image() -> Image:
	var img := Image.create(128, 128, false, Image.FORMAT_RGBA8)
	for y in 128:
		for x in 128:
			img.set_pixel(x, y, Color(x/128.0, y/128.0, 0.5))
	return img

func _get_resource_type():
	return "PortableCompressedTexture2D"

func _get_save_extension():
	return "res"

func _import(source_file, save_path, options, r_platform_variants, r_gen_files):
	var tex := PortableCompressedTexture2D.new()
	tex.create_from_image(
		_test_image(), PortableCompressedTexture2D.COMPRESSION_MODE_BASIS_UNIVERSAL)
	return ResourceSaver.save(tex, "%s.%s" % [save_path, _get_save_extension()])

---

And the formats quickly documented because I wanted to know what exactly was different between the two:

PortableCompressedTexture2D

.res

name	bytes
resource_header	...
compression_mode	2
data_format	2
color_format	4
mip_count	4
width	4
height	4
image_data	...

CompressedTexture2D

.ctex

name	bytes
"GST2"	4
version	4
width	4
height	4
flags	4
mip_count	4
reserved	4
reserved	4
reserved	4
data_format	4
width	2
height	2
mip_count	4
color_format	4
image_data	...

[viniciusgerevini]

Oh! Thank you! This is very promising. I will give it a try.

[viniciusgerevini]

Alright! I just tested this today and it works like a charm.

I did have issues with COMPRESSION_MODE_BASIS_UNIVERSAL, which messed with the colors and quality, but using COMPRESSION_MODE_LOSSLESS worked, and the file size was even better most of the times (not an exhaustive test though).

Thank you. This solves my issue. Cheers