Merge pull request #68487 from clayjohn/RD-mobile-raster

Use raster versions of copy effects for 2D operations when using the mobile renderer

servers/rendering/renderer_rd/effects/copy_effects.cpp

@@ -56,6 +56,7 @@ CopyEffects::CopyEffects(bool p_prefer_raster_effects) {
 		blur_modes.push_back("\n#define MODE_GAUSSIAN_GLOW\n"); // BLUR_MODE_GAUSSIAN_GLOW
 		blur_modes.push_back("\n#define MODE_GAUSSIAN_GLOW\n#define GLOW_USE_AUTO_EXPOSURE\n"); // BLUR_MODE_GAUSSIAN_GLOW_AUTO_EXPOSURE
 		blur_modes.push_back("\n#define MODE_COPY\n"); // BLUR_MODE_COPY
+		blur_modes.push_back("\n#define MODE_SET_COLOR\n"); // BLUR_MODE_SET_COLOR
 
 		blur_raster.shader.initialize(blur_modes);
 		memset(&blur_raster.push_constant, 0, sizeof(BlurRasterPushConstant));
@@ -105,6 +106,7 @@ CopyEffects::CopyEffects(bool p_prefer_raster_effects) {
 		copy_modes.push_back("\n#define MODE_TWO_SOURCES\n"); // COPY_TO_FB_COPY2
 		copy_modes.push_back("\n#define MULTIVIEW\n"); // COPY_TO_FB_MULTIVIEW
 		copy_modes.push_back("\n#define MULTIVIEW\n#define MODE_TWO_SOURCES\n"); // COPY_TO_FB_MULTIVIEW_WITH_DEPTH
+		copy_modes.push_back("\n#define MODE_SET_COLOR\n"); // COPY_TO_FB_SET_COLOR
 
 		copy_to_fb.shader.initialize(copy_modes);
 
@@ -535,7 +537,7 @@ void CopyEffects::copy_to_atlas_fb(RID p_source_rd_texture, RID p_dest_framebuff
 	RD::get_singleton()->draw_list_draw(draw_list, true);
 }
 
-void CopyEffects::copy_to_fb_rect(RID p_source_rd_texture, RID p_dest_framebuffer, const Rect2i &p_rect, bool p_flip_y, bool p_force_luminance, bool p_alpha_to_zero, bool p_srgb, RID p_secondary, bool p_multiview) {
+void CopyEffects::copy_to_fb_rect(RID p_source_rd_texture, RID p_dest_framebuffer, const Rect2i &p_rect, bool p_flip_y, bool p_force_luminance, bool p_alpha_to_zero, bool p_srgb, RID p_secondary, bool p_multiview, bool p_alpha_to_one) {
 	UniformSetCacheRD *uniform_set_cache = UniformSetCacheRD::get_singleton();
 	ERR_FAIL_NULL(uniform_set_cache);
 	MaterialStorage *material_storage = MaterialStorage::get_singleton();
@@ -555,6 +557,9 @@ void CopyEffects::copy_to_fb_rect(RID p_source_rd_texture, RID p_dest_framebuffe
 	if (p_srgb) {
 		copy_to_fb.push_constant.srgb = true;
 	}
+	if (p_alpha_to_one) {
+		copy_to_fb.push_constant.alpha_to_one = true;
+	}
 
 	// setup our uniforms
 	RID default_sampler = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
@@ -608,8 +613,6 @@ void CopyEffects::copy_raster(RID p_source_texture, RID p_dest_framebuffer) {
 	RD::get_singleton()->draw_list_bind_render_pipeline(draw_list, blur_raster.pipelines[BLUR_MODE_COPY].get_render_pipeline(RD::INVALID_ID, RD::get_singleton()->framebuffer_get_format(p_dest_framebuffer)));
 	RD::get_singleton()->draw_list_bind_uniform_set(draw_list, uniform_set_cache->get_cache(shader, 0, u_source_texture), 0);
 	RD::get_singleton()->draw_list_bind_index_array(draw_list, material_storage->get_quad_index_array());
-
-	memset(&blur_raster.push_constant, 0, sizeof(BlurRasterPushConstant));
 	RD::get_singleton()->draw_list_set_push_constant(draw_list, &blur_raster.push_constant, sizeof(BlurRasterPushConstant));
 
 	RD::get_singleton()->draw_list_draw(draw_list, true);
@@ -641,7 +644,6 @@ void CopyEffects::gaussian_blur(RID p_source_rd_texture, RID p_texture, const Re
 	RID shader = copy.shader.version_get_shader(copy.shader_version, mode);
 	ERR_FAIL_COND(shader.is_null());
 
-	//HORIZONTAL
 	RD::DrawListID compute_list = RD::get_singleton()->compute_list_begin();
 	RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, copy.pipelines[mode]);
 	RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 0, u_source_rd_texture), 0);
@@ -654,6 +656,43 @@ void CopyEffects::gaussian_blur(RID p_source_rd_texture, RID p_texture, const Re
 	RD::get_singleton()->compute_list_end();
 }
 
+void CopyEffects::gaussian_blur_raster(RID p_source_rd_texture, RID p_dest_texture, const Rect2i &p_region, const Size2i &p_size) {
+	ERR_FAIL_COND_MSG(!prefer_raster_effects, "Can't use the raster version of the gaussian blur with the clustered renderer.");
+
+	UniformSetCacheRD *uniform_set_cache = UniformSetCacheRD::get_singleton();
+	ERR_FAIL_NULL(uniform_set_cache);
+	MaterialStorage *material_storage = MaterialStorage::get_singleton();
+	ERR_FAIL_NULL(material_storage);
+
+	RID dest_framebuffer = FramebufferCacheRD::get_singleton()->get_cache(p_dest_texture);
+
+	memset(&blur_raster.push_constant, 0, sizeof(BlurRasterPushConstant));
+
+	BlurRasterMode blur_mode = BLUR_MODE_GAUSSIAN_BLUR;
+
+	blur_raster.push_constant.pixel_size[0] = 1.0 / float(p_size.x);
+	blur_raster.push_constant.pixel_size[1] = 1.0 / float(p_size.y);
+
+	// setup our uniforms
+	RID default_sampler = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
+
+	RD::Uniform u_source_rd_texture(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 0, Vector<RID>({ default_sampler, p_source_rd_texture }));
+
+	RID shader = blur_raster.shader.version_get_shader(blur_raster.shader_version, blur_mode);
+	ERR_FAIL_COND(shader.is_null());
+
+	RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(dest_framebuffer, RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_DISCARD);
+	RD::get_singleton()->draw_list_bind_render_pipeline(draw_list, blur_raster.pipelines[blur_mode].get_render_pipeline(RD::INVALID_ID, RD::get_singleton()->framebuffer_get_format(dest_framebuffer)));
+	RD::get_singleton()->draw_list_bind_uniform_set(draw_list, uniform_set_cache->get_cache(shader, 0, u_source_rd_texture), 0);
+
+	RD::get_singleton()->draw_list_bind_index_array(draw_list, material_storage->get_quad_index_array());
+
+	RD::get_singleton()->draw_list_set_push_constant(draw_list, &blur_raster.push_constant, sizeof(BlurRasterPushConstant));
+
+	RD::get_singleton()->draw_list_draw(draw_list, true);
+	RD::get_singleton()->draw_list_end();
+}
+
 void CopyEffects::gaussian_glow(RID p_source_rd_texture, RID p_back_texture, const Size2i &p_size, float p_strength, bool p_high_quality, bool p_first_pass, float p_luminance_cap, float p_exposure, float p_bloom, float p_hdr_bleed_threshold, float p_hdr_bleed_scale, RID p_auto_exposure, float p_auto_exposure_scale) {
 	ERR_FAIL_COND_MSG(prefer_raster_effects, "Can't use the compute version of the gaussian glow with the mobile renderer.");
 
@@ -882,6 +921,36 @@ void CopyEffects::set_color(RID p_dest_texture, const Color &p_color, const Rect
 	RD::get_singleton()->compute_list_end();
 }
 
+void CopyEffects::set_color_raster(RID p_dest_texture, const Color &p_color, const Rect2i &p_region) {
+	ERR_FAIL_COND_MSG(!prefer_raster_effects, "Can't use the raster version of the set_color shader with the clustered renderer.");
+
+	UniformSetCacheRD *uniform_set_cache = UniformSetCacheRD::get_singleton();
+	ERR_FAIL_NULL(uniform_set_cache);
+	MaterialStorage *material_storage = MaterialStorage::get_singleton();
+	ERR_FAIL_NULL(material_storage);
+
+	memset(&copy_to_fb.push_constant, 0, sizeof(CopyToFbPushConstant));
+
+	copy_to_fb.push_constant.set_color[0] = p_color.r;
+	copy_to_fb.push_constant.set_color[1] = p_color.g;
+	copy_to_fb.push_constant.set_color[2] = p_color.b;
+	copy_to_fb.push_constant.set_color[3] = p_color.a;
+
+	RID dest_framebuffer = FramebufferCacheRD::get_singleton()->get_cache(p_dest_texture);
+
+	CopyToFBMode mode = COPY_TO_FB_SET_COLOR;
+
+	RID shader = copy_to_fb.shader.version_get_shader(copy_to_fb.shader_version, mode);
+	ERR_FAIL_COND(shader.is_null());
+
+	RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(dest_framebuffer, RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_DISCARD, Vector<Color>(), 1.0, 0, p_region);
+	RD::get_singleton()->draw_list_bind_render_pipeline(draw_list, copy_to_fb.pipelines[mode].get_render_pipeline(RD::INVALID_ID, RD::get_singleton()->framebuffer_get_format(dest_framebuffer)));
+	RD::get_singleton()->draw_list_bind_index_array(draw_list, material_storage->get_quad_index_array());
+	RD::get_singleton()->draw_list_set_push_constant(draw_list, &copy_to_fb.push_constant, sizeof(CopyToFbPushConstant));
+	RD::get_singleton()->draw_list_draw(draw_list, true);
+	RD::get_singleton()->draw_list_end();
+}
+
 void CopyEffects::copy_cubemap_to_dp(RID p_source_rd_texture, RID p_dst_framebuffer, const Rect2 &p_rect, const Vector2 &p_dst_size, float p_z_near, float p_z_far, bool p_dp_flip) {
 	UniformSetCacheRD *uniform_set_cache = UniformSetCacheRD::get_singleton();
 	ERR_FAIL_NULL(uniform_set_cache);

servers/rendering/renderer_rd/effects/copy_effects.h

@@ -63,6 +63,8 @@ private:
 		BLUR_MODE_GAUSSIAN_GLOW_AUTO_EXPOSURE,
 		BLUR_MODE_COPY,
 
+		BLUR_MODE_SET_COLOR,
+
 		BLUR_MODE_MAX
 	};
 
@@ -174,6 +176,8 @@ private:
 
 		COPY_TO_FB_MULTIVIEW,
 		COPY_TO_FB_MULTIVIEW_WITH_DEPTH,
+
+		COPY_TO_FB_SET_COLOR,
 		COPY_TO_FB_MAX,
 	};
 
@@ -186,7 +190,9 @@ private:
 		uint32_t force_luminance;
 		uint32_t alpha_to_zero;
 		uint32_t srgb;
-		uint32_t pad;
+		uint32_t alpha_to_one;
+
+		float set_color[4];
 	};
 
 	struct CopyToFb {
@@ -316,11 +322,12 @@ public:
 	void copy_cubemap_to_panorama(RID p_source_cube, RID p_dest_panorama, const Size2i &p_panorama_size, float p_lod, bool p_is_array);
 	void copy_depth_to_rect(RID p_source_rd_texture, RID p_dest_framebuffer, const Rect2i &p_rect, bool p_flip_y = false);
 	void copy_depth_to_rect_and_linearize(RID p_source_rd_texture, RID p_dest_texture, const Rect2i &p_rect, bool p_flip_y, float p_z_near, float p_z_far);
-	void copy_to_fb_rect(RID p_source_rd_texture, RID p_dest_framebuffer, const Rect2i &p_rect, bool p_flip_y = false, bool p_force_luminance = false, bool p_alpha_to_zero = false, bool p_srgb = false, RID p_secondary = RID(), bool p_multiview = false);
+	void copy_to_fb_rect(RID p_source_rd_texture, RID p_dest_framebuffer, const Rect2i &p_rect, bool p_flip_y = false, bool p_force_luminance = false, bool p_alpha_to_zero = false, bool p_srgb = false, RID p_secondary = RID(), bool p_multiview = false, bool alpha_to_one = false);
 	void copy_to_atlas_fb(RID p_source_rd_texture, RID p_dest_framebuffer, const Rect2 &p_uv_rect, RD::DrawListID p_draw_list, bool p_flip_y = false, bool p_panorama = false);
 	void copy_raster(RID p_source_texture, RID p_dest_framebuffer);
 
 	void gaussian_blur(RID p_source_rd_texture, RID p_texture, const Rect2i &p_region, bool p_8bit_dst = false);
+	void gaussian_blur_raster(RID p_source_rd_texture, RID p_dest_texture, const Rect2i &p_region, const Size2i &p_size);
 	void gaussian_glow(RID p_source_rd_texture, RID p_back_texture, const Size2i &p_size, float p_strength = 1.0, bool p_high_quality = false, bool p_first_pass = false, float p_luminance_cap = 16.0, float p_exposure = 1.0, float p_bloom = 0.0, float p_hdr_bleed_threshold = 1.0, float p_hdr_bleed_scale = 1.0, RID p_auto_exposure = RID(), float p_auto_exposure_scale = 1.0);
 	void gaussian_glow_raster(RID p_source_rd_texture, RID p_half_texture, RID p_dest_texture, float p_luminance_multiplier, const Size2i &p_size, float p_strength = 1.0, bool p_high_quality = false, bool p_first_pass = false, float p_luminance_cap = 16.0, float p_exposure = 1.0, float p_bloom = 0.0, float p_hdr_bleed_threshold = 1.0, float p_hdr_bleed_scale = 1.0, RID p_auto_exposure = RID(), float p_auto_exposure_scale = 1.0);
 
@@ -328,6 +335,7 @@ public:
 	void make_mipmap_raster(RID p_source_rd_texture, RID p_dest_texture, const Size2i &p_size);
 
 	void set_color(RID p_dest_texture, const Color &p_color, const Rect2i &p_region, bool p_8bit_dst = false);
+	void set_color_raster(RID p_dest_texture, const Color &p_color, const Rect2i &p_region);
 
 	void copy_cubemap_to_dp(RID p_source_rd_texture, RID p_dst_framebuffer, const Rect2 &p_rect, const Vector2 &p_dst_size, float p_z_near, float p_z_far, bool p_dp_flip);
 	void cubemap_downsample(RID p_source_cubemap, RID p_dest_cubemap, const Size2i &p_size);

servers/rendering/renderer_rd/shaders/effects/blur_raster.glsl

@@ -53,30 +53,31 @@ void main() {
 
 #ifdef MODE_GAUSSIAN_BLUR
 
-	// Simpler blur uses SIGMA2 for the gaussian kernel for a stronger effect
-
-	// note, for blur blur.luminance_multiplier is irrelavant, we would be multiplying and then dividing by this amount.
-
-	if (bool(blur.flags & FLAG_HORIZONTAL)) {
-		vec2 pix_size = blur.pixel_size;
-		pix_size *= 0.5; //reading from larger buffer, so use more samples
-		vec4 color = texture(source_color, uv_interp + vec2(0.0, 0.0) * pix_size) * 0.214607;
-		color += texture(source_color, uv_interp + vec2(1.0, 0.0) * pix_size) * 0.189879;
-		color += texture(source_color, uv_interp + vec2(2.0, 0.0) * pix_size) * 0.131514;
-		color += texture(source_color, uv_interp + vec2(3.0, 0.0) * pix_size) * 0.071303;
-		color += texture(source_color, uv_interp + vec2(-1.0, 0.0) * pix_size) * 0.189879;
-		color += texture(source_color, uv_interp + vec2(-2.0, 0.0) * pix_size) * 0.131514;
-		color += texture(source_color, uv_interp + vec2(-3.0, 0.0) * pix_size) * 0.071303;
-		frag_color = color;
-	} else {
-		vec2 pix_size = blur.pixel_size;
-		vec4 color = texture(source_color, uv_interp + vec2(0.0, 0.0) * pix_size) * 0.38774;
-		color += texture(source_color, uv_interp + vec2(0.0, 1.0) * pix_size) * 0.24477;
-		color += texture(source_color, uv_interp + vec2(0.0, 2.0) * pix_size) * 0.06136;
-		color += texture(source_color, uv_interp + vec2(0.0, -1.0) * pix_size) * 0.24477;
-		color += texture(source_color, uv_interp + vec2(0.0, -2.0) * pix_size) * 0.06136;
-		frag_color = color;
-	}
+	// For Gaussian Blur we use 13 taps in a single pass instead of 12 taps over 2 passes.
+	// This minimizes the number of times we change framebuffers which is very important for mobile.
+	// Source: http://www.iryoku.com/next-generation-post-processing-in-call-of-duty-advanced-warfare
+	vec4 A = texture(source_color, uv_interp + blur.pixel_size * vec2(-1.0, -1.0));
+	vec4 B = texture(source_color, uv_interp + blur.pixel_size * vec2(0.0, -1.0));
+	vec4 C = texture(source_color, uv_interp + blur.pixel_size * vec2(1.0, -1.0));
+	vec4 D = texture(source_color, uv_interp + blur.pixel_size * vec2(-0.5, -0.5));
+	vec4 E = texture(source_color, uv_interp + blur.pixel_size * vec2(0.5, -0.5));
+	vec4 F = texture(source_color, uv_interp + blur.pixel_size * vec2(-1.0, 0.0));
+	vec4 G = texture(source_color, uv_interp);
+	vec4 H = texture(source_color, uv_interp + blur.pixel_size * vec2(1.0, 0.0));
+	vec4 I = texture(source_color, uv_interp + blur.pixel_size * vec2(-0.5, 0.5));
+	vec4 J = texture(source_color, uv_interp + blur.pixel_size * vec2(0.5, 0.5));
+	vec4 K = texture(source_color, uv_interp + blur.pixel_size * vec2(-1.0, 1.0));
+	vec4 L = texture(source_color, uv_interp + blur.pixel_size * vec2(0.0, 1.0));
+	vec4 M = texture(source_color, uv_interp + blur.pixel_size * vec2(1.0, 1.0));
+
+	float base_weight = 0.5 / 4.0;
+	float lesser_weight = 0.125 / 4.0;
+
+	frag_color = (D + E + I + J) * base_weight;
+	frag_color += (A + B + G + F) * lesser_weight;
+	frag_color += (B + C + H + G) * lesser_weight;
+	frag_color += (F + G + L + K) * lesser_weight;
+	frag_color += (G + H + M + L) * lesser_weight;
 #endif
 
 #ifdef MODE_GAUSSIAN_GLOW

servers/rendering/renderer_rd/shaders/effects/copy.glsl

@@ -194,10 +194,10 @@ void main() {
 
 		color = min(color * feedback, vec4(params.glow_luminance_cap));
 	}
-#endif
+#endif // MODE_GLOW
 	imageStore(dest_buffer, pos + params.target, color);
 
-#endif
+#endif // MODE_GAUSSIAN_BLUR
 
 #ifdef MODE_SIMPLE_COPY
 
@@ -227,7 +227,7 @@ void main() {
 
 	imageStore(dest_buffer, pos + params.target, color);
 
-#endif
+#endif // MODE_SIMPLE_COPY
 
 #ifdef MODE_SIMPLE_COPY_DEPTH
 
@@ -239,7 +239,7 @@ void main() {
 
 	imageStore(dest_buffer, pos + params.target, vec4(color.r));
 
-#endif
+#endif // MODE_SIMPLE_COPY_DEPTH
 
 #ifdef MODE_LINEARIZE_DEPTH_COPY
 
@@ -253,7 +253,7 @@ void main() {
 	}
 
 	imageStore(dest_buffer, pos + params.target, color);
-#endif
+#endif // MODE_LINEARIZE_DEPTH_COPY
 
 #if defined(MODE_CUBEMAP_TO_PANORAMA) || defined(MODE_CUBEMAP_ARRAY_TO_PANORAMA)
 
@@ -276,7 +276,7 @@ void main() {
 	vec4 color = textureLod(source_color, vec4(normal, params.camera_z_far), 0.0); //the biggest the lod the least the acne
 #endif
 	imageStore(dest_buffer, pos + params.target, color);
-#endif
+#endif // defined(MODE_CUBEMAP_TO_PANORAMA) || defined(MODE_CUBEMAP_ARRAY_TO_PANORAMA)
 
 #ifdef MODE_SET_COLOR
 	imageStore(dest_buffer, pos + params.target, params.set_color);

servers/rendering/renderer_rd/shaders/effects/copy_to_fb.glsl

@@ -26,7 +26,11 @@ layout(push_constant, std430) uniform Params {
 	bool use_section;
 
 	bool force_luminance;
-	uint pad[3];
+	bool alpha_to_zero;
+	bool srgb;
+	bool alpha_to_one;
+
+	vec4 color;
 }
 params;
 
@@ -72,7 +76,9 @@ layout(push_constant, std430) uniform Params {
 	bool force_luminance;
 	bool alpha_to_zero;
 	bool srgb;
-	uint pad;
+	bool alpha_to_one;
+
+	vec4 color;
 }
 params;
 
@@ -105,6 +111,10 @@ vec3 linear_to_srgb(vec3 color) {
 }
 
 void main() {
+#ifdef MODE_SET_COLOR
+	frag_color = params.color;
+#else
+
 #ifdef MULTIVIEW
 	vec3 uv = uv_interp;
 #else
@@ -164,6 +174,10 @@ void main() {
 	if (params.srgb) {
 		color.rgb = linear_to_srgb(color.rgb);
 	}
+	if (params.alpha_to_one) {
+		color.a = 1.0;
+	}
 
 	frag_color = color;
+#endif // MODE_SET_COLOR
 }

servers/rendering/renderer_rd/storage_rd/texture_storage.cpp

@@ -3119,9 +3119,11 @@ void TextureStorage::render_target_copy_to_back_buffer(RID p_render_target, cons
 
 	// TODO figure out stereo support here
 
-	//single texture copy for backbuffer
-	//RD::get_singleton()->texture_copy(rt->color, rt->backbuffer_mipmap0, Vector3(region.position.x, region.position.y, 0), Vector3(region.position.x, region.position.y, 0), Vector3(region.size.x, region.size.y, 1), 0, 0, 0, 0, true);
-	copy_effects->copy_to_rect(rt->color, rt->backbuffer_mipmap0, region, false, false, false, true, true);
+	if (RendererSceneRenderRD::get_singleton()->_render_buffers_can_be_storage()) {
+		copy_effects->copy_to_rect(rt->color, rt->backbuffer_mipmap0, region, false, false, false, true, true);
+	} else {
+		copy_effects->copy_to_fb_rect(rt->color, rt->backbuffer_fb, region, false, false, false, false, RID(), false, true);
+	}
 
 	if (!p_gen_mipmaps) {
 		return;
@@ -3130,6 +3132,8 @@ void TextureStorage::render_target_copy_to_back_buffer(RID p_render_target, cons
 	//then mipmap blur
 	RID prev_texture = rt->color; //use color, not backbuffer, as bb has mipmaps.
 
+	Size2i texture_size = rt->size;
+
 	for (int i = 0; i < rt->backbuffer_mipmaps.size(); i++) {
 		region.position.x >>= 1;
 		region.position.y >>= 1;
@@ -3137,7 +3141,13 @@ void TextureStorage::render_target_copy_to_back_buffer(RID p_render_target, cons
 		region.size.y = MAX(1, region.size.y >> 1);
 
 		RID mipmap = rt->backbuffer_mipmaps[i];
-		copy_effects->gaussian_blur(prev_texture, mipmap, region, true);
+		if (RendererSceneRenderRD::get_singleton()->_render_buffers_can_be_storage()) {
+			copy_effects->gaussian_blur(prev_texture, mipmap, region, true);
+		} else {
+			texture_size.x = MAX(1, texture_size.x >> 1);
+			texture_size.y = MAX(1, texture_size.y >> 1);
+			copy_effects->gaussian_blur_raster(prev_texture, mipmap, region, texture_size);
+		}
 		prev_texture = mipmap;
 	}
 	RD::get_singleton()->draw_command_end_label();
@@ -3165,7 +3175,11 @@ void TextureStorage::render_target_clear_back_buffer(RID p_render_target, const
 	}
 
 	//single texture copy for backbuffer
-	copy_effects->set_color(rt->backbuffer_mipmap0, p_color, region, true);
+	if (RendererSceneRenderRD::get_singleton()->_render_buffers_can_be_storage()) {
+		copy_effects->set_color(rt->backbuffer_mipmap0, p_color, region, true);
+	} else {
+		copy_effects->set_color(rt->backbuffer_mipmap0, p_color, region, true);
+	}
 }
 
 void TextureStorage::render_target_gen_back_buffer_mipmaps(RID p_render_target, const Rect2i &p_region) {
@@ -3191,6 +3205,7 @@ void TextureStorage::render_target_gen_back_buffer_mipmaps(RID p_render_target,
 	RD::get_singleton()->draw_command_begin_label("Gaussian Blur Mipmaps2");
 	//then mipmap blur
 	RID prev_texture = rt->backbuffer_mipmap0;
+	Size2i texture_size = rt->size;
 
 	for (int i = 0; i < rt->backbuffer_mipmaps.size(); i++) {
 		region.position.x >>= 1;
@@ -3199,7 +3214,14 @@ void TextureStorage::render_target_gen_back_buffer_mipmaps(RID p_render_target,
 		region.size.y = MAX(1, region.size.y >> 1);
 
 		RID mipmap = rt->backbuffer_mipmaps[i];
-		copy_effects->gaussian_blur(prev_texture, mipmap, region, true);
+
+		if (RendererSceneRenderRD::get_singleton()->_render_buffers_can_be_storage()) {
+			copy_effects->gaussian_blur(prev_texture, mipmap, region, true);
+		} else {
+			texture_size.x = MAX(1, texture_size.x >> 1);
+			texture_size.y = MAX(1, texture_size.y >> 1);
+			copy_effects->gaussian_blur_raster(prev_texture, mipmap, region, texture_size);
+		}
 		prev_texture = mipmap;
 	}
 	RD::get_singleton()->draw_command_end_label();