Merge pull request #51580 from aaronfranke/particles-real-double

Use real_t and double where appropriate in Particles

10 files changed, 98 insertions, 95 deletions

diff --git a/scene/2d/gpu_particles_2d.cpp b/scene/2d/gpu_particles_2d.cpp
index 4739d3dd46..58525c6954 100644
--- a/scene/2d/gpu_particles_2d.cpp
+++ b/scene/2d/gpu_particles_2d.cpp
@@ -81,12 +81,12 @@ void GPUParticles2D::set_pre_process_time(double p_time) {
 	RS::get_singleton()->particles_set_pre_process_time(particles, pre_process_time);
 }
 
-void GPUParticles2D::set_explosiveness_ratio(float p_ratio) {
+void GPUParticles2D::set_explosiveness_ratio(real_t p_ratio) {
 	explosiveness_ratio = p_ratio;
 	RS::get_singleton()->particles_set_explosiveness_ratio(particles, explosiveness_ratio);
 }
 
-void GPUParticles2D::set_randomness_ratio(float p_ratio) {
+void GPUParticles2D::set_randomness_ratio(real_t p_ratio) {
 	randomness_ratio = p_ratio;
 	RS::get_singleton()->particles_set_randomness_ratio(particles, randomness_ratio);
 }
@@ -176,7 +176,7 @@ bool GPUParticles2D::is_trail_enabled() const {
 	return trail_enabled;
 }
 
-real_t GPUParticles2D::get_trail_length() const {
+double GPUParticles2D::get_trail_length() const {
 	return trail_length;
 }
 
@@ -355,19 +355,19 @@ void GPUParticles2D::_notification(int p_what) {
 			PackedInt32Array indices;
 
 			int total_segments = trail_sections * trail_section_subdivisions;
-			float depth = size.height * trail_sections;
+			real_t depth = size.height * trail_sections;
 
 			for (int j = 0; j <= total_segments; j++) {
-				float v = j;
+				real_t v = j;
 				v /= total_segments;
 
-				float y = depth * v;
+				real_t 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);
+				real_t blend = 1.0 - real_t(j % trail_section_subdivisions) / real_t(trail_section_subdivisions);
 
-				float s = size.width;
+				real_t s = size.width;
 
 				points.push_back(Vector2(-s * 0.5, 0));
 				points.push_back(Vector2(+s * 0.5, 0));
@@ -413,7 +413,7 @@ void GPUParticles2D::_notification(int p_what) {
 			for (int i = 0; i <= trail_sections; i++) {
 				Transform3D xform;
 				/*
-				xform.origin.y = depth / 2.0 - size.height * float(i);
+				xform.origin.y = depth / 2.0 - size.height * real_t(i);
 				xform.origin.y = -xform.origin.y; //bind is an inverse transform, so negate y */
 				xforms.push_back(xform);
 			}
diff --git a/scene/2d/gpu_particles_2d.h b/scene/2d/gpu_particles_2d.h
index a80e52d60c..67a87f2339 100644
--- a/scene/2d/gpu_particles_2d.h
+++ b/scene/2d/gpu_particles_2d.h
@@ -53,8 +53,8 @@ private:
 	int amount;
 	double lifetime;
 	double pre_process_time;
-	float explosiveness_ratio;
-	float randomness_ratio;
+	real_t explosiveness_ratio;
+	real_t randomness_ratio;
 	double speed_scale;
 	Rect2 visibility_rect;
 	bool local_coords;
@@ -70,10 +70,10 @@ private:
 	void _update_particle_emission_transform();
 
 	NodePath sub_emitter;
-	float collision_base_size = 1.0;
+	real_t collision_base_size = 1.0;
 
 	bool trail_enabled = false;
-	float trail_length = 0.3;
+	double trail_length = 0.3;
 	int trail_sections = 8;
 	int trail_section_subdivisions = 4;
 
@@ -92,8 +92,8 @@ public:
 	void set_lifetime(double p_lifetime);
 	void set_one_shot(bool p_enable);
 	void set_pre_process_time(double p_time);
-	void set_explosiveness_ratio(float p_ratio);
-	void set_randomness_ratio(float p_ratio);
+	void set_explosiveness_ratio(real_t p_ratio);
+	void set_randomness_ratio(real_t p_ratio);
 	void set_visibility_rect(const Rect2 &p_visibility_rect);
 	void set_use_local_coordinates(bool p_enable);
 	void set_process_material(const Ref<Material> &p_material);
@@ -118,7 +118,7 @@ public:
 
 	real_t get_collision_base_size() const;
 	bool is_trail_enabled() const;
-	real_t get_trail_length() const;
+	double get_trail_length() const;
 	int get_trail_sections() const;
 	int get_trail_section_subdivisions() const;
 
diff --git a/scene/3d/gpu_particles_3d.cpp b/scene/3d/gpu_particles_3d.cpp
index 8b8b53c3bf..7a6410ec51 100644
--- a/scene/3d/gpu_particles_3d.cpp
+++ b/scene/3d/gpu_particles_3d.cpp
@@ -86,12 +86,12 @@ void GPUParticles3D::set_pre_process_time(double p_time) {
 	RS::get_singleton()->particles_set_pre_process_time(particles, pre_process_time);
 }
 
-void GPUParticles3D::set_explosiveness_ratio(float p_ratio) {
+void GPUParticles3D::set_explosiveness_ratio(real_t p_ratio) {
 	explosiveness_ratio = p_ratio;
 	RS::get_singleton()->particles_set_explosiveness_ratio(particles, explosiveness_ratio);
 }
 
-void GPUParticles3D::set_randomness_ratio(float p_ratio) {
+void GPUParticles3D::set_randomness_ratio(real_t p_ratio) {
 	randomness_ratio = p_ratio;
 	RS::get_singleton()->particles_set_randomness_ratio(particles, randomness_ratio);
 }
@@ -123,7 +123,7 @@ void GPUParticles3D::set_speed_scale(double p_scale) {
 	RS::get_singleton()->particles_set_speed_scale(particles, p_scale);
 }
 
-void GPUParticles3D::set_collision_base_size(float p_size) {
+void GPUParticles3D::set_collision_base_size(real_t p_size) {
 	collision_base_size = p_size;
 	RS::get_singleton()->particles_set_collision_base_size(particles, p_size);
 }
@@ -148,11 +148,11 @@ double GPUParticles3D::get_pre_process_time() const {
 	return pre_process_time;
 }
 
-float GPUParticles3D::get_explosiveness_ratio() const {
+real_t GPUParticles3D::get_explosiveness_ratio() const {
 	return explosiveness_ratio;
 }
 
-float GPUParticles3D::get_randomness_ratio() const {
+real_t GPUParticles3D::get_randomness_ratio() const {
 	return randomness_ratio;
 }
 
@@ -172,7 +172,7 @@ double GPUParticles3D::get_speed_scale() const {
 	return speed_scale;
 }
 
-float GPUParticles3D::get_collision_base_size() const {
+real_t GPUParticles3D::get_collision_base_size() const {
 	return collision_base_size;
 }
 
@@ -186,7 +186,8 @@ void GPUParticles3D::set_trail_enabled(bool p_enabled) {
 	RS::get_singleton()->particles_set_trails(particles, trail_enabled, trail_length);
 	update_configuration_warnings();
 }
-void GPUParticles3D::set_trail_length(float p_seconds) {
+
+void GPUParticles3D::set_trail_length(double p_seconds) {
 	ERR_FAIL_COND(p_seconds < 0.001);
 	trail_length = p_seconds;
 	RS::get_singleton()->particles_set_trails(particles, trail_enabled, trail_length);
@@ -195,7 +196,8 @@ void GPUParticles3D::set_trail_length(float p_seconds) {
 bool GPUParticles3D::is_trail_enabled() const {
 	return trail_enabled;
 }
-float GPUParticles3D::get_trail_length() const {
+
+double GPUParticles3D::get_trail_length() const {
 	return trail_length;
 }
 
diff --git a/scene/3d/gpu_particles_3d.h b/scene/3d/gpu_particles_3d.h
index 31e0e2abf5..31f33fde59 100644
--- a/scene/3d/gpu_particles_3d.h
+++ b/scene/3d/gpu_particles_3d.h
@@ -66,8 +66,8 @@ private:
 	int amount;
 	double lifetime;
 	double pre_process_time;
-	float explosiveness_ratio;
-	float randomness_ratio;
+	real_t explosiveness_ratio;
+	real_t randomness_ratio;
 	double speed_scale;
 	AABB visibility_aabb;
 	bool local_coords;
@@ -75,10 +75,10 @@ private:
 	bool fractional_delta;
 	bool interpolate = true;
 	NodePath sub_emitter;
-	float collision_base_size = 0.01;
+	real_t collision_base_size = 0.01;
 
 	bool trail_enabled = false;
-	float trail_length = 0.3;
+	double trail_length = 0.3;
 
 	TransformAlign transform_align = TRANSFORM_ALIGN_DISABLED;
 
@@ -107,30 +107,30 @@ public:
 	void set_lifetime(double p_lifetime);
 	void set_one_shot(bool p_one_shot);
 	void set_pre_process_time(double p_time);
-	void set_explosiveness_ratio(float p_ratio);
-	void set_randomness_ratio(float p_ratio);
+	void set_explosiveness_ratio(real_t p_ratio);
+	void set_randomness_ratio(real_t p_ratio);
 	void set_visibility_aabb(const AABB &p_aabb);
 	void set_use_local_coordinates(bool p_enable);
 	void set_process_material(const Ref<Material> &p_material);
 	void set_speed_scale(double p_scale);
-	void set_collision_base_size(float p_ratio);
+	void set_collision_base_size(real_t p_ratio);
 	void set_trail_enabled(bool p_enabled);
-	void set_trail_length(float p_seconds);
+	void set_trail_length(double p_seconds);
 
 	bool is_emitting() const;
 	int get_amount() const;
 	double get_lifetime() const;
 	bool get_one_shot() const;
 	double get_pre_process_time() const;
-	float get_explosiveness_ratio() const;
-	float get_randomness_ratio() const;
+	real_t get_explosiveness_ratio() const;
+	real_t get_randomness_ratio() const;
 	AABB get_visibility_aabb() const;
 	bool get_use_local_coordinates() const;
 	Ref<Material> get_process_material() const;
 	double get_speed_scale() const;
-	float get_collision_base_size() const;
+	real_t get_collision_base_size() const;
 	bool is_trail_enabled() const;
-	float get_trail_length() const;
+	double get_trail_length() const;
 
 	void set_fixed_fps(int p_count);
 	int get_fixed_fps() const;
diff --git a/scene/3d/gpu_particles_collision_3d.cpp b/scene/3d/gpu_particles_collision_3d.cpp
index cc1b620025..8b214a9cfb 100644
--- a/scene/3d/gpu_particles_collision_3d.cpp
+++ b/scene/3d/gpu_particles_collision_3d.cpp
@@ -70,13 +70,13 @@ void GPUParticlesCollisionSphere::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "radius", PROPERTY_HINT_RANGE, "0.01,1024,0.01,or_greater"), "set_radius", "get_radius");
 }
 
-void GPUParticlesCollisionSphere::set_radius(float p_radius) {
+void GPUParticlesCollisionSphere::set_radius(real_t p_radius) {
 	radius = p_radius;
 	RS::get_singleton()->particles_collision_set_sphere_radius(_get_collision(), radius);
 	update_gizmos();
 }
 
-float GPUParticlesCollisionSphere::get_radius() const {
+real_t GPUParticlesCollisionSphere::get_radius() const {
 	return radius;
 }
 
@@ -217,7 +217,7 @@ uint32_t GPUParticlesCollisionSDF::_create_bvh(LocalVector<BVH> &bvh_tree, FaceP
 	return index;
 }
 
-static _FORCE_INLINE_ float Vector3_dot2(const Vector3 &p_vec3) {
+static _FORCE_INLINE_ real_t Vector3_dot2(const Vector3 &p_vec3) {
 	return p_vec3.dot(p_vec3);
 }
 
@@ -738,31 +738,31 @@ uint32_t GPUParticlesAttractor3D::get_cull_mask() const {
 	return cull_mask;
 }
 
-void GPUParticlesAttractor3D::set_strength(float p_strength) {
+void GPUParticlesAttractor3D::set_strength(real_t p_strength) {
 	strength = p_strength;
 	RS::get_singleton()->particles_collision_set_attractor_strength(collision, p_strength);
 }
 
-float GPUParticlesAttractor3D::get_strength() const {
+real_t GPUParticlesAttractor3D::get_strength() const {
 	return strength;
 }
 
-void GPUParticlesAttractor3D::set_attenuation(float p_attenuation) {
+void GPUParticlesAttractor3D::set_attenuation(real_t p_attenuation) {
 	attenuation = p_attenuation;
 	RS::get_singleton()->particles_collision_set_attractor_attenuation(collision, p_attenuation);
 }
 
-float GPUParticlesAttractor3D::get_attenuation() const {
+real_t GPUParticlesAttractor3D::get_attenuation() const {
 	return attenuation;
 }
 
-void GPUParticlesAttractor3D::set_directionality(float p_directionality) {
+void GPUParticlesAttractor3D::set_directionality(real_t p_directionality) {
 	directionality = p_directionality;
 	RS::get_singleton()->particles_collision_set_attractor_directionality(collision, p_directionality);
 	update_gizmos();
 }
 
-float GPUParticlesAttractor3D::get_directionality() const {
+real_t GPUParticlesAttractor3D::get_directionality() const {
 	return directionality;
 }
 
@@ -803,13 +803,13 @@ void GPUParticlesAttractorSphere::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "radius", PROPERTY_HINT_RANGE, "0.01,1024,0.01,or_greater"), "set_radius", "get_radius");
 }
 
-void GPUParticlesAttractorSphere::set_radius(float p_radius) {
+void GPUParticlesAttractorSphere::set_radius(real_t p_radius) {
 	radius = p_radius;
 	RS::get_singleton()->particles_collision_set_sphere_radius(_get_collision(), radius);
 	update_gizmos();
 }
 
-float GPUParticlesAttractorSphere::get_radius() const {
+real_t GPUParticlesAttractorSphere::get_radius() const {
 	return radius;
 }
 
diff --git a/scene/3d/gpu_particles_collision_3d.h b/scene/3d/gpu_particles_collision_3d.h
index c55463378d..f96edd4bfc 100644
--- a/scene/3d/gpu_particles_collision_3d.h
+++ b/scene/3d/gpu_particles_collision_3d.h
@@ -60,14 +60,14 @@ public:
 class GPUParticlesCollisionSphere : public GPUParticlesCollision3D {
 	GDCLASS(GPUParticlesCollisionSphere, GPUParticlesCollision3D);
 
-	float radius = 1.0;
+	real_t radius = 1.0;
 
 protected:
 	static void _bind_methods();
 
 public:
-	void set_radius(float p_radius);
-	float get_radius() const;
+	void set_radius(real_t p_radius);
+	real_t get_radius() const;
 
 	virtual AABB get_aabb() const override;
 
@@ -253,9 +253,9 @@ class GPUParticlesAttractor3D : public VisualInstance3D {
 
 	uint32_t cull_mask = 0xFFFFFFFF;
 	RID collision;
-	float strength = 1.0;
-	float attenuation = 1.0;
-	float directionality = 0.0;
+	real_t strength = 1.0;
+	real_t attenuation = 1.0;
+	real_t directionality = 0.0;
 
 protected:
 	_FORCE_INLINE_ RID _get_collision() { return collision; }
@@ -267,14 +267,14 @@ public:
 	void set_cull_mask(uint32_t p_cull_mask);
 	uint32_t get_cull_mask() const;
 
-	void set_strength(float p_strength);
-	float get_strength() const;
+	void set_strength(real_t p_strength);
+	real_t get_strength() const;
 
-	void set_attenuation(float p_attenuation);
-	float get_attenuation() const;
+	void set_attenuation(real_t p_attenuation);
+	real_t get_attenuation() const;
 
-	void set_directionality(float p_directionality);
-	float get_directionality() const;
+	void set_directionality(real_t p_directionality);
+	real_t get_directionality() const;
 
 	virtual Vector<Face3> get_faces(uint32_t p_usage_flags) const override { return Vector<Face3>(); }
 
@@ -284,14 +284,14 @@ public:
 class GPUParticlesAttractorSphere : public GPUParticlesAttractor3D {
 	GDCLASS(GPUParticlesAttractorSphere, GPUParticlesAttractor3D);
 
-	float radius = 1.0;
+	real_t radius = 1.0;
 
 protected:
 	static void _bind_methods();
 
 public:
-	void set_radius(float p_radius);
-	float get_radius() const;
+	void set_radius(real_t p_radius);
+	real_t get_radius() const;
 
 	virtual AABB get_aabb() const override;
 
diff --git a/scene/resources/particles_material.cpp b/scene/resources/particles_material.cpp
index 9c8b3875ad..91569e65d6 100644
--- a/scene/resources/particles_material.cpp
+++ b/scene/resources/particles_material.cpp
@@ -996,7 +996,7 @@ void ParticlesMaterial::set_emission_shape(EmissionShape p_shape) {
 	_queue_shader_change();
 }
 
-void ParticlesMaterial::set_emission_sphere_radius(float p_radius) {
+void ParticlesMaterial::set_emission_sphere_radius(real_t p_radius) {
 	emission_sphere_radius = p_radius;
 	RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_sphere_radius, p_radius);
 }
@@ -1035,17 +1035,17 @@ void ParticlesMaterial::set_emission_ring_axis(Vector3 p_axis) {
 	RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_ring_axis, p_axis);
 }
 
-void ParticlesMaterial::set_emission_ring_height(float p_height) {
+void ParticlesMaterial::set_emission_ring_height(real_t p_height) {
 	emission_ring_height = p_height;
 	RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_ring_height, p_height);
 }
 
-void ParticlesMaterial::set_emission_ring_radius(float p_radius) {
+void ParticlesMaterial::set_emission_ring_radius(real_t p_radius) {
 	emission_ring_radius = p_radius;
 	RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_ring_radius, p_radius);
 }
 
-void ParticlesMaterial::set_emission_ring_inner_radius(float p_radius) {
+void ParticlesMaterial::set_emission_ring_inner_radius(real_t p_radius) {
 	emission_ring_inner_radius = p_radius;
 	RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_ring_inner_radius, p_radius);
 }
@@ -1054,7 +1054,7 @@ ParticlesMaterial::EmissionShape ParticlesMaterial::get_emission_shape() const {
 	return emission_shape;
 }
 
-float ParticlesMaterial::get_emission_sphere_radius() const {
+real_t ParticlesMaterial::get_emission_sphere_radius() const {
 	return emission_sphere_radius;
 }
 
@@ -1082,15 +1082,15 @@ Vector3 ParticlesMaterial::get_emission_ring_axis() const {
 	return emission_ring_axis;
 }
 
-float ParticlesMaterial::get_emission_ring_height() const {
+real_t ParticlesMaterial::get_emission_ring_height() const {
 	return emission_ring_height;
 }
 
-float ParticlesMaterial::get_emission_ring_radius() const {
+real_t ParticlesMaterial::get_emission_ring_radius() const {
 	return emission_ring_radius;
 }
 
-float ParticlesMaterial::get_emission_ring_inner_radius() const {
+real_t ParticlesMaterial::get_emission_ring_inner_radius() const {
 	return emission_ring_inner_radius;
 }
 
@@ -1107,12 +1107,12 @@ Vector3 ParticlesMaterial::get_gravity() const {
 	return gravity;
 }
 
-void ParticlesMaterial::set_lifetime_randomness(float p_lifetime) {
+void ParticlesMaterial::set_lifetime_randomness(double p_lifetime) {
 	lifetime_randomness = p_lifetime;
 	RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->lifetime_randomness, lifetime_randomness);
 }
 
-float ParticlesMaterial::get_lifetime_randomness() const {
+double ParticlesMaterial::get_lifetime_randomness() const {
 	return lifetime_randomness;
 }
 
@@ -1169,11 +1169,12 @@ ParticlesMaterial::SubEmitterMode ParticlesMaterial::get_sub_emitter_mode() cons
 	return sub_emitter_mode;
 }
 
-void ParticlesMaterial::set_sub_emitter_frequency(float p_frequency) {
+void ParticlesMaterial::set_sub_emitter_frequency(double p_frequency) {
 	sub_emitter_frequency = p_frequency;
 	RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->sub_emitter_frequency, 1.0 / p_frequency); //pass delta instead of frequency, since its easier to compute
 }
-float ParticlesMaterial::get_sub_emitter_frequency() const {
+
+double ParticlesMaterial::get_sub_emitter_frequency() const {
 	return sub_emitter_frequency;
 }
 
diff --git a/scene/resources/particles_material.h b/scene/resources/particles_material.h
index 8b0b26a3d1..ac7a500f73 100644
--- a/scene/resources/particles_material.h
+++ b/scene/resources/particles_material.h
@@ -241,19 +241,19 @@ private:
 	Ref<Texture2D> emission_normal_texture;
 	Ref<Texture2D> emission_color_texture;
 	Vector3 emission_ring_axis;
-	float emission_ring_height;
-	float emission_ring_radius;
-	float emission_ring_inner_radius;
+	real_t emission_ring_height;
+	real_t emission_ring_radius;
+	real_t emission_ring_inner_radius;
 	int emission_point_count = 1;
 
 	bool anim_loop;
 
 	Vector3 gravity;
 
-	float lifetime_randomness;
+	double lifetime_randomness;
 
 	SubEmitterMode sub_emitter_mode;
-	float sub_emitter_frequency;
+	double sub_emitter_frequency;
 	int sub_emitter_amount_at_end;
 	bool sub_emitter_keep_velocity;
 	//do not save emission points here
@@ -297,34 +297,34 @@ public:
 	bool get_particle_flag(ParticleFlags p_particle_flag) const;
 
 	void set_emission_shape(EmissionShape p_shape);
-	void set_emission_sphere_radius(float p_radius);
+	void set_emission_sphere_radius(real_t p_radius);
 	void set_emission_box_extents(Vector3 p_extents);
 	void set_emission_point_texture(const Ref<Texture2D> &p_points);
 	void set_emission_normal_texture(const Ref<Texture2D> &p_normals);
 	void set_emission_color_texture(const Ref<Texture2D> &p_colors);
 	void set_emission_ring_axis(Vector3 p_axis);
-	void set_emission_ring_height(float p_height);
-	void set_emission_ring_radius(float p_radius);
-	void set_emission_ring_inner_radius(float p_radius);
+	void set_emission_ring_height(real_t p_height);
+	void set_emission_ring_radius(real_t p_radius);
+	void set_emission_ring_inner_radius(real_t p_radius);
 	void set_emission_point_count(int p_count);
 
 	EmissionShape get_emission_shape() const;
-	float get_emission_sphere_radius() const;
+	real_t get_emission_sphere_radius() const;
 	Vector3 get_emission_box_extents() const;
 	Ref<Texture2D> get_emission_point_texture() const;
 	Ref<Texture2D> get_emission_normal_texture() const;
 	Ref<Texture2D> get_emission_color_texture() const;
 	Vector3 get_emission_ring_axis() const;
-	float get_emission_ring_height() const;
-	float get_emission_ring_radius() const;
-	float get_emission_ring_inner_radius() const;
+	real_t get_emission_ring_height() const;
+	real_t get_emission_ring_radius() const;
+	real_t get_emission_ring_inner_radius() const;
 	int get_emission_point_count() const;
 
 	void set_gravity(const Vector3 &p_gravity);
 	Vector3 get_gravity() const;
 
-	void set_lifetime_randomness(float p_lifetime);
-	float get_lifetime_randomness() const;
+	void set_lifetime_randomness(double p_lifetime);
+	double get_lifetime_randomness() const;
 
 	void set_attractor_interaction_enabled(bool p_enable);
 	bool is_attractor_interaction_enabled() const;
@@ -348,8 +348,8 @@ public:
 	void set_sub_emitter_mode(SubEmitterMode p_sub_emitter_mode);
 	SubEmitterMode get_sub_emitter_mode() const;
 
-	void set_sub_emitter_frequency(float p_frequency);
-	float get_sub_emitter_frequency() const;
+	void set_sub_emitter_frequency(double p_frequency);
+	double get_sub_emitter_frequency() const;
 
 	void set_sub_emitter_amount_at_end(int p_amount);
 	int get_sub_emitter_amount_at_end() const;
diff --git a/scene/resources/style_box.cpp b/scene/resources/style_box.cpp
index 7d5868e3a6..3381043d29 100644
--- a/scene/resources/style_box.cpp
+++ b/scene/resources/style_box.cpp
@@ -461,12 +461,12 @@ bool StyleBoxFlat::is_anti_aliased() const {
 	return anti_aliased;
 }
 
-void StyleBoxFlat::set_aa_size(const real_t &p_aa_size) {
+void StyleBoxFlat::set_aa_size(const real_t p_aa_size) {
 	aa_size = CLAMP(p_aa_size, 0.01, 10);
 	emit_changed();
 }
 
-float StyleBoxFlat::get_aa_size() const {
+real_t StyleBoxFlat::get_aa_size() const {
 	return aa_size;
 }
 
diff --git a/scene/resources/style_box.h b/scene/resources/style_box.h
index 124521b915..a6cd5b7fb7 100644
--- a/scene/resources/style_box.h
+++ b/scene/resources/style_box.h
@@ -205,8 +205,8 @@ public:
 
 	void set_anti_aliased(const bool &p_anti_aliased);
 	bool is_anti_aliased() const;
-	void set_aa_size(const float &p_aa_size);
-	float get_aa_size() const;
+	void set_aa_size(const real_t p_aa_size);
+	real_t get_aa_size() const;
 
 	virtual Size2 get_center_size() const override;