Add color channel filter to editor texture previews

editor/plugins/texture_editor_plugin.cpp

@@ -31,6 +31,7 @@
 #include "texture_editor_plugin.h"
 
 #include "editor/editor_string_names.h"
+#include "editor/plugins/color_channel_selector.h"
 #include "editor/themes/editor_scale.h"
 #include "scene/gui/aspect_ratio_container.h"
 #include "scene/gui/color_rect.h"
@@ -41,6 +42,36 @@
 #include "scene/resources/compressed_texture.h"
 #include "scene/resources/image_texture.h"
 #include "scene/resources/portable_compressed_texture.h"
+#include "scene/resources/style_box_flat.h"
+
+constexpr const char *texture_2d_shader = R"(
+shader_type canvas_item;
+render_mode blend_mix;
+
+uniform vec4 u_channel_factors = vec4(1.0);
+
+vec4 filter_preview_colors(vec4 input_color, vec4 factors) {
+	// Filter RGB.
+	vec4 output_color = input_color * vec4(factors.rgb, input_color.a);
+
+	// Remove transparency when alpha is not enabled.
+	output_color.a = mix(1.0, output_color.a, factors.a);
+
+	// Switch to opaque grayscale when visualizing only one channel.
+	float csum = factors.r + factors.g + factors.b + factors.a;
+	float single = clamp(2.0 - csum, 0.0, 1.0);
+	for (int i = 0; i < 4; i++) {
+		float c = input_color[i];
+		output_color = mix(output_color, vec4(c, c, c, 1.0), factors[i] * single);
+	}
+
+	return output_color;
+}
+
+void fragment() {
+	COLOR = filter_preview_colors(texture(TEXTURE, UV), u_channel_factors);
+}
+)";
 
 TextureRect *TexturePreview::get_texture_display() {
 	return texture_display;
@@ -72,8 +103,8 @@ void TexturePreview::_notification(int p_what) {
 
 void TexturePreview::_draw_outline() {
 	const float outline_width = Math::round(EDSCALE);
-	const Rect2 outline_rect = Rect2(Vector2(), texture_display->get_size()).grow(outline_width * 0.5);
-	texture_display->draw_rect(outline_rect, cached_outline_color, false, outline_width);
+	const Rect2 outline_rect = Rect2(Vector2(), outline_overlay->get_size()).grow(outline_width * 0.5);
+	outline_overlay->draw_rect(outline_rect, cached_outline_color, false, outline_width);
 }
 
 void TexturePreview::_update_texture_display_ratio() {
@@ -82,25 +113,49 @@ void TexturePreview::_update_texture_display_ratio() {
 	}
 }
 
-void TexturePreview::_update_metadata_label_text() {
-	const Ref<Texture2D> texture = texture_display->get_texture();
-
-	String format;
-	if (Object::cast_to<ImageTexture>(*texture)) {
-		format = Image::get_format_name(Object::cast_to<ImageTexture>(*texture)->get_format());
-	} else if (Object::cast_to<CompressedTexture2D>(*texture)) {
-		format = Image::get_format_name(Object::cast_to<CompressedTexture2D>(*texture)->get_format());
-	} else {
-		format = texture->get_class();
+static Image::Format get_texture_2d_format(const Ref<Texture2D> &p_texture) {
+	const Ref<ImageTexture> image_texture = p_texture;
+	if (image_texture.is_valid()) {
+		return image_texture->get_format();
 	}
 
-	const Ref<Image> image = texture->get_image();
+	const Ref<CompressedTexture2D> compressed_texture = p_texture;
+	if (compressed_texture.is_valid()) {
+		return compressed_texture->get_format();
+	}
+
+	// AtlasTexture?
+
+	// Unknown
+	return Image::FORMAT_MAX;
+}
+
+static int get_texture_mipmaps_count(const Ref<Texture2D> &p_texture) {
+	ERR_FAIL_COND_V(p_texture.is_null(), -1);
+	// We are having to download the image only to get its mipmaps count. It would be nice if we didn't have to.
+	Ref<Image> image = p_texture->get_image();
 	if (image.is_valid()) {
-		const int mipmaps = image->get_mipmap_count();
+		return image->get_mipmap_count();
+	}
+	return -1;
+}
+
+void TexturePreview::_update_metadata_label_text() {
+	const Ref<Texture2D> texture = texture_display->get_texture();
+	ERR_FAIL_COND(texture.is_null());
+
+	const Image::Format format = get_texture_2d_format(texture.ptr());
+
+	const String format_name = format != Image::FORMAT_MAX ? Image::get_format_name(format) : texture->get_class();
+
+	const Vector2i resolution = texture->get_size();
+	const int mipmaps = get_texture_mipmaps_count(texture);
+
+	if (format != Image::FORMAT_MAX) {
 		// Avoid signed integer overflow that could occur with huge texture sizes by casting everything to uint64_t.
-		uint64_t memory = uint64_t(image->get_width()) * uint64_t(image->get_height()) * uint64_t(Image::get_format_pixel_size(image->get_format()));
+		uint64_t memory = uint64_t(resolution.x) * uint64_t(resolution.y) * uint64_t(Image::get_format_pixel_size(format));
 		// Handle VRAM-compressed formats that are stored with 4 bpp.
-		memory >>= Image::get_format_pixel_rshift(image->get_format());
+		memory >>= Image::get_format_pixel_rshift(format);
 
 		float mipmaps_multiplier = 1.0;
 		float mipmap_increase = 0.25;
@@ -117,7 +172,7 @@ void TexturePreview::_update_metadata_label_text() {
 					vformat(String::utf8("%d×%d %s\n") + TTR("%s Mipmaps") + "\n" + TTR("Memory: %s"),
 							texture->get_width(),
 							texture->get_height(),
-							format,
+							format_name,
 							mipmaps,
 							String::humanize_size(memory)));
 		} else {
@@ -127,7 +182,7 @@ void TexturePreview::_update_metadata_label_text() {
 					vformat(String::utf8("%d×%d %s\n") + TTR("No Mipmaps") + "\n" + TTR("Memory: %s"),
 							texture->get_width(),
 							texture->get_height(),
-							format,
+							format_name,
 							String::humanize_size(memory)));
 		}
 	} else {
@@ -135,10 +190,14 @@ void TexturePreview::_update_metadata_label_text() {
 				vformat(String::utf8("%d×%d %s"),
 						texture->get_width(),
 						texture->get_height(),
-						format));
+						format_name));
 	}
 }
 
+void TexturePreview::on_selected_channels_changed() {
+	material->set_shader_parameter("u_channel_factors", channel_selector->get_selected_channel_factors());
+}
+
 TexturePreview::TexturePreview(Ref<Texture2D> p_texture, bool p_show_metadata) {
 	set_custom_minimum_size(Size2(0.0, 256.0) * EDSCALE);
 
@@ -163,19 +222,48 @@ TexturePreview::TexturePreview(Ref<Texture2D> p_texture, bool p_show_metadata) {
 	checkerboard->set_texture_repeat(CanvasItem::TEXTURE_REPEAT_ENABLED);
 	centering_container->add_child(checkerboard);
 
+	{
+		Ref<Shader> shader;
+		shader.instantiate();
+		shader->set_code(texture_2d_shader);
+
+		material.instantiate();
+		material->set_shader(shader);
+		material->set_shader_parameter("u_channel_factors", Vector4(1, 1, 1, 1));
+	}
+
 	texture_display = memnew(TextureRect);
 	texture_display->set_texture_filter(TEXTURE_FILTER_NEAREST_WITH_MIPMAPS);
 	texture_display->set_texture(p_texture);
 	texture_display->set_expand_mode(TextureRect::EXPAND_IGNORE_SIZE);
+	texture_display->set_material(material);
 	centering_container->add_child(texture_display);
 
-	texture_display->connect(SceneStringName(draw), callable_mp(this, &TexturePreview::_draw_outline));
+	// Creating a separate control so it is not affected by the filtering shader.
+	outline_overlay = memnew(Control);
+	centering_container->add_child(outline_overlay);
+
+	outline_overlay->connect(SceneStringName(draw), callable_mp(this, &TexturePreview::_draw_outline));
 
 	if (p_texture.is_valid()) {
 		_update_texture_display_ratio();
 		p_texture->connect_changed(callable_mp(this, &TexturePreview::_update_texture_display_ratio));
 	}
 
+	// Null can be passed by `Camera3DPreview` (which immediately after sets a texture anyways).
+	const Image::Format format = p_texture.is_valid() ? get_texture_2d_format(p_texture.ptr()) : Image::FORMAT_MAX;
+	const uint32_t components_mask = format != Image::FORMAT_MAX ? Image::get_format_component_mask(format) : 0xf;
+
+	// Add color channel selector at the bottom left if more than 1 channel is available.
+	if (p_show_metadata && !is_power_of_2(components_mask)) {
+		channel_selector = memnew(ColorChannelSelector);
+		channel_selector->connect("selected_channels_changed", callable_mp(this, &TexturePreview::on_selected_channels_changed));
+		channel_selector->set_h_size_flags(Control::SIZE_SHRINK_BEGIN);
+		channel_selector->set_v_size_flags(Control::SIZE_SHRINK_BEGIN);
+		channel_selector->set_available_channels_mask(components_mask);
+		add_child(channel_selector);
+	}
+
 	if (p_show_metadata) {
 		metadata_label = memnew(Label);