Basic 2D engine is more or less working, needs more work for editor t…

…o be usable.

core/rid_owner.h

@@ -45,7 +45,7 @@ class RID_Alloc : public RID_AllocBase {
 
 		if (alloc_count == max_alloc) {
 			//allocate a new chunk
-			uint32_t chunk_count = alloc_count == 0 ? 0 : (max_alloc / elements_in_chunk + 1);
+			uint32_t chunk_count = alloc_count == 0 ? 0 : (max_alloc / elements_in_chunk);
 
 			//grow chunks
 			chunks = (T **)memrealloc(chunks, sizeof(T *) * (chunk_count + 1));
@@ -140,8 +140,8 @@ class RID_Alloc : public RID_AllocBase {
 		chunks[idx_chunk][idx_element].~T();
 		validator_chunks[idx_chunk][idx_element] = 0xFFFFFFFF; // go invalid
 
-		free_list_chunks[alloc_count / elements_in_chunk][alloc_count % elements_in_chunk] = idx;
 		alloc_count--;
+		free_list_chunks[alloc_count / elements_in_chunk][alloc_count % elements_in_chunk] = idx;
 	}
 
 	void get_owned_list(List<RID> *p_owned) {

drivers/vulkan/rendering_device_vulkan.cpp

@@ -721,7 +721,8 @@ uint32_t RenderingDeviceVulkan::get_image_format_pixel_size(DataFormat p_format)
 		case DATA_FORMAT_S8_UINT: return 1;
 		case DATA_FORMAT_D16_UNORM_S8_UINT: return 4;
 		case DATA_FORMAT_D24_UNORM_S8_UINT: return 4;
-		case DATA_FORMAT_D32_SFLOAT_S8_UINT: return 5; //?
+		case DATA_FORMAT_D32_SFLOAT_S8_UINT:
+			return 5; //?
 		case DATA_FORMAT_BC1_RGB_UNORM_BLOCK:
 		case DATA_FORMAT_BC1_RGB_SRGB_BLOCK:
 		case DATA_FORMAT_BC1_RGBA_UNORM_BLOCK:
@@ -965,15 +966,17 @@ uint32_t RenderingDeviceVulkan::get_compressed_image_format_block_byte_size(Data
 		case DATA_FORMAT_ASTC_12x10_UNORM_BLOCK:
 		case DATA_FORMAT_ASTC_12x10_SRGB_BLOCK:
 		case DATA_FORMAT_ASTC_12x12_UNORM_BLOCK:
-		case DATA_FORMAT_ASTC_12x12_SRGB_BLOCK: return 8; //wrong
+		case DATA_FORMAT_ASTC_12x12_SRGB_BLOCK:
+			return 8; //wrong
 		case DATA_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG:
 		case DATA_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG:
 		case DATA_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG:
 		case DATA_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG:
 		case DATA_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG:
 		case DATA_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG:
 		case DATA_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG:
-		case DATA_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: return 8; //what varies is resolution
+		case DATA_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG:
+			return 8; //what varies is resolution
 		default: {
 		}
 	}
@@ -1027,7 +1030,6 @@ uint32_t RenderingDeviceVulkan::get_image_format_required_size(DataFormat p_form
 		uint32_t bw = w % blockw != 0 ? w + (blockw - w % blockw) : w;
 		uint32_t bh = h % blockh != 0 ? h + (blockh - h % blockh) : h;
 
-		print_line("bw " + itos(bw) + " bh " + itos(bh) + " pixsize " + itos(pixel_size) + " shift " + itos(pixel_rshift));
 		uint32_t s = bw * bh;
 
 		s *= pixel_size;
@@ -1466,6 +1468,26 @@ RID RenderingDeviceVulkan::texture_create(const TextureFormat &p_format, const T
 	image_create_info.pNext = NULL;
 	image_create_info.flags = 0;
 
+	VkImageFormatListCreateInfoKHR format_list_create_info;
+	Vector<VkFormat> allowed_formats;
+
+	if (p_format.shareable_formats.size()) {
+		image_create_info.flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
+		for (int i = 0; i < p_format.shareable_formats.size(); i++) {
+			allowed_formats.push_back(vulkan_formats[p_format.shareable_formats[i]]);
+		}
+
+		format_list_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR;
+		format_list_create_info.pNext = NULL;
+		format_list_create_info.viewFormatCount = allowed_formats.size();
+		format_list_create_info.pViewFormats = allowed_formats.ptr();
+		image_create_info.pNext = &format_list_create_info;
+
+		ERR_FAIL_COND_V_MSG(p_format.shareable_formats.find(p_format.format) == -1, RID(),
+				"If supplied a list of shareable formats, the current format must be present in the list");
+		ERR_FAIL_COND_V_MSG(p_view.format_override != DATA_FORMAT_MAX && p_format.shareable_formats.find(p_view.format_override) == -1, RID(),
+				"If supplied a list of shareable formats, the current view format override must be present in the list");
+	}
 	if (p_format.type == TEXTURE_TYPE_CUBE || p_format.type == TEXTURE_TYPE_CUBE_ARRAY) {
 		image_create_info.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
 	}
@@ -1647,6 +1669,7 @@ RID RenderingDeviceVulkan::texture_create(const TextureFormat &p_format, const T
 	texture.mipmaps = image_create_info.mipLevels;
 	texture.usage_flags = p_format.usage_bits;
 	texture.samples = p_format.samples;
+	texture.allowed_shared_formats = p_format.shareable_formats;
 
 	//set bound and unbound layouts
 	if (p_format.usage_bits & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
@@ -1803,10 +1826,13 @@ RID RenderingDeviceVulkan::texture_create_shared(const TextureView &p_view, RID
 	};
 
 	image_view_create_info.viewType = view_types[texture.type];
-	if (p_view.format_override == DATA_FORMAT_MAX) {
+	if (p_view.format_override == DATA_FORMAT_MAX || p_view.format_override == texture.format) {
 		image_view_create_info.format = vulkan_formats[texture.format];
 	} else {
 		ERR_FAIL_INDEX_V(p_view.format_override, DATA_FORMAT_MAX, RID());
+
+		ERR_FAIL_COND_V_MSG(texture.allowed_shared_formats.find(p_view.format_override) == -1, RID(),
+				"Format override is not in the list of allowed shareable formats for original texture.");
 		image_view_create_info.format = vulkan_formats[p_view.format_override];
 	}
 
@@ -1877,6 +1903,13 @@ Error RenderingDeviceVulkan::texture_update(RID p_texture, uint32_t p_layer, con
 	uint32_t width, height;
 	uint32_t image_size = get_image_format_required_size(texture->format, texture->width, texture->height, 1, texture->mipmaps, &width, &height);
 	uint32_t required_size = image_size * texture->depth;
+	uint32_t required_align = get_compressed_image_format_block_byte_size(texture->format);
+	if (required_align == 1) {
+		required_align = get_image_format_pixel_size(texture->format);
+	}
+	if ((required_align % 4) != 0) { //alignment rules are really strange
+		required_align *= 4;
+	}
 
 	ERR_FAIL_COND_V_MSG(required_size != (uint32_t)p_data.size(), ERR_INVALID_PARAMETER,
 			"Required size for texture update (" + itos(required_size) + ") does not match data supplied size (" + itos(p_data.size()) + ").");
@@ -1914,12 +1947,12 @@ Error RenderingDeviceVulkan::texture_update(RID p_texture, uint32_t p_layer, con
 
 		uint32_t image_total = get_image_format_required_size(texture->format, texture->width, texture->height, 1, mm_i + 1, &width, &height);
 
-		const uint8_t *read_ptr = r.ptr() + mipmap_offset;
+		const uint8_t *read_ptr_mipmap = r.ptr() + mipmap_offset;
 		image_size = image_total - mipmap_offset;
 
 		for (uint32_t z = 0; z < texture->depth; z++) { //for 3D textures, depth may be > 0
 
-			read_ptr += image_size;
+			const uint8_t *read_ptr = read_ptr_mipmap + image_size * z;
 
 			for (uint32_t x = 0; x < width; x += region_size) {
 				for (uint32_t y = 0; y < height; y += region_size) {
@@ -1932,7 +1965,7 @@ Error RenderingDeviceVulkan::texture_update(RID p_texture, uint32_t p_layer, con
 					to_allocate >>= get_compressed_image_format_pixel_rshift(texture->format);
 
 					uint32_t alloc_offset, alloc_size;
-					Error err = _staging_buffer_allocate(to_allocate, 32, alloc_offset, alloc_size, false, p_sync_with_draw);
+					Error err = _staging_buffer_allocate(to_allocate, required_align, alloc_offset, alloc_size, false, p_sync_with_draw);
 					ERR_FAIL_COND_V(err, ERR_CANT_CREATE);
 
 					uint8_t *write_ptr;
@@ -2937,7 +2970,7 @@ bool RenderingDeviceVulkan::_uniform_add_binding(Vector<Vector<VkDescriptorSetLa
 		bindings.resize(set + 1);
 		uniform_infos.resize(set + 1);
 	}
-#if 1
+#if 0
 	print_line("stage: " + String(shader_stage_names[p_stage]) + " set: " + itos(set) + " binding: " + itos(info.binding) + " type:" + shader_uniform_names[info.type] + " length: " + itos(info.length));
 #endif
 	bindings.write[set].push_back(layout_binding);
@@ -3087,7 +3120,7 @@ RID RenderingDeviceVulkan::shader_create_from_source(const Vector<ShaderStageSou
 			for (int j = 0; j < program.getNumPipeInputs(); j++) {
 				if (program.getPipeInput(i).getType()->getQualifier().hasLocation()) {
 					int location = program.getPipeInput(i).getType()->getQualifier().layoutLocation;
-					print_line("found vertex location: " + itos(location));
+
 					if (vertex_input_locations.find(location) == -1) {
 						vertex_input_locations.push_back(location);
 					}
@@ -3470,13 +3503,10 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 
 	uint32_t uniform_count = p_uniforms.size();
 	const Uniform *uniforms = p_uniforms.ptr();
-	print_line("uniform count: " + itos(uniform_count));
 
 	uint32_t set_uniform_count = set.uniform_info.size();
 	const Shader::UniformInfo *set_uniforms = set.uniform_info.ptr();
 
-	print_line("set_uniform count: " + itos(set_uniform_count));
-
 	Vector<VkWriteDescriptorSet> writes;
 	DescriptorPoolKey pool_key;
 

drivers/vulkan/rendering_device_vulkan.h

@@ -101,6 +101,8 @@ class RenderingDeviceVulkan : public RenderingDevice {
 		uint32_t mipmaps;
 		uint32_t usage_flags;
 
+		Vector<DataFormat> allowed_shared_formats;
+
 		VkImageLayout bound_layout; //layout used when bound to framebuffer being drawn
 		VkImageLayout unbound_layout; //layout used otherwise
 		uint32_t aspect_mask;

drivers/vulkan/vulkan_context.cpp

@@ -18,6 +18,12 @@ VKAPI_ATTR VkBool32 VKAPI_CALL VulkanContext::_debug_messenger_callback(VkDebugU
 	char *message = (char *)malloc(strlen(pCallbackData->pMessage) + 5000);
 	ERR_FAIL_COND_V(!message, false);
 
+	//This error needs to be ignored because the AMD allocator will mix up memory types on IGP processors
+	if (strstr(pCallbackData->pMessage, "Mapping an image with layout") != NULL &&
+			strstr(pCallbackData->pMessage, "can result in undefined behavior if this memory is used by the device") != NULL) {
+		return VK_FALSE;
+	}
+
 	if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) {
 		strcat(prefix, "VERBOSE : ");
 	} else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) {

scene/register_scene_types.cpp

@@ -649,6 +649,7 @@ void register_scene_types() {
 	ClassDB::register_class<World>();
 	ClassDB::register_class<Environment>();
 	ClassDB::register_class<World2D>();
+	ClassDB::register_virtual_class<Texture>();
 	ClassDB::register_virtual_class<Texture2D>();
 	ClassDB::register_virtual_class<Sky>();
 	ClassDB::register_class<PanoramaSky>();

scene/resources/texture.h

@@ -42,7 +42,15 @@
 #include "servers/camera_server.h"
 #include "servers/visual_server.h"
 
-class Texture2D : public Resource {
+class Texture : public Resource {
+	GDCLASS(Texture, Resource);
+
+public:
+	Texture() {}
+};
+
+class Texture2D : public Texture {
+
 	GDCLASS(Texture2D, Resource);
 	OBJ_SAVE_TYPE(Texture2D); // Saves derived classes with common type so they can be interchanged.
 
@@ -332,7 +340,7 @@ class LargeTexture : public Texture2D {
 	LargeTexture();
 };
 
-class TextureLayered : public Resource {
+class TextureLayered : public Texture {
 
 	GDCLASS(TextureLayered, Resource);
 

servers/visual/rasterizer/rasterizer_canvas_rd.cpp

@@ -131,7 +131,7 @@ RasterizerCanvas::TextureBindingID RasterizerCanvasRD::request_texture_binding(R
 			u.binding = 2;
 			RID texture = storage->texture_get_rd_texture(p_normalmap);
 			if (!texture.is_valid()) {
-				//use default white texture
+				//use default normal texture
 				texture = default_textures.normal_texture;
 			}
 			u.ids.push_back(texture);
@@ -202,7 +202,7 @@ void RasterizerCanvasRD::_dispose_bindings() {
 	}
 }
 
-void RasterizerCanvasRD::_render_item(RD::DrawListID p_draw_list, const Item *p_item, RenderTargetFormat p_render_target_format, const Color &p_modulate, const Transform2D &p_canvas_transform_inverse) {
+void RasterizerCanvasRD::_render_item(RD::DrawListID p_draw_list, const Item *p_item, RenderTargetFormat p_render_target_format, RD::TextureSamples p_samples, const Color &p_modulate, const Transform2D &p_canvas_transform_inverse) {
 
 	int cc = p_item->commands.size();
 	const Item::Command *const *commands = p_item->commands.ptr();
@@ -217,10 +217,9 @@ void RasterizerCanvasRD::_render_item(RD::DrawListID p_draw_list, const Item *p_
 		push_constant.dst_rect[i] = 0;
 	}
 	push_constant.flags = 0;
-	push_constant.ninepatch_repeat = 0;
+	push_constant.specular_shininess = 0xFFFFFFFF;
 	push_constant.color_texture_pixel_size[0] = 0;
 	push_constant.color_texture_pixel_size[1] = 0;
-	push_constant.specular_shininess = 0xFFFFFFFF;
 	push_constant.pad[0] = 0;
 	push_constant.pad[1] = 0;
 	push_constant.pad[2] = 0;
@@ -347,7 +346,7 @@ void RasterizerCanvasRD::_render_item(RD::DrawListID p_draw_list, const Item *p_
 
 				//bind pipeline
 				{
-					RID pipeline = pipeline_variants->variants[p_render_target_format][PIPELINE_VARIANT_QUAD];
+					RID pipeline = pipeline_variants->variants[p_render_target_format][PIPELINE_VARIANT_QUAD].get_render_pipeline(RD::INVALID_ID, p_samples);
 					RD::get_singleton()->draw_list_bind_render_pipeline(p_draw_list, pipeline);
 				}
 
@@ -358,6 +357,7 @@ void RasterizerCanvasRD::_render_item(RD::DrawListID p_draw_list, const Item *p_
 					TextureBinding **texture_binding_ptr = bindings.texture_bindings.getptr(rect->texture_binding.binding_id);
 					ERR_CONTINUE(!texture_binding_ptr);
 					TextureBinding *texture_binding = *texture_binding_ptr;
+
 					RD::get_singleton()->draw_list_bind_uniform_set(p_draw_list, texture_binding->uniform_set, 0);
 					if (texture_binding->key.texture.is_valid()) {
 						Size2i tex_size = storage->texture_2d_get_size(texture_binding->key.texture);
@@ -449,7 +449,7 @@ void RasterizerCanvasRD::_render_item(RD::DrawListID p_draw_list, const Item *p_
 
 				//bind pipeline
 				{
-					RID pipeline = pipeline_variants->variants[p_render_target_format][PIPELINE_VARIANT_NINEPATCH];
+					RID pipeline = pipeline_variants->variants[p_render_target_format][PIPELINE_VARIANT_NINEPATCH].get_render_pipeline(RD::INVALID_ID, p_samples);
 					RD::get_singleton()->draw_list_bind_render_pipeline(p_draw_list, pipeline);
 				}
 
@@ -506,8 +506,8 @@ void RasterizerCanvasRD::_render_item(RD::DrawListID p_draw_list, const Item *p_
 				push_constant.color_texture_pixel_size[0] = texpixel_size.x;
 				push_constant.color_texture_pixel_size[1] = texpixel_size.y;
 
-				push_constant.ninepatch_repeat = int(np->axis_x) << 16;
-				push_constant.ninepatch_repeat |= int(np->axis_y);
+				push_constant.flags |= int(np->axis_x) << FLAGS_NINEPATCH_H_MODE_SHIFT;
+				push_constant.flags |= int(np->axis_y) << FLAGS_NINEPATCH_V_MODE_SHIFT;
 
 				if (np->draw_center) {
 					push_constant.flags |= FLAGS_NINEPACH_DRAW_CENTER;
@@ -926,7 +926,8 @@ void RasterizerCanvasRD::_render_items(RID p_to_render_target, bool p_clear, con
 	if (p_clear) {
 		clear_colors.push_back(p_clear_color);
 	}
-
+#warning TODO obtain from framebuffer format eventually when this is implemented
+	RD::TextureSamples texture_samples = RD::TEXTURE_SAMPLES_1;
 	RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(framebuffer, p_clear ? RD::INITIAL_ACTION_CLEAR : RD::INITIAL_ACTION_KEEP_COLOR, RD::FINAL_ACTION_READ_COLOR_DISCARD_DEPTH, clear_colors);
 
 	RD::get_singleton()->draw_list_bind_uniform_set(draw_list, state.canvas_state_uniform_set, 3);
@@ -950,12 +951,12 @@ void RasterizerCanvasRD::_render_items(RID p_to_render_target, bool p_clear, con
 			}
 		}
 
-		if (true) { //not skeleton
+		if (false) { //not skeleton
 
 			RD::get_singleton()->draw_list_bind_uniform_set(draw_list, shader.default_material_uniform_set, 1);
 		}
 
-		_render_item(draw_list, ci, render_target_format, p_modulate, canvas_transform_inverse);
+		_render_item(draw_list, ci, render_target_format, texture_samples, p_modulate, canvas_transform_inverse);
 	}
 
 	RD::get_singleton()->draw_list_end();
@@ -1180,7 +1181,7 @@ RasterizerCanvasRD::RasterizerCanvasRD(RasterizerStorageRD *p_storage) {
 			RD::AttachmentFormat af;
 			af.format = RD::DATA_FORMAT_R8G8B8A8_UNORM;
 			af.samples = RD::TEXTURE_SAMPLES_1;
-			af.usage_flags = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
+			af.usage_flags = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;
 			Vector<RD::AttachmentFormat> formats;
 			formats.push_back(af);
 			shader.framebuffer_formats[RENDER_TARGET_FORMAT_8_BIT_INT] = RD::get_singleton()->framebuffer_format_create(formats);
@@ -1198,8 +1199,7 @@ RasterizerCanvasRD::RasterizerCanvasRD(RasterizerStorageRD *p_storage) {
 				ShaderVariant shader_variants[PIPELINE_VARIANT_MAX] = { SHADER_VARIANT_QUAD, SHADER_VARIANT_NINEPATCH, SHADER_VARIANT_VERTICES, SHADER_VARIANT_VERTICES, SHADER_VARIANT_POINTS };
 
 				RID shader_variant = shader.canvas_shader.version_get_shader(shader.default_version, shader_variants[j]);
-				RID pipeline = RD::get_singleton()->render_pipeline_create(shader_variant, fb_format, RD::INVALID_ID, primitive[j], RD::PipelineRasterizationState(), RD::PipelineMultisampleState(), RD::PipelineDepthStencilState(), RD::PipelineColorBlendState::create_blend(), j == PIPELINE_VARIANT_LINES ? RD::DYNAMIC_STATE_LINE_WIDTH : 0);
-				shader.pipeline_variants.variants[i][j] = pipeline;
+				shader.pipeline_variants.variants[i][j].setup(shader_variant, fb_format, primitive[j], RD::PipelineRasterizationState(), RD::PipelineMultisampleState(), RD::PipelineDepthStencilState(), RD::PipelineColorBlendState::create_blend(), j == PIPELINE_VARIANT_LINES ? RD::DYNAMIC_STATE_LINE_WIDTH : 0);
 			}
 		}
 

servers/visual/rasterizer/rasterizer_canvas_rd.h

@@ -3,6 +3,7 @@
 
 #include "servers/visual/rasterizer/rasterizer.h"
 #include "servers/visual/rasterizer/rasterizer_storage_rd.h"
+#include "servers/visual/rasterizer/render_pipeline_vertex_format_cache_rd.h"
 #include "servers/visual/rasterizer/shaders/canvas.glsl.gen.h"
 #include "servers/visual/rendering_device.h"
 
@@ -38,7 +39,9 @@ class RasterizerCanvasRD : public RasterizerCanvas {
 		FLAGS_USING_PARTICLES = (1 << 13),
 		FLAGS_USE_PIXEL_SNAP = (1 << 14),
 
-		FLAGS_USE_SKELETON = (1 << 16)
+		FLAGS_USE_SKELETON = (1 << 15),
+		FLAGS_NINEPATCH_H_MODE_SHIFT = 16,
+		FLAGS_NINEPATCH_V_MODE_SHIFT = 18
 	};
 
 	/****************/
@@ -51,13 +54,10 @@ class RasterizerCanvasRD : public RasterizerCanvas {
 		PIPELINE_VARIANT_TRIANGLES,
 		PIPELINE_VARIANT_LINES,
 		PIPELINE_VARIANT_POINTS,
-		PIPELINE_VARIANT_TRIANGLES_COMPRESSED,
-		PIPELINE_VARIANT_LINES_COMPRESSED,
-		PIPELINE_VARIANT_POINTS_COMPRESSED,
 		PIPELINE_VARIANT_MAX
 	};
 	struct PipelineVariants {
-		RID variants[RENDER_TARGET_FORMAT_MAX][PIPELINE_VARIANT_MAX];
+		RenderPipelineVertexFormatCacheRD variants[RENDER_TARGET_FORMAT_MAX][PIPELINE_VARIANT_MAX];
 	};
 
 	struct {
@@ -177,10 +177,9 @@ class RasterizerCanvasRD : public RasterizerCanvas {
 		float dst_rect[4];
 		float src_rect[4];
 		uint32_t flags;
-		uint32_t ninepatch_repeat;
-		float color_texture_pixel_size[2];
 		uint32_t specular_shininess;
-		uint32_t pad[3];
+		float color_texture_pixel_size[2];
+		uint32_t pad[4];
 	};
 
 	struct SkeletonUniform {
@@ -194,7 +193,7 @@ class RasterizerCanvasRD : public RasterizerCanvas {
 
 	Item *items[MAX_RENDER_ITEMS];
 
-	void _render_item(RenderingDevice::DrawListID p_draw_list, const Item *p_item, RenderTargetFormat p_render_target_format, const Color &p_modulate, const Transform2D &p_canvas_transform_inverse);
+	void _render_item(RenderingDevice::DrawListID p_draw_list, const Item *p_item, RenderTargetFormat p_render_target_format, RenderingDevice::TextureSamples p_samples, const Color &p_modulate, const Transform2D &p_canvas_transform_inverse);
 	void _render_items(RID p_to_render_target, bool p_clear, const Color &p_clear_color, int p_item_count, const Color &p_modulate, const Transform2D &p_transform);
 
 	void _update_transform_2d_to_mat2x4(const Transform2D &p_transform, float *p_mat2x4);