Refactored Mesh internals and formats.

-Changed how mesh data is organized, hoping to make it more efficient on Vulkan and GLES.
-Removed compression, it now always uses the most efficient format.
-Added support for custom arrays (up to 8 custom formats)
-Added support for 8 weights in skeleton data.
-Added a simple optional versioning system for imported assets, to reimport if binary is newer
-Fixes #43979 (I needed to test)

WARNING:

-NOT backwards compatible with previous 4.x-devel, will most likely never be, but it will force reimport scenes due to version change.
-NOT backwards compatible with 3.x scenes, this will be eventually re-added.
-Skeletons not working any longer, will fix in next PR.

8 files changed, 277 insertions, 141 deletions

diff --git a/servers/rendering/rasterizer_rd/rasterizer_canvas_rd.cpp b/servers/rendering/rasterizer_rd/rasterizer_canvas_rd.cpp
index 921a7b966e..f5360cbd36 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_canvas_rd.cpp
+++ b/servers/rendering/rasterizer_rd/rasterizer_canvas_rd.cpp
@@ -119,9 +119,9 @@ RasterizerCanvas::PolygonID RasterizerCanvasRD::request_polygon(const Vector<int
 	Vector<uint8_t> polygon_buffer;
 	polygon_buffer.resize(buffer_size * sizeof(float));
 	Vector<RD::VertexAttribute> descriptions;
-	descriptions.resize(4);
+	descriptions.resize(5);
 	Vector<RID> buffers;
-	buffers.resize(4);
+	buffers.resize(5);
 
 	{
 		const uint8_t *r = polygon_buffer.ptr();
@@ -218,7 +218,7 @@ RasterizerCanvas::PolygonID RasterizerCanvasRD::request_polygon(const Vector<int
 		//bones
 		if ((uint32_t)p_indices.size() == vertex_count * 4 && (uint32_t)p_weights.size() == vertex_count * 4) {
 			RD::VertexAttribute vd;
-			vd.format = RD::DATA_FORMAT_R32G32B32A32_UINT;
+			vd.format = RD::DATA_FORMAT_R16G16B16A16_UINT;
 			vd.offset = base_offset * sizeof(float);
 			vd.location = RS::ARRAY_BONES;
 			vd.stride = stride * sizeof(float);
@@ -226,16 +226,42 @@ RasterizerCanvas::PolygonID RasterizerCanvasRD::request_polygon(const Vector<int
 			descriptions.write[3] = vd;
 
 			const int *bone_ptr = p_bones.ptr();
-			const float *weight_ptr = p_weights.ptr();
 
 			for (uint32_t i = 0; i < vertex_count; i++) {
 				uint16_t *bone16w = (uint16_t *)&uptr[base_offset + i * stride];
-				uint16_t *weight16w = (uint16_t *)&uptr[base_offset + i * stride + 2];
 
 				bone16w[0] = bone_ptr[i * 4 + 0];
 				bone16w[1] = bone_ptr[i * 4 + 1];
 				bone16w[2] = bone_ptr[i * 4 + 2];
 				bone16w[3] = bone_ptr[i * 4 + 3];
+			}
+
+			base_offset += 2;
+		} else {
+			RD::VertexAttribute vd;
+			vd.format = RD::DATA_FORMAT_R32G32B32A32_UINT;
+			vd.offset = 0;
+			vd.location = RS::ARRAY_BONES;
+			vd.stride = 0;
+
+			descriptions.write[3] = vd;
+			buffers.write[3] = storage->mesh_get_default_rd_buffer(RasterizerStorageRD::DEFAULT_RD_BUFFER_BONES);
+		}
+
+		//weights
+		if ((uint32_t)p_weights.size() == vertex_count * 4) {
+			RD::VertexAttribute vd;
+			vd.format = RD::DATA_FORMAT_R16G16B16A16_UNORM;
+			vd.offset = base_offset * sizeof(float);
+			vd.location = RS::ARRAY_WEIGHTS;
+			vd.stride = stride * sizeof(float);
+
+			descriptions.write[4] = vd;
+
+			const float *weight_ptr = p_weights.ptr();
+
+			for (uint32_t i = 0; i < vertex_count; i++) {
+				uint16_t *weight16w = (uint16_t *)&uptr[base_offset + i * stride];
 
 				weight16w[0] = CLAMP(weight_ptr[i * 4 + 0] * 65535, 0, 65535);
 				weight16w[1] = CLAMP(weight_ptr[i * 4 + 1] * 65535, 0, 65535);
@@ -243,16 +269,16 @@ RasterizerCanvas::PolygonID RasterizerCanvasRD::request_polygon(const Vector<int
 				weight16w[3] = CLAMP(weight_ptr[i * 4 + 3] * 65535, 0, 65535);
 			}
 
-			base_offset += 4;
+			base_offset += 2;
 		} else {
 			RD::VertexAttribute vd;
-			vd.format = RD::DATA_FORMAT_R32G32B32A32_UINT;
+			vd.format = RD::DATA_FORMAT_R32G32B32A32_SFLOAT;
 			vd.offset = 0;
-			vd.location = RS::ARRAY_BONES;
+			vd.location = RS::ARRAY_WEIGHTS;
 			vd.stride = 0;
 
-			descriptions.write[3] = vd;
-			buffers.write[3] = storage->mesh_get_default_rd_buffer(RasterizerStorageRD::DEFAULT_RD_BUFFER_BONES);
+			descriptions.write[4] = vd;
+			buffers.write[4] = storage->mesh_get_default_rd_buffer(RasterizerStorageRD::DEFAULT_RD_BUFFER_BONES);
 		}
 
 		//check that everything is as it should be
@@ -1796,22 +1822,25 @@ void RasterizerCanvasRD::occluder_polygon_set_shape(RID p_occluder, const Vector
 	ERR_FAIL_COND(!oc);
 
 	Vector<Vector2> lines;
-	int lc = p_points.size() * 2;
 
-	lines.resize(lc - (p_closed ? 0 : 2));
-	{
-		Vector2 *w = lines.ptrw();
-		const Vector2 *r = p_points.ptr();
+	if (p_points.size()) {
+		int lc = p_points.size() * 2;
 
-		int max = lc / 2;
-		if (!p_closed) {
-			max--;
-		}
-		for (int i = 0; i < max; i++) {
-			Vector2 a = r[i];
-			Vector2 b = r[(i + 1) % (lc / 2)];
-			w[i * 2 + 0] = a;
-			w[i * 2 + 1] = b;
+		lines.resize(lc - (p_closed ? 0 : 2));
+		{
+			Vector2 *w = lines.ptrw();
+			const Vector2 *r = p_points.ptr();
+
+			int max = lc / 2;
+			if (!p_closed) {
+				max--;
+			}
+			for (int i = 0; i < max; i++) {
+				Vector2 a = r[i];
+				Vector2 b = r[(i + 1) % (lc / 2)];
+				w[i * 2 + 0] = a;
+				w[i * 2 + 1] = b;
+			}
 		}
 	}
 
@@ -1832,7 +1861,7 @@ void RasterizerCanvasRD::occluder_polygon_set_shape(RID p_occluder, const Vector
 	if (lines.size()) {
 		Vector<uint8_t> geometry;
 		Vector<uint8_t> indices;
-		lc = lines.size();
+		int lc = lines.size();
 
 		geometry.resize(lc * 6 * sizeof(float));
 		indices.resize(lc * 3 * sizeof(uint16_t));
@@ -1902,19 +1931,21 @@ void RasterizerCanvasRD::occluder_polygon_set_shape(RID p_occluder, const Vector
 
 	Vector<int> sdf_indices;
 
-	if (p_closed) {
-		sdf_indices = Geometry2D::triangulate_polygon(p_points);
-		oc->sdf_is_lines = false;
-	} else {
-		int max = p_points.size();
-		sdf_indices.resize(max * 2);
+	if (p_points.size()) {
+		if (p_closed) {
+			sdf_indices = Geometry2D::triangulate_polygon(p_points);
+			oc->sdf_is_lines = false;
+		} else {
+			int max = p_points.size();
+			sdf_indices.resize(max * 2);
 
-		int *iw = sdf_indices.ptrw();
-		for (int i = 0; i < max; i++) {
-			iw[i * 2 + 0] = i;
-			iw[i * 2 + 1] = (i + 1) % max;
+			int *iw = sdf_indices.ptrw();
+			for (int i = 0; i < max; i++) {
+				iw[i * 2 + 0] = i;
+				iw[i * 2 + 1] = (i + 1) % max;
+			}
+			oc->sdf_is_lines = true;
 		}
-		oc->sdf_is_lines = true;
 	}
 
 	if (oc->sdf_index_count != sdf_indices.size() && oc->sdf_point_count != p_points.size() && oc->sdf_vertex_array.is_valid()) {
diff --git a/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.cpp b/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.cpp
index 313188ba87..66561958fc 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.cpp
+++ b/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.cpp
@@ -2795,6 +2795,12 @@ RasterizerSceneHighEndRD::RasterizerSceneHighEndRD(RasterizerStorageRD *p_storag
 		actions.renames["FOG"] = "custom_fog";
 		actions.renames["RADIANCE"] = "custom_radiance";
 		actions.renames["IRRADIANCE"] = "custom_irradiance";
+		actions.renames["BONE_INDICES"] = "bone_attrib";
+		actions.renames["BONE_WEIGHTS"] = "weight_attrib";
+		actions.renames["CUSTOM0"] = "custom0_attrib";
+		actions.renames["CUSTOM1"] = "custom1_attrib";
+		actions.renames["CUSTOM2"] = "custom2_attrib";
+		actions.renames["CUSTOM3"] = "custom3_attrib";
 
 		//for light
 		actions.renames["VIEW"] = "view";
@@ -2817,6 +2823,12 @@ RasterizerSceneHighEndRD::RasterizerSceneHighEndRD(RasterizerStorageRD *p_storag
 		actions.usage_defines["AO_LIGHT_AFFECT"] = "#define AO_USED\n";
 		actions.usage_defines["UV"] = "#define UV_USED\n";
 		actions.usage_defines["UV2"] = "#define UV2_USED\n";
+		actions.usage_defines["BONE_INDICES"] = "#define BONES_USED\n";
+		actions.usage_defines["BONE_WEIGHTS"] = "#define WEIGHTS_USED\n";
+		actions.usage_defines["CUSTOM0"] = "#define CUSTOM0\n";
+		actions.usage_defines["CUSTOM1"] = "#define CUSTOM1\n";
+		actions.usage_defines["CUSTOM2"] = "#define CUSTOM2\n";
+		actions.usage_defines["CUSTOM3"] = "#define CUSTOM3\n";
 		actions.usage_defines["NORMALMAP"] = "#define NORMALMAP_USED\n";
 		actions.usage_defines["NORMALMAP_DEPTH"] = "@NORMALMAP";
 		actions.usage_defines["COLOR"] = "#define COLOR_USED\n";
diff --git a/servers/rendering/rasterizer_rd/rasterizer_scene_rd.cpp b/servers/rendering/rasterizer_rd/rasterizer_scene_rd.cpp
index 3c4cac7ba9..d6f08370e0 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_scene_rd.cpp
+++ b/servers/rendering/rasterizer_rd/rasterizer_scene_rd.cpp
@@ -5336,18 +5336,19 @@ void RasterizerSceneRD::_render_buffers_post_process_and_tonemap(RID p_render_bu
 			tonemap.exposure = env->exposure;
 		}
 
+		tonemap.use_color_correction = false;
+		tonemap.use_1d_color_correction = false;
+		tonemap.color_correction_texture = storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
+
 		if (can_use_effects && env) {
 			tonemap.use_bcs = env->adjustments_enabled;
 			tonemap.brightness = env->adjustments_brightness;
 			tonemap.contrast = env->adjustments_contrast;
 			tonemap.saturation = env->adjustments_saturation;
-			tonemap.use_1d_color_correction = env->use_1d_color_correction;
 			if (env->adjustments_enabled && env->color_correction.is_valid()) {
 				tonemap.use_color_correction = true;
+				tonemap.use_1d_color_correction = env->use_1d_color_correction;
 				tonemap.color_correction_texture = storage->texture_get_rd_texture(env->color_correction);
-			} else {
-				tonemap.use_color_correction = false;
-				tonemap.color_correction_texture = storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_WHITE);
 			}
 		}
 
diff --git a/servers/rendering/rasterizer_rd/rasterizer_storage_rd.cpp b/servers/rendering/rasterizer_rd/rasterizer_storage_rd.cpp
index a4d79ffc87..819404b316 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_storage_rd.cpp
+++ b/servers/rendering/rasterizer_rd/rasterizer_storage_rd.cpp
@@ -2398,13 +2398,15 @@ void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_
 	ERR_FAIL_COND(!mesh);
 
 	//ensure blend shape consistency
-	ERR_FAIL_COND(mesh->blend_shape_count && p_surface.blend_shapes.size() != (int)mesh->blend_shape_count);
+	ERR_FAIL_COND(mesh->blend_shape_count && p_surface.blend_shape_count != mesh->blend_shape_count);
 	ERR_FAIL_COND(mesh->blend_shape_count && p_surface.bone_aabbs.size() != mesh->bone_aabbs.size());
 
 #ifdef DEBUG_ENABLED
 	//do a validation, to catch errors first
 	{
 		uint32_t stride = 0;
+		uint32_t attrib_stride = 0;
+		uint32_t skin_stride = 0;
 
 		for (int i = 0; i < RS::ARRAY_WEIGHTS; i++) {
 			if ((p_surface.format & (1 << i))) {
@@ -2418,59 +2420,54 @@ void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_
 
 					} break;
 					case RS::ARRAY_NORMAL: {
-						if (p_surface.format & RS::ARRAY_COMPRESS_NORMAL) {
-							stride += sizeof(int8_t) * 4;
-						} else {
-							stride += sizeof(float) * 4;
-						}
+						stride += sizeof(int32_t);
 
 					} break;
 					case RS::ARRAY_TANGENT: {
-						if (p_surface.format & RS::ARRAY_COMPRESS_TANGENT) {
-							stride += sizeof(int8_t) * 4;
-						} else {
-							stride += sizeof(float) * 4;
-						}
+						stride += sizeof(int32_t);
 
 					} break;
 					case RS::ARRAY_COLOR: {
-						if (p_surface.format & RS::ARRAY_COMPRESS_COLOR) {
-							stride += sizeof(int8_t) * 4;
-						} else {
-							stride += sizeof(float) * 4;
-						}
-
+						attrib_stride += sizeof(int16_t) * 4;
 					} break;
 					case RS::ARRAY_TEX_UV: {
-						if (p_surface.format & RS::ARRAY_COMPRESS_TEX_UV) {
-							stride += sizeof(int16_t) * 2;
-						} else {
-							stride += sizeof(float) * 2;
-						}
+						attrib_stride += sizeof(float) * 2;
 
 					} break;
 					case RS::ARRAY_TEX_UV2: {
-						if (p_surface.format & RS::ARRAY_COMPRESS_TEX_UV2) {
-							stride += sizeof(int16_t) * 2;
-						} else {
-							stride += sizeof(float) * 2;
-						}
+						attrib_stride += sizeof(float) * 2;
 
 					} break;
-					case RS::ARRAY_BONES: {
-						//assumed weights too
-
-						//unique format, internally 16 bits, exposed as single array for 32
-
-						stride += sizeof(int32_t) * 4;
+					case RS::ARRAY_CUSTOM0:
+					case RS::ARRAY_CUSTOM1:
+					case RS::ARRAY_CUSTOM2:
+					case RS::ARRAY_CUSTOM3: {
+						int idx = i - RS::ARRAY_CUSTOM0;
+						uint32_t fmt_shift[RS::ARRAY_CUSTOM_COUNT] = { RS::ARRAY_FORMAT_CUSTOM0_SHIFT, RS::ARRAY_FORMAT_CUSTOM1_SHIFT, RS::ARRAY_FORMAT_CUSTOM2_SHIFT, RS::ARRAY_FORMAT_CUSTOM3_SHIFT };
+						uint32_t fmt = (p_surface.format >> fmt_shift[idx]) & RS::ARRAY_FORMAT_CUSTOM_MASK;
+						uint32_t fmtsize[RS::ARRAY_CUSTOM_MAX] = { 4, 4, 4, 8, 4, 8, 12, 16 };
+						attrib_stride += fmtsize[fmt];
 
 					} break;
+					case RS::ARRAY_WEIGHTS:
+					case RS::ARRAY_BONES: {
+						//uses a separate array
+						bool use_8 = p_surface.format & RS::ARRAY_FLAG_USE_8_BONE_WEIGHTS;
+						skin_stride += sizeof(int16_t) * (use_8 ? 8 : 4);
+					} break;
 				}
 			}
 		}
 
 		int expected_size = stride * p_surface.vertex_count;
-		ERR_FAIL_COND_MSG(expected_size != p_surface.vertex_data.size(), "Size of data provided (" + itos(p_surface.vertex_data.size()) + ") does not match expected (" + itos(expected_size) + ")");
+		ERR_FAIL_COND_MSG(expected_size != p_surface.vertex_data.size(), "Size of vertex data provided (" + itos(p_surface.vertex_data.size()) + ") does not match expected (" + itos(expected_size) + ")");
+		int expected_attrib_size = attrib_stride * p_surface.vertex_count;
+		ERR_FAIL_COND_MSG(expected_attrib_size != p_surface.attribute_data.size(), "Size of attribute data provided (" + itos(p_surface.attribute_data.size()) + ") does not match expected (" + itos(expected_attrib_size) + ")");
+
+		if ((p_surface.format & RS::ARRAY_FORMAT_WEIGHTS) && (p_surface.format & RS::ARRAY_FORMAT_BONES)) {
+			expected_size = skin_stride * p_surface.vertex_count;
+			ERR_FAIL_COND_MSG(expected_size != p_surface.skin_data.size(), "Size of skin data provided (" + itos(p_surface.skin_data.size()) + ") does not match expected (" + itos(expected_size) + ")");
+		}
 	}
 
 #endif
@@ -2481,6 +2478,12 @@ void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_
 	s->primitive = p_surface.primitive;
 
 	s->vertex_buffer = RD::get_singleton()->vertex_buffer_create(p_surface.vertex_data.size(), p_surface.vertex_data);
+	if (p_surface.attribute_data.size()) {
+		s->attribute_buffer = RD::get_singleton()->vertex_buffer_create(p_surface.attribute_data.size(), p_surface.attribute_data);
+	}
+	if (p_surface.skin_data.size()) {
+		s->skin_buffer = RD::get_singleton()->vertex_buffer_create(p_surface.skin_data.size(), p_surface.skin_data);
+	}
 	s->vertex_count = p_surface.vertex_count;
 
 	if (p_surface.index_count) {
@@ -2504,7 +2507,7 @@ void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_
 
 	s->aabb = p_surface.aabb;
 	s->bone_aabbs = p_surface.bone_aabbs; //only really useful for returning them.
-
+#if 0
 	for (int i = 0; i < p_surface.blend_shapes.size(); i++) {
 		if (p_surface.blend_shapes[i].size() != p_surface.vertex_data.size()) {
 			memdelete(s);
@@ -2513,8 +2516,8 @@ void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_
 		RID vertex_buffer = RD::get_singleton()->vertex_buffer_create(p_surface.blend_shapes[i].size(), p_surface.blend_shapes[i]);
 		s->blend_shapes.push_back(vertex_buffer);
 	}
-
-	mesh->blend_shape_count = p_surface.blend_shapes.size();
+#endif
+	mesh->blend_shape_count = p_surface.blend_shape_count;
 
 	if (mesh->surface_count == 0) {
 		mesh->bone_aabbs = p_surface.bone_aabbs;
@@ -2596,6 +2599,12 @@ RS::SurfaceData RasterizerStorageRD::mesh_get_surface(RID p_mesh, int p_surface)
 	RS::SurfaceData sd;
 	sd.format = s.format;
 	sd.vertex_data = RD::get_singleton()->buffer_get_data(s.vertex_buffer);
+	if (s.attribute_buffer.is_valid()) {
+		sd.attribute_data = RD::get_singleton()->buffer_get_data(s.attribute_buffer);
+	}
+	if (s.skin_buffer.is_valid()) {
+		sd.skin_data = RD::get_singleton()->buffer_get_data(s.skin_buffer);
+	}
 	sd.vertex_count = s.vertex_count;
 	sd.index_count = s.index_count;
 	sd.primitive = s.primitive;
@@ -2613,9 +2622,8 @@ RS::SurfaceData RasterizerStorageRD::mesh_get_surface(RID p_mesh, int p_surface)
 
 	sd.bone_aabbs = s.bone_aabbs;
 
-	for (int i = 0; i < s.blend_shapes.size(); i++) {
-		Vector<uint8_t> bs = RD::get_singleton()->buffer_get_data(s.blend_shapes[i]);
-		sd.blend_shapes.push_back(bs);
+	if (s.blend_shape_buffer.is_valid()) {
+		sd.blend_shape_data = RD::get_singleton()->buffer_get_data(s.blend_shape_buffer);
 	}
 
 	return sd;
@@ -2750,6 +2758,12 @@ void RasterizerStorageRD::mesh_clear(RID p_mesh) {
 	for (uint32_t i = 0; i < mesh->surface_count; i++) {
 		Mesh::Surface &s = *mesh->surfaces[i];
 		RD::get_singleton()->free(s.vertex_buffer); //clears arrays as dependency automatically, including all versions
+		if (s.attribute_buffer.is_valid()) {
+			RD::get_singleton()->free(s.attribute_buffer);
+		}
+		if (s.skin_buffer.is_valid()) {
+			RD::get_singleton()->free(s.skin_buffer);
+		}
 		if (s.versions) {
 			memfree(s.versions); //reallocs, so free with memfree.
 		}
@@ -2765,12 +2779,8 @@ void RasterizerStorageRD::mesh_clear(RID p_mesh) {
 			memdelete_arr(s.lods);
 		}
 
-		for (int32_t j = 0; j < s.blend_shapes.size(); j++) {
-			RD::get_singleton()->free(s.blend_shapes[j]);
-		}
-
-		if (s.blend_shape_base_buffer.is_valid()) {
-			RD::get_singleton()->free(s.blend_shape_base_buffer);
+		if (s.blend_shape_buffer.is_valid()) {
+			RD::get_singleton()->free(s.blend_shape_buffer);
 		}
 
 		memdelete(mesh->surfaces[i]);
@@ -2796,8 +2806,10 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 	Vector<RID> buffers;
 
 	uint32_t stride = 0;
+	uint32_t attribute_stride = 0;
+	uint32_t skin_stride = 0;
 
-	for (int i = 0; i < RS::ARRAY_WEIGHTS; i++) {
+	for (int i = 0; i < RS::ARRAY_INDEX; i++) {
 		RD::VertexAttribute vd;
 		RID buffer;
 		vd.location = i;
@@ -2805,6 +2817,7 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 		if (!(s->format & (1 << i))) {
 			// Not supplied by surface, use default value
 			buffer = mesh_default_rd_buffers[i];
+			vd.stride = 0;
 			switch (i) {
 				case RS::ARRAY_VERTEX: {
 					vd.format = RD::DATA_FORMAT_R32G32B32_SFLOAT;
@@ -2827,20 +2840,31 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 				case RS::ARRAY_TEX_UV2: {
 					vd.format = RD::DATA_FORMAT_R32G32_SFLOAT;
 				} break;
+				case RS::ARRAY_CUSTOM0:
+				case RS::ARRAY_CUSTOM1:
+				case RS::ARRAY_CUSTOM2:
+				case RS::ARRAY_CUSTOM3: {
+					//assumed weights too
+					vd.format = RD::DATA_FORMAT_R32G32B32A32_SFLOAT;
+				} break;
 				case RS::ARRAY_BONES: {
 					//assumed weights too
 					vd.format = RD::DATA_FORMAT_R32G32B32A32_UINT;
 				} break;
+				case RS::ARRAY_WEIGHTS: {
+					//assumed weights too
+					vd.format = RD::DATA_FORMAT_R32G32B32A32_UINT;
+				} break;
 			}
 		} else {
 			//Supplied, use it
 
-			vd.offset = stride;
-			vd.stride = 1; //mark that it needs a stride set
-			buffer = s->vertex_buffer;
+			vd.stride = 1; //mark that it needs a stride set (default uses 0)
 
 			switch (i) {
 				case RS::ARRAY_VERTEX: {
+					vd.offset = stride;
+
 					if (s->format & RS::ARRAY_FLAG_USE_2D_VERTICES) {
 						vd.format = RD::DATA_FORMAT_R32G32_SFLOAT;
 						stride += sizeof(float) * 2;
@@ -2849,71 +2873,80 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 						stride += sizeof(float) * 3;
 					}
 
+					buffer = s->vertex_buffer;
+
 				} break;
 				case RS::ARRAY_NORMAL: {
-					if (s->format & RS::ARRAY_COMPRESS_NORMAL) {
-						vd.format = RD::DATA_FORMAT_R8G8B8A8_SNORM;
-						stride += sizeof(int8_t) * 4;
-					} else {
-						vd.format = RD::DATA_FORMAT_R32G32B32A32_SFLOAT;
-						stride += sizeof(float) * 4;
-					}
+					vd.offset = stride;
 
+					vd.format = RD::DATA_FORMAT_A2B10G10R10_UNORM_PACK32;
+
+					stride += sizeof(uint32_t);
+					buffer = s->vertex_buffer;
 				} break;
 				case RS::ARRAY_TANGENT: {
-					if (s->format & RS::ARRAY_COMPRESS_TANGENT) {
-						vd.format = RD::DATA_FORMAT_R8G8B8A8_SNORM;
-						stride += sizeof(int8_t) * 4;
-					} else {
-						vd.format = RD::DATA_FORMAT_R32G32B32A32_SFLOAT;
-						stride += sizeof(float) * 4;
-					}
+					vd.offset = stride;
 
+					vd.format = RD::DATA_FORMAT_A2B10G10R10_UNORM_PACK32;
+					stride += sizeof(uint32_t);
+					buffer = s->vertex_buffer;
 				} break;
 				case RS::ARRAY_COLOR: {
-					if (s->format & RS::ARRAY_COMPRESS_COLOR) {
-						vd.format = RD::DATA_FORMAT_R8G8B8A8_UNORM;
-						stride += sizeof(int8_t) * 4;
-					} else {
-						vd.format = RD::DATA_FORMAT_R32G32B32A32_SFLOAT;
-						stride += sizeof(float) * 4;
-					}
+					vd.offset = attribute_stride;
 
+					vd.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
+					attribute_stride += sizeof(int16_t) * 4;
+					buffer = s->attribute_buffer;
 				} break;
 				case RS::ARRAY_TEX_UV: {
-					if (s->format & RS::ARRAY_COMPRESS_TEX_UV) {
-						vd.format = RD::DATA_FORMAT_R16G16_SFLOAT;
-						stride += sizeof(int16_t) * 2;
-					} else {
-						vd.format = RD::DATA_FORMAT_R32G32_SFLOAT;
-						stride += sizeof(float) * 2;
-					}
+					vd.offset = attribute_stride;
+
+					vd.format = RD::DATA_FORMAT_R32G32_SFLOAT;
+					attribute_stride += sizeof(float) * 2;
+					buffer = s->attribute_buffer;
 
 				} break;
 				case RS::ARRAY_TEX_UV2: {
-					if (s->format & RS::ARRAY_COMPRESS_TEX_UV2) {
-						vd.format = RD::DATA_FORMAT_R16G16_SFLOAT;
-						stride += sizeof(int16_t) * 2;
-					} else {
-						vd.format = RD::DATA_FORMAT_R32G32_SFLOAT;
-						stride += sizeof(float) * 2;
-					}
+					vd.offset = attribute_stride;
 
+					vd.format = RD::DATA_FORMAT_R32G32_SFLOAT;
+					attribute_stride += sizeof(float) * 2;
+					buffer = s->attribute_buffer;
+				} break;
+				case RS::ARRAY_CUSTOM0:
+				case RS::ARRAY_CUSTOM1:
+				case RS::ARRAY_CUSTOM2:
+				case RS::ARRAY_CUSTOM3: {
+					vd.offset = attribute_stride;
+
+					int idx = i - RS::ARRAY_CUSTOM0;
+					uint32_t fmt_shift[RS::ARRAY_CUSTOM_COUNT] = { RS::ARRAY_FORMAT_CUSTOM0_SHIFT, RS::ARRAY_FORMAT_CUSTOM1_SHIFT, RS::ARRAY_FORMAT_CUSTOM2_SHIFT, RS::ARRAY_FORMAT_CUSTOM3_SHIFT };
+					uint32_t fmt = (s->format >> fmt_shift[idx]) & RS::ARRAY_FORMAT_CUSTOM_MASK;
+					uint32_t fmtsize[RS::ARRAY_CUSTOM_MAX] = { 4, 4, 4, 8, 4, 8, 12, 16 };
+					RD::DataFormat fmtrd[RS::ARRAY_CUSTOM_MAX] = { RD::DATA_FORMAT_R8G8B8A8_UNORM, RD::DATA_FORMAT_R8G8B8A8_SNORM, RD::DATA_FORMAT_R16G16_SFLOAT, RD::DATA_FORMAT_R16G16B16A16_SFLOAT, RD::DATA_FORMAT_R32_SFLOAT, RD::DATA_FORMAT_R32G32_SFLOAT, RD::DATA_FORMAT_R32G32B32_SFLOAT, RD::DATA_FORMAT_R32G32B32A32_SFLOAT };
+					vd.format = fmtrd[fmt];
+					attribute_stride += fmtsize[fmt];
+					buffer = s->attribute_buffer;
 				} break;
 				case RS::ARRAY_BONES: {
-					//assumed weights too
-
-					//unique format, internally 16 bits, exposed as single array for 32
+					vd.offset = skin_stride;
 
-					vd.format = RD::DATA_FORMAT_R32G32B32A32_UINT;
-					stride += sizeof(int32_t) * 4;
+					vd.format = RD::DATA_FORMAT_R16G16B16A16_UINT;
+					skin_stride += sizeof(int16_t) * 4;
+					buffer = s->skin_buffer;
+				} break;
+				case RS::ARRAY_WEIGHTS: {
+					vd.offset = skin_stride;
 
+					vd.format = RD::DATA_FORMAT_R16G16B16A16_UNORM;
+					skin_stride += sizeof(int16_t) * 4;
+					buffer = s->skin_buffer;
 				} break;
 			}
 		}
 
 		if (!(p_input_mask & (1 << i))) {
-			continue; // Shader does not need this, skip it
+			continue; // Shader does not need this, skip it (but computing stride was important anyway)
 		}
 
 		attributes.push_back(vd);
@@ -2922,8 +2955,17 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 
 	//update final stride
 	for (int i = 0; i < attributes.size(); i++) {
-		if (attributes[i].stride == 1) {
+		if (attributes[i].stride == 0) {
+			continue; //default location
+		}
+		int loc = attributes[i].location;
+
+		if (loc < RS::ARRAY_COLOR) {
 			attributes.write[i].stride = stride;
+		} else if (loc < RS::ARRAY_BONES) {
+			attributes.write[i].stride = attribute_stride;
+		} else {
+			attributes.write[i].stride = skin_stride;
 		}
 	}
 
@@ -8263,6 +8305,19 @@ RasterizerStorageRD::RasterizerStorageRD() {
 			mesh_default_rd_buffers[DEFAULT_RD_BUFFER_TEX_UV2] = RD::get_singleton()->vertex_buffer_create(buffer.size(), buffer);
 		}
 
+		for (int i = 0; i < RS::ARRAY_CUSTOM_COUNT; i++) {
+			buffer.resize(sizeof(float) * 4);
+			{
+				uint8_t *w = buffer.ptrw();
+				float *fptr = (float *)w;
+				fptr[0] = 0.0;
+				fptr[1] = 0.0;
+				fptr[2] = 0.0;
+				fptr[3] = 0.0;
+			}
+			mesh_default_rd_buffers[DEFAULT_RD_BUFFER_CUSTOM0 + i] = RD::get_singleton()->vertex_buffer_create(buffer.size(), buffer);
+		}
+
 		{ //bones
 			buffer.resize(sizeof(uint32_t) * 4);
 			{
diff --git a/servers/rendering/rasterizer_rd/rasterizer_storage_rd.h b/servers/rendering/rasterizer_rd/rasterizer_storage_rd.h
index 42dd0616b0..d887f122c9 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_storage_rd.h
+++ b/servers/rendering/rasterizer_rd/rasterizer_storage_rd.h
@@ -170,6 +170,10 @@ public:
 		DEFAULT_RD_BUFFER_COLOR,
 		DEFAULT_RD_BUFFER_TEX_UV,
 		DEFAULT_RD_BUFFER_TEX_UV2,
+		DEFAULT_RD_BUFFER_CUSTOM0,
+		DEFAULT_RD_BUFFER_CUSTOM1,
+		DEFAULT_RD_BUFFER_CUSTOM2,
+		DEFAULT_RD_BUFFER_CUSTOM3,
 		DEFAULT_RD_BUFFER_BONES,
 		DEFAULT_RD_BUFFER_WEIGHTS,
 		DEFAULT_RD_BUFFER_MAX,
@@ -378,6 +382,8 @@ private:
 			uint32_t format = 0;
 
 			RID vertex_buffer;
+			RID attribute_buffer;
+			RID skin_buffer;
 			uint32_t vertex_count = 0;
 
 			// A different pipeline needs to be allocated
@@ -414,8 +420,7 @@ private:
 
 			Vector<AABB> bone_aabbs;
 
-			Vector<RID> blend_shapes;
-			RID blend_shape_base_buffer; //source buffer goes here when using blend shapes, and main one is uncompressed
+			RID blend_shape_buffer;
 
 			RID material;
 
diff --git a/servers/rendering/rasterizer_rd/shaders/canvas.glsl b/servers/rendering/rasterizer_rd/shaders/canvas.glsl
index 51d7193a03..7808e7ed52 100644
--- a/servers/rendering/rasterizer_rd/shaders/canvas.glsl
+++ b/servers/rendering/rasterizer_rd/shaders/canvas.glsl
@@ -9,7 +9,8 @@ layout(location = 0) in vec2 vertex_attrib;
 layout(location = 3) in vec4 color_attrib;
 layout(location = 4) in vec2 uv_attrib;
 
-layout(location = 6) in uvec4 bones_attrib;
+layout(location = 10) in uvec4 bone_attrib;
+layout(location = 11) in vec4 weight_attrib;
 
 #endif
 
@@ -61,6 +62,7 @@ void main() {
 		color = vec4(unpackHalf2x16(draw_data.colors[4]), unpackHalf2x16(draw_data.colors[5]));
 	}
 	uvec4 bones = uvec4(0, 0, 0, 0);
+	vec4 bone_weights = vec4(0.0);
 
 #elif defined(USE_ATTRIBUTES)
 
@@ -68,7 +70,8 @@ void main() {
 	vec4 color = color_attrib;
 	vec2 uv = uv_attrib;
 
-	uvec4 bones = bones_attrib;
+	uvec4 bones = bone_attrib;
+	vec4 bone_weights = weight_attrib;
 #else
 
 	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));
diff --git a/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl b/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl
index 285698f060..5d87dec79f 100644
--- a/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl
+++ b/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl
@@ -24,7 +24,29 @@ layout(location = 4) in vec2 uv_attrib;
 layout(location = 5) in vec2 uv2_attrib;
 #endif
 
-layout(location = 6) in uvec4 bone_attrib; // always bound, even if unused
+#if defined(CUSTOM0_USED)
+layout(location = 6) in vec4 custom0_attrib;
+#endif
+
+#if defined(CUSTOM1_USED)
+layout(location = 7) in vec4 custom1_attrib;
+#endif
+
+#if defined(CUSTOM2_USED)
+layout(location = 8) in vec4 custom2_attrib;
+#endif
+
+#if defined(CUSTOM3_USED)
+layout(location = 9) in vec4 custom3_attrib;
+#endif
+
+#if defined(BONES_USED)
+layout(location = 10) in uvec4 bone_attrib;
+#endif
+
+#if defined(WEIGHTS_USED)
+layout(location = 11) in vec4 weight_attrib;
+#endif
 
 /* Varyings */
 
@@ -116,14 +138,15 @@ void main() {
 	}
 
 	vec3 vertex = vertex_attrib;
-	vec3 normal = normal_attrib;
+	vec3 normal = normal_attrib * 2.0 - 1.0;
 
 #if defined(TANGENT_USED) || defined(NORMALMAP_USED) || defined(LIGHT_ANISOTROPY_USED)
-	vec3 tangent = tangent_attrib.xyz;
-	float binormalf = tangent_attrib.a;
+	vec3 tangent = tangent_attrib.xyz * 2.0 - 1.0;
+	float binormalf = tangent_attrib.a * 2.0 - 1.0;
 	vec3 binormal = normalize(cross(normal, tangent) * binormalf);
 #endif
 
+#if 0
 	if (bool(instances.data[instance_index].flags & INSTANCE_FLAGS_SKELETON)) {
 		//multimesh, instances are for it
 
@@ -147,7 +170,7 @@ void main() {
 		binormal = (vec4(binormal, 0.0) * m).xyz;
 #endif
 	}
-
+#endif
 	uv_interp = uv_attrib;
 
 #if defined(UV2_USED) || defined(USE_LIGHTMAP)
diff --git a/servers/rendering/shader_types.cpp b/servers/rendering/shader_types.cpp
index bd61f2a549..0c9b2ddf2f 100644
--- a/servers/rendering/shader_types.cpp
+++ b/servers/rendering/shader_types.cpp
@@ -67,6 +67,12 @@ ShaderTypes::ShaderTypes() {
 	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].built_ins["INSTANCE_ID"] = constt(ShaderLanguage::TYPE_INT);
 	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].built_ins["INSTANCE_CUSTOM"] = constt(ShaderLanguage::TYPE_VEC4);
 	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].built_ins["ROUGHNESS"] = ShaderLanguage::TYPE_FLOAT;
+	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].built_ins["BONE_INDICES"] = ShaderLanguage::TYPE_UVEC4;
+	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].built_ins["BONE_WEIGHTS"] = ShaderLanguage::TYPE_VEC4;
+	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].built_ins["CUSTOM0"] = ShaderLanguage::TYPE_VEC4;
+	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].built_ins["CUSTOM1"] = ShaderLanguage::TYPE_VEC4;
+	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].built_ins["CUSTOM2"] = ShaderLanguage::TYPE_VEC4;
+	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].built_ins["CUSTOM3"] = ShaderLanguage::TYPE_VEC4;
 	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].can_discard = false;
 
 	//builtins