Use float and double directly. Fixes 107

Author: AndreaCatania

data_buffer.cpp

@@ -619,7 +619,7 @@ double DataBuffer::read_real(CompressionLevel p_compression_level) {
 	return value;
 }
 
-real_t DataBuffer::add_positive_unit_real(real_t p_input, CompressionLevel p_compression_level) {
+float DataBuffer::add_positive_unit_real(float p_input, CompressionLevel p_compression_level) {
 #ifdef DEBUG_ENABLED
 	ERR_FAIL_COND_V_MSG(p_input < 0 || p_input > 1, p_input, "Value must be between zero and one.");
 #endif
@@ -642,12 +642,12 @@ real_t DataBuffer::add_positive_unit_real(real_t p_input, CompressionLevel p_com
 	CRASH_COND((metadata_size + bit_size) > buffer.size_in_bits() && bit_offset > buffer.size_in_bits());
 #endif
 
-	const real_t value = decompress_unit_float(compressed_val, max_value);
+	const float value = decompress_unit_float(compressed_val, max_value);
 	DEB_WRITE(DATA_TYPE_POSITIVE_UNIT_REAL, p_compression_level, rtos(value).utf8());
 	return value;
 }
 
-real_t DataBuffer::read_positive_unit_real(CompressionLevel p_compression_level) {
+float DataBuffer::read_positive_unit_real(CompressionLevel p_compression_level) {
 	ERR_FAIL_COND_V(is_reading == false, 0.0);
 
 	const int bits = get_bit_taken(DATA_TYPE_POSITIVE_UNIT_REAL, p_compression_level);
@@ -661,17 +661,17 @@ real_t DataBuffer::read_positive_unit_real(CompressionLevel p_compression_level)
 	}
 	bit_offset += bits;
 
-	const real_t value = decompress_unit_float(compressed_val, max_value);
+	const float value = decompress_unit_float(compressed_val, max_value);
 
 	DEB_READ(DATA_TYPE_POSITIVE_UNIT_REAL, p_compression_level, rtos(value).utf8());
 
 	return value;
 }
 
-real_t DataBuffer::add_unit_real(real_t p_input, CompressionLevel p_compression_level) {
+float DataBuffer::add_unit_real(float p_input, CompressionLevel p_compression_level) {
 	ERR_FAIL_COND_V(is_reading == true, p_input);
 
-	const real_t added_real = add_positive_unit_real(ABS(p_input), p_compression_level);
+	const float added_real = add_positive_unit_real(ABS(p_input), p_compression_level);
 
 	const int bits_for_sign = 1;
 	const uint32_t is_negative = p_input < 0.0;
@@ -686,16 +686,16 @@ real_t DataBuffer::add_unit_real(real_t p_input, CompressionLevel p_compression_
 	CRASH_COND((metadata_size + bit_size) > buffer.size_in_bits() && bit_offset > buffer.size_in_bits());
 #endif
 
-	const real_t value = is_negative ? -added_real : added_real;
+	const float value = is_negative ? -added_real : added_real;
 	DEB_WRITE(DATA_TYPE_UNIT_REAL, p_compression_level, rtos(value).utf8());
 
 	return value;
 }
 
-real_t DataBuffer::read_unit_real(CompressionLevel p_compression_level) {
+float DataBuffer::read_unit_real(CompressionLevel p_compression_level) {
 	ERR_FAIL_COND_V(is_reading == false, 0.0);
 
-	const real_t value = read_positive_unit_real(p_compression_level);
+	const float value = read_positive_unit_real(p_compression_level);
 
 	const int bits_for_sign = 1;
 	std::uint64_t is_negative;
@@ -705,7 +705,7 @@ real_t DataBuffer::read_unit_real(CompressionLevel p_compression_level) {
 	}
 	bit_offset += bits_for_sign;
 
-	const real_t ret = is_negative != 0 ? -value : value;
+	const float ret = is_negative != 0 ? -value : value;
 
 	DEB_READ(DATA_TYPE_UNIT_REAL, p_compression_level, rtos(ret).utf8());
 
@@ -772,9 +772,9 @@ Vector2 DataBuffer::add_normalized_vector2(Vector2 p_input, CompressionLevel p_c
 	}
 	bit_offset += bits;
 
-	const real_t decompressed_angle = (decompress_unit_float(compressed_angle, max_value) * Math_TAU) - Math_PI;
-	const real_t x = Math::cos(decompressed_angle);
-	const real_t y = Math::sin(decompressed_angle);
+	const double decompressed_angle = (decompress_unit_float(compressed_angle, max_value) * Math_TAU) - Math_PI;
+	const double x = Math::cos(decompressed_angle);
+	const double y = Math::sin(decompressed_angle);
 
 #ifdef DEBUG_ENABLED
 	// Can't never happen because the buffer size is correctly handled.
@@ -807,9 +807,9 @@ Vector2 DataBuffer::read_normalized_vector2(CompressionLevel p_compression_level
 	}
 	bit_offset += bits;
 
-	const real_t decompressed_angle = (decompress_unit_float(compressed_angle, max_value) * Math_TAU) - Math_PI;
-	const real_t x = Math::cos(decompressed_angle);
-	const real_t y = Math::sin(decompressed_angle);
+	const double decompressed_angle = (decompress_unit_float(compressed_angle, max_value) * Math_TAU) - Math_PI;
+	const double x = Math::cos(decompressed_angle);
+	const double y = Math::sin(decompressed_angle);
 
 	const Vector2 value = Vector2(x, y) * static_cast<float>(is_not_zero);
 
@@ -859,9 +859,9 @@ Vector3 DataBuffer::add_normalized_vector3(Vector3 p_input, CompressionLevel p_c
 
 	DEB_DISABLE
 
-	const real_t x_axis = add_unit_real(p_input.x, p_compression_level);
-	const real_t y_axis = add_unit_real(p_input.y, p_compression_level);
-	const real_t z_axis = add_unit_real(p_input.z, p_compression_level);
+	const float x_axis = add_unit_real(p_input.x, p_compression_level);
+	const float y_axis = add_unit_real(p_input.y, p_compression_level);
+	const float z_axis = add_unit_real(p_input.z, p_compression_level);
 
 	DEB_ENABLE
 
@@ -875,9 +875,9 @@ Vector3 DataBuffer::read_normalized_vector3(CompressionLevel p_compression_level
 
 	DEB_DISABLE
 
-	const real_t x_axis = read_unit_real(p_compression_level);
-	const real_t y_axis = read_unit_real(p_compression_level);
-	const real_t z_axis = read_unit_real(p_compression_level);
+	const float x_axis = read_unit_real(p_compression_level);
+	const float y_axis = read_unit_real(p_compression_level);
+	const float z_axis = read_unit_real(p_compression_level);
 
 	DEB_ENABLE
 

data_buffer.h

@@ -75,7 +75,7 @@ class DataBuffer : public Object {
 	///
 	///
 	/// ## Vector2
-	/// COMPRESSION_LEVEL_0: 2 * 64 bits are used - Double precision (will fallback to level 1 if REAL_T_IS_DOUBLE is not defined)
+	/// COMPRESSION_LEVEL_0: 2 * 64 bits are used - Double precision
 	/// COMPRESSION_LEVEL_1: 2 * 32 bits are used - Single precision
 	/// COMPRESSION_LEVEL_2: 2 * 16 bits are used - Half precision
 	/// COMPRESSION_LEVEL_3: 2 * 8 bits are used - Minifloat
@@ -91,7 +91,7 @@ class DataBuffer : public Object {
 	///
 	///
 	/// ## Vector3
-	/// COMPRESSION_LEVEL_0: 3 * 64 bits are used - Double precision (will fallback to level 1 if REAL_T_IS_DOUBLE is not defined)
+	/// COMPRESSION_LEVEL_0: 3 * 64 bits are used - Double precision
 	/// COMPRESSION_LEVEL_1: 3 * 32 bits are used - Single precision
 	/// COMPRESSION_LEVEL_2: 3 * 16 bits are used - Half precision
 	/// COMPRESSION_LEVEL_3: 3 * 8 bits are used - Minifloat
@@ -244,21 +244,21 @@ class DataBuffer : public Object {
 	///
 	/// Returns the compressed value so both the client and the peers can use
 	/// the same data.
-	real_t add_positive_unit_real(real_t p_input, CompressionLevel p_compression_level);
+	float add_positive_unit_real(float p_input, CompressionLevel p_compression_level);
 
 	/// Parse the following data as a positive unit real.
-	real_t read_positive_unit_real(CompressionLevel p_compression_level);
+	float read_positive_unit_real(CompressionLevel p_compression_level);
 
 	/// Add a unit real into the buffer.
 	///
 	/// **Note:** Not unitary values lead to unexpected behaviour.
 	///
 	/// Returns the compressed value so both the client and the peers can use
 	/// the same data.
-	real_t add_unit_real(real_t p_input, CompressionLevel p_compression_level);
+	float add_unit_real(float p_input, CompressionLevel p_compression_level);
 
 	/// Parse the following data as an unit real.
-	real_t read_unit_real(CompressionLevel p_compression_level);
+	float read_unit_real(CompressionLevel p_compression_level);
 
 	/// Add a vector2 into the buffer.
 	/// Note: This kind of vector occupies more space than the normalized verison.

input_network_encoder.cpp

@@ -19,7 +19,7 @@ uint32_t InputNetworkEncoder::register_input(
 		const Variant &p_default_value,
 		DataBuffer::DataType p_type,
 		DataBuffer::CompressionLevel p_compression_level,
-		real_t p_comparison_floating_point_precision) {
+		float p_comparison_floating_point_precision) {
 	switch (p_type) {
 		case DataBuffer::DATA_TYPE_BOOL:
 			ERR_FAIL_COND_V_MSG(p_default_value.get_type() != Variant::BOOL, UINT32_MAX, "The moveset initialization failed for" + p_name + " the specified data type is `BOOL` but the default parameter is " + itos(p_default_value.get_type()));
@@ -225,18 +225,18 @@ void InputNetworkEncoder::reset_inputs_to_defaults(LocalVector<Variant> &r_input
 	}
 }
 
-bool compare(const Vector2 &p_first, const Vector2 &p_second, real_t p_tolerance) {
+bool compare(const Vector2 &p_first, const Vector2 &p_second, float p_tolerance) {
 	return Math::is_equal_approx(p_first.x, p_second.x, p_tolerance) &&
 			Math::is_equal_approx(p_first.y, p_second.y, p_tolerance);
 }
 
-bool compare(const Vector3 &p_first, const Vector3 &p_second, real_t p_tolerance) {
+bool compare(const Vector3 &p_first, const Vector3 &p_second, float p_tolerance) {
 	return Math::is_equal_approx(p_first.x, p_second.x, p_tolerance) &&
 			Math::is_equal_approx(p_first.y, p_second.y, p_tolerance) &&
 			Math::is_equal_approx(p_first.z, p_second.z, p_tolerance);
 }
 
-bool compare(const Variant &p_first, const Variant &p_second, real_t p_tolerance) {
+bool compare(const Variant &p_first, const Variant &p_second, float p_tolerance) {
 	if (p_first.get_type() != p_second.get_type()) {
 		return false;
 	}

input_network_encoder.h

@@ -11,7 +11,7 @@ struct NetworkedInputInfo {
 	uint32_t index;
 	DataBuffer::DataType data_type;
 	DataBuffer::CompressionLevel compression_level;
-	real_t comparison_floating_point_precision;
+	float comparison_floating_point_precision;
 };
 
 class InputNetworkEncoder : public Resource {
@@ -32,7 +32,7 @@ class InputNetworkEncoder : public Resource {
 			const Variant &p_default_value,
 			DataBuffer::DataType p_type,
 			DataBuffer::CompressionLevel p_compression_level,
-			real_t p_comparison_floating_point_precision = CMP_EPSILON);
+			float p_comparison_floating_point_precision = CMP_EPSILON);
 
 	uint32_t find_input_id(const StringName &p_name) const;
 	const LocalVector<NetworkedInputInfo> &get_input_info() const;

net_utilities.cpp

@@ -240,13 +240,13 @@ void NS::SyncGroup::notify_variable_changed(ObjectData *p_object_data, const std
 	}
 }
 
-void NS::SyncGroup::set_trickled_update_rate(NS::ObjectData *p_object_data, real_t p_update_rate) {
+void NS::SyncGroup::set_trickled_update_rate(NS::ObjectData *p_object_data, float p_update_rate) {
 	const int index = trickled_sync_objects.find(p_object_data);
 	ERR_FAIL_COND(index < 0);
 	trickled_sync_objects[index].update_rate = p_update_rate;
 }
 
-real_t NS::SyncGroup::get_trickled_update_rate(const NS::ObjectData *p_object_data) const {
+float NS::SyncGroup::get_trickled_update_rate(const NS::ObjectData *p_object_data) const {
 	for (int i = 0; i < int(trickled_sync_objects.size()); ++i) {
 		if (trickled_sync_objects[i].od == p_object_data) {
 			return trickled_sync_objects[i].update_rate;

net_utilities.h

@@ -533,7 +533,7 @@ struct SyncGroup {
 public:
 	uint64_t user_data = 0;
 
-	real_t state_notifier_timer = 0.0;
+	float state_notifier_timer = 0.0;
 
 public:
 	bool is_realtime_node_list_changed() const;
@@ -560,8 +560,8 @@ struct SyncGroup {
 	void notify_new_variable(struct ObjectData *p_object_data, const std::string &p_var_name);
 	void notify_variable_changed(struct ObjectData *p_object_data, const std::string &p_var_name);
 
-	void set_trickled_update_rate(struct ObjectData *p_object_data, real_t p_update_rate);
-	real_t get_trickled_update_rate(const struct ObjectData *p_object_data) const;
+	void set_trickled_update_rate(struct ObjectData *p_object_data, float p_update_rate);
+	float get_trickled_update_rate(const struct ObjectData *p_object_data) const;
 
 	void sort_trickled_node_by_update_priority();
 

networked_controller.cpp

@@ -510,7 +510,7 @@ FrameIndex RemotelyControlledController::last_known_frame_index() const {
 	}
 }
 
-bool RemotelyControlledController::fetch_next_input(real_t p_delta) {
+bool RemotelyControlledController::fetch_next_input(double p_delta) {
 	bool is_new_input = true;
 
 	if (unlikely(current_input_buffer_id == FrameIndex::NONE)) {
@@ -962,7 +962,7 @@ int AutonomousServerController::get_inputs_count() const {
 	return 0;
 }
 
-bool AutonomousServerController::fetch_next_input(real_t p_delta) {
+bool AutonomousServerController::fetch_next_input(double p_delta) {
 	SceneSynchronizerDebugger::singleton()->debug_print(&node->get_network_interface(), "Autonomous server fetch input.", true);
 
 	node->get_inputs_buffer_mut().begin_write(METADATA_SIZE);
@@ -1396,7 +1396,7 @@ void DollController::queue_instant_process(FrameIndex p_frame_index, int p_index
 	return;
 }
 
-bool DollController::fetch_next_input(real_t p_delta) {
+bool DollController::fetch_next_input(double p_delta) {
 	if (queued_instant_to_process >= 0) {
 		if (queued_instant_to_process >= int(snapshots.size())) {
 			return false;

networked_controller.h

@@ -306,7 +306,7 @@ struct RemotelyControlledController : public Controller {
 	FrameIndex last_known_frame_index() const;
 
 	/// Fetch the next inputs, returns true if the input is new.
-	virtual bool fetch_next_input(real_t p_delta);
+	virtual bool fetch_next_input(double p_delta);
 
 	virtual void set_frame_input(const FrameSnapshot &p_frame_snapshot, bool p_first_input);
 
@@ -349,7 +349,7 @@ struct AutonomousServerController final : public ServerController {
 
 	virtual bool receive_inputs(const Vector<uint8_t> &p_data) override;
 	virtual int get_inputs_count() const override;
-	virtual bool fetch_next_input(real_t p_delta) override;
+	virtual bool fetch_next_input(double p_delta) override;
 };
 
 struct PlayerController final : public Controller {
@@ -399,7 +399,7 @@ struct DollController final : public RemotelyControlledController {
 
 	virtual bool receive_inputs(const Vector<uint8_t> &p_data) override;
 	virtual void queue_instant_process(FrameIndex p_input_id, int p_index, int p_count) override;
-	virtual bool fetch_next_input(real_t p_delta) override;
+	virtual bool fetch_next_input(double p_delta) override;
 	virtual void process(double p_delta) override;
 	virtual void on_state_validated(FrameIndex p_frame_index) override;
 	void notify_frame_checked(FrameIndex p_input_id);

scene_synchronizer.cpp

@@ -253,7 +253,7 @@ float SceneSynchronizerBase::get_max_trickled_interpolation_alpha() const {
 	return max_trickled_interpolation_alpha;
 }
 
-void SceneSynchronizerBase::set_frame_confirmation_timespan(real_t p_interval) {
+void SceneSynchronizerBase::set_frame_confirmation_timespan(float p_interval) {
 	frame_confirmation_timespan = p_interval;
 }
 
@@ -269,11 +269,11 @@ float SceneSynchronizerBase::get_max_predicted_intervals() const {
 	return max_predicted_intervals;
 }
 
-void SceneSynchronizerBase::set_objects_relevancy_update_time(real_t p_time) {
+void SceneSynchronizerBase::set_objects_relevancy_update_time(float p_time) {
 	objects_relevancy_update_time = p_time;
 }
 
-real_t SceneSynchronizerBase::get_objects_relevancy_update_time() const {
+float SceneSynchronizerBase::get_objects_relevancy_update_time() const {
 	return objects_relevancy_update_time;
 }
 
@@ -729,25 +729,25 @@ const std::vector<int> *SceneSynchronizerBase::sync_group_get_listening_peers(Sy
 	return static_cast<ServerSynchronizer *>(synchronizer)->sync_group_get_listening_peers(p_group_id);
 }
 
-void SceneSynchronizerBase::sync_group_set_trickled_update_rate(ObjectLocalId p_node_id, SyncGroupId p_group_id, real_t p_update_rate) {
+void SceneSynchronizerBase::sync_group_set_trickled_update_rate(ObjectLocalId p_node_id, SyncGroupId p_group_id, float p_update_rate) {
 	NS::ObjectData *od = get_object_data(p_node_id);
 	ENSURE_MSG(is_server(), "This function CAN be used only on the server.");
 	static_cast<ServerSynchronizer *>(synchronizer)->sync_group_set_trickled_update_rate(od, p_group_id, p_update_rate);
 }
 
-void SceneSynchronizerBase::sync_group_set_trickled_update_rate(ObjectNetId p_node_id, SyncGroupId p_group_id, real_t p_update_rate) {
+void SceneSynchronizerBase::sync_group_set_trickled_update_rate(ObjectNetId p_node_id, SyncGroupId p_group_id, float p_update_rate) {
 	NS::ObjectData *od = get_object_data(p_node_id);
 	ENSURE_MSG(is_server(), "This function CAN be used only on the server.");
 	static_cast<ServerSynchronizer *>(synchronizer)->sync_group_set_trickled_update_rate(od, p_group_id, p_update_rate);
 }
 
-real_t SceneSynchronizerBase::sync_group_get_trickled_update_rate(ObjectLocalId p_id, SyncGroupId p_group_id) const {
+float SceneSynchronizerBase::sync_group_get_trickled_update_rate(ObjectLocalId p_id, SyncGroupId p_group_id) const {
 	const NS::ObjectData *od = get_object_data(p_id);
 	ENSURE_V_MSG(is_server(), 0.0, "This function CAN be used only on the server.");
 	return static_cast<ServerSynchronizer *>(synchronizer)->sync_group_get_trickled_update_rate(od, p_group_id);
 }
 
-real_t SceneSynchronizerBase::sync_group_get_trickled_update_rate(ObjectNetId p_id, SyncGroupId p_group_id) const {
+float SceneSynchronizerBase::sync_group_get_trickled_update_rate(ObjectNetId p_id, SyncGroupId p_group_id) const {
 	const NS::ObjectData *od = get_object_data(p_id);
 	ENSURE_V_MSG(is_server(), 0.0, "This function CAN be used only on the server.");
 	return static_cast<ServerSynchronizer *>(synchronizer)->sync_group_get_trickled_update_rate(od, p_group_id);
@@ -1861,14 +1861,14 @@ void ServerSynchronizer::set_peer_networking_enable(int p_peer, bool p_enable) {
 	sync_group_update(p_peer);
 }
 
-void ServerSynchronizer::sync_group_set_trickled_update_rate(NS::ObjectData *p_object_data, SyncGroupId p_group_id, real_t p_update_rate) {
+void ServerSynchronizer::sync_group_set_trickled_update_rate(NS::ObjectData *p_object_data, SyncGroupId p_group_id, float p_update_rate) {
 	ERR_FAIL_COND(p_object_data == nullptr);
 	ERR_FAIL_COND_MSG(p_group_id.id >= sync_groups.size(), "The group id `" + itos(p_group_id.id) + "` doesn't exist.");
 	ERR_FAIL_COND_MSG(p_group_id == SyncGroupId::GLOBAL, "You can't change this SyncGroup in any way. Create a new one.");
 	sync_groups[p_group_id.id].set_trickled_update_rate(p_object_data, p_update_rate);
 }
 
-real_t ServerSynchronizer::sync_group_get_trickled_update_rate(const NS::ObjectData *p_object_data, SyncGroupId p_group_id) const {
+float ServerSynchronizer::sync_group_get_trickled_update_rate(const NS::ObjectData *p_object_data, SyncGroupId p_group_id) const {
 	ERR_FAIL_COND_V(p_object_data == nullptr, 0.0);
 	ERR_FAIL_COND_V_MSG(p_group_id.id >= sync_groups.size(), 0.0, "The group id `" + itos(p_group_id.id) + "` doesn't exist.");
 	ERR_FAIL_COND_V_MSG(p_group_id == SyncGroupId::GLOBAL, 0.0, "You can't change this SyncGroup in any way. Create a new one.");