Mask out shadows on CanvasItems that don't have a matching item_shadow_mask

This restores the behavior from 3.x

4 files changed, 106 insertions, 97 deletions

diff --git a/servers/rendering/renderer_rd/renderer_canvas_render_rd.cpp b/servers/rendering/renderer_rd/renderer_canvas_render_rd.cpp
index 0dcdb90948..165168cb29 100644
--- a/servers/rendering/renderer_rd/renderer_canvas_render_rd.cpp
+++ b/servers/rendering/renderer_rd/renderer_canvas_render_rd.cpp
@@ -666,6 +666,8 @@ void RendererCanvasRenderRD::canvas_render_items(RID p_to_render_target, Item *p
 		RD::get_singleton()->buffer_update(state.lights_uniform_buffer, 0, sizeof(LightUniform) * light_count, &state.light_uniforms[0]);
 	}
 
+	bool use_linear_colors = texture_storage->render_target_is_using_hdr(p_to_render_target);
+
 	{
 		//update canvas state uniform buffer
 		State::Buffer state_buffer;
@@ -684,7 +686,6 @@ void RendererCanvasRenderRD::canvas_render_items(RID p_to_render_target, Item *p
 		normal_transform.columns[2] = Vector2();
 		_update_transform_2d_to_mat4(normal_transform, state_buffer.canvas_normal_transform);
 
-		bool use_linear_colors = texture_storage->render_target_is_using_hdr(p_to_render_target);
 		Color modulate = p_modulate;
 		if (use_linear_colors) {
 			modulate = p_modulate.srgb_to_linear();
@@ -722,6 +723,8 @@ void RendererCanvasRenderRD::canvas_render_items(RID p_to_render_target, Item *p
 		//print_line("w: " + itos(ssize.width) + " s: " + rtos(canvas_scale));
 		state_buffer.tex_to_sdf = 1.0 / ((canvas_scale.x + canvas_scale.y) * 0.5);
 
+		state_buffer.flags = use_linear_colors ? CANVAS_FLAGS_CONVERT_ATTRIBUTES_TO_LINEAR : 0;
+
 		RD::get_singleton()->buffer_update(state.canvas_state_buffer, 0, sizeof(State::Buffer), &state_buffer);
 	}
 
@@ -752,8 +755,7 @@ void RendererCanvasRenderRD::canvas_render_items(RID p_to_render_target, Item *p
 
 	RenderTarget to_render_target;
 	to_render_target.render_target = p_to_render_target;
-	bool use_linear_colors = texture_storage->render_target_is_using_hdr(p_to_render_target);
-	to_render_target.base_flags = use_linear_colors ? FLAGS_CONVERT_ATTRIBUTES_TO_LINEAR : 0;
+	to_render_target.use_linear_colors = use_linear_colors;
 
 	while (ci) {
 		if (ci->copy_back_buffer && canvas_group_owner == nullptr) {
@@ -2244,7 +2246,7 @@ RendererCanvasRenderRD::InstanceData *RendererCanvasRenderRD::new_instance_data(
 		instance_data->world[i] = p_world[i];
 	}
 
-	instance_data->flags = p_base_flags | p_info->flags; // Reset on each command for safety, keep canvas texture binding config.
+	instance_data->flags = p_base_flags; // Reset on each command for safety.
 
 	instance_data->color_texture_pixel_size[0] = p_info->texpixel_size.width;
 	instance_data->color_texture_pixel_size[1] = p_info->texpixel_size.height;
@@ -2265,8 +2267,8 @@ void RendererCanvasRenderRD::_record_item_commands(const Item *p_item, RenderTar
 	_update_transform_2d_to_mat2x3(base_transform, world);
 
 	Color base_color = p_item->final_modulate;
-	bool use_linear_colors = bool(p_render_target.base_flags & FLAGS_CONVERT_ATTRIBUTES_TO_LINEAR);
-	uint32_t base_flags = p_render_target.base_flags;
+	bool use_linear_colors = p_render_target.use_linear_colors;
+	uint32_t base_flags = 0;
 
 	bool reclip = false;
 
@@ -2276,6 +2278,7 @@ void RendererCanvasRenderRD::_record_item_commands(const Item *p_item, RenderTar
 	uint32_t lights[4] = { 0, 0, 0, 0 };
 
 	uint16_t light_count = 0;
+	uint16_t shadow_mask = 0;
 
 	{
 		Light *light = p_lights;
@@ -2285,6 +2288,10 @@ void RendererCanvasRenderRD::_record_item_commands(const Item *p_item, RenderTar
 				uint32_t light_index = light->render_index_cache;
 				lights[light_count >> 2] |= light_index << ((light_count & 3) * 8);
 
+				if (p_item->light_mask & light->item_shadow_mask) {
+					shadow_mask |= 1 << light_count;
+				}
+
 				light_count++;
 
 				if (light_count == MAX_LIGHTS_PER_ITEM - 1) {
@@ -2294,7 +2301,8 @@ void RendererCanvasRenderRD::_record_item_commands(const Item *p_item, RenderTar
 			light = light->next_ptr;
 		}
 
-		base_flags |= light_count << FLAGS_LIGHT_COUNT_SHIFT;
+		base_flags |= light_count << INSTANCE_FLAGS_LIGHT_COUNT_SHIFT;
+		base_flags |= shadow_mask << INSTANCE_FLAGS_SHADOW_MASKED_SHIFT;
 	}
 
 	bool use_lighting = (light_count > 0 || using_directional_lights);
@@ -2323,6 +2331,7 @@ void RendererCanvasRenderRD::_record_item_commands(const Item *p_item, RenderTar
 					// default variant
 					r_current_batch->shader_variant = SHADER_VARIANT_QUAD;
 					r_current_batch->render_primitive = RD::RENDER_PRIMITIVE_TRIANGLES;
+					r_current_batch->flags = 0;
 				}
 
 				RenderingServer::CanvasItemTextureRepeat rect_repeat = texture_repeat;
@@ -2378,20 +2387,18 @@ void RendererCanvasRenderRD::_record_item_commands(const Item *p_item, RenderTar
 
 					if (rect->flags & CANVAS_RECT_FLIP_H) {
 						src_rect.size.x *= -1;
-						instance_data->flags |= FLAGS_FLIP_H;
 					}
 
 					if (rect->flags & CANVAS_RECT_FLIP_V) {
 						src_rect.size.y *= -1;
-						instance_data->flags |= FLAGS_FLIP_V;
 					}
 
 					if (rect->flags & CANVAS_RECT_TRANSPOSE) {
-						instance_data->flags |= FLAGS_TRANSPOSE_RECT;
+						instance_data->flags |= INSTANCE_FLAGS_TRANSPOSE_RECT;
 					}
 
 					if (rect->flags & CANVAS_RECT_CLIP_UV) {
-						instance_data->flags |= FLAGS_CLIP_RECT_UV;
+						instance_data->flags |= INSTANCE_FLAGS_CLIP_RECT_UV;
 					}
 
 				} else {
@@ -2410,13 +2417,13 @@ void RendererCanvasRenderRD::_record_item_commands(const Item *p_item, RenderTar
 				}
 
 				if (has_msdf) {
-					instance_data->flags |= FLAGS_USE_MSDF;
+					instance_data->flags |= INSTANCE_FLAGS_USE_MSDF;
 					instance_data->msdf[0] = rect->px_range; // Pixel range.
 					instance_data->msdf[1] = rect->outline; // Outline size.
 					instance_data->msdf[2] = 0.f; // Reserved.
 					instance_data->msdf[3] = 0.f; // Reserved.
 				} else if (rect->flags & CANVAS_RECT_LCD) {
-					instance_data->flags |= FLAGS_USE_LCD;
+					instance_data->flags |= INSTANCE_FLAGS_USE_LCD;
 				}
 
 				instance_data->modulation[0] = modulated.r;
@@ -2447,6 +2454,7 @@ void RendererCanvasRenderRD::_record_item_commands(const Item *p_item, RenderTar
 					r_current_batch->has_blend = false;
 					r_current_batch->shader_variant = SHADER_VARIANT_NINEPATCH;
 					r_current_batch->render_primitive = RD::RENDER_PRIMITIVE_TRIANGLES;
+					r_current_batch->flags = 0;
 				}
 
 				TextureState tex_state(np->texture, texture_filter, texture_repeat, false, use_linear_colors);
@@ -2498,11 +2506,11 @@ void RendererCanvasRenderRD::_record_item_commands(const Item *p_item, RenderTar
 				instance_data->dst_rect[2] = dst_rect.size.width;
 				instance_data->dst_rect[3] = dst_rect.size.height;
 
-				instance_data->flags |= int(np->axis_x) << FLAGS_NINEPATCH_H_MODE_SHIFT;
-				instance_data->flags |= int(np->axis_y) << FLAGS_NINEPATCH_V_MODE_SHIFT;
+				instance_data->flags |= int(np->axis_x) << INSTANCE_FLAGS_NINEPATCH_H_MODE_SHIFT;
+				instance_data->flags |= int(np->axis_y) << INSTANCE_FLAGS_NINEPATCH_V_MODE_SHIFT;
 
 				if (np->draw_center) {
-					instance_data->flags |= FLAGS_NINEPACH_DRAW_CENTER;
+					instance_data->flags |= INSTANCE_FLAGS_NINEPACH_DRAW_CENTER;
 				}
 
 				instance_data->ninepatch_margins[0] = np->margin[SIDE_LEFT];
@@ -2522,6 +2530,7 @@ void RendererCanvasRenderRD::_record_item_commands(const Item *p_item, RenderTar
 				r_current_batch->command_type = Item::Command::TYPE_POLYGON;
 				r_current_batch->has_blend = false;
 				r_current_batch->command = c;
+				r_current_batch->flags = 0;
 
 				TextureState tex_state(polygon->texture, texture_filter, texture_repeat, false, use_linear_colors);
 				TextureInfo *tex_info = texture_info_map.getptr(tex_state);
@@ -2566,6 +2575,7 @@ void RendererCanvasRenderRD::_record_item_commands(const Item *p_item, RenderTar
 					r_current_batch->has_blend = false;
 					r_current_batch->command = c;
 					r_current_batch->primitive_points = primitive->point_count;
+					r_current_batch->flags = 0;
 
 					ERR_CONTINUE(primitive->point_count == 0 || primitive->point_count > 4);
 
@@ -2648,6 +2658,7 @@ void RendererCanvasRenderRD::_record_item_commands(const Item *p_item, RenderTar
 				r_current_batch->command = c;
 				r_current_batch->command_type = c->type;
 				r_current_batch->has_blend = false;
+				r_current_batch->flags = 0;
 
 				InstanceData *instance_data = nullptr;
 
@@ -2690,13 +2701,13 @@ void RendererCanvasRenderRD::_record_item_commands(const Item *p_item, RenderTar
 					r_current_batch->tex_info = tex_info;
 					instance_data = new_instance_data(world, lights, base_flags, r_index, tex_info);
 
-					instance_data->flags |= 1; // multimesh, trails disabled
+					r_current_batch->flags |= 1; // multimesh, trails disabled
 
 					if (mesh_storage->multimesh_uses_colors(mm->multimesh)) {
-						instance_data->flags |= FLAGS_INSTANCING_HAS_COLORS;
+						r_current_batch->flags |= BATCH_FLAGS_INSTANCING_HAS_COLORS;
 					}
 					if (mesh_storage->multimesh_uses_custom_data(mm->multimesh)) {
-						instance_data->flags |= FLAGS_INSTANCING_HAS_CUSTOM_DATA;
+						r_current_batch->flags |= BATCH_FLAGS_INSTANCING_HAS_CUSTOM_DATA;
 					}
 				} else if (c->type == Item::Command::TYPE_PARTICLES) {
 					RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
@@ -2714,13 +2725,13 @@ void RendererCanvasRenderRD::_record_item_commands(const Item *p_item, RenderTar
 
 					uint32_t divisor = 1;
 					r_current_batch->mesh_instance_count = particles_storage->particles_get_amount(pt->particles, divisor);
-					instance_data->flags |= (divisor & FLAGS_INSTANCING_MASK);
+					r_current_batch->flags |= (divisor & BATCH_FLAGS_INSTANCING_MASK);
 					r_current_batch->mesh_instance_count /= divisor;
 
 					RID particles = pt->particles;
 
-					instance_data->flags |= FLAGS_INSTANCING_HAS_COLORS;
-					instance_data->flags |= FLAGS_INSTANCING_HAS_CUSTOM_DATA;
+					r_current_batch->flags |= BATCH_FLAGS_INSTANCING_HAS_COLORS;
+					r_current_batch->flags |= BATCH_FLAGS_INSTANCING_HAS_CUSTOM_DATA;
 
 					if (particles_storage->particles_has_collision(particles) && texture_storage->render_target_is_sdf_enabled(p_render_target.render_target)) {
 						// Pass collision information.
@@ -2806,6 +2817,7 @@ void RendererCanvasRenderRD::_record_item_commands(const Item *p_item, RenderTar
 			// default variant
 			r_current_batch->shader_variant = SHADER_VARIANT_QUAD;
 			r_current_batch->render_primitive = RD::RENDER_PRIMITIVE_TRIANGLES;
+			r_current_batch->flags = 0;
 		}
 
 		// 2: If the current batch has lighting, start a new batch.
@@ -2920,6 +2932,7 @@ void RendererCanvasRenderRD::_render_batch(RD::DrawListID p_draw_list, CanvasSha
 	PushConstant push_constant;
 	push_constant.base_instance_index = p_batch->start;
 	push_constant.specular_shininess = p_batch->tex_info->specular_shininess;
+	push_constant.batch_flags = p_batch->tex_info->flags | p_batch->flags;
 
 	RID pipeline;
 	PipelineKey pipeline_key;
@@ -3168,11 +3181,11 @@ void RendererCanvasRenderRD::_prepare_batch_texture_info(RID p_texture, TextureS
 
 	// cache values to be copied to instance data
 	if (info.specular_color.a < 0.999) {
-		p_info->flags |= FLAGS_DEFAULT_SPECULAR_MAP_USED;
+		p_info->flags |= BATCH_FLAGS_DEFAULT_SPECULAR_MAP_USED;
 	}
 
 	if (info.use_normal) {
-		p_info->flags |= FLAGS_DEFAULT_NORMAL_MAP_USED;
+		p_info->flags |= BATCH_FLAGS_DEFAULT_NORMAL_MAP_USED;
 	}
 
 	uint8_t a = uint8_t(CLAMP(info.specular_color.a * 255.0, 0.0, 255.0));
diff --git a/servers/rendering/renderer_rd/renderer_canvas_render_rd.h b/servers/rendering/renderer_rd/renderer_canvas_render_rd.h
index 1bdc5076c5..e4f1779b09 100644
--- a/servers/rendering/renderer_rd/renderer_canvas_render_rd.h
+++ b/servers/rendering/renderer_rd/renderer_canvas_render_rd.h
@@ -65,31 +65,31 @@ class RendererCanvasRenderRD : public RendererCanvasRender {
 	};
 
 	enum {
+		INSTANCE_FLAGS_LIGHT_COUNT_SHIFT = 0, // 4 bits for light count.
 
-		FLAGS_INSTANCING_MASK = 0x7F,
-		FLAGS_INSTANCING_HAS_COLORS = (1 << 7),
-		FLAGS_INSTANCING_HAS_CUSTOM_DATA = (1 << 8),
+		INSTANCE_FLAGS_CLIP_RECT_UV = (1 << 4),
+		INSTANCE_FLAGS_TRANSPOSE_RECT = (1 << 5),
+		INSTANCE_FLAGS_USE_MSDF = (1 << 6),
+		INSTANCE_FLAGS_USE_LCD = (1 << 7),
 
-		FLAGS_CLIP_RECT_UV = (1 << 9),
-		FLAGS_TRANSPOSE_RECT = (1 << 10),
+		INSTANCE_FLAGS_NINEPACH_DRAW_CENTER = (1 << 8),
+		INSTANCE_FLAGS_NINEPATCH_H_MODE_SHIFT = 9,
+		INSTANCE_FLAGS_NINEPATCH_V_MODE_SHIFT = 11,
 
-		FLAGS_CONVERT_ATTRIBUTES_TO_LINEAR = (1 << 11),
-
-		FLAGS_NINEPACH_DRAW_CENTER = (1 << 12),
-
-		FLAGS_USE_SKELETON = (1 << 15),
-		FLAGS_NINEPATCH_H_MODE_SHIFT = 16,
-		FLAGS_NINEPATCH_V_MODE_SHIFT = 18,
-		FLAGS_LIGHT_COUNT_SHIFT = 20,
+		INSTANCE_FLAGS_SHADOW_MASKED_SHIFT = 13, // 16 bits.
+	};
 
-		FLAGS_DEFAULT_NORMAL_MAP_USED = (1 << 24),
-		FLAGS_DEFAULT_SPECULAR_MAP_USED = (1 << 25),
+	enum {
+		BATCH_FLAGS_INSTANCING_MASK = 0x7F,
+		BATCH_FLAGS_INSTANCING_HAS_COLORS = (1 << 7),
+		BATCH_FLAGS_INSTANCING_HAS_CUSTOM_DATA = (1 << 8),
 
-		FLAGS_USE_MSDF = (1 << 26),
-		FLAGS_USE_LCD = (1 << 27),
+		BATCH_FLAGS_DEFAULT_NORMAL_MAP_USED = (1 << 9),
+		BATCH_FLAGS_DEFAULT_SPECULAR_MAP_USED = (1 << 10),
+	};
 
-		FLAGS_FLIP_H = (1 << 28),
-		FLAGS_FLIP_V = (1 << 29),
+	enum {
+		CANVAS_FLAGS_CONVERT_ATTRIBUTES_TO_LINEAR = (1 << 0),
 	};
 
 	enum {
@@ -370,7 +370,7 @@ class RendererCanvasRenderRD : public RendererCanvasRender {
 		uint32_t base_instance_index;
 		ShaderSpecialization shader_specialization;
 		uint32_t specular_shininess;
-		uint32_t pad;
+		uint32_t batch_flags;
 	};
 
 	// TextureState is used to determine when a new batch is required due to a change of texture state.
@@ -508,6 +508,7 @@ class RendererCanvasRenderRD : public RendererCanvasRender {
 			uint32_t mesh_instance_count;
 		};
 		bool has_blend = false;
+		uint32_t flags = 0;
 	};
 
 	HashMap<TextureState, TextureInfo, HashableHasher<TextureState>> texture_info_map;
@@ -535,7 +536,7 @@ class RendererCanvasRenderRD : public RendererCanvasRender {
 
 			uint32_t directional_light_count;
 			float tex_to_sdf;
-			uint32_t pad1;
+			uint32_t flags;
 			uint32_t pad2;
 		};
 
@@ -596,9 +597,7 @@ class RendererCanvasRenderRD : public RendererCanvasRender {
 	struct RenderTarget {
 		// Current render target for the canvas.
 		RID render_target;
-		// The base flags for each InstanceData, derived from the render target.
-		// Either FLAGS_CONVERT_ATTRIBUTES_TO_LINEAR or 0
-		uint32_t base_flags = 0;
+		bool use_linear_colors = false;
 	};
 
 	inline RID _get_pipeline_specialization_or_ubershader(CanvasShaderData *p_shader_data, PipelineKey &r_pipeline_key, PushConstant &r_push_constant, RID p_mesh_instance = RID(), void *p_surface = nullptr, uint32_t p_surface_index = 0, RID *r_vertex_array = nullptr);
diff --git a/servers/rendering/renderer_rd/shaders/canvas.glsl b/servers/rendering/renderer_rd/shaders/canvas.glsl
index f665bc24a4..b66aa71f6b 100644
--- a/servers/rendering/renderer_rd/shaders/canvas.glsl
+++ b/servers/rendering/renderer_rd/shaders/canvas.glsl
@@ -101,7 +101,7 @@ void main() {
 
 	vec2 vertex = vertex_attrib;
 	vec4 color = color_attrib;
-	if (bool(draw_data.flags & FLAGS_CONVERT_ATTRIBUTES_TO_LINEAR)) {
+	if (bool(canvas_data.flags & CANVAS_FLAGS_CONVERT_ATTRIBUTES_TO_LINEAR)) {
 		color.rgb = srgb_to_linear(color.rgb);
 	}
 	color *= draw_data.modulation;
@@ -122,7 +122,7 @@ void main() {
 	vec2 vertex_base_arr[4] = vec2[](vec2(0.0, 0.0), vec2(0.0, 1.0), vec2(1.0, 1.0), vec2(1.0, 0.0));
 	vec2 vertex_base = vertex_base_arr[gl_VertexIndex];
 
-	vec2 uv = draw_data.src_rect.xy + abs(draw_data.src_rect.zw) * ((draw_data.flags & FLAGS_TRANSPOSE_RECT) != 0 ? vertex_base.yx : vertex_base.xy);
+	vec2 uv = draw_data.src_rect.xy + abs(draw_data.src_rect.zw) * ((draw_data.flags & INSTANCE_FLAGS_TRANSPOSE_RECT) != 0 ? vertex_base.yx : vertex_base.xy);
 	vec4 color = draw_data.modulation;
 	vec2 vertex = draw_data.dst_rect.xy + abs(draw_data.dst_rect.zw) * mix(vertex_base, vec2(1.0, 1.0) - vertex_base, lessThan(draw_data.src_rect.zw, vec2(0.0, 0.0)));
 	uvec4 bones = uvec4(0, 0, 0, 0);
@@ -133,7 +133,7 @@ void main() {
 
 #ifdef USE_ATTRIBUTES
 
-	uint instancing = draw_data.flags & FLAGS_INSTANCING_MASK;
+	uint instancing = params.batch_flags & BATCH_FLAGS_INSTANCING_MASK;
 
 	if (instancing > 1) {
 		// trails
@@ -172,19 +172,19 @@ void main() {
 		vertex = new_vertex;
 		color *= pcolor;
 	} else if (instancing == 1) {
-		uint stride = 2 + bitfieldExtract(draw_data.flags, FLAGS_INSTANCING_HAS_COLORS_SHIFT, 1) + bitfieldExtract(draw_data.flags, FLAGS_INSTANCING_HAS_CUSTOM_DATA_SHIFT, 1);
+		uint stride = 2 + bitfieldExtract(params.batch_flags, BATCH_FLAGS_INSTANCING_HAS_COLORS_SHIFT, 1) + bitfieldExtract(params.batch_flags, BATCH_FLAGS_INSTANCING_HAS_CUSTOM_DATA_SHIFT, 1);
 
 		uint offset = stride * gl_InstanceIndex;
 
 		mat4 matrix = mat4(transforms.data[offset + 0], transforms.data[offset + 1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0));
 		offset += 2;
 
-		if (bool(draw_data.flags & FLAGS_INSTANCING_HAS_COLORS)) {
+		if (bool(params.batch_flags & BATCH_FLAGS_INSTANCING_HAS_COLORS)) {
 			color *= transforms.data[offset];
 			offset += 1;
 		}
 
-		if (bool(draw_data.flags & FLAGS_INSTANCING_HAS_CUSTOM_DATA)) {
+		if (bool(params.batch_flags & BATCH_FLAGS_INSTANCING_HAS_CUSTOM_DATA)) {
 			instance_custom = transforms.data[offset];
 		}
 
@@ -331,7 +331,7 @@ float map_ninepatch_axis(float pixel, float draw_size, float tex_pixel_size, flo
 	} else if (pixel >= draw_size - margin_end) {
 		return (tex_size - (draw_size - pixel)) * tex_pixel_size;
 	} else {
-		draw_center -= 1 - int(bitfieldExtract(draw_data.flags, FLAGS_NINEPACH_DRAW_CENTER_SHIFT, 1));
+		draw_center -= 1 - int(bitfieldExtract(draw_data.flags, INSTANCE_FLAGS_NINEPATCH_DRAW_CENTER_SHIFT, 1));
 
 		// np_repeat is passed as uniform using NinePatchRect::AxisStretchMode enum.
 		if (np_repeat == 0) { // Stretch.
@@ -472,8 +472,8 @@ void main() {
 
 	int draw_center = 2;
 	uv = vec2(
-			map_ninepatch_axis(pixel_size_interp.x, abs(draw_data.dst_rect.z), draw_data.color_texture_pixel_size.x, draw_data.ninepatch_margins.x, draw_data.ninepatch_margins.z, int(bitfieldExtract(draw_data.flags, FLAGS_NINEPATCH_H_MODE_SHIFT, 2)), draw_center),
-			map_ninepatch_axis(pixel_size_interp.y, abs(draw_data.dst_rect.w), draw_data.color_texture_pixel_size.y, draw_data.ninepatch_margins.y, draw_data.ninepatch_margins.w, int(bitfieldExtract(draw_data.flags, FLAGS_NINEPATCH_V_MODE_SHIFT, 2)), draw_center));
+			map_ninepatch_axis(pixel_size_interp.x, abs(draw_data.dst_rect.z), draw_data.color_texture_pixel_size.x, draw_data.ninepatch_margins.x, draw_data.ninepatch_margins.z, int(bitfieldExtract(draw_data.flags, INSTANCE_FLAGS_NINEPATCH_H_MODE_SHIFT, 2)), draw_center),
+			map_ninepatch_axis(pixel_size_interp.y, abs(draw_data.dst_rect.w), draw_data.color_texture_pixel_size.y, draw_data.ninepatch_margins.y, draw_data.ninepatch_margins.w, int(bitfieldExtract(draw_data.flags, INSTANCE_FLAGS_NINEPATCH_V_MODE_SHIFT, 2)), draw_center));
 
 	if (draw_center == 0) {
 		color.a = 0.0;
@@ -482,7 +482,7 @@ void main() {
 	uv = uv * draw_data.src_rect.zw + draw_data.src_rect.xy; //apply region if needed
 
 #endif
-	if (bool(draw_data.flags & FLAGS_CLIP_RECT_UV)) {
+	if (bool(draw_data.flags & INSTANCE_FLAGS_CLIP_RECT_UV)) {
 		vec2 half_texpixel = draw_data.color_texture_pixel_size * 0.5;
 		uv = clamp(uv, draw_data.src_rect.xy + half_texpixel, draw_data.src_rect.xy + abs(draw_data.src_rect.zw) - half_texpixel);
 	}
@@ -490,7 +490,7 @@ void main() {
 #endif
 
 #ifndef USE_PRIMITIVE
-	if (bool(draw_data.flags & FLAGS_USE_MSDF)) {
+	if (bool(draw_data.flags & INSTANCE_FLAGS_USE_MSDF)) {
 		float px_range = draw_data.ninepatch_margins.x;
 		float outline_thickness = draw_data.ninepatch_margins.y;
 		//float reserved1 = draw_data.ninepatch_margins.z;
@@ -510,7 +510,7 @@ void main() {
 			float a = clamp(d * px_size + 0.5, 0.0, 1.0);
 			color.a = a * color.a;
 		}
-	} else if (bool(draw_data.flags & FLAGS_USE_LCD)) {
+	} else if (bool(draw_data.flags & INSTANCE_FLAGS_USE_LCD)) {
 		vec4 lcd_sample = texture(sampler2D(color_texture, texture_sampler), uv);
 		if (lcd_sample.a == 1.0) {
 			color.rgb = lcd_sample.rgb * color.a;
@@ -524,7 +524,7 @@ void main() {
 		color *= texture(sampler2D(color_texture, texture_sampler), uv);
 	}
 
-	uint light_count = bitfieldExtract(draw_data.flags, FLAGS_LIGHT_COUNT_SHIFT, 4); //max 15 lights
+	uint light_count = draw_data.flags & 15u; //max 15 lights
 	bool using_light = (light_count + canvas_data.directional_light_count) > 0;
 
 	vec3 normal;
@@ -535,17 +535,15 @@ void main() {
 	bool normal_used = false;
 #endif
 
-	if (normal_used || (using_light && bool(draw_data.flags & FLAGS_DEFAULT_NORMAL_MAP_USED))) {
+	if (normal_used || (using_light && bool(params.batch_flags & BATCH_FLAGS_DEFAULT_NORMAL_MAP_USED))) {
 		normal.xy = texture(sampler2D(normal_texture, texture_sampler), uv).xy * vec2(2.0, -2.0) - vec2(1.0, -1.0);
-		if (bool(draw_data.flags & FLAGS_TRANSPOSE_RECT)) {
+
+#if !defined(USE_ATTRIBUTES) && !defined(USE_PRIMITIVE)
+		if (bool(draw_data.flags & INSTANCE_FLAGS_TRANSPOSE_RECT)) {
 			normal.xy = normal.yx;
 		}
-		if (bool(draw_data.flags & FLAGS_FLIP_H)) {
-			normal.x = -normal.x;
-		}
-		if (bool(draw_data.flags & FLAGS_FLIP_V)) {
-			normal.y = -normal.y;
-		}
+		normal.xy *= sign(draw_data.src_rect.zw);
+#endif
 		normal.z = sqrt(max(0.0, 1.0 - dot(normal.xy, normal.xy)));
 		normal_used = true;
 	} else {
@@ -561,7 +559,7 @@ void main() {
 	bool specular_shininess_used = false;
 #endif
 
-	if (specular_shininess_used || (using_light && normal_used && bool(draw_data.flags & FLAGS_DEFAULT_SPECULAR_MAP_USED))) {
+	if (specular_shininess_used || (using_light && normal_used && bool(params.batch_flags & BATCH_FLAGS_DEFAULT_SPECULAR_MAP_USED))) {
 		specular_shininess = texture(sampler2D(specular_texture, texture_sampler), uv);
 		specular_shininess *= unpackUnorm4x8(params.specular_shininess);
 		specular_shininess_used = true;
@@ -632,7 +630,7 @@ void main() {
 			}
 #endif
 
-			if (bool(light_array.data[light_base].flags & LIGHT_FLAGS_HAS_SHADOW)) {
+			if (bool(light_array.data[light_base].flags & LIGHT_FLAGS_HAS_SHADOW) && bool(draw_data.flags & (INSTANCE_FLAGS_SHADOW_MASKED << i))) {
 				vec2 shadow_pos = (vec4(shadow_vertex, 0.0, 1.0) * mat4(light_array.data[light_base].shadow_matrix[0], light_array.data[light_base].shadow_matrix[1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0))).xy; //multiply inverse given its transposed. Optimizer removes useless operations.
 
 				vec4 shadow_uv = vec4(shadow_pos.x, light_array.data[light_base].shadow_y_ofs, shadow_pos.y * light_array.data[light_base].shadow_zfar_inv, 1.0);
@@ -692,7 +690,7 @@ void main() {
 			}
 #endif
 
-			if (bool(light_array.data[light_base].flags & LIGHT_FLAGS_HAS_SHADOW)) {
+			if (bool(light_array.data[light_base].flags & LIGHT_FLAGS_HAS_SHADOW) && bool(draw_data.flags & (INSTANCE_FLAGS_SHADOW_MASKED << i))) {
 				vec2 shadow_pos = (vec4(shadow_vertex, 0.0, 1.0) * mat4(light_array.data[light_base].shadow_matrix[0], light_array.data[light_base].shadow_matrix[1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0))).xy; //multiply inverse given its transposed. Optimizer removes useless operations.
 
 				vec2 pos_norm = normalize(shadow_pos);
diff --git a/servers/rendering/renderer_rd/shaders/canvas_uniforms_inc.glsl b/servers/rendering/renderer_rd/shaders/canvas_uniforms_inc.glsl
index 84017a1fe1..2186b08e89 100644
--- a/servers/rendering/renderer_rd/shaders/canvas_uniforms_inc.glsl
+++ b/servers/rendering/renderer_rd/shaders/canvas_uniforms_inc.glsl
@@ -5,32 +5,19 @@
 
 #define SDF_MAX_LENGTH 16384.0
 
-//1 means enabled, 2+ means trails in use
-#define FLAGS_INSTANCING_MASK 0x7F
-#define FLAGS_INSTANCING_HAS_COLORS_SHIFT 7
-#define FLAGS_INSTANCING_HAS_COLORS (1 << FLAGS_INSTANCING_HAS_COLORS_SHIFT)
-#define FLAGS_INSTANCING_HAS_CUSTOM_DATA_SHIFT 8
-#define FLAGS_INSTANCING_HAS_CUSTOM_DATA (1 << FLAGS_INSTANCING_HAS_CUSTOM_DATA_SHIFT)
-
-#define FLAGS_CLIP_RECT_UV (1 << 9)
-#define FLAGS_TRANSPOSE_RECT (1 << 10)
-#define FLAGS_CONVERT_ATTRIBUTES_TO_LINEAR (1 << 11)
-#define FLAGS_NINEPACH_DRAW_CENTER_SHIFT 12
-#define FLAGS_NINEPACH_DRAW_CENTER (1 << FLAGS_NINEPACH_DRAW_CENTER_SHIFT)
-
-#define FLAGS_NINEPATCH_H_MODE_SHIFT 16
-#define FLAGS_NINEPATCH_V_MODE_SHIFT 18
+#define INSTANCE_FLAGS_LIGHT_COUNT_SHIFT 0 // 4 bits.
 
-#define FLAGS_LIGHT_COUNT_SHIFT 20
+#define INSTANCE_FLAGS_CLIP_RECT_UV (1 << 4)
+#define INSTANCE_FLAGS_TRANSPOSE_RECT (1 << 5)
+#define INSTANCE_FLAGS_USE_MSDF (1 << 6)
+#define INSTANCE_FLAGS_USE_LCD (1 << 7)
 
-#define FLAGS_DEFAULT_NORMAL_MAP_USED (1 << 24)
-#define FLAGS_DEFAULT_SPECULAR_MAP_USED (1 << 25)
+#define INSTANCE_FLAGS_NINEPATCH_DRAW_CENTER_SHIFT 8
+#define INSTANCE_FLAGS_NINEPATCH_H_MODE_SHIFT 9
+#define INSTANCE_FLAGS_NINEPATCH_V_MODE_SHIFT 11
 
-#define FLAGS_USE_MSDF (1 << 26)
-#define FLAGS_USE_LCD (1 << 27)
-
-#define FLAGS_FLIP_H (1 << 28)
-#define FLAGS_FLIP_V (1 << 29)
+#define INSTANCE_FLAGS_SHADOW_MASKED_SHIFT 13 // 16 bits.
+#define INSTANCE_FLAGS_SHADOW_MASKED (1 << INSTANCE_FLAGS_SHADOW_MASKED_SHIFT)
 
 struct InstanceData {
 	vec2 world_x;
@@ -54,11 +41,21 @@ struct InstanceData {
 	uint lights[4];
 };
 
+//1 means enabled, 2+ means trails in use
+#define BATCH_FLAGS_INSTANCING_MASK 0x7F
+#define BATCH_FLAGS_INSTANCING_HAS_COLORS_SHIFT 7
+#define BATCH_FLAGS_INSTANCING_HAS_COLORS (1 << BATCH_FLAGS_INSTANCING_HAS_COLORS_SHIFT)
+#define BATCH_FLAGS_INSTANCING_HAS_CUSTOM_DATA_SHIFT 8
+#define BATCH_FLAGS_INSTANCING_HAS_CUSTOM_DATA (1 << BATCH_FLAGS_INSTANCING_HAS_CUSTOM_DATA_SHIFT)
+
+#define BATCH_FLAGS_DEFAULT_NORMAL_MAP_USED (1 << 9)
+#define BATCH_FLAGS_DEFAULT_SPECULAR_MAP_USED (1 << 10)
+
 layout(push_constant, std430) uniform Params {
 	uint base_instance_index; // base index to instance data
 	uint sc_packed_0;
 	uint specular_shininess;
-	uint pad;
+	uint batch_flags;
 }
 params;
 
@@ -94,6 +91,8 @@ bool sc_use_lighting() {
 
 /* SET0: Globals */
 
+#define CANVAS_FLAGS_CONVERT_ATTRIBUTES_TO_LINEAR (1 << 0)
+
 // The values passed per draw primitives are cached within it
 
 layout(set = 0, binding = 1, std140) uniform CanvasData {
@@ -111,7 +110,7 @@ layout(set = 0, binding = 1, std140) uniform CanvasData {
 
 	uint directional_light_count;
 	float tex_to_sdf;
-	uint pad1;
+	uint flags;
 	uint pad2;
 }
 canvas_data;