8 files changed, 362 insertions, 13 deletions

diff --git a/scene/3d/particles.cpp b/scene/3d/particles.cpp
index 7b5eb8ebc3..2b3a62fcdc 100644
--- a/scene/3d/particles.cpp
+++ b/scene/3d/particles.cpp
@@ -1444,7 +1444,7 @@ void ParticlesMaterial::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "trail_color_modifier", PROPERTY_HINT_RESOURCE_TYPE, "GradientTexture"), "set_trail_color_modifier", "get_trail_color_modifier");
 	ADD_GROUP("Emission Shape", "emission_");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "emission_shape", PROPERTY_HINT_ENUM, "Point,Sphere,Box,Points,Directed Points"), "set_emission_shape", "get_emission_shape");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL, "emission_sphere_radius", PROPERTY_HINT_RANGE, "0.01,128,0.01"), "set_emission_sphere_radius", "get_emission_sphere_radius");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "emission_sphere_radius", PROPERTY_HINT_RANGE, "0.01,128,0.01,or_greater"), "set_emission_sphere_radius", "get_emission_sphere_radius");
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "emission_box_extents"), "set_emission_box_extents", "get_emission_box_extents");
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "emission_point_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_emission_point_texture", "get_emission_point_texture");
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "emission_normal_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_emission_normal_texture", "get_emission_normal_texture");
@@ -1483,7 +1483,7 @@ void ParticlesMaterial::_bind_methods() {
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "tangential_accel_random", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_param_randomness", "get_param_randomness", PARAM_TANGENTIAL_ACCEL);
 	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "tangential_accel_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_TANGENTIAL_ACCEL);
 	ADD_GROUP("Damping", "");
-	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "damping", PROPERTY_HINT_RANGE, "0,100,0.01"), "set_param", "get_param", PARAM_DAMPING);
+	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "damping", PROPERTY_HINT_RANGE, "0,100,0.01,or_greater"), "set_param", "get_param", PARAM_DAMPING);
 	ADD_PROPERTYI(PropertyInfo(Variant::REAL, "damping_random", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_param_randomness", "get_param_randomness", PARAM_DAMPING);
 	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "damping_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_DAMPING);
 	ADD_GROUP("Angle", "");
diff --git a/scene/3d/path.cpp b/scene/3d/path.cpp
index 154dcb4259..9acaa15641 100644
--- a/scene/3d/path.cpp
+++ b/scene/3d/path.cpp
@@ -329,3 +329,219 @@ PathFollow::PathFollow() {
 	cubic = true;
 	loop = true;
 }
+
+//////////////
+
+void OrientedPathFollow::_update_transform() {
+
+	if (!path)
+		return;
+
+	Ref<Curve3D> c = path->get_curve();
+	if (!c.is_valid())
+		return;
+
+	int count = c->get_point_count();
+	if (count < 2)
+		return;
+
+	if (delta_offset == 0) {
+		return;
+	}
+
+	float offset = get_offset();
+	float bl = c->get_baked_length();
+	float bi = c->get_bake_interval();
+	float o = offset;
+	float o_next = offset + bi;
+
+	if (has_loop()) {
+		o = Math::fposmod(o, bl);
+		o_next = Math::fposmod(o_next, bl);
+	} else if (o_next >= bl) {
+		o = bl - bi;
+		o_next = bl;
+	}
+
+	bool cubic = get_cubic_interpolation();
+	Vector3 pos = c->interpolate_baked(o, cubic);
+	Vector3 forward = c->interpolate_baked(o_next, cubic) - pos;
+
+	if (forward.length_squared() < CMP_EPSILON2)
+		forward = Vector3(0, 0, 1);
+	else
+		forward.normalize();
+
+	Vector3 up = c->interpolate_baked_up_vector(o, true);
+
+	if (o_next < o) {
+		Vector3 up1 = c->interpolate_baked_up_vector(o_next, true);
+		Vector3 axis = up.cross(up1);
+
+		if (axis.length_squared() < CMP_EPSILON2)
+			axis = forward;
+		else
+			axis.normalize();
+
+		up.rotate(axis, up.angle_to(up1) * 0.5f);
+	}
+
+	Transform t = get_transform();
+	Vector3 scale = t.basis.get_scale();
+
+	Vector3 sideways = up.cross(forward).normalized();
+	up = forward.cross(sideways).normalized();
+
+	t.basis.set(sideways, up, forward);
+	t.basis.scale_local(scale);
+
+	t.origin = pos + sideways * get_h_offset() + up * get_v_offset();
+
+	set_transform(t);
+}
+
+void OrientedPathFollow::_notification(int p_what) {
+
+	switch (p_what) {
+
+		case NOTIFICATION_ENTER_TREE: {
+
+			Node *parent = get_parent();
+			if (parent) {
+				path = Object::cast_to<Path>(parent);
+				if (path) {
+					_update_transform();
+				}
+			}
+
+		} break;
+		case NOTIFICATION_EXIT_TREE: {
+
+			path = NULL;
+		} break;
+	}
+}
+
+void OrientedPathFollow::set_cubic_interpolation(bool p_enable) {
+
+	cubic = p_enable;
+}
+
+bool OrientedPathFollow::get_cubic_interpolation() const {
+
+	return cubic;
+}
+
+void OrientedPathFollow::_validate_property(PropertyInfo &property) const {
+
+	if (property.name == "offset") {
+
+		float max = 10000;
+		if (path && path->get_curve().is_valid())
+			max = path->get_curve()->get_baked_length();
+
+		property.hint_string = "0," + rtos(max) + ",0.01";
+	}
+}
+
+void OrientedPathFollow::_bind_methods() {
+
+	ClassDB::bind_method(D_METHOD("set_offset", "offset"), &OrientedPathFollow::set_offset);
+	ClassDB::bind_method(D_METHOD("get_offset"), &OrientedPathFollow::get_offset);
+
+	ClassDB::bind_method(D_METHOD("set_h_offset", "h_offset"), &OrientedPathFollow::set_h_offset);
+	ClassDB::bind_method(D_METHOD("get_h_offset"), &OrientedPathFollow::get_h_offset);
+
+	ClassDB::bind_method(D_METHOD("set_v_offset", "v_offset"), &OrientedPathFollow::set_v_offset);
+	ClassDB::bind_method(D_METHOD("get_v_offset"), &OrientedPathFollow::get_v_offset);
+
+	ClassDB::bind_method(D_METHOD("set_unit_offset", "unit_offset"), &OrientedPathFollow::set_unit_offset);
+	ClassDB::bind_method(D_METHOD("get_unit_offset"), &OrientedPathFollow::get_unit_offset);
+
+	ClassDB::bind_method(D_METHOD("set_cubic_interpolation", "enable"), &OrientedPathFollow::set_cubic_interpolation);
+	ClassDB::bind_method(D_METHOD("get_cubic_interpolation"), &OrientedPathFollow::get_cubic_interpolation);
+
+	ClassDB::bind_method(D_METHOD("set_loop", "loop"), &OrientedPathFollow::set_loop);
+	ClassDB::bind_method(D_METHOD("has_loop"), &OrientedPathFollow::has_loop);
+
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "offset", PROPERTY_HINT_RANGE, "0,10000,0.01"), "set_offset", "get_offset");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "unit_offset", PROPERTY_HINT_RANGE, "0,1,0.0001", PROPERTY_USAGE_EDITOR), "set_unit_offset", "get_unit_offset");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "h_offset"), "set_h_offset", "get_h_offset");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "v_offset"), "set_v_offset", "get_v_offset");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "cubic_interp"), "set_cubic_interpolation", "get_cubic_interpolation");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "loop"), "set_loop", "has_loop");
+}
+
+void OrientedPathFollow::set_offset(float p_offset) {
+	delta_offset = p_offset - offset;
+	offset = p_offset;
+
+	if (path)
+		_update_transform();
+	_change_notify("offset");
+	_change_notify("unit_offset");
+}
+
+void OrientedPathFollow::set_h_offset(float p_h_offset) {
+
+	h_offset = p_h_offset;
+	if (path)
+		_update_transform();
+}
+
+float OrientedPathFollow::get_h_offset() const {
+
+	return h_offset;
+}
+
+void OrientedPathFollow::set_v_offset(float p_v_offset) {
+
+	v_offset = p_v_offset;
+	if (path)
+		_update_transform();
+}
+
+float OrientedPathFollow::get_v_offset() const {
+
+	return v_offset;
+}
+
+float OrientedPathFollow::get_offset() const {
+
+	return offset;
+}
+
+void OrientedPathFollow::set_unit_offset(float p_unit_offset) {
+
+	if (path && path->get_curve().is_valid() && path->get_curve()->get_baked_length())
+		set_offset(p_unit_offset * path->get_curve()->get_baked_length());
+}
+
+float OrientedPathFollow::get_unit_offset() const {
+
+	if (path && path->get_curve().is_valid() && path->get_curve()->get_baked_length())
+		return get_offset() / path->get_curve()->get_baked_length();
+	else
+		return 0;
+}
+
+void OrientedPathFollow::set_loop(bool p_loop) {
+
+	loop = p_loop;
+}
+
+bool OrientedPathFollow::has_loop() const {
+
+	return loop;
+}
+
+OrientedPathFollow::OrientedPathFollow() {
+
+	offset = 0;
+	delta_offset = 0;
+	h_offset = 0;
+	v_offset = 0;
+	path = NULL;
+	cubic = true;
+	loop = true;
+}
diff --git a/scene/3d/path.h b/scene/3d/path.h
index 2ed686ac3c..f73bf17dfe 100644
--- a/scene/3d/path.h
+++ b/scene/3d/path.h
@@ -111,4 +111,47 @@ public:
 
 VARIANT_ENUM_CAST(PathFollow::RotationMode);
 
+class OrientedPathFollow : public Spatial {
+
+	GDCLASS(OrientedPathFollow, Spatial);
+
+private:
+	Path *path;
+	real_t delta_offset; // change in offset since last _update_transform
+	real_t offset;
+	real_t h_offset;
+	real_t v_offset;
+	bool cubic;
+	bool loop;
+
+	void _update_transform();
+
+protected:
+	virtual void _validate_property(PropertyInfo &property) const;
+
+	void _notification(int p_what);
+	static void _bind_methods();
+
+public:
+	void set_offset(float p_offset);
+	float get_offset() const;
+
+	void set_h_offset(float p_h_offset);
+	float get_h_offset() const;
+
+	void set_v_offset(float p_v_offset);
+	float get_v_offset() const;
+
+	void set_unit_offset(float p_unit_offset);
+	float get_unit_offset() const;
+
+	void set_loop(bool p_loop);
+	bool has_loop() const;
+
+	void set_cubic_interpolation(bool p_enable);
+	bool get_cubic_interpolation() const;
+
+	OrientedPathFollow();
+};
+
 #endif // PATH_H
diff --git a/scene/3d/reflection_probe.cpp b/scene/3d/reflection_probe.cpp
index 7e3a87cbd4..4d50945062 100644
--- a/scene/3d/reflection_probe.cpp
+++ b/scene/3d/reflection_probe.cpp
@@ -241,8 +241,8 @@ void ReflectionProbe::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "update_mode", PROPERTY_HINT_ENUM, "Once,Always"), "set_update_mode", "get_update_mode");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "intensity", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_intensity", "get_intensity");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "max_distance", PROPERTY_HINT_EXP_RANGE, "0,16384,0.1,or_greater"), "set_max_distance", "get_max_distance");
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "extents"), "set_extents", "get_extents");
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "origin_offset"), "set_origin_offset", "get_origin_offset");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "extents"), "set_extents", "get_extents");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "origin_offset"), "set_origin_offset", "get_origin_offset");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "box_projection"), "set_enable_box_projection", "is_box_projection_enabled");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "enable_shadows"), "set_enable_shadows", "are_shadows_enabled");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "cull_mask", PROPERTY_HINT_LAYERS_3D_RENDER), "set_cull_mask", "get_cull_mask");
diff --git a/scene/3d/scenario_fx.cpp b/scene/3d/scenario_fx.cpp
index d5bff676cb..26cbfc0b11 100644
--- a/scene/3d/scenario_fx.cpp
+++ b/scene/3d/scenario_fx.cpp
@@ -93,9 +93,10 @@ String WorldEnvironment::get_configuration_warning() const {
 		return TTR("Only one WorldEnvironment is allowed per scene (or set of instanced scenes).");
 	}
 
-	if (environment.is_valid() && get_viewport() && !get_viewport()->get_camera() && environment->get_background() != Environment::BG_CANVAS) {
-		return TTR("This WorldEnvironment is ignored. Either add a Camera (for 3D scenes) or set this environment's Background Mode to Canvas (for 2D scenes).");
-	}
+	// Commenting this warning for now, I think it makes no sense. If anyone can figure out what its supposed to do, feedback welcome. Else it should be deprecated.
+	//if (environment.is_valid() && get_viewport() && !get_viewport()->get_camera() && environment->get_background() != Environment::BG_CANVAS) {
+	//	return TTR("This WorldEnvironment is ignored. Either add a Camera (for 3D scenes) or set this environment's Background Mode to Canvas (for 2D scenes).");
+	//}
 
 	return String();
 }
diff --git a/scene/3d/sprite_3d.cpp b/scene/3d/sprite_3d.cpp
index 232855c978..036a748c83 100644
--- a/scene/3d/sprite_3d.cpp
+++ b/scene/3d/sprite_3d.cpp
@@ -185,6 +185,9 @@ void SpriteBase3D::_queue_update() {
 	if (pending_update)
 		return;
 
+	triangle_mesh.unref();
+	update_gizmo();
+
 	pending_update = true;
 	call_deferred(SceneStringNames::get_singleton()->_im_update);
 }
@@ -198,6 +201,66 @@ PoolVector<Face3> SpriteBase3D::get_faces(uint32_t p_usage_flags) const {
 	return PoolVector<Face3>();
 }
 
+Ref<TriangleMesh> SpriteBase3D::generate_triangle_mesh() const {
+	if (triangle_mesh.is_valid())
+		return triangle_mesh;
+
+	PoolVector<Vector3> faces;
+	faces.resize(6);
+	PoolVector<Vector3>::Write facesw = faces.write();
+
+	Rect2 final_rect = get_item_rect();
+
+	if (final_rect.size.x == 0 || final_rect.size.y == 0)
+		return Ref<TriangleMesh>();
+
+	float pixel_size = get_pixel_size();
+
+	Vector2 vertices[4] = {
+
+		(final_rect.position + Vector2(0, final_rect.size.y)) * pixel_size,
+		(final_rect.position + final_rect.size) * pixel_size,
+		(final_rect.position + Vector2(final_rect.size.x, 0)) * pixel_size,
+		final_rect.position * pixel_size,
+
+	};
+
+	int x_axis = ((axis + 1) % 3);
+	int y_axis = ((axis + 2) % 3);
+
+	if (axis != Vector3::AXIS_Z) {
+		SWAP(x_axis, y_axis);
+
+		for (int i = 0; i < 4; i++) {
+			if (axis == Vector3::AXIS_Y) {
+				vertices[i].y = -vertices[i].y;
+			} else if (axis == Vector3::AXIS_X) {
+				vertices[i].x = -vertices[i].x;
+			}
+		}
+	}
+
+	static const int indices[6] = {
+		0, 1, 2,
+		0, 2, 3
+	};
+
+	for (int j = 0; j < 6; j++) {
+		int i = indices[j];
+		Vector3 vtx;
+		vtx[x_axis] = vertices[i][0];
+		vtx[y_axis] = vertices[i][1];
+		facesw[j] = vtx;
+	}
+
+	facesw = PoolVector<Vector3>::Write();
+
+	triangle_mesh = Ref<TriangleMesh>(memnew(TriangleMesh));
+	triangle_mesh->create(faces);
+
+	return triangle_mesh;
+}
+
 void SpriteBase3D::set_draw_flag(DrawFlags p_flag, bool p_enable) {
 
 	ERR_FAIL_INDEX(p_flag, FLAG_MAX);
@@ -255,6 +318,7 @@ void SpriteBase3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_alpha_cut_mode"), &SpriteBase3D::get_alpha_cut_mode);
 
 	ClassDB::bind_method(D_METHOD("get_item_rect"), &SpriteBase3D::get_item_rect);
+	ClassDB::bind_method(D_METHOD("generate_triangle_mesh"), &SpriteBase3D::generate_triangle_mesh);
 
 	ClassDB::bind_method(D_METHOD("_queue_update"), &SpriteBase3D::_queue_update);
 	ClassDB::bind_method(D_METHOD("_im_update"), &SpriteBase3D::_im_update);
@@ -366,6 +430,16 @@ void Sprite3D::_draw() {
 		final_rect.position * pixel_size,
 
 	};
+
+	Vector2 src_tsize = Vector2(texture->get_width(), texture->get_height());
+
+	// Properly setup UVs for impostor textures (AtlasTexture).
+	Ref<AtlasTexture> atlas_tex = texture;
+	if (atlas_tex != NULL) {
+		src_tsize[0] = atlas_tex->get_atlas()->get_width();
+		src_tsize[1] = atlas_tex->get_atlas()->get_height();
+	}
+
 	Vector2 uvs[4] = {
 		final_src_rect.position / tsize,
 		(final_src_rect.position + Vector2(final_src_rect.size.x, 0)) / tsize,
@@ -656,6 +730,16 @@ void AnimatedSprite3D::_draw() {
 		final_rect.position * pixel_size,
 
 	};
+
+	Vector2 src_tsize = Vector2(texture->get_width(), texture->get_height());
+
+	// Properly setup UVs for impostor textures (AtlasTexture).
+	Ref<AtlasTexture> atlas_tex = texture;
+	if (atlas_tex != NULL) {
+		src_tsize[0] = atlas_tex->get_atlas()->get_width();
+		src_tsize[1] = atlas_tex->get_atlas()->get_height();
+	}
+
 	Vector2 uvs[4] = {
 		final_src_rect.position / tsize,
 		(final_src_rect.position + Vector2(final_src_rect.size.x, 0)) / tsize,
@@ -881,7 +965,7 @@ Rect2 AnimatedSprite3D::get_item_rect() const {
 		return Rect2(0, 0, 1, 1);
 	Size2i s = t->get_size();
 
-	Point2 ofs = offset;
+	Point2 ofs = get_offset();
 	if (centered)
 		ofs -= s / 2;
 
diff --git a/scene/3d/sprite_3d.h b/scene/3d/sprite_3d.h
index 23e1d96b4b..a4705a8970 100644
--- a/scene/3d/sprite_3d.h
+++ b/scene/3d/sprite_3d.h
@@ -38,6 +38,8 @@ class SpriteBase3D : public GeometryInstance {
 
 	GDCLASS(SpriteBase3D, GeometryInstance);
 
+	mutable Ref<TriangleMesh> triangle_mesh; //cached
+
 public:
 	enum DrawFlags {
 		FLAG_TRANSPARENT,
@@ -133,6 +135,7 @@ public:
 
 	virtual AABB get_aabb() const;
 	virtual PoolVector<Face3> get_faces(uint32_t p_usage_flags) const;
+	Ref<TriangleMesh> generate_triangle_mesh() const;
 
 	SpriteBase3D();
 	~SpriteBase3D();
@@ -192,7 +195,6 @@ class AnimatedSprite3D : public SpriteBase3D {
 	int frame;
 
 	bool centered;
-	Point2 offset;
 
 	float timeout;
 
diff --git a/scene/3d/vehicle_body.cpp b/scene/3d/vehicle_body.cpp
index ee8d249981..385956dc16 100644
--- a/scene/3d/vehicle_body.cpp
+++ b/scene/3d/vehicle_body.cpp
@@ -583,11 +583,14 @@ void VehicleBody::_resolve_single_bilateral(PhysicsDirectBodyState *s, const Vec
 	rel_vel = normal.dot(vel);
 
 	// !BAS! We had this set to 0.4, in bullet its 0.2
-	// real_t contactDamping = real_t(0.2);
+	real_t contactDamping = real_t(0.2);
+
+	if (p_rollInfluence > 0.0) {
+		// !BAS! But seeing we apply this frame by frame, makes more sense to me to make this time based
+		// keeping in mind our anti roll factor if it is set
+		contactDamping = s->get_step() / p_rollInfluence;
+	}
 
-	// !BAS! But seeing we apply this frame by frame, makes more sense to me to make this time based
-	// keeping in mind our anti roll factor
-	real_t contactDamping = s->get_step() / p_rollInfluence;
 #define ONLY_USE_LINEAR_MASS
 #ifdef ONLY_USE_LINEAR_MASS
 	real_t massTerm = real_t(1.) / ((1.0 / mass) + b2invmass);