Ported: SurfaceTool - efficiency improvements

Changed to use LocalVector rather than linked lists.
- lawnjelly
ff714fbe02

scene/resources/surface_tool.cpp

@@ -60,17 +60,17 @@ bool SurfaceTool::Vertex::operator==(const Vertex &p_vertex) const {
 		return false;
 	}
 
-	if (bones.size() != p_vertex.bones.size()) {
+	if (num_bones != p_vertex.num_bones) {
 		return false;
 	}
 
-	for (int i = 0; i < bones.size(); i++) {
+	for (int i = 0; i < num_bones; i++) {
 		if (bones[i] != p_vertex.bones[i]) {
 			return false;
 		}
 	}
 
-	for (int i = 0; i < weights.size(); i++) {
+	for (int i = 0; i < num_bones; i++) {
 		if (weights[i] != p_vertex.weights[i]) {
 			return false;
 		}
@@ -87,8 +87,8 @@ uint32_t SurfaceTool::VertexHasher::hash(const Vertex &p_vtx) {
 	h = hash_djb2_buffer((const uint8_t *)&p_vtx.uv, sizeof(real_t) * 2, h);
 	h = hash_djb2_buffer((const uint8_t *)&p_vtx.uv2, sizeof(real_t) * 2, h);
 	h = hash_djb2_buffer((const uint8_t *)&p_vtx.color, sizeof(real_t) * 4, h);
-	h = hash_djb2_buffer((const uint8_t *)p_vtx.bones.ptr(), p_vtx.bones.size() * sizeof(int), h);
+	h = hash_djb2_buffer((const uint8_t *)p_vtx.bones, p_vtx.num_bones * sizeof(int16_t), h);
-	h = hash_djb2_buffer((const uint8_t *)p_vtx.weights.ptr(), p_vtx.weights.size() * sizeof(float), h);
+	h = hash_djb2_buffer((const uint8_t *)p_vtx.weights, p_vtx.num_bones * sizeof(float), h);
 	return h;
 }
 
@@ -100,6 +100,59 @@ void SurfaceTool::begin(Mesh::PrimitiveType p_primitive) {
 	first = true;
 }
 
+bool SurfaceTool::_sanitize_last_bones_and_weights() {
+	const int expected_vertices = Vertex::MAX_BONES;
+
+	if ((last_bones.size() == expected_vertices) && (last_weights.size() == expected_vertices)) {
+		// already ideal
+		return true;
+	}
+	ERR_FAIL_COND_V(last_bones.size() != last_weights.size(), false);
+
+	int num_orig = last_weights.size();
+
+	if (num_orig < expected_vertices) {
+		//less than required, fill
+		for (int i = last_weights.size(); i < expected_vertices; i++) {
+			last_weights.push_back(0);
+			last_bones.push_back(0);
+		}
+	} else if (num_orig > expected_vertices) {
+		//more than required, sort, cap and normalize.
+		Vector<WeightSort> weights;
+		for (int i = 0; i < num_orig; i++) {
+			WeightSort ws;
+			ws.index = last_bones[i];
+			ws.weight = last_weights[i];
+			weights.push_back(ws);
+		}
+
+		//sort
+		weights.sort();
+		//cap
+		weights.resize(expected_vertices);
+		//renormalize
+		float total = 0;
+		for (int i = 0; i < expected_vertices; i++) {
+			total += weights[i].weight;
+		}
+
+		last_weights.resize(expected_vertices);
+		last_bones.resize(expected_vertices);
+
+		for (int i = 0; i < expected_vertices; i++) {
+			if (total > 0) {
+				last_weights.write[i] = weights[i].weight / total;
+			} else {
+				last_weights.write[i] = 0;
+			}
+			last_bones.write[i] = weights[i].index;
+		}
+	}
+
+	return true;
+}
+
 void SurfaceTool::add_vertex(const Vector3 &p_vertex) {
 	ERR_FAIL_COND(!begun);
 
@@ -109,53 +162,16 @@ void SurfaceTool::add_vertex(const Vector3 &p_vertex) {
 	vtx.normal = last_normal;
 	vtx.uv = last_uv;
 	vtx.uv2 = last_uv2;
-	vtx.weights = last_weights;
-	vtx.bones = last_bones;
 	vtx.tangent = last_tangent.normal;
 	vtx.binormal = last_normal.cross(last_tangent.normal).normalized() * last_tangent.d;
 
-	const int expected_vertices = 4;
+	if (format & Mesh::ARRAY_FORMAT_WEIGHTS || format & Mesh::ARRAY_FORMAT_BONES) {
+		ERR_FAIL_COND(!_sanitize_last_bones_and_weights());
 
-	if ((format & Mesh::ARRAY_FORMAT_WEIGHTS || format & Mesh::ARRAY_FORMAT_BONES) && (vtx.weights.size() != expected_vertices || vtx.bones.size() != expected_vertices)) {
+		vtx.num_bones = last_bones.size();
-		//ensure vertices are the expected amount
+		for (int n = 0; n < last_bones.size(); n++) {
-		ERR_FAIL_COND(vtx.weights.size() != vtx.bones.size());
+			vtx.bones[n] = last_bones[n];
-		if (vtx.weights.size() < expected_vertices) {
+			vtx.weights[n] = last_weights[n];
-			//less than required, fill
-			for (int i = vtx.weights.size(); i < expected_vertices; i++) {
-				vtx.weights.push_back(0);
-				vtx.bones.push_back(0);
-			}
-		} else if (vtx.weights.size() > expected_vertices) {
-			//more than required, sort, cap and normalize.
-			Vector<WeightSort> weights;
-			for (int i = 0; i < vtx.weights.size(); i++) {
-				WeightSort ws;
-				ws.index = vtx.bones[i];
-				ws.weight = vtx.weights[i];
-				weights.push_back(ws);
-			}
-
-			//sort
-			weights.sort();
-			//cap
-			weights.resize(expected_vertices);
-			//renormalize
-			float total = 0;
-			for (int i = 0; i < expected_vertices; i++) {
-				total += weights[i].weight;
-			}
-
-			vtx.weights.resize(expected_vertices);
-			vtx.bones.resize(expected_vertices);
-
-			for (int i = 0; i < expected_vertices; i++) {
-				if (total > 0) {
-					vtx.weights.write[i] = weights[i].weight / total;
-				} else {
-					vtx.weights.write[i] = 0;
-				}
-				vtx.bones.write[i] = weights[i].index;
-			}
 		}
 	}
 
@@ -223,11 +239,8 @@ void SurfaceTool::add_weights(const Vector<float> &p_weights) {
 
 void SurfaceTool::add_smooth_group(bool p_smooth) {
 	ERR_FAIL_COND(!begun);
-	if (index_array.size()) {
+
-		smooth_groups[index_array.size()] = p_smooth;
+	smooth_groups[get_num_draw_vertices()] = p_smooth;
-	} else {
-		smooth_groups[vertex_array.size()] = p_smooth;
-	}
 }
 
 void SurfaceTool::add_triangle_fan(const Vector<Vector3> &p_vertices, const Vector<Vector2> &p_uvs, const Vector<Color> &p_colors, const Vector<Vector2> &p_uv2s, const Vector<Vector3> &p_normals, const Vector<Plane> &p_tangents) {
@@ -285,16 +298,15 @@ Array SurfaceTool::commit_to_arrays() {
 				array.resize(varr_len);
 				PoolVector<Vector3>::Write w = array.write();
 
-				int idx = 0;
+				for (uint32_t n = 0; n < vertex_array.size(); n++) {
-				for (List<Vertex>::Element *E = vertex_array.front(); E; E = E->next(), idx++) {
+					const Vertex &v = vertex_array[n];
-					const Vertex &v = E->get();
 
 					switch (i) {
 						case Mesh::ARRAY_VERTEX: {
-							w[idx] = v.vertex;
+							w[n] = v.vertex;
 						} break;
 						case Mesh::ARRAY_NORMAL: {
-							w[idx] = v.normal;
+							w[n] = v.normal;
 						} break;
 					}
 				}
@@ -311,8 +323,8 @@ Array SurfaceTool::commit_to_arrays() {
 				PoolVector<Vector2>::Write w = array.write();
 
 				int idx = 0;
-				for (List<Vertex>::Element *E = vertex_array.front(); E; E = E->next(), idx++) {
+				for (uint32_t n = 0; n < vertex_array.size(); n++, idx++) {
-					const Vertex &v = E->get();
+					const Vertex &v = vertex_array[n];
 
 					switch (i) {
 						case Mesh::ARRAY_TEX_UV: {
@@ -333,8 +345,8 @@ Array SurfaceTool::commit_to_arrays() {
 				PoolVector<float>::Write w = array.write();
 
 				int idx = 0;
-				for (List<Vertex>::Element *E = vertex_array.front(); E; E = E->next(), idx += 4) {
+				for (uint32_t n = 0; n < vertex_array.size(); n++, idx += 4) {
-					const Vertex &v = E->get();
+					const Vertex &v = vertex_array[n];
 
 					w[idx + 0] = v.tangent.x;
 					w[idx + 1] = v.tangent.y;
@@ -355,8 +367,8 @@ Array SurfaceTool::commit_to_arrays() {
 				PoolVector<Color>::Write w = array.write();
 
 				int idx = 0;
-				for (List<Vertex>::Element *E = vertex_array.front(); E; E = E->next(), idx++) {
+				for (uint32_t n = 0; n < vertex_array.size(); n++, idx++) {
-					const Vertex &v = E->get();
+					const Vertex &v = vertex_array[n];
 					w[idx] = v.color;
 				}
 
@@ -365,16 +377,15 @@ Array SurfaceTool::commit_to_arrays() {
 			} break;
 			case Mesh::ARRAY_BONES: {
 				PoolVector<int> array;
-				array.resize(varr_len * 4);
+				array.resize(varr_len * Vertex::MAX_BONES);
 				PoolVector<int>::Write w = array.write();
 
 				int idx = 0;
-				for (List<Vertex>::Element *E = vertex_array.front(); E; E = E->next(), idx += 4) {
+				for (uint32_t n = 0; n < vertex_array.size(); n++, idx += Vertex::MAX_BONES) {
-					const Vertex &v = E->get();
+					const Vertex &v = vertex_array[n];
 
-					ERR_CONTINUE(v.bones.size() != 4);
+					ERR_CONTINUE(v.num_bones != Vertex::MAX_BONES);
-
+					for (int j = 0; j < Vertex::MAX_BONES; j++) {
-					for (int j = 0; j < 4; j++) {
 						w[idx + j] = v.bones[j];
 					}
 				}
@@ -385,15 +396,16 @@ Array SurfaceTool::commit_to_arrays() {
 			} break;
 			case Mesh::ARRAY_WEIGHTS: {
 				PoolVector<float> array;
-				array.resize(varr_len * 4);
+				array.resize(varr_len * Vertex::MAX_BONES);
 				PoolVector<float>::Write w = array.write();
 
 				int idx = 0;
-				for (List<Vertex>::Element *E = vertex_array.front(); E; E = E->next(), idx += 4) {
+				for (uint32_t n = 0; n < vertex_array.size(); n++, idx += Vertex::MAX_BONES) {
-					const Vertex &v = E->get();
+					const Vertex &v = vertex_array[n];
-					ERR_CONTINUE(v.weights.size() != 4);
 
-					for (int j = 0; j < 4; j++) {
+					ERR_CONTINUE(v.num_bones != Vertex::MAX_BONES);
+
+					for (int j = 0; j < Vertex::MAX_BONES; j++) {
 						w[idx + j] = v.weights[j];
 					}
 				}
@@ -409,9 +421,8 @@ Array SurfaceTool::commit_to_arrays() {
 				array.resize(index_array.size());
 				PoolVector<int>::Write w = array.write();
 
-				int idx = 0;
+				for (uint32_t n = 0; n < index_array.size(); n++) {
-				for (List<int>::Element *E = index_array.front(); E; E = E->next(), idx++) {
+					w[n] = index_array[n];
-					w[idx] = E->get();
 				}
 
 				w.release();
@@ -460,15 +471,22 @@ void SurfaceTool::index() {
 	}
 
 	HashMap<Vertex, int, VertexHasher> indices;
-	List<Vertex> new_vertices;
 
-	for (List<Vertex>::Element *E = vertex_array.front(); E; E = E->next()) {
+	LocalVector<Vertex> new_vertices;
-		int *idxptr = indices.getptr(E->get());
+
+	// probably will use less, but this prevents a bunch of resizing
+	new_vertices.reserve(vertex_array.size());
+
+	for (uint32_t n = 0; n < vertex_array.size(); n++) {
+		const Vertex &v = vertex_array[n];
+
+		int *idxptr = indices.getptr(v);
+
 		int idx;
 		if (!idxptr) {
 			idx = indices.size();
-			new_vertices.push_back(E->get());
+			new_vertices.push_back(v);
-			indices[E->get()] = idx;
+			indices[v] = idx;
 		} else {
 			idx = *idxptr;
 		}
@@ -486,22 +504,23 @@ void SurfaceTool::deindex() {
 	if (index_array.size() == 0) {
 		return; //nothing to deindex
 	}
-	Vector<Vertex> varr;
+
-	varr.resize(vertex_array.size());
+	// make a copy of source verts
-	int idx = 0;
+	LocalVector<Vertex> varr = vertex_array;
-	for (List<Vertex>::Element *E = vertex_array.front(); E; E = E->next()) {
+	vertex_array.resize(index_array.size());
-		varr.write[idx++] = E->get();
+	Vertex *dest_vert = vertex_array.ptr();
-	}
+
-	vertex_array.clear();
+	for (uint32_t n = 0; n < index_array.size(); n++) {
-	for (List<int>::Element *E = index_array.front(); E; E = E->next()) {
+		int idx = index_array[n];
-		ERR_FAIL_INDEX(E->get(), varr.size());
+		ERR_FAIL_INDEX(idx, (int)varr.size());
-		vertex_array.push_back(varr[E->get()]);
+		*dest_vert++ = varr[idx];
 	}
+
 	format &= ~Mesh::ARRAY_FORMAT_INDEX;
 	index_array.clear();
 }
 
-void SurfaceTool::_create_list(const Ref<Mesh> &p_existing, int p_surface, List<Vertex> *r_vertex, List<int> *r_index, int &lformat) {
+void SurfaceTool::_create_list(const Ref<Mesh> &p_existing, int p_surface, LocalVector<Vertex> *r_vertex, LocalVector<int> *r_index, uint32_t &lformat) {
 	ERR_FAIL_COND_MSG(p_existing.is_null(), "First argument in SurfaceTool::_create_list() must be a valid object of type Mesh");
 	Array arr = p_existing->surface_get_arrays(p_surface);
 	ERR_FAIL_COND(arr.size() != RS::ARRAY_MAX);
@@ -572,8 +591,12 @@ Vector<SurfaceTool::Vertex> SurfaceTool::create_vertex_array_from_triangle_array
 		rw = warr.read();
 	}
 
+	ret.resize(vc);
+	Vertex *ret_dest = ret.ptrw();
+
 	for (int i = 0; i < vc; i++) {
-		Vertex v;
+		Vertex &v = *ret_dest++;
+
 		if (lformat & RS::ARRAY_FORMAT_VERTEX) {
 			v.vertex = varr[i];
 		}
@@ -595,31 +618,23 @@ Vector<SurfaceTool::Vertex> SurfaceTool::create_vertex_array_from_triangle_array
 			v.uv2 = uv2arr[i];
 		}
 		if (lformat & RS::ARRAY_FORMAT_BONES) {
-			Vector<int> b;
+			v.num_bones = Vertex::MAX_BONES;
-			b.resize(4);
+			for (int b = 0; b < Vertex::MAX_BONES; b++) {
-			b.write[0] = barr[i * 4 + 0];
+				v.bones[b] = barr[i * Vertex::MAX_BONES + b];
-			b.write[1] = barr[i * 4 + 1];
+			}
-			b.write[2] = barr[i * 4 + 2];
-			b.write[3] = barr[i * 4 + 3];
-			v.bones = b;
 		}
 		if (lformat & RS::ARRAY_FORMAT_WEIGHTS) {
-			Vector<float> w;
+			v.num_bones = Vertex::MAX_BONES;
-			w.resize(4);
+			for (int b = 0; b < Vertex::MAX_BONES; b++) {
-			w.write[0] = warr[i * 4 + 0];
+				v.weights[b] = warr[i * Vertex::MAX_BONES + b];
-			w.write[1] = warr[i * 4 + 1];
+			}
-			w.write[2] = warr[i * 4 + 2];
-			w.write[3] = warr[i * 4 + 3];
-			v.weights = w;
 		}
-
-		ret.push_back(v);
 	}
 
 	return ret;
 }
 
-void SurfaceTool::_create_list_from_arrays(Array arr, List<Vertex> *r_vertex, List<int> *r_index, int &lformat) {
+void SurfaceTool::_create_list_from_arrays(Array arr, LocalVector<Vertex> *r_vertex, LocalVector<int> *r_index, uint32_t &lformat) {
 	PoolVector<Vector3> varr = arr[RS::ARRAY_VERTEX];
 	PoolVector<Vector3> narr = arr[RS::ARRAY_NORMAL];
 	PoolVector<float> tarr = arr[RS::ARRAY_TANGENT];
@@ -681,8 +696,14 @@ void SurfaceTool::_create_list_from_arrays(Array arr, List<Vertex> *r_vertex, Li
 		rw = warr.read();
 	}
 
+	DEV_ASSERT(vc);
+	uint32_t start = r_vertex->size();
+	r_vertex->resize(start + vc);
+	Vertex *vert_dest = &r_vertex->operator[](start);
+
 	for (int i = 0; i < vc; i++) {
-		Vertex v;
+		Vertex &v = *vert_dest++;
+
 		if (lformat & RS::ARRAY_FORMAT_VERTEX) {
 			v.vertex = varr[i];
 		}
@@ -704,25 +725,17 @@ void SurfaceTool::_create_list_from_arrays(Array arr, List<Vertex> *r_vertex, Li
 			v.uv2 = uv2arr[i];
 		}
 		if (lformat & RS::ARRAY_FORMAT_BONES) {
-			Vector<int> b;
+			v.num_bones = Vertex::MAX_BONES;
-			b.resize(4);
+			for (int b = 0; b < Vertex::MAX_BONES; b++) {
-			b.write[0] = barr[i * 4 + 0];
+				v.bones[b] = barr[i * Vertex::MAX_BONES + b];
-			b.write[1] = barr[i * 4 + 1];
+			}
-			b.write[2] = barr[i * 4 + 2];
-			b.write[3] = barr[i * 4 + 3];
-			v.bones = b;
 		}
 		if (lformat & RS::ARRAY_FORMAT_WEIGHTS) {
-			Vector<float> w;
+			v.num_bones = Vertex::MAX_BONES;
-			w.resize(4);
+			for (int b = 0; b < Vertex::MAX_BONES; b++) {
-			w.write[0] = warr[i * 4 + 0];
+				v.weights[b] = warr[i * Vertex::MAX_BONES + b];
-			w.write[1] = warr[i * 4 + 1];
+			}
-			w.write[2] = warr[i * 4 + 2];
-			w.write[3] = warr[i * 4 + 3];
-			v.weights = w;
 		}
-
-		r_vertex->push_back(v);
 	}
 
 	//indices
@@ -732,8 +745,14 @@ void SurfaceTool::_create_list_from_arrays(Array arr, List<Vertex> *r_vertex, Li
 	if (is) {
 		lformat |= RS::ARRAY_FORMAT_INDEX;
 		PoolVector<int>::Read iarr = idx.read();
+
+		uint32_t ind_start = r_index->size();
+		r_index->resize(ind_start + is);
+		int *ind_dest = &r_index->operator[](ind_start);
+
 		for (int i = 0; i < is; i++) {
-			r_index->push_back(iarr[i]);
+			*ind_dest = iarr[i];
+			ind_dest++;
 		}
 	}
 }
@@ -780,31 +799,43 @@ void SurfaceTool::append_from(const Ref<Mesh> &p_existing, int p_surface, const
 		format = 0;
 	}
 
-	int nformat;
+	uint32_t nformat;
-	List<Vertex> nvertices;
+	LocalVector<Vertex> nvertices;
-	List<int> nindices;
+	LocalVector<int> nindices;
+
 	_create_list(p_existing, p_surface, &nvertices, &nindices, nformat);
 	format |= nformat;
 	int vfrom = vertex_array.size();
 
-	for (List<Vertex>::Element *E = nvertices.front(); E; E = E->next()) {
+	if (nvertices.size()) {
-		Vertex v = E->get();
+		vertex_array.resize(vfrom + nvertices.size());
-		v.vertex = p_xform.xform(v.vertex);
+		Vertex *dest_vert = &vertex_array[vfrom];
-		if (nformat & RS::ARRAY_FORMAT_NORMAL) {
-			v.normal = p_xform.basis.xform(v.normal);
-		}
-		if (nformat & RS::ARRAY_FORMAT_TANGENT) {
-			v.tangent = p_xform.basis.xform(v.tangent);
-			v.binormal = p_xform.basis.xform(v.binormal);
-		}
 
-		vertex_array.push_back(v);
+		for (uint32_t n = 0; n < nvertices.size(); n++) {
-	}
+			Vertex &v = *dest_vert++;
+			v = nvertices[n];
+			v.vertex = p_xform.xform(v.vertex);
+			if (nformat & RS::ARRAY_FORMAT_NORMAL) {
+				v.normal = p_xform.basis.xform(v.normal);
+			}
+			if (nformat & RS::ARRAY_FORMAT_TANGENT) {
+				v.tangent = p_xform.basis.xform(v.tangent);
+				v.binormal = p_xform.basis.xform(v.binormal);
+			}
+		}
+	} // if there were new vertices to add
+
+	if (nindices.size()) {
+		int ind_start = index_array.size();
+		index_array.resize(ind_start + nindices.size());
+		int *dest_ind = &index_array[ind_start];
+
+		for (uint32_t n = 0; n < nindices.size(); n++) {
+			int dst_index = nindices[n] + vfrom;
+			*dest_ind++ = dst_index;
+		}
+	} // if there were new indices to add
 
-	for (List<int>::Element *E = nindices.front(); E; E = E->next()) {
-		int dst_index = E->get() + vfrom;
-		index_array.push_back(dst_index);
-	}
 	if (index_array.size() % 3) {
 		WARN_PRINT("SurfaceTool: Index array not a multiple of 3.");
 	}
@@ -813,8 +844,8 @@ void SurfaceTool::append_from(const Ref<Mesh> &p_existing, int p_surface, const
 //mikktspace callbacks
 namespace {
 struct TangentGenerationContextUserData {
-	Vector<List<SurfaceTool::Vertex>::Element *> vertices;
+	Vector<SurfaceTool::Vertex *> vertices;
-	Vector<List<int>::Element *> indices;
+	Vector<int> indices;
 };
 } // namespace
 
@@ -834,12 +865,12 @@ void SurfaceTool::mikktGetPosition(const SMikkTSpaceContext *pContext, float fvP
 	TangentGenerationContextUserData &triangle_data = *reinterpret_cast<TangentGenerationContextUserData *>(pContext->m_pUserData);
 	Vector3 v;
 	if (triangle_data.indices.size() > 0) {
-		int index = triangle_data.indices[iFace * 3 + iVert]->get();
+		int index = triangle_data.indices[iFace * 3 + iVert];
 		if (index < triangle_data.vertices.size()) {
-			v = triangle_data.vertices[index]->get().vertex;
+			v = triangle_data.vertices[index]->vertex;
 		}
 	} else {
-		v = triangle_data.vertices[iFace * 3 + iVert]->get().vertex;
+		v = triangle_data.vertices[iFace * 3 + iVert]->vertex;
 	}
 
 	fvPosOut[0] = v.x;
@@ -851,12 +882,12 @@ void SurfaceTool::mikktGetNormal(const SMikkTSpaceContext *pContext, float fvNor
 	TangentGenerationContextUserData &triangle_data = *reinterpret_cast<TangentGenerationContextUserData *>(pContext->m_pUserData);
 	Vector3 v;
 	if (triangle_data.indices.size() > 0) {
-		int index = triangle_data.indices[iFace * 3 + iVert]->get();
+		int index = triangle_data.indices[iFace * 3 + iVert];
 		if (index < triangle_data.vertices.size()) {
-			v = triangle_data.vertices[index]->get().normal;
+			v = triangle_data.vertices[index]->normal;
 		}
 	} else {
-		v = triangle_data.vertices[iFace * 3 + iVert]->get().normal;
+		v = triangle_data.vertices[iFace * 3 + iVert]->normal;
 	}
 
 	fvNormOut[0] = v.x;
@@ -867,12 +898,12 @@ void SurfaceTool::mikktGetTexCoord(const SMikkTSpaceContext *pContext, float fvT
 	TangentGenerationContextUserData &triangle_data = *reinterpret_cast<TangentGenerationContextUserData *>(pContext->m_pUserData);
 	Vector2 v;
 	if (triangle_data.indices.size() > 0) {
-		int index = triangle_data.indices[iFace * 3 + iVert]->get();
+		int index = triangle_data.indices[iFace * 3 + iVert];
 		if (index < triangle_data.vertices.size()) {
-			v = triangle_data.vertices[index]->get().uv;
+			v = triangle_data.vertices[index]->uv;
 		}
 	} else {
-		v = triangle_data.vertices[iFace * 3 + iVert]->get().uv;
+		v = triangle_data.vertices[iFace * 3 + iVert]->uv;
 	}
 
 	fvTexcOut[0] = v.x;
@@ -884,12 +915,12 @@ void SurfaceTool::mikktSetTSpaceDefault(const SMikkTSpaceContext *pContext, cons
 	TangentGenerationContextUserData &triangle_data = *reinterpret_cast<TangentGenerationContextUserData *>(pContext->m_pUserData);
 	Vertex *vtx = nullptr;
 	if (triangle_data.indices.size() > 0) {
-		int index = triangle_data.indices[iFace * 3 + iVert]->get();
+		int index = triangle_data.indices[iFace * 3 + iVert];
 		if (index < triangle_data.vertices.size()) {
-			vtx = &triangle_data.vertices[index]->get();
+			vtx = triangle_data.vertices[index];
 		}
 	} else {
-		vtx = &triangle_data.vertices[iFace * 3 + iVert]->get();
+		vtx = triangle_data.vertices[iFace * 3 + iVert];
 	}
 
 	if (vtx != nullptr) {
@@ -917,15 +948,16 @@ void SurfaceTool::generate_tangents() {
 	TangentGenerationContextUserData triangle_data;
 	triangle_data.vertices.resize(vertex_array.size());
 	int idx = 0;
-	for (List<Vertex>::Element *E = vertex_array.front(); E; E = E->next()) {
+	for (uint32_t n = 0; n < vertex_array.size(); n++) {
-		triangle_data.vertices.write[idx++] = E;
+		Vertex &v = vertex_array[n];
-		E->get().binormal = Vector3();
+		triangle_data.vertices.write[idx++] = &v;
-		E->get().tangent = Vector3();
+		v.binormal = Vector3();
+		v.tangent = Vector3();
 	}
 	triangle_data.indices.resize(index_array.size());
 	idx = 0;
-	for (List<int>::Element *E = index_array.front(); E; E = E->next()) {
+	for (uint32_t n = 0; n < index_array.size(); n++) {
-		triangle_data.indices.write[idx++] = E;
+		triangle_data.indices.write[n] = index_array[n];
 	}
 	msc.m_pUserData = &triangle_data;
 
@@ -946,65 +978,50 @@ void SurfaceTool::generate_normals(bool p_flip) {
 
 	int count = 0;
 	bool smooth = false;
+	int smooth_group_start = 0;
 	if (smooth_groups.has(0)) {
 		smooth = smooth_groups[0];
 	}
 
-	List<Vertex>::Element *B = vertex_array.front();
+	for (uint32_t t = 0; t < vertex_array.size(); t += 3) {
-	for (List<Vertex>::Element *E = B; E;) {
+		Vertex *v[3];
-		List<Vertex>::Element *v[3];
+		v[0] = &vertex_array[t];
-		v[0] = E;
+		v[1] = &vertex_array[t + 1];
-		v[1] = v[0]->next();
+		v[2] = &vertex_array[t + 2];
-		ERR_FAIL_COND(!v[1]);
-		v[2] = v[1]->next();
-		ERR_FAIL_COND(!v[2]);
-		E = v[2]->next();
 
 		Vector3 normal;
 		if (!p_flip) {
-			normal = Plane(v[0]->get().vertex, v[1]->get().vertex, v[2]->get().vertex).normal;
+			normal = Plane(v[0]->vertex, v[1]->vertex, v[2]->vertex).normal;
 		} else {
-			normal = Plane(v[2]->get().vertex, v[1]->get().vertex, v[0]->get().vertex).normal;
+			normal = Plane(v[2]->vertex, v[1]->vertex, v[0]->vertex).normal;
 		}
 
 		if (smooth) {
 			for (int i = 0; i < 3; i++) {
-				Vector3 *lv = vertex_hash.getptr(v[i]->get());
+				Vector3 *lv = vertex_hash.getptr(*v[i]);
 				if (!lv) {
-					vertex_hash.set(v[i]->get(), normal);
+					vertex_hash.set(*v[i], normal);
 				} else {
 					(*lv) += normal;
 				}
 			}
 		} else {
 			for (int i = 0; i < 3; i++) {
-				v[i]->get().normal = normal;
+				v[i]->normal = normal;
 			}
 		}
 		count += 3;
 
-		if (smooth_groups.has(count) || !E) {
+		// terminating smooth group, bake the smoothing group
-			if (vertex_hash.size()) {
+		if (smooth_groups.has(count)) {
-				while (B != E) {
+			_apply_smoothing_group(vertex_hash, smooth_group_start, count, smooth);
-					Vector3 *lv = vertex_hash.getptr(B->get());
+			smooth_group_start = count;
-					if (lv) {
-						B->get().normal = lv->normalized();
-					}
-
-					B = B->next();
-				}
-
-			} else {
-				B = E;
-			}
-
-			vertex_hash.clear();
-			if (E) {
-				smooth = smooth_groups[count];
-			}
 		}
 	}
 
+	// always terminate the last smoothing group
+	_apply_smoothing_group(vertex_hash, smooth_group_start, vertex_array.size(), smooth);
+
 	format |= Mesh::ARRAY_FORMAT_NORMAL;
 
 	if (was_indexed) {
@@ -1013,6 +1030,24 @@ void SurfaceTool::generate_normals(bool p_flip) {
 	}
 }
 
+void SurfaceTool::_apply_smoothing_group(HashMap<Vertex, Vector3, VertexHasher> &r_vertex_hash, uint32_t p_from, uint32_t p_to, bool &r_smooth) {
+	if (r_vertex_hash.size()) {
+		for (uint32_t n = p_from; n < p_to; n++) {
+			Vertex &v = vertex_array[n];
+
+			Vector3 *lv = r_vertex_hash.getptr(v);
+			if (lv) {
+				v.normal = lv->normalized();
+			}
+		}
+	}
+
+	r_vertex_hash.clear();
+	if (p_to < vertex_array.size()) {
+		r_smooth = smooth_groups[p_to];
+	}
+}
+
 void SurfaceTool::set_material(const Ref<Material> &p_material) {
 	material = p_material;
 }

scene/resources/surface_tool.h

@@ -39,6 +39,8 @@ class SurfaceTool : public Reference {
 
 public:
 	struct Vertex {
+		enum { MAX_BONES = 4 };
+
 		Vector3 vertex;
 		Color color;
 		Vector3 normal; // normal, binormal, tangent
@@ -46,8 +48,10 @@ public:
 		Vector3 tangent;
 		Vector2 uv;
 		Vector2 uv2;
-		Vector<int> bones;
+
-		Vector<float> weights;
+		int16_t bones[MAX_BONES];
+		float weights[MAX_BONES];
+		int32_t num_bones = 0;
 
 		bool operator==(const Vertex &p_vertex) const;
 
@@ -70,11 +74,13 @@ private:
 	bool begun;
 	bool first;
 	Mesh::PrimitiveType primitive;
-	int format;
+	uint32_t format;
 	Ref<Material> material;
+
 	//arrays
-	List<Vertex> vertex_array;
+	LocalVector<Vertex> vertex_array;
-	List<int> index_array;
+	LocalVector<int> index_array;
+
 	RBMap<int, bool> smooth_groups;
 
 	//memory
@@ -86,8 +92,13 @@ private:
 	Vector<float> last_weights;
 	Plane last_tangent;
 
-	void _create_list_from_arrays(Array arr, List<Vertex> *r_vertex, List<int> *r_index, int &lformat);
+	void _create_list_from_arrays(Array arr, LocalVector<Vertex> *r_vertex, LocalVector<int> *r_index, uint32_t &lformat);
-	void _create_list(const Ref<Mesh> &p_existing, int p_surface, List<Vertex> *r_vertex, List<int> *r_index, int &lformat);
+	void _create_list(const Ref<Mesh> &p_existing, int p_surface, LocalVector<Vertex> *r_vertex, LocalVector<int> *r_index, uint32_t &lformat);
+	void _apply_smoothing_group(HashMap<Vertex, Vector3, VertexHasher> &r_vertex_hash, uint32_t p_from, uint32_t p_to, bool &r_smooth);
+	void _mask_format_flags(uint32_t p_mask) { format &= p_mask; }
+	bool _sanitize_last_bones_and_weights();
+
+	uint32_t get_num_draw_vertices() const { return index_array.size() ? index_array.size() : vertex_array.size(); }
 
 	//mikktspace callbacks
 	static int mikktGetNumFaces(const SMikkTSpaceContext *pContext);
@@ -127,7 +138,7 @@ public:
 
 	void clear();
 
-	List<Vertex> &get_vertex_array() { return vertex_array; }
+	LocalVector<Vertex> &get_vertex_array() { return vertex_array; }
 
 	void create_from_triangle_arrays(const Array &p_arrays);
 	static Vector<Vertex> create_vertex_array_from_triangle_arrays(const Array &p_arrays);