-Added GLTF scene support (still missing animations and .glb extension)

-Fixed bugs regarding tangent generation in SurfaceTool

4 files changed, 184 insertions, 34 deletions

diff --git a/scene/resources/material.cpp b/scene/resources/material.cpp
index 24ec39afe3..5a79e49240 100644
--- a/scene/resources/material.cpp
+++ b/scene/resources/material.cpp
@@ -234,6 +234,14 @@ void SpatialMaterial::init_shaders() {
 
 	shader_names->grow = "grow";
 
+	shader_names->metallic_texture_channel = "metallic_texture_channel";
+	shader_names->roughness_texture_channel = "roughness_texture_channel";
+	shader_names->ao_texture_channel = "ao_texture_channel";
+	shader_names->clearcoat_texture_channel = "clearcoat_texture_channel";
+	shader_names->rim_texture_channel = "rim_texture_channel";
+	shader_names->depth_texture_channel = "depth_texture_channel";
+	shader_names->refraction_texture_channel = "refraction_texture_channel";
+
 	shader_names->texture_names[TEXTURE_ALBEDO] = "texture_albedo";
 	shader_names->texture_names[TEXTURE_METALLIC] = "texture_metallic";
 	shader_names->texture_names[TEXTURE_ROUGHNESS] = "texture_roughness";
@@ -354,7 +362,9 @@ void SpatialMaterial::_update_shader() {
 	code += "uniform float roughness : hint_range(0,1);\n";
 	code += "uniform float point_size : hint_range(0,128);\n";
 	code += "uniform sampler2D texture_metallic : hint_white;\n";
+	code += "uniform vec4 metallic_texture_channel;\n";
 	code += "uniform sampler2D texture_roughness : hint_white;\n";
+	code += "uniform vec4 roughness_texture_channel;\n";
 	if (billboard_mode == BILLBOARD_PARTICLES) {
 		code += "uniform int particles_anim_h_frames;\n";
 		code += "uniform int particles_anim_v_frames;\n";
@@ -371,6 +381,7 @@ void SpatialMaterial::_update_shader() {
 	if (features[FEATURE_REFRACTION]) {
 		code += "uniform sampler2D texture_refraction;\n";
 		code += "uniform float refraction : hint_range(-16,16);\n";
+		code += "uniform vec4 refraction_texture_channel;\n";
 	}
 
 	if (features[FEATURE_NORMAL_MAPPING]) {
@@ -393,6 +404,7 @@ void SpatialMaterial::_update_shader() {
 	}
 	if (features[FEATURE_AMBIENT_OCCLUSION]) {
 		code += "uniform sampler2D texture_ambient_occlusion : hint_white;\n";
+		code += "uniform vec4 ao_texture_channel;\n";
 	}
 
 	if (features[FEATURE_DETAIL]) {
@@ -617,15 +629,15 @@ void SpatialMaterial::_update_shader() {
 
 	code += "\tALBEDO = albedo.rgb * albedo_tex.rgb;\n";
 	if (flags[FLAG_UV1_USE_TRIPLANAR]) {
-		code += "\tfloat metallic_tex = triplanar_texture(texture_metallic,uv1_power_normal,uv1_world_pos).r;\n";
+		code += "\tfloat metallic_tex = dot(triplanar_texture(texture_metallic,uv1_power_normal,uv1_world_pos),metallic_texture_channel);\n";
 	} else {
-		code += "\tfloat metallic_tex = texture(texture_metallic,base_uv).r;\n";
+		code += "\tfloat metallic_tex = dot(texture(texture_metallic,base_uv),metallic_texture_channel);\n";
 	}
 	code += "\tMETALLIC = metallic_tex * metallic;\n";
 	if (flags[FLAG_UV1_USE_TRIPLANAR]) {
-		code += "\tfloat roughness_tex = triplanar_texture(texture_roughness,uv1_power_normal,uv1_world_pos).r;\n";
+		code += "\tfloat roughness_tex = dot(triplanar_texture(texture_roughness,uv1_power_normal,uv1_world_pos),roughness_texture_channel);\n";
 	} else {
-		code += "\tfloat roughness_tex = texture(texture_roughness,base_uv).r;\n";
+		code += "\tfloat roughness_tex = dot(texture(texture_roughness,base_uv),roughness_texture_channel);\n";
 	}
 	code += "\tROUGHNESS = roughness_tex * roughness;\n";
 	code += "\tSPECULAR = specular;\n";
@@ -656,7 +668,7 @@ void SpatialMaterial::_update_shader() {
 			code += "\tvec3 ref_normal = NORMAL;\n";
 		}
 
-		code += "\tvec2 ref_ofs = SCREEN_UV - ref_normal.xy * texture(texture_refraction,base_uv).r * refraction;\n";
+		code += "\tvec2 ref_ofs = SCREEN_UV - ref_normal.xy * dot(texture(texture_refraction,base_uv),refraction_texture_channel) * refraction;\n";
 		code += "\tfloat ref_amount = 1.0 - albedo.a * albedo_tex.a;\n";
 		code += "\tEMISSION += textureLod(SCREEN_TEXTURE,ref_ofs,ROUGHNESS * 8.0).rgb * ref_amount;\n";
 		code += "\tALBEDO *= 1.0 - ref_amount;\n";
@@ -699,15 +711,15 @@ void SpatialMaterial::_update_shader() {
 	if (features[FEATURE_AMBIENT_OCCLUSION]) {
 		if (flags[FLAG_AO_ON_UV2]) {
 			if (flags[FLAG_UV2_USE_TRIPLANAR]) {
-				code += "\tAO = triplanar_texture(texture_ambient_occlusion,uv2_power_normal,uv2_world_pos).r;\n";
+				code += "\tAO = dot(triplanar_texture(texture_ambient_occlusion,uv2_power_normal,uv2_world_pos),ao_texture_channel);\n";
 			} else {
-				code += "\tAO = texture(texture_ambient_occlusion,base_uv2).r;\n";
+				code += "\tAO = dot(texture(texture_ambient_occlusion,base_uv2),ao_texture_channel);\n";
 			}
 		} else {
 			if (flags[FLAG_UV1_USE_TRIPLANAR]) {
-				code += "\tAO = triplanar_texture(texture_ambient_occlusion,uv1_power_normal,uv1_world_pos).r;\n";
+				code += "\tAO = dot(triplanar_texture(texture_ambient_occlusion,uv1_power_normal,uv1_world_pos),ao_texture_channel);\n";
 			} else {
-				code += "\tAO = texture(texture_ambient_occlusion,base_uv).r;\n";
+				code += "\tAO = dot(texture(texture_ambient_occlusion,base_uv),ao_texture_channel);\n";
 			}
 		}
 	}
@@ -1327,6 +1339,58 @@ float SpatialMaterial::get_grow() const {
 	return grow;
 }
 
+static Plane _get_texture_mask(SpatialMaterial::TextureChannel p_channel) {
+	static const Plane masks[5] = {
+		Plane(1, 0, 0, 0),
+		Plane(0, 1, 0, 0),
+		Plane(0, 0, 1, 0),
+		Plane(0, 0, 0, 1),
+		Plane(0.3333333, 0.3333333, 0.3333333, 0),
+	};
+
+	return masks[p_channel];
+}
+
+void SpatialMaterial::set_metallic_texture_channel(TextureChannel p_channel) {
+
+	metallic_texture_channel = p_channel;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->metallic_texture_channel, _get_texture_mask(p_channel));
+}
+
+SpatialMaterial::TextureChannel SpatialMaterial::get_metallic_texture_channel() const {
+	return metallic_texture_channel;
+}
+
+void SpatialMaterial::set_roughness_texture_channel(TextureChannel p_channel) {
+
+	roughness_texture_channel = p_channel;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->roughness_texture_channel, _get_texture_mask(p_channel));
+}
+
+SpatialMaterial::TextureChannel SpatialMaterial::get_roughness_texture_channel() const {
+	return roughness_texture_channel;
+}
+
+void SpatialMaterial::set_ao_texture_channel(TextureChannel p_channel) {
+
+	ao_texture_channel = p_channel;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->ao_texture_channel, _get_texture_mask(p_channel));
+}
+
+SpatialMaterial::TextureChannel SpatialMaterial::get_ao_texture_channel() const {
+	return ao_texture_channel;
+}
+
+void SpatialMaterial::set_refraction_texture_channel(TextureChannel p_channel) {
+
+	refraction_texture_channel = p_channel;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->refraction_texture_channel, _get_texture_mask(p_channel));
+}
+
+SpatialMaterial::TextureChannel SpatialMaterial::get_refraction_texture_channel() const {
+	return refraction_texture_channel;
+}
+
 void SpatialMaterial::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("set_albedo", "albedo"), &SpatialMaterial::set_albedo);
@@ -1455,6 +1519,18 @@ void SpatialMaterial::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_grow_enabled", "enable"), &SpatialMaterial::set_grow_enabled);
 	ClassDB::bind_method(D_METHOD("is_grow_enabled"), &SpatialMaterial::is_grow_enabled);
 
+	ClassDB::bind_method(D_METHOD("set_metallic_texture_channel", "channel"), &SpatialMaterial::set_metallic_texture_channel);
+	ClassDB::bind_method(D_METHOD("get_metallic_texture_channel"), &SpatialMaterial::get_metallic_texture_channel);
+
+	ClassDB::bind_method(D_METHOD("set_roughness_texture_channel", "channel"), &SpatialMaterial::set_roughness_texture_channel);
+	ClassDB::bind_method(D_METHOD("get_roughness_texture_channel"), &SpatialMaterial::get_roughness_texture_channel);
+
+	ClassDB::bind_method(D_METHOD("set_ao_texture_channel", "channel"), &SpatialMaterial::set_ao_texture_channel);
+	ClassDB::bind_method(D_METHOD("get_ao_texture_channel"), &SpatialMaterial::get_ao_texture_channel);
+
+	ClassDB::bind_method(D_METHOD("set_refraction_texture_channel", "channel"), &SpatialMaterial::set_refraction_texture_channel);
+	ClassDB::bind_method(D_METHOD("get_refraction_texture_channel"), &SpatialMaterial::get_refraction_texture_channel);
+
 	ADD_GROUP("Flags", "flags_");
 	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "flags_transparent"), "set_feature", "get_feature", FEATURE_TRANSPARENT);
 	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "flags_unshaded"), "set_flag", "get_flag", FLAG_UNSHADED);
@@ -1490,10 +1566,12 @@ void SpatialMaterial::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "metallic", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_metallic", "get_metallic");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "metallic_specular", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_specular", "get_specular");
 	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "metallic_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture", TEXTURE_METALLIC);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "metallic_texture_channel", PROPERTY_HINT_ENUM, "Red,Green,Blue,Alpha,Gray"), "set_metallic_texture_channel", "get_metallic_texture_channel");
 
 	ADD_GROUP("Roughness", "roughness_");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "roughness", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_roughness", "get_roughness");
 	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "roughness_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture", TEXTURE_ROUGHNESS);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "roughness_texture_channel", PROPERTY_HINT_ENUM, "Red,Green,Blue,Alpha,Gray"), "set_roughness_texture_channel", "get_roughness_texture_channel");
 
 	ADD_GROUP("Emission", "emission_");
 	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "emission_enabled"), "set_feature", "get_feature", FEATURE_EMISSION);
@@ -1527,6 +1605,7 @@ void SpatialMaterial::_bind_methods() {
 	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "ao_enabled"), "set_feature", "get_feature", FEATURE_AMBIENT_OCCLUSION);
 	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "ao_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture", TEXTURE_AMBIENT_OCCLUSION);
 	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "ao_on_uv2"), "set_flag", "get_flag", FLAG_AO_ON_UV2);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "ao_texture_channel", PROPERTY_HINT_ENUM, "Red,Green,Blue,Alpha,Gray"), "set_ao_texture_channel", "get_ao_texture_channel");
 
 	ADD_GROUP("Depth", "depth_");
 	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "depth_enabled"), "set_feature", "get_feature", FEATURE_DEPTH_MAPPING);
@@ -1545,6 +1624,7 @@ void SpatialMaterial::_bind_methods() {
 	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "refraction_enabled"), "set_feature", "get_feature", FEATURE_REFRACTION);
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "refraction_scale", PROPERTY_HINT_RANGE, "-1,1,0.01"), "set_refraction", "get_refraction");
 	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "refraction_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture", TEXTURE_REFRACTION);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "refraction_texture_channel", PROPERTY_HINT_ENUM, "Red,Green,Blue,Alpha,Gray"), "set_refraction_texture_channel", "get_refraction_texture_channel");
 
 	ADD_GROUP("Detail", "detail_");
 	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "detail_enabled"), "set_feature", "get_feature", FEATURE_DETAIL);
@@ -1638,6 +1718,12 @@ void SpatialMaterial::_bind_methods() {
 	BIND_CONSTANT(BILLBOARD_ENABLED);
 	BIND_CONSTANT(BILLBOARD_FIXED_Y);
 	BIND_CONSTANT(BILLBOARD_PARTICLES);
+
+	BIND_CONSTANT(TEXTURE_CHANNEL_RED);
+	BIND_CONSTANT(TEXTURE_CHANNEL_GREEN);
+	BIND_CONSTANT(TEXTURE_CHANNEL_BLUE);
+	BIND_CONSTANT(TEXTURE_CHANNEL_ALPHA);
+	BIND_CONSTANT(TEXTURE_CHANNEL_GRAYSCALE);
 }
 
 SpatialMaterial::SpatialMaterial()
@@ -1672,6 +1758,11 @@ SpatialMaterial::SpatialMaterial()
 	set_particles_anim_v_frames(1);
 	set_particles_anim_loop(false);
 
+	set_metallic_texture_channel(TEXTURE_CHANNEL_RED);
+	set_roughness_texture_channel(TEXTURE_CHANNEL_RED);
+	set_ao_texture_channel(TEXTURE_CHANNEL_RED);
+	set_refraction_texture_channel(TEXTURE_CHANNEL_RED);
+
 	grow_enabled = false;
 	set_grow(0.0);
 
diff --git a/scene/resources/material.h b/scene/resources/material.h
index 7587fc7927..1484b79fc6 100644
--- a/scene/resources/material.h
+++ b/scene/resources/material.h
@@ -190,6 +190,14 @@ public:
 		BILLBOARD_PARTICLES,
 	};
 
+	enum TextureChannel {
+		TEXTURE_CHANNEL_RED,
+		TEXTURE_CHANNEL_GREEN,
+		TEXTURE_CHANNEL_BLUE,
+		TEXTURE_CHANNEL_ALPHA,
+		TEXTURE_CHANNEL_GRAYSCALE
+	};
+
 private:
 	union MaterialKey {
 
@@ -283,6 +291,14 @@ private:
 		StringName uv2_blend_sharpness;
 		StringName grow;
 
+		StringName metallic_texture_channel;
+		StringName roughness_texture_channel;
+		StringName ao_texture_channel;
+		StringName clearcoat_texture_channel;
+		StringName rim_texture_channel;
+		StringName depth_texture_channel;
+		StringName refraction_texture_channel;
+
 		StringName texture_names[TEXTURE_MAX];
 	};
 
@@ -342,6 +358,11 @@ private:
 	DiffuseMode diffuse_mode;
 	BillboardMode billboard_mode;
 
+	TextureChannel metallic_texture_channel;
+	TextureChannel roughness_texture_channel;
+	TextureChannel ao_texture_channel;
+	TextureChannel refraction_texture_channel;
+
 	bool features[FEATURE_MAX];
 
 	Ref<Texture> textures[TEXTURE_MAX];
@@ -478,6 +499,15 @@ public:
 	void set_grow(float p_grow);
 	float get_grow() const;
 
+	void set_metallic_texture_channel(TextureChannel p_channel);
+	TextureChannel get_metallic_texture_channel() const;
+	void set_roughness_texture_channel(TextureChannel p_channel);
+	TextureChannel get_roughness_texture_channel() const;
+	void set_ao_texture_channel(TextureChannel p_channel);
+	TextureChannel get_ao_texture_channel() const;
+	void set_refraction_texture_channel(TextureChannel p_channel);
+	TextureChannel get_refraction_texture_channel() const;
+
 	static void init_shaders();
 	static void finish_shaders();
 	static void flush_changes();
@@ -496,6 +526,7 @@ VARIANT_ENUM_CAST(SpatialMaterial::Flags)
 VARIANT_ENUM_CAST(SpatialMaterial::DiffuseMode)
 VARIANT_ENUM_CAST(SpatialMaterial::SpecularMode)
 VARIANT_ENUM_CAST(SpatialMaterial::BillboardMode)
+VARIANT_ENUM_CAST(SpatialMaterial::TextureChannel)
 
 //////////////////////
 
diff --git a/scene/resources/surface_tool.cpp b/scene/resources/surface_tool.cpp
index 8478432a04..3932917ebe 100644
--- a/scene/resources/surface_tool.cpp
+++ b/scene/resources/surface_tool.cpp
@@ -224,30 +224,22 @@ void SurfaceTool::add_index(int p_index) {
 	index_array.push_back(p_index);
 }
 
-Ref<ArrayMesh> SurfaceTool::commit(const Ref<ArrayMesh> &p_existing) {
-
-	Ref<ArrayMesh> mesh;
-	if (p_existing.is_valid())
-		mesh = p_existing;
-	else
-		mesh.instance();
+Array SurfaceTool::commit_to_arrays() {
 
 	int varr_len = vertex_array.size();
 
-	if (varr_len == 0)
-		return mesh;
-
-	int surface = mesh->get_surface_count();
-
 	Array a;
 	a.resize(Mesh::ARRAY_MAX);
 
 	for (int i = 0; i < Mesh::ARRAY_MAX; i++) {
 
-		switch (format & (1 << i)) {
+		if (!(format & (1 << i)))
+			continue; //not in format
+
+		switch (i) {
 
-			case Mesh::ARRAY_FORMAT_VERTEX:
-			case Mesh::ARRAY_FORMAT_NORMAL: {
+			case Mesh::ARRAY_VERTEX:
+			case Mesh::ARRAY_NORMAL: {
 
 				PoolVector<Vector3> array;
 				array.resize(varr_len);
@@ -273,8 +265,8 @@ Ref<ArrayMesh> SurfaceTool::commit(const Ref<ArrayMesh> &p_existing) {
 
 			} break;
 
-			case Mesh::ARRAY_FORMAT_TEX_UV:
-			case Mesh::ARRAY_FORMAT_TEX_UV2: {
+			case Mesh::ARRAY_TEX_UV:
+			case Mesh::ARRAY_TEX_UV2: {
 
 				PoolVector<Vector2> array;
 				array.resize(varr_len);
@@ -299,7 +291,7 @@ Ref<ArrayMesh> SurfaceTool::commit(const Ref<ArrayMesh> &p_existing) {
 				w = PoolVector<Vector2>::Write();
 				a[i] = array;
 			} break;
-			case Mesh::ARRAY_FORMAT_TANGENT: {
+			case Mesh::ARRAY_TANGENT: {
 
 				PoolVector<float> array;
 				array.resize(varr_len * 4);
@@ -323,7 +315,7 @@ Ref<ArrayMesh> SurfaceTool::commit(const Ref<ArrayMesh> &p_existing) {
 				a[i] = array;
 
 			} break;
-			case Mesh::ARRAY_FORMAT_COLOR: {
+			case Mesh::ARRAY_COLOR: {
 
 				PoolVector<Color> array;
 				array.resize(varr_len);
@@ -339,7 +331,7 @@ Ref<ArrayMesh> SurfaceTool::commit(const Ref<ArrayMesh> &p_existing) {
 				w = PoolVector<Color>::Write();
 				a[i] = array;
 			} break;
-			case Mesh::ARRAY_FORMAT_BONES: {
+			case Mesh::ARRAY_BONES: {
 
 				PoolVector<int> array;
 				array.resize(varr_len * 4);
@@ -361,7 +353,7 @@ Ref<ArrayMesh> SurfaceTool::commit(const Ref<ArrayMesh> &p_existing) {
 				a[i] = array;
 
 			} break;
-			case Mesh::ARRAY_FORMAT_WEIGHTS: {
+			case Mesh::ARRAY_WEIGHTS: {
 
 				PoolVector<float> array;
 				array.resize(varr_len * 4);
@@ -383,7 +375,7 @@ Ref<ArrayMesh> SurfaceTool::commit(const Ref<ArrayMesh> &p_existing) {
 				a[i] = array;
 
 			} break;
-			case Mesh::ARRAY_FORMAT_INDEX: {
+			case Mesh::ARRAY_INDEX: {
 
 				ERR_CONTINUE(index_array.size() == 0);
 
@@ -398,6 +390,7 @@ Ref<ArrayMesh> SurfaceTool::commit(const Ref<ArrayMesh> &p_existing) {
 				}
 
 				w = PoolVector<int>::Write();
+
 				a[i] = array;
 			} break;
 
@@ -405,6 +398,26 @@ Ref<ArrayMesh> SurfaceTool::commit(const Ref<ArrayMesh> &p_existing) {
 		}
 	}
 
+	return a;
+}
+
+Ref<ArrayMesh> SurfaceTool::commit(const Ref<ArrayMesh> &p_existing) {
+
+	Ref<ArrayMesh> mesh;
+	if (p_existing.is_valid())
+		mesh = p_existing;
+	else
+		mesh.instance();
+
+	int varr_len = vertex_array.size();
+
+	if (varr_len == 0)
+		return mesh;
+
+	int surface = mesh->get_surface_count();
+
+	Array a = commit_to_arrays();
+
 	mesh->add_surface_from_arrays(primitive, a);
 	if (material.is_valid())
 		mesh->surface_set_material(surface, material);
@@ -459,12 +472,17 @@ void SurfaceTool::deindex() {
 		vertex_array.push_back(varr[E->get()]);
 	}
 	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) {
 
 	Array arr = p_existing->surface_get_arrays(p_surface);
 	ERR_FAIL_COND(arr.size() != VS::ARRAY_MAX);
+	_create_list_from_arrays(arr, r_vertex, r_index, lformat);
+}
+
+void SurfaceTool::_create_list_from_arrays(Array arr, List<Vertex> *r_vertex, List<int> *r_index, int &lformat) {
 
 	PoolVector<Vector3> varr = arr[VS::ARRAY_VERTEX];
 	PoolVector<Vector3> narr = arr[VS::ARRAY_NORMAL];
@@ -536,7 +554,7 @@ void SurfaceTool::_create_list(const Ref<Mesh> &p_existing, int p_surface, List<
 		if (lformat & VS::ARRAY_FORMAT_TANGENT) {
 			Plane p(tarr[i * 4 + 0], tarr[i * 4 + 1], tarr[i * 4 + 2], tarr[i * 4 + 3]);
 			v.tangent = p.normal;
-			v.binormal = p.normal.cross(last_normal).normalized() * p.d;
+			v.binormal = p.normal.cross(v.tangent).normalized() * p.d;
 		}
 		if (lformat & VS::ARRAY_FORMAT_COLOR)
 			v.color = carr[i];
@@ -580,6 +598,13 @@ void SurfaceTool::_create_list(const Ref<Mesh> &p_existing, int p_surface, List<
 	}
 }
 
+void SurfaceTool::create_from_triangle_arrays(const Array &p_arrays) {
+
+	clear();
+	primitive = Mesh::PRIMITIVE_TRIANGLES;
+	_create_list_from_arrays(p_arrays, &vertex_array, &index_array, format);
+}
+
 void SurfaceTool::create_from(const Ref<Mesh> &p_existing, int p_surface) {
 
 	clear();
@@ -711,8 +736,9 @@ void SurfaceTool::generate_tangents() {
 	ERR_FAIL_COND(!res);
 	format |= Mesh::ARRAY_FORMAT_TANGENT;
 
-	if (indexed)
+	if (indexed) {
 		index();
+	}
 }
 
 void SurfaceTool::generate_normals() {
@@ -784,7 +810,6 @@ void SurfaceTool::generate_normals() {
 			vertex_hash.clear();
 			if (E) {
 				smooth = smooth_groups[count];
-				print_line("SMOOTH AT " + itos(count) + ": " + itos(smooth));
 			}
 		}
 	}
diff --git a/scene/resources/surface_tool.h b/scene/resources/surface_tool.h
index 753c3626b8..d02e170b02 100644
--- a/scene/resources/surface_tool.h
+++ b/scene/resources/surface_tool.h
@@ -80,6 +80,7 @@ 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(const Ref<Mesh> &p_existing, int p_surface, List<Vertex> *r_vertex, List<int> *r_index, int &lformat);
 
 	//mikktspace callbacks
@@ -123,6 +124,8 @@ public:
 
 	List<Vertex> &get_vertex_array() { return vertex_array; }
 
+	void create_from_triangle_arrays(const Array &p_arrays);
+	Array commit_to_arrays();
 	void create_from(const Ref<Mesh> &p_existing, int p_surface);
 	void append_from(const Ref<Mesh> &p_existing, int p_surface, const Transform &p_xform);
 	Ref<ArrayMesh> commit(const Ref<ArrayMesh> &p_existing = Ref<ArrayMesh>());