Added performance mode settings so that Texture2D's can be downsized at runtime for performance reasons

Author: LizzyTB

core/io/image.cpp

@@ -455,6 +455,18 @@ Size2i Image::get_size() const {
 	return Size2i(width, height);
 }
 
+int Image::get_original_width() const {
+	return original_width;
+}
+
+int Image::get_original_height() const {
+	return original_height;
+}
+
+Size2i Image::get_original_size() const {
+	return Size2i(original_width, original_height);
+}
+
 bool Image::has_mipmaps() const {
 	return mipmaps;
 }
@@ -765,6 +777,102 @@ void Image::convert(Format p_new_format) {
 	_copy_internals_from(new_img);
 }
 
+Image::PerformanceMode Image::get_performance_mode() const {
+	return performance_mode;
+}
+
+Error Image::set_performance_mode(PerformanceMode p_performance_mode) {
+	switch (performance_mode) {
+		case PERFORMANCE_MODE_ORIGINAL_SIZE:
+			break;
+
+		default:
+			ERR_FAIL_V_MSG(FAILED, "Image's performance_mode has already been set. It needs to be reloaded/recreated before it can be set again");
+	}
+
+	performance_mode = p_performance_mode;
+
+	Size2i size = get_size();
+	Vector2i desired_size = size;
+
+	switch (performance_mode) {
+		case PERFORMANCE_MODE_ORIGINAL_SIZE:
+			break;
+
+		case PERFORMANCE_MODE_MAX_SIZE: {
+			Vector2i max_size = GLOBAL_GET("rendering/textures/performance/max_size");
+
+			if (desired_size.x > max_size.x) {
+				desired_size.x = max_size.x;
+			}
+
+			if (desired_size.y > max_size.y) {
+				desired_size.y = max_size.y;
+			}
+
+			break;
+		}
+
+		case PERFORMANCE_MODE_DOWNSCALE_SIZE: {
+			int factor = GLOBAL_GET("rendering/textures/performance/downscale_factor");
+			factor = CLAMP(factor, 1, 14);
+
+			desired_size.x >>= factor;
+			desired_size.y >>= factor;
+
+			break;
+		}
+
+		default:
+			ERR_FAIL_V_MSG(FAILED, vformat("Unknown image performance mode '%i'", performance_mode));
+	}
+
+	desired_size = desired_size.max(Vector2i(1, 1));
+
+	if (desired_size == size) {
+		return OK;
+	}
+
+	if (is_compressed()) {
+		Format current_format = get_format();
+
+		Error err = decompress();
+
+		if (err != OK) {
+			ERR_FAIL_V_MSG(FAILED, vformat("Cannot decompress image format '%s'", current_format));
+		}
+
+		resize(desired_size.x, desired_size.y);
+
+		Image::CompressMode compress_mode = COMPRESS_MAX;
+
+		if ((current_format >= FORMAT_DXT1 && current_format <= FORMAT_RGTC_RG) || (current_format == FORMAT_DXT5_RA_AS_RG)) {
+			compress_mode = COMPRESS_S3TC;
+		} else if (current_format >= FORMAT_BPTC_RGBA && current_format <= FORMAT_BPTC_RGBFU) {
+			compress_mode = COMPRESS_BPTC;
+		} else if (current_format == FORMAT_ETC) {
+			compress_mode = COMPRESS_ETC;
+		} else if (current_format >= FORMAT_ETC2_R11 && current_format <= FORMAT_ETC2_RA_AS_RG) {
+			compress_mode = COMPRESS_ETC2;
+		} else if (current_format >= FORMAT_ASTC_4x4 && current_format <= FORMAT_ASTC_8x8_HDR) {
+			compress_mode = COMPRESS_ASTC;
+		}
+
+		if (compress_mode != COMPRESS_MAX) {
+			compress(compress_mode);
+		} else {
+			ERR_PRINT(vformat("Cannot recompress image format '%s'", current_format));
+		}
+	} else {
+		resize(desired_size.x, desired_size.y);
+	}
+
+	original_width = size.x;
+	original_height = size.y;
+
+	return OK;
+}
+
 Image::Format Image::get_format() const {
 	return format;
 }
@@ -1429,6 +1537,7 @@ void Image::resize(int p_width, int p_height, Interpolation p_interpolation) {
 	}
 
 	_copy_internals_from(dst);
+	performance_mode = PERFORMANCE_MODE_ORIGINAL_SIZE;
 }
 
 void Image::crop_from_point(int p_x, int p_y, int p_width, int p_height) {
@@ -1592,6 +1701,10 @@ void Image::rotate_90(ClockDirection p_direction) {
 
 			width = h;
 			height = w;
+			int o_h = original_height;
+			int o_w = original_width;
+			original_height = o_w;
+			original_width = o_h;
 		}
 
 #undef PREV_INDEX_IN_CYCLE
@@ -1902,6 +2015,8 @@ void Image::shrink_x2() {
 
 	width = MAX(width / 2, 1);
 	height = MAX(height / 2, 1);
+	original_width = width;
+	original_height = height;
 	data = new_data;
 }
 
@@ -2193,6 +2308,8 @@ void Image::initialize_data(int p_width, int p_height, bool p_use_mipmaps, Forma
 
 	width = p_width;
 	height = p_height;
+	original_width = p_width;
+	original_height = p_height;
 	mipmaps = p_use_mipmaps;
 	format = p_format;
 }
@@ -2229,10 +2346,14 @@ void Image::initialize_data(int p_width, int p_height, bool p_use_mipmaps, Forma
 
 	height = p_height;
 	width = p_width;
+	original_height = p_height;
+	original_width = p_width;
 	format = p_format;
 	data = p_data;
 
 	mipmaps = p_use_mipmaps;
+
+	performance_mode = PERFORMANCE_MODE_ORIGINAL_SIZE;
 }
 
 void Image::initialize_data(const char **p_xpm) {
@@ -2242,6 +2363,8 @@ void Image::initialize_data(const char **p_xpm) {
 	mipmaps = false;
 	bool has_alpha = false;
 
+	performance_mode = PERFORMANCE_MODE_ORIGINAL_SIZE;
+
 	enum Status {
 		READING_HEADER,
 		READING_COLORS,
@@ -2775,6 +2898,8 @@ Error Image::compress_from_channels(CompressMode p_mode, UsedChannels p_channels
 Image::Image(const char **p_xpm) {
 	width = 0;
 	height = 0;
+	original_width = 0;
+	original_height = 0;
 	mipmaps = false;
 	format = FORMAT_L8;
 
@@ -2784,6 +2909,8 @@ Image::Image(const char **p_xpm) {
 Image::Image(int p_width, int p_height, bool p_use_mipmaps, Format p_format) {
 	width = 0;
 	height = 0;
+	original_width = 0;
+	original_height = 0;
 	mipmaps = p_use_mipmaps;
 	format = FORMAT_L8;
 
@@ -2793,6 +2920,8 @@ Image::Image(int p_width, int p_height, bool p_use_mipmaps, Format p_format) {
 Image::Image(int p_width, int p_height, bool p_mipmaps, Format p_format, const Vector<uint8_t> &p_data) {
 	width = 0;
 	height = 0;
+	original_width = 0;
+	original_height = 0;
 	mipmaps = p_mipmaps;
 	format = FORMAT_L8;
 
@@ -3113,6 +3242,8 @@ void Image::fill_rect(const Rect2i &p_rect, const Color &p_color) {
 void Image::_set_data(const Dictionary &p_data) {
 	ERR_FAIL_COND(!p_data.has("width"));
 	ERR_FAIL_COND(!p_data.has("height"));
+	ERR_FAIL_COND(!p_data.has("original_width"));
+	ERR_FAIL_COND(!p_data.has("original_height"));
 	ERR_FAIL_COND(!p_data.has("format"));
 	ERR_FAIL_COND(!p_data.has("mipmaps"));
 	ERR_FAIL_COND(!p_data.has("data"));
@@ -3133,12 +3264,17 @@ void Image::_set_data(const Dictionary &p_data) {
 	ERR_FAIL_COND(ddformat == FORMAT_MAX);
 
 	initialize_data(dwidth, dheight, dmipmaps, ddformat, ddata);
+
+	original_width = p_data["original_width"];
+	original_height = p_data["original_height"];
 }
 
 Dictionary Image::_get_data() const {
 	Dictionary d;
 	d["width"] = width;
 	d["height"] = height;
+	d["original_width"] = original_width;
+	d["original_height"] = original_height;
 	d["format"] = get_format_name(format);
 	d["mipmaps"] = mipmaps;
 	d["data"] = data;
@@ -3153,6 +3289,8 @@ void Image::_copy_internals_from(const Image &p_image) {
 	format = p_image.format;
 	width = p_image.width;
 	height = p_image.height;
+	original_width = p_image.original_width;
+	original_height = p_image.original_height;
 	mipmaps = p_image.mipmaps;
 	data = p_image.data;
 }
@@ -3515,7 +3653,12 @@ void Image::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_width"), &Image::get_width);
 	ClassDB::bind_method(D_METHOD("get_height"), &Image::get_height);
 	ClassDB::bind_method(D_METHOD("get_size"), &Image::get_size);
+	ClassDB::bind_method(D_METHOD("get_original_width"), &Image::get_original_width);
+	ClassDB::bind_method(D_METHOD("get_original_height"), &Image::get_original_height);
+	ClassDB::bind_method(D_METHOD("get_original_size"), &Image::get_original_size);
 	ClassDB::bind_method(D_METHOD("has_mipmaps"), &Image::has_mipmaps);
+	ClassDB::bind_method(D_METHOD("get_performance_mode"), &Image::get_performance_mode);
+	ClassDB::bind_method(D_METHOD("set_performance_mode", "performance_mode"), &Image::set_performance_mode);
 	ClassDB::bind_method(D_METHOD("get_format"), &Image::get_format);
 	ClassDB::bind_method(D_METHOD("get_data"), &Image::get_data);
 	ClassDB::bind_method(D_METHOD("get_data_size"), &Image::get_data_size);
@@ -3618,6 +3761,9 @@ void Image::_bind_methods() {
 	BIND_CONSTANT(MAX_WIDTH);
 	BIND_CONSTANT(MAX_HEIGHT);
 
+	BIND_ENUM_CONSTANT(PERFORMANCE_MODE_ORIGINAL_SIZE);
+	BIND_ENUM_CONSTANT(PERFORMANCE_MODE_MAX_SIZE);
+	BIND_ENUM_CONSTANT(PERFORMANCE_MODE_DOWNSCALE_SIZE);
 	BIND_ENUM_CONSTANT(FORMAT_L8);
 	BIND_ENUM_CONSTANT(FORMAT_LA8);
 	BIND_ENUM_CONSTANT(FORMAT_R8);
@@ -3748,6 +3894,8 @@ Ref<Image> Image::get_image_from_mipmap(int p_mipmap) const {
 	image.instantiate();
 	image->width = w;
 	image->height = h;
+	image->original_width = w;
+	image->original_height = h;
 	image->format = format;
 	image->data = new_data;
 
@@ -4249,6 +4397,8 @@ void Image::renormalize_rgbe9995(uint32_t *p_rgb) {
 Image::Image(const uint8_t *p_mem_png_jpg, int p_len) {
 	width = 0;
 	height = 0;
+	original_width = 0;
+	original_height = 0;
 	mipmaps = false;
 	format = FORMAT_L8;
 
@@ -4281,6 +4431,8 @@ void Image::copy_internals_from(const Ref<Image> &p_image) {
 	format = p_image->format;
 	width = p_image->width;
 	height = p_image->height;
+	original_width = p_image->original_width;
+	original_height = p_image->original_height;
 	mipmaps = p_image->mipmaps;
 	data = p_image->data;
 }

core/io/image.h

@@ -71,6 +71,12 @@ class Image : public Resource {
 		MAX_PIXELS = 268435456 // 16384 ^ 2
 	};
 
+	enum PerformanceMode {
+		PERFORMANCE_MODE_ORIGINAL_SIZE,
+		PERFORMANCE_MODE_MAX_SIZE,
+		PERFORMANCE_MODE_DOWNSCALE_SIZE
+	};
+
 	enum Format : int32_t {
 		FORMAT_L8, // Luminance
 		FORMAT_LA8, // Luminance-Alpha
@@ -249,10 +255,13 @@ class Image : public Resource {
 	static void _bind_methods();
 
 private:
+	PerformanceMode performance_mode = PERFORMANCE_MODE_ORIGINAL_SIZE;
 	Format format = FORMAT_L8;
 	Vector<uint8_t> data;
 	int width = 0;
 	int height = 0;
+	int original_width = 0;
+	int original_height = 0;
 	bool mipmaps = false;
 
 	void _copy_internals_from(const Image &p_image);
@@ -291,12 +300,18 @@ class Image : public Resource {
 	int get_width() const;
 	int get_height() const;
 	Size2i get_size() const;
+	int get_original_width() const;
+	int get_original_height() const;
+	Size2i get_original_size() const;
 	bool has_mipmaps() const;
 	int get_mipmap_count() const;
 
 	// Convert the image to another format, conversion only to raw byte format.
 	void convert(Format p_new_format);
 
+	PerformanceMode get_performance_mode() const;
+	Error set_performance_mode(PerformanceMode p_performance_mode);
+
 	Format get_format() const;
 
 	// Get where the mipmap begins in data.
@@ -448,6 +463,7 @@ class Image : public Resource {
 	Dictionary compute_image_metrics(const Ref<Image> p_compared_image, bool p_luma_metric = true);
 };
 
+VARIANT_ENUM_CAST(Image::PerformanceMode)
 VARIANT_ENUM_CAST(Image::Format)
 VARIANT_ENUM_CAST(Image::Interpolation)
 VARIANT_ENUM_CAST(Image::CompressMode)