Support for 2D particles to collide against SDF

-Added SDF collision support for 2D particles
-Changed the SDF generation to be fully signed

doc/classes/GPUParticles2D.xml

@@ -31,7 +31,9 @@
 		<member name="amount" type="int" setter="set_amount" getter="get_amount" default="8">
 			Number of particles emitted in one emission cycle.
 		</member>
-		<member name="draw_order" type="int" setter="set_draw_order" getter="get_draw_order" enum="GPUParticles2D.DrawOrder" default="0">
+		<member name="collision_base_size" type="float" setter="set_collision_base_size" getter="get_collision_base_size" default="1.0">
+		</member>
+		<member name="draw_order" type="int" setter="set_draw_order" getter="get_draw_order" enum="GPUParticles2D.DrawOrder" default="1">
 			Particle draw order. Uses [enum DrawOrder] values.
 		</member>
 		<member name="emitting" type="bool" setter="set_emitting" getter="is_emitting" default="true">
@@ -40,7 +42,7 @@
 		<member name="explosiveness" type="float" setter="set_explosiveness_ratio" getter="get_explosiveness_ratio" default="0.0">
 			How rapidly particles in an emission cycle are emitted. If greater than [code]0[/code], there will be a gap in emissions before the next cycle begins.
 		</member>
-		<member name="fixed_fps" type="int" setter="set_fixed_fps" getter="get_fixed_fps" default="0">
+		<member name="fixed_fps" type="int" setter="set_fixed_fps" getter="get_fixed_fps" default="30">
 			The particle system's frame rate is fixed to a value. For instance, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the simulation of the particle system itself.
 		</member>
 		<member name="fract_delta" type="bool" setter="set_fractional_delta" getter="get_fractional_delta" default="true">
@@ -70,6 +72,14 @@
 		<member name="texture" type="Texture2D" setter="set_texture" getter="get_texture">
 			Particle texture. If [code]null[/code], particles will be squares.
 		</member>
+		<member name="trail_enabled" type="bool" setter="set_trail_enabled" getter="is_trail_enabled" default="false">
+		</member>
+		<member name="trail_length_secs" type="float" setter="set_trail_length" getter="get_trail_length" default="0.3">
+		</member>
+		<member name="trail_section_subdivisions" type="int" setter="set_trail_section_subdivisions" getter="get_trail_section_subdivisions" default="4">
+		</member>
+		<member name="trail_sections" type="int" setter="set_trail_sections" getter="get_trail_sections" default="8">
+		</member>
 		<member name="visibility_rect" type="Rect2" setter="set_visibility_rect" getter="get_visibility_rect" default="Rect2( -100, -100, 200, 200 )">
 			The [Rect2] that determines the node's region which needs to be visible on screen for the particle system to be active.
 			Grow the rect if particles suddenly appear/disappear when the node enters/exits the screen. The [Rect2] can be grown via code or with the [b]Particles → Generate Visibility Rect[/b] editor tool.
@@ -82,5 +92,7 @@
 		<constant name="DRAW_ORDER_LIFETIME" value="1" enum="DrawOrder">
 			Particles are drawn in order of remaining lifetime.
 		</constant>
+		<constant name="DRAW_ORDER_REVERSE_LIFETIME" value="2" enum="DrawOrder">
+		</constant>
 	</constants>
 </class>

doc/classes/GPUParticles3D.xml

@@ -126,7 +126,7 @@
 		</member>
 		<member name="sub_emitter" type="NodePath" setter="set_sub_emitter" getter="get_sub_emitter" default="NodePath(&quot;&quot;)">
 		</member>
-		<member name="trail_enabled" type="bool" setter="set_enable_trail" getter="is_trail_enabled" default="false">
+		<member name="trail_enabled" type="bool" setter="set_trail_enabled" getter="is_trail_enabled" default="false">
 		</member>
 		<member name="trail_length_secs" type="float" setter="set_trail_length" getter="get_trail_length" default="0.3">
 		</member>
@@ -144,7 +144,9 @@
 		<constant name="DRAW_ORDER_LIFETIME" value="1" enum="DrawOrder">
 			Particles are drawn in order of remaining lifetime.
 		</constant>
-		<constant name="DRAW_ORDER_VIEW_DEPTH" value="2" enum="DrawOrder">
+		<constant name="DRAW_ORDER_REVERSE_LIFETIME" value="2" enum="DrawOrder">
+		</constant>
+		<constant name="DRAW_ORDER_VIEW_DEPTH" value="3" enum="DrawOrder">
 			Particles are drawn in order of depth.
 		</constant>
 		<constant name="EMIT_FLAG_POSITION" value="1" enum="EmitFlags">

doc/classes/ParticlesMaterial.xml

@@ -135,7 +135,7 @@
 		</member>
 		<member name="collision_bounce" type="float" setter="set_collision_bounce" getter="get_collision_bounce" default="0.0">
 		</member>
-		<member name="collision_enabled" type="bool" setter="set_collision_enabled" getter="is_collision_enabled" default="true">
+		<member name="collision_enabled" type="bool" setter="set_collision_enabled" getter="is_collision_enabled" default="false">
 		</member>
 		<member name="collision_friction" type="float" setter="set_collision_friction" getter="get_collision_friction" default="0.0">
 		</member>

doc/classes/RenderingServer.xml

@@ -3388,7 +3388,7 @@
 		<constant name="PARTICLES_DRAW_ORDER_LIFETIME" value="1" enum="ParticlesDrawOrder">
 			Sort particles based on their lifetime.
 		</constant>
-		<constant name="PARTICLES_DRAW_ORDER_VIEW_DEPTH" value="2" enum="ParticlesDrawOrder">
+		<constant name="PARTICLES_DRAW_ORDER_VIEW_DEPTH" value="3" enum="ParticlesDrawOrder">
 			Sort particles based on their distance to the camera.
 		</constant>
 		<constant name="VIEWPORT_UPDATE_DISABLED" value="0" enum="ViewportUpdateMode">

scene/2d/gpu_particles_2d.cpp

@@ -140,6 +140,62 @@ void GPUParticles2D::set_process_material(const Ref<Material> &p_material) {
 	update_configuration_warnings();
 }
 
+void GPUParticles2D::set_trail_enabled(bool p_enabled) {
+	trail_enabled = p_enabled;
+	RS::get_singleton()->particles_set_trails(particles, trail_enabled, trail_length);
+	update_configuration_warnings();
+	update();
+
+	RS::get_singleton()->particles_set_transform_align(particles, p_enabled ? RS::PARTICLES_TRANSFORM_ALIGN_Y_TO_VELOCITY : RS::PARTICLES_TRANSFORM_ALIGN_DISABLED);
+}
+void GPUParticles2D::set_trail_length(float p_seconds) {
+	ERR_FAIL_COND(p_seconds < 0.001);
+	trail_length = p_seconds;
+	RS::get_singleton()->particles_set_trails(particles, trail_enabled, trail_length);
+	update();
+}
+
+void GPUParticles2D::set_trail_sections(int p_sections) {
+	ERR_FAIL_COND(p_sections < 2);
+	ERR_FAIL_COND(p_sections > 128);
+
+	trail_sections = p_sections;
+	update();
+}
+void GPUParticles2D::set_trail_section_subdivisions(int p_subdivisions) {
+	ERR_FAIL_COND(trail_section_subdivisions < 1);
+	ERR_FAIL_COND(trail_section_subdivisions > 1024);
+
+	trail_section_subdivisions = p_subdivisions;
+	update();
+}
+
+bool GPUParticles2D::is_trail_enabled() const {
+	return trail_enabled;
+}
+float GPUParticles2D::get_trail_length() const {
+	return trail_length;
+}
+
+void GPUParticles2D::_update_collision_size() {
+	float csize = collision_base_size;
+
+	if (texture.is_valid()) {
+		csize *= (texture->get_width() + texture->get_height()) / 4.0; //half size since its a radius
+	}
+
+	RS::get_singleton()->particles_set_collision_base_size(particles, csize);
+}
+
+void GPUParticles2D::set_collision_base_size(float p_size) {
+	collision_base_size = p_size;
+	_update_collision_size();
+}
+
+float GPUParticles2D::get_collision_base_size() const {
+	return collision_base_size;
+}
+
 void GPUParticles2D::set_speed_scale(float p_scale) {
 	speed_scale = p_scale;
 	RS::get_singleton()->particles_set_speed_scale(particles, p_scale);
@@ -157,6 +213,13 @@ float GPUParticles2D::get_lifetime() const {
 	return lifetime;
 }
 
+int GPUParticles2D::get_trail_sections() const {
+	return trail_sections;
+}
+int GPUParticles2D::get_trail_section_subdivisions() const {
+	return trail_section_subdivisions;
+}
+
 bool GPUParticles2D::get_one_shot() const {
 	return one_shot;
 }
@@ -253,6 +316,7 @@ Rect2 GPUParticles2D::capture_rect() const {
 
 void GPUParticles2D::set_texture(const Ref<Texture2D> &p_texture) {
 	texture = p_texture;
+	_update_collision_size();
 	update();
 }
 
@@ -271,10 +335,119 @@ void GPUParticles2D::restart() {
 void GPUParticles2D::_notification(int p_what) {
 	if (p_what == NOTIFICATION_DRAW) {
 		RID texture_rid;
+		Size2 size;
 		if (texture.is_valid()) {
 			texture_rid = texture->get_rid();
+			size = texture->get_size();
+		} else {
+			size = Size2(1, 1);
 		}
 
+		if (trail_enabled) {
+			RS::get_singleton()->mesh_clear(mesh);
+			PackedVector2Array points;
+			PackedVector2Array uvs;
+			PackedInt32Array bone_indices;
+			PackedFloat32Array bone_weights;
+			PackedInt32Array indices;
+
+			int total_segments = trail_sections * trail_section_subdivisions;
+			float depth = size.height * trail_sections;
+
+			for (int j = 0; j <= total_segments; j++) {
+				float v = j;
+				v /= total_segments;
+
+				float y = depth * v;
+				y = (depth * 0.5) - y;
+
+				int bone = j / trail_section_subdivisions;
+				float blend = 1.0 - float(j % trail_section_subdivisions) / float(trail_section_subdivisions);
+
+				float s = size.width;
+
+				points.push_back(Vector2(-s * 0.5, 0));
+				points.push_back(Vector2(+s * 0.5, 0));
+
+				uvs.push_back(Vector2(0, v));
+				uvs.push_back(Vector2(1, v));
+
+				for (int i = 0; i < 2; i++) {
+					bone_indices.push_back(bone);
+					bone_indices.push_back(MIN(trail_sections, bone + 1));
+					bone_indices.push_back(0);
+					bone_indices.push_back(0);
+
+					bone_weights.push_back(blend);
+					bone_weights.push_back(1.0 - blend);
+					bone_weights.push_back(0);
+					bone_weights.push_back(0);
+				}
+
+				if (j > 0) {
+					int base = j * 2 - 2;
+					indices.push_back(base + 0);
+					indices.push_back(base + 1);
+					indices.push_back(base + 2);
+
+					indices.push_back(base + 1);
+					indices.push_back(base + 3);
+					indices.push_back(base + 2);
+				}
+			}
+
+			Array arr;
+			arr.resize(RS::ARRAY_MAX);
+			arr[RS::ARRAY_VERTEX] = points;
+			arr[RS::ARRAY_TEX_UV] = uvs;
+			arr[RS::ARRAY_BONES] = bone_indices;
+			arr[RS::ARRAY_WEIGHTS] = bone_weights;
+			arr[RS::ARRAY_INDEX] = indices;
+
+			RS::get_singleton()->mesh_add_surface_from_arrays(mesh, RS::PRIMITIVE_TRIANGLES, arr, Array(), Dictionary(), RS::ARRAY_FLAG_USE_2D_VERTICES);
+
+			Vector<Transform> xforms;
+			for (int i = 0; i <= trail_sections; i++) {
+				Transform xform;
+				/*
+				xform.origin.y = depth / 2.0 - size.height * float(i);
+				xform.origin.y = -xform.origin.y; //bind is an inverse transform, so negate y */
+				xforms.push_back(xform);
+			}
+
+			RS::get_singleton()->particles_set_trail_bind_poses(particles, xforms);
+
+		} else {
+			RS::get_singleton()->mesh_clear(mesh);
+			Vector<Vector2> points;
+			points.resize(4);
+			points.write[0] = Vector2(-size.x / 2.0, -size.y / 2.0);
+			points.write[1] = Vector2(size.x / 2.0, -size.y / 2.0);
+			points.write[2] = Vector2(size.x / 2.0, size.y / 2.0);
+			points.write[3] = Vector2(-size.x / 2.0, size.y / 2.0);
+			Vector<Vector2> uvs;
+			uvs.resize(4);
+			uvs.write[0] = Vector2(0, 0);
+			uvs.write[1] = Vector2(1, 0);
+			uvs.write[2] = Vector2(1, 1);
+			uvs.write[3] = Vector2(0, 1);
+			Vector<int> indices;
+			indices.resize(6);
+			indices.write[0] = 0;
+			indices.write[1] = 1;
+			indices.write[2] = 2;
+			indices.write[3] = 0;
+			indices.write[4] = 2;
+			indices.write[5] = 3;
+			Array arr;
+			arr.resize(RS::ARRAY_MAX);
+			arr[RS::ARRAY_VERTEX] = points;
+			arr[RS::ARRAY_TEX_UV] = uvs;
+			arr[RS::ARRAY_INDEX] = indices;
+
+			RS::get_singleton()->mesh_add_surface_from_arrays(mesh, RS::PRIMITIVE_TRIANGLES, arr, Array(), Dictionary(), RS::ARRAY_FLAG_USE_2D_VERTICES);
+			RS::get_singleton()->particles_set_trail_bind_poses(particles, Vector<Transform>());
+		}
 		RS::get_singleton()->canvas_item_add_particles(get_canvas_item(), particles, texture_rid);
 
 #ifdef TOOLS_ENABLED
@@ -318,6 +491,7 @@ void GPUParticles2D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_fractional_delta", "enable"), &GPUParticles2D::set_fractional_delta);
 	ClassDB::bind_method(D_METHOD("set_process_material", "material"), &GPUParticles2D::set_process_material);
 	ClassDB::bind_method(D_METHOD("set_speed_scale", "scale"), &GPUParticles2D::set_speed_scale);
+	ClassDB::bind_method(D_METHOD("set_collision_base_size", "size"), &GPUParticles2D::set_collision_base_size);
 
 	ClassDB::bind_method(D_METHOD("is_emitting"), &GPUParticles2D::is_emitting);
 	ClassDB::bind_method(D_METHOD("get_amount"), &GPUParticles2D::get_amount);
@@ -332,6 +506,7 @@ void GPUParticles2D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_fractional_delta"), &GPUParticles2D::get_fractional_delta);
 	ClassDB::bind_method(D_METHOD("get_process_material"), &GPUParticles2D::get_process_material);
 	ClassDB::bind_method(D_METHOD("get_speed_scale"), &GPUParticles2D::get_speed_scale);
+	ClassDB::bind_method(D_METHOD("get_collision_base_size"), &GPUParticles2D::get_collision_base_size);
 
 	ClassDB::bind_method(D_METHOD("set_draw_order", "order"), &GPUParticles2D::set_draw_order);
 	ClassDB::bind_method(D_METHOD("get_draw_order"), &GPUParticles2D::get_draw_order);
@@ -343,6 +518,18 @@ void GPUParticles2D::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("restart"), &GPUParticles2D::restart);
 
+	ClassDB::bind_method(D_METHOD("set_trail_enabled", "enabled"), &GPUParticles2D::set_trail_enabled);
+	ClassDB::bind_method(D_METHOD("set_trail_length", "secs"), &GPUParticles2D::set_trail_length);
+
+	ClassDB::bind_method(D_METHOD("is_trail_enabled"), &GPUParticles2D::is_trail_enabled);
+	ClassDB::bind_method(D_METHOD("get_trail_length"), &GPUParticles2D::get_trail_length);
+
+	ClassDB::bind_method(D_METHOD("set_trail_sections", "sections"), &GPUParticles2D::set_trail_sections);
+	ClassDB::bind_method(D_METHOD("get_trail_sections"), &GPUParticles2D::get_trail_sections);
+
+	ClassDB::bind_method(D_METHOD("set_trail_section_subdivisions", "subdivisions"), &GPUParticles2D::set_trail_section_subdivisions);
+	ClassDB::bind_method(D_METHOD("get_trail_section_subdivisions"), &GPUParticles2D::get_trail_section_subdivisions);
+
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "emitting"), "set_emitting", "is_emitting");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "amount", PROPERTY_HINT_EXP_RANGE, "1,1000000,1"), "set_amount", "get_amount");
 	ADD_GROUP("Time", "");
@@ -354,10 +541,17 @@ void GPUParticles2D::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "randomness", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_randomness_ratio", "get_randomness_ratio");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "fixed_fps", PROPERTY_HINT_RANGE, "0,1000,1"), "set_fixed_fps", "get_fixed_fps");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "fract_delta"), "set_fractional_delta", "get_fractional_delta");
+	ADD_GROUP("Collision", "collision_");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "collision_base_size", PROPERTY_HINT_RANGE, "0,128,0.01,or_greater"), "set_collision_base_size", "get_collision_base_size");
 	ADD_GROUP("Drawing", "");
 	ADD_PROPERTY(PropertyInfo(Variant::RECT2, "visibility_rect"), "set_visibility_rect", "get_visibility_rect");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "local_coords"), "set_use_local_coordinates", "get_use_local_coordinates");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "draw_order", PROPERTY_HINT_ENUM, "Index,Lifetime"), "set_draw_order", "get_draw_order");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "draw_order", PROPERTY_HINT_ENUM, "Index,Lifetime,Reverse Lifetime"), "set_draw_order", "get_draw_order");
+	ADD_GROUP("Trails", "trail_");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "trail_enabled"), "set_trail_enabled", "is_trail_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "trail_length_secs", PROPERTY_HINT_RANGE, "0.01,10,0.01"), "set_trail_length", "get_trail_length");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "trail_sections", PROPERTY_HINT_RANGE, "2,128,1"), "set_trail_sections", "get_trail_sections");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "trail_section_subdivisions", PROPERTY_HINT_RANGE, "1,1024,1"), "set_trail_section_subdivisions", "get_trail_section_subdivisions");
 	ADD_GROUP("Process Material", "process_");
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "process_material", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial,ParticlesMaterial"), "set_process_material", "get_process_material");
 	ADD_GROUP("Textures", "");
@@ -365,12 +559,17 @@ void GPUParticles2D::_bind_methods() {
 
 	BIND_ENUM_CONSTANT(DRAW_ORDER_INDEX);
 	BIND_ENUM_CONSTANT(DRAW_ORDER_LIFETIME);
+	BIND_ENUM_CONSTANT(DRAW_ORDER_REVERSE_LIFETIME);
 }
 
 GPUParticles2D::GPUParticles2D() {
 	particles = RS::get_singleton()->particles_create();
 	RS::get_singleton()->particles_set_mode(particles, RS::PARTICLES_MODE_2D);
 
+	mesh = RS::get_singleton()->mesh_create();
+	RS::get_singleton()->particles_set_draw_passes(particles, 1);
+	RS::get_singleton()->particles_set_draw_pass_mesh(particles, 0, mesh);
+
 	one_shot = false; // Needed so that set_emitting doesn't access uninitialized values
 	set_emitting(true);
 	set_one_shot(false);
@@ -383,10 +582,13 @@ GPUParticles2D::GPUParticles2D() {
 	set_randomness_ratio(0);
 	set_visibility_rect(Rect2(Vector2(-100, -100), Vector2(200, 200)));
 	set_use_local_coordinates(true);
-	set_draw_order(DRAW_ORDER_INDEX);
+	set_draw_order(DRAW_ORDER_LIFETIME);
 	set_speed_scale(1);
+	set_fixed_fps(30);
+	set_collision_base_size(collision_base_size);
 }
 
 GPUParticles2D::~GPUParticles2D() {
 	RS::get_singleton()->free(particles);
+	RS::get_singleton()->free(mesh);
 }

scene/2d/gpu_particles_2d.h

@@ -43,6 +43,7 @@ public:
 	enum DrawOrder {
 		DRAW_ORDER_INDEX,
 		DRAW_ORDER_LIFETIME,
+		DRAW_ORDER_REVERSE_LIFETIME,
 	};
 
 private:
@@ -68,11 +69,23 @@ private:
 
 	void _update_particle_emission_transform();
 
+	NodePath sub_emitter;
+	float collision_base_size = 1.0;
+
+	bool trail_enabled = false;
+	float trail_length = 0.3;
+	int trail_sections = 8;
+	int trail_section_subdivisions = 4;
+
+	RID mesh;
+
 protected:
 	static void _bind_methods();
 	virtual void _validate_property(PropertyInfo &property) const override;
 	void _notification(int p_what);
 
+	void _update_collision_size();
+
 public:
 	void set_emitting(bool p_emitting);
 	void set_amount(int p_amount);
@@ -85,6 +98,11 @@ public:
 	void set_use_local_coordinates(bool p_enable);
 	void set_process_material(const Ref<Material> &p_material);
 	void set_speed_scale(float p_scale);
+	void set_collision_base_size(float p_ratio);
+	void set_trail_enabled(bool p_enabled);
+	void set_trail_length(float p_seconds);
+	void set_trail_sections(int p_sections);
+	void set_trail_section_subdivisions(int p_subdivisions);
 
 	bool is_emitting() const;
 	int get_amount() const;
@@ -98,6 +116,12 @@ public:
 	Ref<Material> get_process_material() const;
 	float get_speed_scale() const;
 
+	float get_collision_base_size() const;
+	bool is_trail_enabled() const;
+	float get_trail_length() const;
+	int get_trail_sections() const;
+	int get_trail_section_subdivisions() const;
+
 	void set_fixed_fps(int p_count);
 	int get_fixed_fps() const;
 

scene/3d/gpu_particles_3d.cpp

@@ -181,7 +181,7 @@ void GPUParticles3D::set_draw_order(DrawOrder p_order) {
 	RS::get_singleton()->particles_set_draw_order(particles, RS::ParticlesDrawOrder(p_order));
 }
 
-void GPUParticles3D::set_enable_trail(bool p_enabled) {
+void GPUParticles3D::set_trail_enabled(bool p_enabled) {
 	trail_enabled = p_enabled;
 	RS::get_singleton()->particles_set_trails(particles, trail_enabled, trail_length);
 	update_configuration_warnings();
@@ -552,7 +552,7 @@ void GPUParticles3D::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("emit_particle", "xform", "velocity", "color", "custom", "flags"), &GPUParticles3D::emit_particle);
 
-	ClassDB::bind_method(D_METHOD("set_enable_trail", "enabled"), &GPUParticles3D::set_enable_trail);
+	ClassDB::bind_method(D_METHOD("set_trail_enabled", "enabled"), &GPUParticles3D::set_trail_enabled);
 	ClassDB::bind_method(D_METHOD("set_trail_length", "secs"), &GPUParticles3D::set_trail_length);
 
 	ClassDB::bind_method(D_METHOD("is_trail_enabled"), &GPUParticles3D::is_trail_enabled);
@@ -579,11 +579,11 @@ void GPUParticles3D::_bind_methods() {
 	ADD_GROUP("Drawing", "");
 	ADD_PROPERTY(PropertyInfo(Variant::AABB, "visibility_aabb"), "set_visibility_aabb", "get_visibility_aabb");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "local_coords"), "set_use_local_coordinates", "get_use_local_coordinates");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "draw_order", PROPERTY_HINT_ENUM, "Index,Lifetime,View Depth"), "set_draw_order", "get_draw_order");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "draw_order", PROPERTY_HINT_ENUM, "Index,Lifetime,Reverse Lifetime,View Depth"), "set_draw_order", "get_draw_order");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "transform_align", PROPERTY_HINT_ENUM, "Disabled,ZBillboard,YToVelocity,ZBillboardYToVelocity"), "set_transform_align", "get_transform_align");
 	ADD_GROUP("Trails", "trail_");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "trail_enabled"), "set_enable_trail", "is_trail_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "trail_length_secs", PROPERTY_HINT_RANGE, "0.01,4,0.01"), "set_trail_length", "get_trail_length");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "trail_enabled"), "set_trail_enabled", "is_trail_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "trail_length_secs", PROPERTY_HINT_RANGE, "0.01,10,0.01"), "set_trail_length", "get_trail_length");
 	ADD_GROUP("Process Material", "");
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "process_material", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial,ParticlesMaterial"), "set_process_material", "get_process_material");
 	ADD_GROUP("Draw Passes", "draw_");
@@ -595,6 +595,7 @@ void GPUParticles3D::_bind_methods() {
 
 	BIND_ENUM_CONSTANT(DRAW_ORDER_INDEX);
 	BIND_ENUM_CONSTANT(DRAW_ORDER_LIFETIME);
+	BIND_ENUM_CONSTANT(DRAW_ORDER_REVERSE_LIFETIME);
 	BIND_ENUM_CONSTANT(DRAW_ORDER_VIEW_DEPTH);
 
 	BIND_ENUM_CONSTANT(EMIT_FLAG_POSITION);
@@ -632,7 +633,7 @@ GPUParticles3D::GPUParticles3D() {
 	set_draw_passes(1);
 	set_draw_order(DRAW_ORDER_INDEX);
 	set_speed_scale(1);
-	set_collision_base_size(0.01);
+	set_collision_base_size(collision_base_size);
 	set_transform_align(TRANSFORM_ALIGN_DISABLED);
 }
 

scene/3d/gpu_particles_3d.h

@@ -44,6 +44,7 @@ public:
 	enum DrawOrder {
 		DRAW_ORDER_INDEX,
 		DRAW_ORDER_LIFETIME,
+		DRAW_ORDER_REVERSE_LIFETIME,
 		DRAW_ORDER_VIEW_DEPTH,
 	};
 
@@ -74,7 +75,7 @@ private:
 	bool fractional_delta;
 	bool interpolate = true;
 	NodePath sub_emitter;
-	float collision_base_size;
+	float collision_base_size = 0.01;
 
 	bool trail_enabled = false;
 	float trail_length = 0.3;
@@ -113,7 +114,7 @@ public:
 	void set_process_material(const Ref<Material> &p_material);
 	void set_speed_scale(float p_scale);
 	void set_collision_base_size(float p_ratio);
-	void set_enable_trail(bool p_enabled);
+	void set_trail_enabled(bool p_enabled);
 	void set_trail_length(float p_seconds);
 
 	bool is_emitting() const;

scene/resources/particles_material.cpp

@@ -1391,7 +1391,7 @@ ParticlesMaterial::ParticlesMaterial() :
 	set_sub_emitter_keep_velocity(false);
 
 	set_attractor_interaction_enabled(true);
-	set_collision_enabled(true);
+	set_collision_enabled(false);
 	set_collision_bounce(0.0);
 	set_collision_friction(0.0);
 	set_collision_use_scale(false);

servers/rendering/renderer_rd/renderer_canvas_render_rd.cpp

@@ -33,6 +33,7 @@
 #include "core/math/geometry_2d.h"
 #include "core/math/math_funcs.h"
 #include "renderer_compositor_rd.h"
+#include "servers/rendering/rendering_server_default.h"
 
 void RendererCanvasRenderRD::_update_transform_2d_to_mat4(const Transform2D &p_transform, float *p_mat4) {
 	p_mat4[0] = p_transform.elements[0][0];
@@ -390,7 +391,7 @@ void RendererCanvasRenderRD::_bind_canvas_texture(RD::DrawListID p_draw_list, RI
 	r_last_texture = p_texture;
 }
 
-void RendererCanvasRenderRD::_render_item(RD::DrawListID p_draw_list, const Item *p_item, RD::FramebufferFormatID p_framebuffer_format, const Transform2D &p_canvas_transform_inverse, Item *&current_clip, Light *p_lights, PipelineVariants *p_pipeline_variants) {
+void RendererCanvasRenderRD::_render_item(RD::DrawListID p_draw_list, RID p_render_target, const Item *p_item, RD::FramebufferFormatID p_framebuffer_format, const Transform2D &p_canvas_transform_inverse, Item *&current_clip, Light *p_lights, PipelineVariants *p_pipeline_variants) {
 	//create an empty push constant
 
 	RS::CanvasItemTextureFilter current_filter = default_filter;
@@ -747,9 +748,15 @@ void RendererCanvasRenderRD::_render_item(RD::DrawListID p_draw_list, const Item
 				} else if (c->type == Item::Command::TYPE_PARTICLES) {
 					const Item::CommandParticles *pt = static_cast<const Item::CommandParticles *>(c);
 					ERR_BREAK(storage->particles_get_mode(pt->particles) != RS::PARTICLES_MODE_2D);
+					storage->particles_request_process(pt->particles);
+
 					if (storage->particles_is_inactive(pt->particles)) {
 						break;
 					}
+
+					RenderingServerDefault::redraw_request(); // active particles means redraw request
+
+					bool local_coords = true;
 					int dpc = storage->particles_get_draw_passes(pt->particles);
 					if (dpc == 0) {
 						break; //nothing to draw
@@ -768,6 +775,30 @@ void RendererCanvasRenderRD::_render_item(RD::DrawListID p_draw_list, const Item
 
 					mesh = storage->particles_get_draw_pass_mesh(pt->particles, 0); //higher ones are ignored
 					texture = pt->texture;
+
+					if (storage->particles_has_collision(pt->particles) && storage->render_target_is_sdf_enabled(p_render_target)) {
+						//pass collision information
+						Transform2D xform;
+						if (local_coords) {
+							xform = p_item->final_transform;
+						} else {
+							xform = p_canvas_transform_inverse;
+						}
+
+						RID sdf_texture = storage->render_target_get_sdf_texture(p_render_target);
+
+						Rect2 to_screen;
+						{
+							Rect2 sdf_rect = storage->render_target_get_sdf_rect(p_render_target);
+
+							to_screen.size = Vector2(1.0 / sdf_rect.size.width, 1.0 / sdf_rect.size.height);
+							to_screen.position = -sdf_rect.position * to_screen.size;
+						}
+
+						storage->particles_set_canvas_sdf_collision(pt->particles, true, xform, to_screen, sdf_texture);
+					} else {
+						storage->particles_set_canvas_sdf_collision(pt->particles, false, Transform2D(), Rect2(), RID());
+					}
 				}
 
 				if (mesh.is_null()) {
@@ -1052,7 +1083,7 @@ void RendererCanvasRenderRD::_render_items(RID p_to_render_target, int p_item_co
 			}
 		}
 
-		_render_item(draw_list, ci, fb_format, canvas_transform_inverse, current_clip, p_lights, pipeline_variants);
+		_render_item(draw_list, p_to_render_target, ci, fb_format, canvas_transform_inverse, current_clip, p_lights, pipeline_variants);
 
 		prev_material = material;
 	}
@@ -1280,6 +1311,7 @@ void RendererCanvasRenderRD::canvas_render_items(RID p_to_render_target, Item *p
 	Item *canvas_group_owner = nullptr;
 
 	bool update_skeletons = false;
+	bool time_used = false;
 
 	while (ci) {
 		if (ci->copy_back_buffer && canvas_group_owner == nullptr) {
@@ -1305,6 +1337,9 @@ void RendererCanvasRenderRD::canvas_render_items(RID p_to_render_target, Item *p
 				if (md->shader_data->uses_sdf) {
 					r_sdf_used = true;
 				}
+				if (md->shader_data->uses_time) {
+					time_used = true;
+				}
 				if (md->last_frame != RendererCompositorRD::singleton->get_frame_number()) {
 					md->last_frame = RendererCompositorRD::singleton->get_frame_number();
 					if (!RD::get_singleton()->uniform_set_is_valid(md->uniform_set)) {
@@ -1401,6 +1436,10 @@ void RendererCanvasRenderRD::canvas_render_items(RID p_to_render_target, Item *p
 
 		ci = ci->next;
 	}
+
+	if (time_used) {
+		RenderingServerDefault::redraw_request();
+	}
 }
 
 RID RendererCanvasRenderRD::light_create() {
@@ -1877,6 +1916,7 @@ void RendererCanvasRenderRD::ShaderData::set_code(const String &p_code) {
 	uniforms.clear();
 	uses_screen_texture = false;
 	uses_sdf = false;
+	uses_time = false;
 
 	if (code == String()) {
 		return; //just invalid, but no error
@@ -1901,6 +1941,7 @@ void RendererCanvasRenderRD::ShaderData::set_code(const String &p_code) {
 
 	actions.usage_flag_pointers["SCREEN_TEXTURE"] = &uses_screen_texture;
 	actions.usage_flag_pointers["texture_sdf"] = &uses_sdf;
+	actions.usage_flag_pointers["TIME"] = &uses_time;
 
 	actions.uniforms = &uniforms;
 

servers/rendering/renderer_rd/renderer_canvas_render_rd.h

@@ -176,6 +176,7 @@ class RendererCanvasRenderRD : public RendererCanvasRender {
 
 		bool uses_screen_texture = false;
 		bool uses_sdf = false;
+		bool uses_time = false;
 
 		virtual void set_code(const String &p_Code);
 		virtual void set_default_texture_param(const StringName &p_name, RID p_texture);
@@ -425,7 +426,7 @@ class RendererCanvasRenderRD : public RendererCanvasRender {
 	RID _create_base_uniform_set(RID p_to_render_target, bool p_backbuffer);
 
 	inline void _bind_canvas_texture(RD::DrawListID p_draw_list, RID p_texture, RS::CanvasItemTextureFilter p_base_filter, RS::CanvasItemTextureRepeat p_base_repeat, RID &r_last_texture, PushConstant &push_constant, Size2 &r_texpixel_size); //recursive, so regular inline used instead.
-	void _render_item(RenderingDevice::DrawListID p_draw_list, const Item *p_item, RenderingDevice::FramebufferFormatID p_framebuffer_format, const Transform2D &p_canvas_transform_inverse, Item *&current_clip, Light *p_lights, PipelineVariants *p_pipeline_variants);
+	void _render_item(RenderingDevice::DrawListID p_draw_list, RID p_render_target, const Item *p_item, RenderingDevice::FramebufferFormatID p_framebuffer_format, const Transform2D &p_canvas_transform_inverse, Item *&current_clip, Light *p_lights, PipelineVariants *p_pipeline_variants);
 	void _render_items(RID p_to_render_target, int p_item_count, const Transform2D &p_canvas_transform_inverse, Light *p_lights, bool p_to_backbuffer = false);
 
 	_FORCE_INLINE_ void _update_transform_2d_to_mat2x4(const Transform2D &p_transform, float *p_mat2x4);

servers/rendering/renderer_rd/renderer_storage_rd.cpp

@@ -4305,6 +4305,15 @@ void RendererStorageRD::particles_remove_collision(RID p_particles, RID p_partic
 	particles->collisions.erase(p_particles_collision_instance);
 }
 
+void RendererStorageRD::particles_set_canvas_sdf_collision(RID p_particles, bool p_enable, const Transform2D &p_xform, const Rect2 &p_to_screen, RID p_texture) {
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+	particles->has_sdf_collision = p_enable;
+	particles->sdf_collision_transform = p_xform;
+	particles->sdf_collision_to_screen = p_to_screen;
+	particles->sdf_collision_texture = p_texture;
+}
+
 void RendererStorageRD::_particles_process(Particles *p_particles, float p_delta) {
 	if (p_particles->particles_material_uniform_set.is_null() || !RD::get_singleton()->uniform_set_is_valid(p_particles->particles_material_uniform_set)) {
 		Vector<RD::Uniform> uniforms;
@@ -4410,6 +4419,50 @@ void RendererStorageRD::_particles_process(Particles *p_particles, float p_delta
 		if (p_particles->use_local_coords) {
 			to_particles = p_particles->emission_transform.affine_inverse();
 		}
+
+		if (p_particles->has_sdf_collision && RD::get_singleton()->texture_is_valid(p_particles->sdf_collision_texture)) {
+			//2D collision
+
+			Transform2D xform = p_particles->sdf_collision_transform; //will use dotproduct manually so invert beforehand
+			Transform2D revert = xform.affine_inverse();
+			frame_params.collider_count = 1;
+			frame_params.colliders[0].transform[0] = xform.elements[0][0];
+			frame_params.colliders[0].transform[1] = xform.elements[0][1];
+			frame_params.colliders[0].transform[2] = 0;
+			frame_params.colliders[0].transform[3] = xform.elements[2][0];
+
+			frame_params.colliders[0].transform[4] = xform.elements[1][0];
+			frame_params.colliders[0].transform[5] = xform.elements[1][1];
+			frame_params.colliders[0].transform[6] = 0;
+			frame_params.colliders[0].transform[7] = xform.elements[2][1];
+
+			frame_params.colliders[0].transform[8] = revert.elements[0][0];
+			frame_params.colliders[0].transform[9] = revert.elements[0][1];
+			frame_params.colliders[0].transform[10] = 0;
+			frame_params.colliders[0].transform[11] = revert.elements[2][0];
+
+			frame_params.colliders[0].transform[12] = revert.elements[1][0];
+			frame_params.colliders[0].transform[13] = revert.elements[1][1];
+			frame_params.colliders[0].transform[14] = 0;
+			frame_params.colliders[0].transform[15] = revert.elements[2][1];
+
+			frame_params.colliders[0].extents[0] = p_particles->sdf_collision_to_screen.size.x;
+			frame_params.colliders[0].extents[1] = p_particles->sdf_collision_to_screen.size.y;
+			frame_params.colliders[0].extents[2] = p_particles->sdf_collision_to_screen.position.x;
+			frame_params.colliders[0].scale = p_particles->sdf_collision_to_screen.position.y;
+			frame_params.colliders[0].texture_index = 0;
+			frame_params.colliders[0].type = ParticlesFrameParams::COLLISION_TYPE_2D_SDF;
+
+			collision_heightmap_texture = p_particles->sdf_collision_texture;
+
+			//replace in all other history frames where used because parameters are no longer valid if screen moves
+			for (uint32_t i = 1; i < p_particles->frame_history.size(); i++) {
+				if (p_particles->frame_history[i].collider_count > 0 && p_particles->frame_history[i].colliders[0].type == ParticlesFrameParams::COLLISION_TYPE_2D_SDF) {
+					p_particles->frame_history[i].colliders[0] = frame_params.colliders[0];
+				}
+			}
+		}
+
 		uint32_t collision_3d_textures_used = 0;
 		for (const Set<RID>::Element *E = p_particles->collisions.front(); E; E = E->next()) {
 			ParticlesCollisionInstance *pci = particles_collision_instance_owner.getornull(E->get());
@@ -4657,6 +4710,8 @@ void RendererStorageRD::_particles_process(Particles *p_particles, float p_delta
 
 	ERR_FAIL_COND(!m);
 
+	p_particles->has_collision_cache = m->shader_data->uses_collision;
+
 	//todo should maybe compute all particle systems together?
 	RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
 	RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, m->shader_data->pipeline);
@@ -4740,6 +4795,11 @@ void RendererStorageRD::particles_set_view_axis(RID p_particles, const Vector3 &
 		copy_push_constant.trail_total = 1;
 		copy_push_constant.frame_delta = 0.0;
 	}
+
+	copy_push_constant.order_by_lifetime = (particles->draw_order == RS::PARTICLES_DRAW_ORDER_LIFETIME || particles->draw_order == RS::PARTICLES_DRAW_ORDER_REVERSE_LIFETIME);
+	copy_push_constant.lifetime_split = MIN(particles->amount * particles->phase, particles->amount - 1);
+	copy_push_constant.lifetime_reverse = particles->draw_order == RS::PARTICLES_DRAW_ORDER_REVERSE_LIFETIME;
+
 	copy_push_constant.frame_remainder = particles->interpolate ? particles->frame_remainder : 0.0;
 	copy_push_constant.total_particles = particles->amount;
 
@@ -5019,6 +5079,10 @@ void RendererStorageRD::update_particles() {
 				copy_push_constant.frame_delta = 0.0;
 			}
 
+			copy_push_constant.order_by_lifetime = (particles->draw_order == RS::PARTICLES_DRAW_ORDER_LIFETIME || particles->draw_order == RS::PARTICLES_DRAW_ORDER_REVERSE_LIFETIME);
+			copy_push_constant.lifetime_split = MIN(particles->amount * particles->phase, particles->amount - 1);
+			copy_push_constant.lifetime_reverse = particles->draw_order == RS::PARTICLES_DRAW_ORDER_REVERSE_LIFETIME;
+
 			RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
 			RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, particles_shader.copy_pipelines[particles->mode == RS::PARTICLES_MODE_2D ? ParticlesShader::COPY_MODE_FILL_INSTANCES_2D : ParticlesShader::COPY_MODE_FILL_INSTANCES]);
 			RD::get_singleton()->compute_list_bind_uniform_set(compute_list, particles->particles_copy_uniform_set, 0);
@@ -5049,6 +5113,7 @@ void RendererStorageRD::ParticlesShaderData::set_code(const String &p_code) {
 	valid = false;
 	ubo_size = 0;
 	uniforms.clear();
+	uses_collision = false;
 
 	if (code == String()) {
 		return; //just invalid, but no error
@@ -5068,6 +5133,8 @@ void RendererStorageRD::ParticlesShaderData::set_code(const String &p_code) {
 	actions.usage_flag_pointers["TIME"] = &uses_time;
 */
 
+	actions.usage_flag_pointers["COLLIDED"] = &uses_collision;
+
 	actions.uniforms = &uniforms;
 
 	Error err = base_singleton->particles_shader.compiler.compile(RS::SHADER_PARTICLES, code, &actions, path, gen_code);
@@ -7133,6 +7200,20 @@ Rect2i RendererStorageRD::render_target_get_sdf_rect(RID p_render_target) const
 	return _render_target_get_sdf_rect(rt);
 }
 
+void RendererStorageRD::render_target_mark_sdf_enabled(RID p_render_target, bool p_enabled) {
+	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	ERR_FAIL_COND(!rt);
+
+	rt->sdf_enabled = p_enabled;
+}
+
+bool RendererStorageRD::render_target_is_sdf_enabled(RID p_render_target) const {
+	const RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	ERR_FAIL_COND_V(!rt, false);
+
+	return rt->sdf_enabled;
+}
+
 RID RendererStorageRD::render_target_get_sdf_texture(RID p_render_target) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
@@ -7200,7 +7281,7 @@ void RendererStorageRD::_render_target_allocate_sdf(RenderTarget *rt) {
 	rt->process_size.x = MAX(rt->process_size.x, 1);
 	rt->process_size.y = MAX(rt->process_size.y, 1);
 
-	tformat.format = RD::DATA_FORMAT_R16G16_UINT;
+	tformat.format = RD::DATA_FORMAT_R16G16_SINT;
 	tformat.width = rt->process_size.width;
 	tformat.height = rt->process_size.height;
 	tformat.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT;
@@ -7208,7 +7289,7 @@ void RendererStorageRD::_render_target_allocate_sdf(RenderTarget *rt) {
 	rt->sdf_buffer_process[0] = RD::get_singleton()->texture_create(tformat, RD::TextureView());
 	rt->sdf_buffer_process[1] = RD::get_singleton()->texture_create(tformat, RD::TextureView());
 
-	tformat.format = RD::DATA_FORMAT_R16_UNORM;
+	tformat.format = RD::DATA_FORMAT_R16_SNORM;
 	tformat.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
 
 	rt->sdf_buffer_read = RD::get_singleton()->texture_create(tformat, RD::TextureView());

servers/rendering/renderer_rd/renderer_storage_rd.h

@@ -638,7 +638,9 @@ private:
 			COLLISION_TYPE_SPHERE,
 			COLLISION_TYPE_BOX,
 			COLLISION_TYPE_SDF,
-			COLLISION_TYPE_HEIGHT_FIELD
+			COLLISION_TYPE_HEIGHT_FIELD,
+			COLLISION_TYPE_2D_SDF,
+
 		};
 
 		struct Collider {
@@ -710,6 +712,13 @@ private:
 		bool restart_request = false;
 		AABB custom_aabb = AABB(Vector3(-4, -4, -4), Vector3(8, 8, 8));
 		bool use_local_coords = true;
+		bool has_collision_cache = false;
+
+		bool has_sdf_collision = false;
+		Transform2D sdf_collision_transform;
+		Rect2 sdf_collision_to_screen;
+		RID sdf_collision_texture;
+
 		RID process_material;
 		uint32_t frame_counter = 0;
 		RS::ParticlesTransformAlign transform_align = RS::PARTICLES_TRANSFORM_ALIGN_DISABLED;
@@ -820,6 +829,11 @@ private:
 
 			float align_up[3];
 			uint32_t align_mode;
+
+			uint32_t order_by_lifetime;
+			uint32_t lifetime_split;
+			uint32_t lifetime_reverse;
+			uint32_t pad;
 		};
 
 		enum {
@@ -843,6 +857,7 @@ private:
 	struct ParticlesShaderData : public ShaderData {
 		bool valid;
 		RID version;
+		bool uses_collision = false;
 
 		//PipelineCacheRD pipelines[SKY_VERSION_MAX];
 		Map<StringName, ShaderLanguage::ShaderNode::Uniform> uniforms;
@@ -1120,6 +1135,8 @@ private:
 
 		bool flags[RENDER_TARGET_FLAG_MAX];
 
+		bool sdf_enabled = false;
+
 		RID backbuffer; //used for effects
 		RID backbuffer_fb;
 		RID backbuffer_mipmap0;
@@ -2175,6 +2192,13 @@ public:
 		return particles->amount * r_trail_divisor;
 	}
 
+	_FORCE_INLINE_ bool particles_has_collision(RID p_particles) {
+		Particles *particles = particles_owner.getornull(p_particles);
+		ERR_FAIL_COND_V(!particles, 0);
+
+		return particles->has_collision_cache;
+	}
+
 	_FORCE_INLINE_ uint32_t particles_is_using_local_coords(RID p_particles) {
 		Particles *particles = particles_owner.getornull(p_particles);
 		ERR_FAIL_COND_V(!particles, false);
@@ -2206,6 +2230,7 @@ public:
 
 	virtual void particles_add_collision(RID p_particles, RID p_particles_collision_instance);
 	virtual void particles_remove_collision(RID p_particles, RID p_particles_collision_instance);
+	virtual void particles_set_canvas_sdf_collision(RID p_particles, bool p_enable, const Transform2D &p_xform, const Rect2 &p_to_screen, RID p_texture);
 
 	/* PARTICLES COLLISION */
 
@@ -2280,6 +2305,8 @@ public:
 	RID render_target_get_sdf_framebuffer(RID p_render_target);
 	void render_target_sdf_process(RID p_render_target);
 	virtual Rect2i render_target_get_sdf_rect(RID p_render_target) const;
+	void render_target_mark_sdf_enabled(RID p_render_target, bool p_enabled);
+	bool render_target_is_sdf_enabled(RID p_render_target) const;
 
 	Size2 render_target_get_size(RID p_render_target);
 	RID render_target_get_rd_framebuffer(RID p_render_target);

servers/rendering/renderer_rd/shaders/canvas.glsl

@@ -101,36 +101,34 @@ void main() {
 
 		uint offset = trail_size * stride * gl_InstanceIndex;
 
-		mat4 matrix;
 		vec4 pcolor;
+		vec2 new_vertex;
 		{
 			uint boffset = offset + bone_attrib.x * stride;
-			matrix = mat4(transforms.data[boffset + 0], transforms.data[boffset + 1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0)) * weight_attrib.x;
-			pcolor = transforms.data[boffset + 3] * weight_attrib.x;
+			new_vertex = (vec4(vertex, 0.0, 1.0) * mat4(transforms.data[boffset + 0], transforms.data[boffset + 1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0))).xy * weight_attrib.x;
+			pcolor = transforms.data[boffset + 2] * weight_attrib.x;
 		}
 		if (weight_attrib.y > 0.001) {
 			uint boffset = offset + bone_attrib.y * stride;
-			matrix += mat4(transforms.data[boffset + 0], transforms.data[boffset + 1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0)) * weight_attrib.y;
-			pcolor += transforms.data[boffset + 3] * weight_attrib.y;
+			new_vertex += (vec4(vertex, 0.0, 1.0) * mat4(transforms.data[boffset + 0], transforms.data[boffset + 1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0))).xy * weight_attrib.y;
+			pcolor += transforms.data[boffset + 2] * weight_attrib.y;
 		}
 		if (weight_attrib.z > 0.001) {
 			uint boffset = offset + bone_attrib.z * stride;
-			matrix += mat4(transforms.data[boffset + 0], transforms.data[boffset + 1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0)) * weight_attrib.z;
-			pcolor += transforms.data[boffset + 3] * weight_attrib.z;
+			new_vertex += (vec4(vertex, 0.0, 1.0) * mat4(transforms.data[boffset + 0], transforms.data[boffset + 1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0))).xy * weight_attrib.z;
+			pcolor += transforms.data[boffset + 2] * weight_attrib.z;
 		}
 		if (weight_attrib.w > 0.001) {
 			uint boffset = offset + bone_attrib.w * stride;
-			matrix += mat4(transforms.data[boffset + 0], transforms.data[boffset + 1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0)) * weight_attrib.w;
-			pcolor += transforms.data[boffset + 3] * weight_attrib.w;
+			new_vertex += (vec4(vertex, 0.0, 1.0) * mat4(transforms.data[boffset + 0], transforms.data[boffset + 1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0))).xy * weight_attrib.w;
+			pcolor += transforms.data[boffset + 2] * weight_attrib.w;
 		}
 
-		instance_custom = transforms.data[offset + 4];
+		instance_custom = transforms.data[offset + 3];
 
+		vertex = new_vertex;
 		color *= pcolor;
 
-		matrix = transpose(matrix);
-		world_matrix = world_matrix * matrix;
-
 	} else
 #endif // USE_ATTRIBUTES
 
@@ -283,7 +281,7 @@ vec2 screen_uv_to_sdf(vec2 p_uv) {
 float texture_sdf(vec2 p_sdf) {
 	vec2 uv = p_sdf * canvas_data.sdf_to_tex.xy + canvas_data.sdf_to_tex.zw;
 	float d = texture(sampler2D(sdf_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uv).r;
-	d = d * SDF_MAX_LENGTH - 1.0;
+	d *= SDF_MAX_LENGTH;
 	return d * canvas_data.tex_to_sdf;
 }
 

servers/rendering/renderer_rd/shaders/canvas_sdf.glsl

@@ -7,7 +7,7 @@
 layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
 
 layout(r8, set = 0, binding = 1) uniform restrict readonly image2D src_pixels;
-layout(r16, set = 0, binding = 2) uniform restrict writeonly image2D dst_sdf;
+layout(r16_snorm, set = 0, binding = 2) uniform restrict writeonly image2D dst_sdf;
 
 layout(rg16i, set = 0, binding = 3) uniform restrict readonly iimage2D src_process;
 layout(rg16i, set = 0, binding = 4) uniform restrict writeonly iimage2D dst_process;
@@ -32,7 +32,7 @@ void main() {
 #ifdef MODE_LOAD
 
 	bool solid = imageLoad(src_pixels, pos).r > 0.5;
-	imageStore(dst_process, pos, solid ? ivec4(pos, 0, 0) : ivec4(ivec2(32767), 0, 0));
+	imageStore(dst_process, pos, solid ? ivec4(ivec2(-32767), 0, 0) : ivec4(ivec2(32767), 0, 0));
 #endif
 
 #ifdef MODE_LOAD_SHRINK
@@ -43,6 +43,8 @@ void main() {
 
 	ivec2 rel = ivec2(32767);
 	float d = 1e20;
+	int found = 0;
+	int solid_found = 0;
 	for (int i = 0; i < s; i++) {
 		for (int j = 0; j < s; j++) {
 			ivec2 src_pos = base + ivec2(i, j);
@@ -56,10 +58,17 @@ void main() {
 					d = dist;
 					rel = src_pos;
 				}
+				solid_found++;
 			}
+			found++;
 		}
 	}
 
+	if (solid_found == found) {
+		//mark solid only if all are solid
+		rel = ivec2(-32767);
+	}
+
 	imageStore(dst_process, pos, ivec4(rel, 0, 0));
 #endif
 
@@ -70,6 +79,12 @@ void main() {
 
 	ivec2 rel = imageLoad(src_process, pos).xy;
 
+	bool solid = rel.x < 0;
+
+	if (solid) {
+		rel = -rel - ivec2(1);
+	}
+
 	if (center != rel) {
 		//only process if it does not point to itself
 		const int ofs_table_size = 8;
@@ -92,6 +107,15 @@ void main() {
 				continue;
 			}
 			ivec2 src_rel = imageLoad(src_process, src_pos).xy;
+			bool src_solid = src_rel.x < 0;
+			if (src_solid) {
+				src_rel = -src_rel - ivec2(1);
+			}
+
+			if (src_solid != solid) {
+				src_rel = ivec2(src_pos << params.shift); //point to itself if of different type
+			}
+
 			float src_dist = length(vec2(src_rel - center));
 			if (src_dist < dist) {
 				dist = src_dist;
@@ -100,18 +124,31 @@ void main() {
 		}
 	}
 
+	if (solid) {
+		rel = -rel - ivec2(1);
+	}
+
 	imageStore(dst_process, pos, ivec4(rel, 0, 0));
 #endif
 
 #ifdef MODE_STORE
 
 	ivec2 rel = imageLoad(src_process, pos).xy;
+
+	bool solid = rel.x < 0;
+
+	if (solid) {
+		rel = -rel - ivec2(1);
+	}
+
 	float d = length(vec2(rel - pos));
-	if (d > 0.01) {
-		d += 1.0; //make it signed
+
+	if (solid) {
+		d = -d;
 	}
+
 	d /= SDF_MAX_LENGTH;
-	d = clamp(d, 0.0, 1.0);
+	d = clamp(d, -1.0, 1.0);
 	imageStore(dst_sdf, pos, vec4(d));
 
 #endif
@@ -122,13 +159,20 @@ void main() {
 	ivec2 center = base + ivec2(params.shift);
 
 	ivec2 rel = imageLoad(src_process, pos).xy;
+
+	bool solid = rel.x < 0;
+
+	if (solid) {
+		rel = -rel - ivec2(1);
+	}
+
 	float d = length(vec2(rel - center));
 
-	if (d > 0.01) {
-		d += 1.0; //make it signed
+	if (solid) {
+		d = -d;
 	}
 	d /= SDF_MAX_LENGTH;
-	d = clamp(d, 0.0, 1.0);
+	d = clamp(d, -1.0, 1.0);
 	imageStore(dst_sdf, pos, vec4(d));
 
 #endif

servers/rendering/renderer_rd/shaders/particles.glsl

@@ -19,6 +19,8 @@ layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
 #define SAMPLER_NEAREST_WITH_MIPMAPS_ANISOTROPIC_REPEAT 10
 #define SAMPLER_LINEAR_WITH_MIPMAPS_ANISOTROPIC_REPEAT 11
 
+#define SDF_MAX_LENGTH 16384.0
+
 /* SET 0: GLOBAL DATA */
 
 layout(set = 0, binding = 1) uniform sampler material_samplers[12];
@@ -54,6 +56,7 @@ struct Attractor {
 #define COLLIDER_TYPE_BOX 1
 #define COLLIDER_TYPE_SDF 2
 #define COLLIDER_TYPE_HEIGHT_FIELD 3
+#define COLLIDER_TYPE_2D_SDF 4
 
 struct Collider {
 	mat4 transform;
@@ -452,128 +455,167 @@ void main() {
 
 #endif
 
-		for (uint i = 0; i < FRAME.collider_count; i++) {
-			vec3 normal;
-			float depth;
-			bool col = false;
+		if (FRAME.collider_count == 1 && FRAME.colliders[0].type == COLLIDER_TYPE_2D_SDF) {
+			//2D collision
 
-			vec3 rel_vec = PARTICLE.xform[3].xyz - FRAME.colliders[i].transform[3].xyz;
-			vec3 local_pos = rel_vec * mat3(FRAME.colliders[i].transform);
+			vec2 pos = PARTICLE.xform[3].xy;
+			vec4 to_sdf_x = FRAME.colliders[0].transform[0];
+			vec4 to_sdf_y = FRAME.colliders[0].transform[1];
+			vec2 sdf_pos = vec2(dot(vec4(pos, 0, 1), to_sdf_x), dot(vec4(pos, 0, 1), to_sdf_y));
 
-			switch (FRAME.colliders[i].type) {
-				case COLLIDER_TYPE_SPHERE: {
-					float d = length(rel_vec) - (particle_size + FRAME.colliders[i].extents.x);
+			vec4 sdf_to_screen = vec4(FRAME.colliders[0].extents, FRAME.colliders[0].scale);
 
-					if (d < 0.0) {
-						col = true;
-						depth = -d;
-						normal = normalize(rel_vec);
-					}
+			vec2 uv_pos = sdf_pos * sdf_to_screen.xy + sdf_to_screen.zw;
 
-				} break;
-				case COLLIDER_TYPE_BOX: {
-					vec3 abs_pos = abs(local_pos);
-					vec3 sgn_pos = sign(local_pos);
+			if (all(greaterThan(uv_pos, vec2(0.0))) && all(lessThan(uv_pos, vec2(1.0)))) {
+				vec2 pos2 = pos + vec2(0, particle_size);
+				vec2 sdf_pos2 = vec2(dot(vec4(pos2, 0, 1), to_sdf_x), dot(vec4(pos2, 0, 1), to_sdf_y));
+				float sdf_particle_size = distance(sdf_pos, sdf_pos2);
+
+				float d = texture(sampler2D(height_field_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uv_pos).r * SDF_MAX_LENGTH;
+
+				d -= sdf_particle_size;
+
+				if (d < 0.0) {
+					const float EPSILON = 0.001;
+					vec2 n = normalize(vec2(
+							texture(sampler2D(height_field_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uv_pos + vec2(EPSILON, 0.0)).r - texture(sampler2D(height_field_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uv_pos - vec2(EPSILON, 0.0)).r,
+							texture(sampler2D(height_field_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uv_pos + vec2(0.0, EPSILON)).r - texture(sampler2D(height_field_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uv_pos - vec2(0.0, EPSILON)).r));
+
+					collided = true;
+					sdf_pos2 = sdf_pos + n * d;
+					pos2 = vec2(dot(vec4(sdf_pos2, 0, 1), FRAME.colliders[0].transform[2]), dot(vec4(sdf_pos2, 0, 1), FRAME.colliders[0].transform[3]));
+
+					n = pos - pos2;
+
+					collision_normal = normalize(vec3(n, 0.0));
+					collision_depth = length(n);
+				}
+			}
+
+		} else {
+			for (uint i = 0; i < FRAME.collider_count; i++) {
+				vec3 normal;
+				float depth;
+				bool col = false;
 
-					if (any(greaterThan(abs_pos, FRAME.colliders[i].extents))) {
-						//point outside box
+				vec3 rel_vec = PARTICLE.xform[3].xyz - FRAME.colliders[i].transform[3].xyz;
+				vec3 local_pos = rel_vec * mat3(FRAME.colliders[i].transform);
 
-						vec3 closest = min(abs_pos, FRAME.colliders[i].extents);
-						vec3 rel = abs_pos - closest;
-						depth = length(rel) - particle_size;
-						if (depth < 0.0) {
+				switch (FRAME.colliders[i].type) {
+					case COLLIDER_TYPE_SPHERE: {
+						float d = length(rel_vec) - (particle_size + FRAME.colliders[i].extents.x);
+
+						if (d < 0.0) {
 							col = true;
-							normal = mat3(FRAME.colliders[i].transform) * (normalize(rel) * sgn_pos);
-							depth = -depth;
+							depth = -d;
+							normal = normalize(rel_vec);
 						}
-					} else {
-						//point inside box
-						vec3 axis_len = FRAME.colliders[i].extents - abs_pos;
-						// there has to be a faster way to do this?
-						if (all(lessThan(axis_len.xx, axis_len.yz))) {
-							normal = vec3(1, 0, 0);
-						} else if (all(lessThan(axis_len.yy, axis_len.xz))) {
-							normal = vec3(0, 1, 0);
+
+					} break;
+					case COLLIDER_TYPE_BOX: {
+						vec3 abs_pos = abs(local_pos);
+						vec3 sgn_pos = sign(local_pos);
+
+						if (any(greaterThan(abs_pos, FRAME.colliders[i].extents))) {
+							//point outside box
+
+							vec3 closest = min(abs_pos, FRAME.colliders[i].extents);
+							vec3 rel = abs_pos - closest;
+							depth = length(rel) - particle_size;
+							if (depth < 0.0) {
+								col = true;
+								normal = mat3(FRAME.colliders[i].transform) * (normalize(rel) * sgn_pos);
+								depth = -depth;
+							}
 						} else {
-							normal = vec3(0, 0, 1);
+							//point inside box
+							vec3 axis_len = FRAME.colliders[i].extents - abs_pos;
+							// there has to be a faster way to do this?
+							if (all(lessThan(axis_len.xx, axis_len.yz))) {
+								normal = vec3(1, 0, 0);
+							} else if (all(lessThan(axis_len.yy, axis_len.xz))) {
+								normal = vec3(0, 1, 0);
+							} else {
+								normal = vec3(0, 0, 1);
+							}
+
+							col = true;
+							depth = dot(normal * axis_len, vec3(1)) + particle_size;
+							normal = mat3(FRAME.colliders[i].transform) * (normal * sgn_pos);
 						}
 
-						col = true;
-						depth = dot(normal * axis_len, vec3(1)) + particle_size;
-						normal = mat3(FRAME.colliders[i].transform) * (normal * sgn_pos);
-					}
+					} break;
+					case COLLIDER_TYPE_SDF: {
+						vec3 apos = abs(local_pos);
+						float extra_dist = 0.0;
+						if (any(greaterThan(apos, FRAME.colliders[i].extents))) { //outside
+							vec3 mpos = min(apos, FRAME.colliders[i].extents);
+							extra_dist = distance(mpos, apos);
+						}
 
-				} break;
-				case COLLIDER_TYPE_SDF: {
-					vec3 apos = abs(local_pos);
-					float extra_dist = 0.0;
-					if (any(greaterThan(apos, FRAME.colliders[i].extents))) { //outside
-						vec3 mpos = min(apos, FRAME.colliders[i].extents);
-						extra_dist = distance(mpos, apos);
-					}
+						if (extra_dist > particle_size) {
+							continue;
+						}
 
-					if (extra_dist > particle_size) {
-						continue;
-					}
+						vec3 uvw_pos = (local_pos / FRAME.colliders[i].extents) * 0.5 + 0.5;
+						float s = texture(sampler3D(sdf_vec_textures[FRAME.colliders[i].texture_index], material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos).r;
+						s *= FRAME.colliders[i].scale;
+						s += extra_dist;
+						if (s < particle_size) {
+							col = true;
+							depth = particle_size - s;
+							const float EPSILON = 0.001;
+							normal = mat3(FRAME.colliders[i].transform) *
+									 normalize(
+											 vec3(
+													 texture(sampler3D(sdf_vec_textures[FRAME.colliders[i].texture_index], material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos + vec3(EPSILON, 0.0, 0.0)).r - texture(sampler3D(sdf_vec_textures[FRAME.colliders[i].texture_index], material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos - vec3(EPSILON, 0.0, 0.0)).r,
+													 texture(sampler3D(sdf_vec_textures[FRAME.colliders[i].texture_index], material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos + vec3(0.0, EPSILON, 0.0)).r - texture(sampler3D(sdf_vec_textures[FRAME.colliders[i].texture_index], material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos - vec3(0.0, EPSILON, 0.0)).r,
+													 texture(sampler3D(sdf_vec_textures[FRAME.colliders[i].texture_index], material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos + vec3(0.0, 0.0, EPSILON)).r - texture(sampler3D(sdf_vec_textures[FRAME.colliders[i].texture_index], material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos - vec3(0.0, 0.0, EPSILON)).r));
+						}
 
-					vec3 uvw_pos = (local_pos / FRAME.colliders[i].extents) * 0.5 + 0.5;
-					float s = texture(sampler3D(sdf_vec_textures[FRAME.colliders[i].texture_index], material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos).r;
-					s *= FRAME.colliders[i].scale;
-					s += extra_dist;
-					if (s < particle_size) {
-						col = true;
-						depth = particle_size - s;
-						const float EPSILON = 0.001;
-						normal = mat3(FRAME.colliders[i].transform) *
-								 normalize(
-										 vec3(
-												 texture(sampler3D(sdf_vec_textures[FRAME.colliders[i].texture_index], material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos + vec3(EPSILON, 0.0, 0.0)).r - texture(sampler3D(sdf_vec_textures[FRAME.colliders[i].texture_index], material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos - vec3(EPSILON, 0.0, 0.0)).r,
-												 texture(sampler3D(sdf_vec_textures[FRAME.colliders[i].texture_index], material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos + vec3(0.0, EPSILON, 0.0)).r - texture(sampler3D(sdf_vec_textures[FRAME.colliders[i].texture_index], material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos - vec3(0.0, EPSILON, 0.0)).r,
-												 texture(sampler3D(sdf_vec_textures[FRAME.colliders[i].texture_index], material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos + vec3(0.0, 0.0, EPSILON)).r - texture(sampler3D(sdf_vec_textures[FRAME.colliders[i].texture_index], material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos - vec3(0.0, 0.0, EPSILON)).r));
-					}
+					} break;
+					case COLLIDER_TYPE_HEIGHT_FIELD: {
+						vec3 local_pos_bottom = local_pos;
+						local_pos_bottom.y -= particle_size;
 
-				} break;
-				case COLLIDER_TYPE_HEIGHT_FIELD: {
-					vec3 local_pos_bottom = local_pos;
-					local_pos_bottom.y -= particle_size;
+						if (any(greaterThan(abs(local_pos_bottom), FRAME.colliders[i].extents))) {
+							continue;
+						}
+						const float DELTA = 1.0 / 8192.0;
 
-					if (any(greaterThan(abs(local_pos_bottom), FRAME.colliders[i].extents))) {
-						continue;
-					}
+						vec3 uvw_pos = vec3(local_pos_bottom / FRAME.colliders[i].extents) * 0.5 + 0.5;
 
-					const float DELTA = 1.0 / 8192.0;
+						float y = 1.0 - texture(sampler2D(height_field_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos.xz).r;
 
-					vec3 uvw_pos = vec3(local_pos_bottom / FRAME.colliders[i].extents) * 0.5 + 0.5;
+						if (y > uvw_pos.y) {
+							//inside heightfield
 
-					float y = 1.0 - texture(sampler2D(height_field_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos.xz).r;
+							vec3 pos1 = (vec3(uvw_pos.x, y, uvw_pos.z) * 2.0 - 1.0) * FRAME.colliders[i].extents;
+							vec3 pos2 = (vec3(uvw_pos.x + DELTA, 1.0 - texture(sampler2D(height_field_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos.xz + vec2(DELTA, 0)).r, uvw_pos.z) * 2.0 - 1.0) * FRAME.colliders[i].extents;
+							vec3 pos3 = (vec3(uvw_pos.x, 1.0 - texture(sampler2D(height_field_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos.xz + vec2(0, DELTA)).r, uvw_pos.z + DELTA) * 2.0 - 1.0) * FRAME.colliders[i].extents;
 
-					if (y > uvw_pos.y) {
-						//inside heightfield
+							normal = normalize(cross(pos1 - pos2, pos1 - pos3));
+							float local_y = (vec3(local_pos / FRAME.colliders[i].extents) * 0.5 + 0.5).y;
 
-						vec3 pos1 = (vec3(uvw_pos.x, y, uvw_pos.z) * 2.0 - 1.0) * FRAME.colliders[i].extents;
-						vec3 pos2 = (vec3(uvw_pos.x + DELTA, 1.0 - texture(sampler2D(height_field_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos.xz + vec2(DELTA, 0)).r, uvw_pos.z) * 2.0 - 1.0) * FRAME.colliders[i].extents;
-						vec3 pos3 = (vec3(uvw_pos.x, 1.0 - texture(sampler2D(height_field_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uvw_pos.xz + vec2(0, DELTA)).r, uvw_pos.z + DELTA) * 2.0 - 1.0) * FRAME.colliders[i].extents;
+							col = true;
+							depth = dot(normal, pos1) - dot(normal, local_pos_bottom);
+						}
 
-						normal = normalize(cross(pos1 - pos2, pos1 - pos3));
-						float local_y = (vec3(local_pos / FRAME.colliders[i].extents) * 0.5 + 0.5).y;
+					} break;
+				}
 
-						col = true;
-						depth = dot(normal, pos1) - dot(normal, local_pos_bottom);
+				if (col) {
+					if (!collided) {
+						collided = true;
+						collision_normal = normal;
+						collision_depth = depth;
+					} else {
+						vec3 c = collision_normal * collision_depth;
+						c += normal * max(0.0, depth - dot(normal, c));
+						collision_normal = normalize(c);
+						collision_depth = length(c);
 					}
-
-				} break;
-			}
-
-			if (col) {
-				if (!collided) {
-					collided = true;
-					collision_normal = normal;
-					collision_depth = depth;
-				} else {
-					vec3 c = collision_normal * collision_depth;
-					c += normal * max(0.0, depth - dot(normal, c));
-					collision_normal = normalize(c);
-					collision_depth = length(c);
 				}
 			}
 		}

servers/rendering/renderer_rd/shaders/particles_copy.glsl

@@ -53,6 +53,11 @@ layout(push_constant, binding = 0, std430) uniform Params {
 
 	vec3 align_up;
 	uint align_mode;
+
+	bool order_by_lifetime;
+	uint lifetime_split;
+	bool lifetime_reverse;
+	uint pad;
 }
 params;
 
@@ -80,7 +85,6 @@ void main() {
 #ifdef MODE_FILL_INSTANCES
 
 	uint particle = gl_GlobalInvocationID.x;
-	uint write_offset = gl_GlobalInvocationID.x * (3 + 1 + 1); //xform + color + custom
 
 	if (particle >= params.total_particles) {
 		return; //discard
@@ -93,7 +97,41 @@ void main() {
 	} else {
 		particle = uint(sort_buffer.data[particle].y); //use index from sort buffer
 	}
-#endif
+#else
+	if (params.order_by_lifetime) {
+		if (params.trail_size > 1) {
+			uint limit = (params.total_particles / params.trail_size) - params.lifetime_split;
+
+			uint base_index = particle / params.trail_size;
+			uint base_offset = particle % params.trail_size;
+
+			if (params.lifetime_reverse) {
+				base_index = (params.total_particles / params.trail_size) - base_index - 1;
+			}
+
+			if (base_index < limit) {
+				base_index = params.lifetime_split + base_index;
+			} else {
+				base_index -= limit;
+			}
+
+			particle = base_index * params.trail_size + base_offset;
+
+		} else {
+			uint limit = params.total_particles - params.lifetime_split;
+
+			if (params.lifetime_reverse) {
+				particle = params.total_particles - particle - 1;
+			}
+
+			if (particle < limit) {
+				particle = params.lifetime_split + particle;
+			} else {
+				particle -= limit;
+			}
+		}
+	}
+#endif // USE_SORT_BUFFER
 
 	mat4 txform;
 
@@ -165,12 +203,17 @@ void main() {
 
 #ifdef MODE_2D
 
+	uint write_offset = gl_GlobalInvocationID.x * (2 + 1 + 1); //xform + color + custom
+
 	instances.data[write_offset + 0] = txform[0];
 	instances.data[write_offset + 1] = txform[1];
 	instances.data[write_offset + 2] = particles.data[particle].color;
 	instances.data[write_offset + 3] = particles.data[particle].custom;
 
 #else
+
+	uint write_offset = gl_GlobalInvocationID.x * (3 + 1 + 1); //xform + color + custom
+
 	instances.data[write_offset + 0] = txform[0];
 	instances.data[write_offset + 1] = txform[1];
 	instances.data[write_offset + 2] = txform[2];

servers/rendering/renderer_storage.h

@@ -534,6 +534,8 @@ public:
 	virtual void particles_add_collision(RID p_particles, RID p_particles_collision_instance) = 0;
 	virtual void particles_remove_collision(RID p_particles, RID p_particles_collision_instance) = 0;
 
+	virtual void particles_set_canvas_sdf_collision(RID p_particles, bool p_enable, const Transform2D &p_xform, const Rect2 &p_to_screen, RID p_texture) = 0;
+
 	virtual void update_particles() = 0;
 
 	/* PARTICLES COLLISION */
@@ -603,6 +605,7 @@ public:
 
 	virtual void render_target_set_sdf_size_and_scale(RID p_render_target, RS::ViewportSDFOversize p_size, RS::ViewportSDFScale p_scale) = 0;
 	virtual Rect2i render_target_get_sdf_rect(RID p_render_target) const = 0;
+	virtual void render_target_mark_sdf_enabled(RID p_render_target, bool p_enabled) = 0;
 
 	virtual RS::InstanceType get_base_type(RID p_rid) const = 0;
 	virtual bool free(RID p_rid) = 0;

servers/rendering/renderer_viewport.cpp

@@ -186,8 +186,11 @@ void RendererViewport::_draw_viewport(Viewport *p_viewport, XRInterface::Eyes p_
 			}
 
 			RSG::canvas_render->render_sdf(p_viewport->render_target, occluders);
+			RSG::storage->render_target_mark_sdf_enabled(p_viewport->render_target, true);
 
 			p_viewport->sdf_active = false; // if used, gets set active again
+		} else {
+			RSG::storage->render_target_mark_sdf_enabled(p_viewport->render_target, false);
 		}
 
 		Rect2 shadow_rect;

servers/rendering_server.h

@@ -672,6 +672,7 @@ public:
 	enum ParticlesDrawOrder {
 		PARTICLES_DRAW_ORDER_INDEX,
 		PARTICLES_DRAW_ORDER_LIFETIME,
+		PARTICLES_DRAW_ORDER_REVERSE_LIFETIME,
 		PARTICLES_DRAW_ORDER_VIEW_DEPTH,
 	};