Cleaned up GSAIUtils, and registered it as a singleton.

modules/steering_ai/SCsub

@@ -6,6 +6,8 @@ module_env = env.Clone()
 
 sources = [
     "register_types.cpp",
+
+    "gsai_utils.cpp",
 ]
 
 

modules/steering_ai/config.py

@@ -6,7 +6,7 @@ def configure(env):
 
 def get_doc_classes():
     return [
-        #"",
+        "GSAIUtils",
     ]
 
 def get_doc_path():

modules/steering_ai/gsai_utils.cpp

@@ -1,63 +1,21 @@
 
 #include "gsai_utils.h"
 
-// Math and vector utility functions.;
+GSAIUtils *GSAIUtils::_singleton = NULL;
-// @Category - Utilities;
-// Returns the `vector` with its length capped to `limit`.;
-
-Vector3 GSAIUtils::clampedv3(const Vector3 &vector, const float limit) {
-	float length_squared = vector.length_squared();
-	float limit_squared = limit * limit;
-
-	if (length_squared > limit_squared) {
-		vector *= sqrt(limit_squared / length_squared);
-	}
-
-	return vector;
-}
-
-// Returns an angle in radians between the positive X axis and the `vector`.;
-//;
-// This assumes orientation for 3D agents that are upright and rotate;
-// around the Y axis.;
-
-float GSAIUtils::vector3_to_angle(const Vector3 &vector) {
-	return atan2(vector.x, vector.z);
-}
-
-// Returns an angle in radians between the positive X axis and the `vector`.;
-
-float GSAIUtils::vector2_to_angle(const Vector2 &vector) {
-	return atan2(vector.x, -vector.y);
-}
-
-// Returns a directional vector from the given orientation angle.;
-//;
-// This assumes orientation for 2D agents or 3D agents that are upright and;
-// rotate around the Y axis.;
-
-Vector2 GSAIUtils::angle_to_vector2(const float angle) {
-	return Vector2(sin(-angle), cos(angle));
-}
-
-// Returns a vector2 with `vector`'s x and y components.;
-
-Vector2 GSAIUtils::to_vector2(const Vector3 &vector) {
-	return Vector2(vector.x, vector.y);
-}
-
-// Returns a vector3 with `vector`'s x and y components and 0 in z.;
-
-Vector3 GSAIUtils::to_vector3(const Vector2 &vector) {
-	return Vector3(vector.x, vector.y, 0);
-}
-}
 
 GSAIUtils::GSAIUtils() {
+	_singleton = this;
 }
 
 GSAIUtils::~GSAIUtils() {
+  _singleton = NULL;
 }
 
-static void GSAIUtils::_bind_methods() {
+void GSAIUtils::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("clampedv3", "vector", "limit"), &GSAIUtils::bclampedv3);
+	ClassDB::bind_method(D_METHOD("vector3_to_angle", "vector"), &GSAIUtils::bvector3_to_angle);
+	ClassDB::bind_method(D_METHOD("vector2_to_angle", "vector"), &GSAIUtils::bvector2_to_angle);
+	ClassDB::bind_method(D_METHOD("angle_to_vector2", "angle"), &GSAIUtils::bangle_to_vector2);
+	ClassDB::bind_method(D_METHOD("to_vector2", "vector"), &GSAIUtils::bto_vector2);
+	ClassDB::bind_method(D_METHOD("to_vector3", "vector"), &GSAIUtils::bto_vector3);
 }

modules/steering_ai/gsai_utils.h

@@ -1,14 +1,89 @@
 #ifndef GSAIUTILS_H
 #define GSAIUTILS_H
 
-class GSAIUtils {
+#include "core/int_types.h"
+#include "core/math/math_funcs.h"
+#include "core/math/vector2.h"
+#include "core/math/vector3.h"
+
+#include "core/object/object.h"
+
+// Math and vector utility functions.
+
+class GSAIUtils : public Object {
+	GDCLASS(GSAIUtils, Object);
+
 public:
-	static Vector3 clampedv3(const Vector3 &vector, const float limit);
+	// Returns the `vector` with its length capped to `limit`.
-	static float vector3_to_angle(const Vector3 &vector);
+
-	static float vector2_to_angle(const Vector2 &vector);
+	static _ALWAYS_INLINE_ Vector3 clampedv3(Vector3 vector, const float limit) {
-	static Vector2 angle_to_vector2(const float angle);
+		float length_squared = vector.length_squared();
-	static Vector2 to_vector2(const Vector3 &vector);
+		float limit_squared = limit * limit;
-	static Vector3 to_vector3(const Vector2 &vector);
+
+		if (length_squared > limit_squared) {
+			vector *= Math::sqrt(limit_squared / length_squared);
+		}
+
+		return vector;
+	}
+
+	// Returns an angle in radians between the positive X axis and the `vector`.
+	// This assumes orientation for 3D agents that are upright and rotate
+	// around the Y axis.
+
+	static _ALWAYS_INLINE_ float vector3_to_angle(const Vector3 &vector) {
+		return atan2(vector.x, vector.z);
+	}
+
+	// Returns an angle in radians between the positive X axis and the `vector`.
+
+	static _ALWAYS_INLINE_ float vector2_to_angle(const Vector2 &vector) {
+		return atan2(vector.x, -vector.y);
+	}
+
+	// Returns a directional vector from the given orientation angle.
+	// This assumes orientation for 2D agents or 3D agents that are upright and
+	// rotate around the Y axis.
+
+	static _ALWAYS_INLINE_ Vector2 angle_to_vector2(const float angle) {
+		return Vector2(sin(-angle), cos(angle));
+	}
+
+	// Returns a vector2 with `vector`'s x and y components.
+
+	static _ALWAYS_INLINE_ Vector2 to_vector2(const Vector3 &vector) {
+		return Vector2(vector.x, vector.y);
+	}
+
+	// Returns a vector3 with `vector`'s x and y components and 0 in z.
+
+	static _ALWAYS_INLINE_ Vector3 to_vector3(const Vector2 &vector) {
+		return Vector3(vector.x, vector.y, 0);
+	}
+
+	// Binds for scripting
+	_FORCE_INLINE_ Vector3 bclampedv3(const Vector3 &vector, const float limit) {
+		return GSAIUtils::clampedv3(vector, limit);
+	}
+	_FORCE_INLINE_ float bvector3_to_angle(const Vector3 &vector) {
+		return GSAIUtils::vector3_to_angle(vector);
+	}
+	_FORCE_INLINE_ float bvector2_to_angle(const Vector2 &vector) {
+		return GSAIUtils::vector2_to_angle(vector);
+	}
+	_FORCE_INLINE_ Vector2 bangle_to_vector2(const float angle) {
+		return GSAIUtils::angle_to_vector2(angle);
+	}
+	_FORCE_INLINE_ Vector2 bto_vector2(const Vector3 &vector) {
+		return GSAIUtils::to_vector2(vector);
+	}
+	_FORCE_INLINE_ Vector3 bto_vector3(const Vector2 &vector) {
+		return GSAIUtils::to_vector3(vector);
+	}
+
+	static _FORCE_INLINE_ GSAIUtils *get_singleton() {
+		return _singleton;
+	}
 
 	GSAIUtils();
 	~GSAIUtils();
@@ -16,20 +91,7 @@ public:
 protected:
 	static void _bind_methods();
 
-	// Math and vector utility functions.
+	static GSAIUtils *_singleton;
-	// @Category - Utilities
-	// Returns the `vector` with its length capped to `limit`.
-	// Returns an angle in radians between the positive X axis and the `vector`.
-	//
-	// This assumes orientation for 3D agents that are upright and rotate
-	// around the Y axis.
-	// Returns an angle in radians between the positive X axis and the `vector`.
-	// Returns a directional vector from the given orientation angle.
-	//
-	// This assumes orientation for 2D agents or 3D agents that are upright and
-	// rotate around the Y axis.
-	// Returns a vector2 with `vector`'s x and y components.
-	// Returns a vector3 with `vector`'s x and y components and 0 in z.
 };
 
 #endif

modules/steering_ai/register_types.cpp

@@ -23,10 +23,20 @@ SOFTWARE.
 
 #include "register_types.h"
 
+#include "core/config/engine.h"
+
+#include "gsai_utils.h"
+
+static GSAIUtils *gs_ai_utils = NULL;
 
 void register_steering_ai_types() {
-	//ClassDB::register_class<TexturePacker>();
+	gs_ai_utils = memnew(GSAIUtils);
+	ClassDB::register_class<GSAIUtils>();
+	Engine::get_singleton()->add_singleton(Engine::Singleton("GSAIUtils", GSAIUtils::get_singleton()));
 }
 
 void unregister_steering_ai_types() {
+	if (gs_ai_utils) {
+		memdelete(gs_ai_utils);
+	}
 }

modules/steering_ai/register_types.h

@@ -1,3 +1,7 @@
+
+#ifndef REGSITER_STEERING_AI_TYPES
+#define REGSITER_STEERING_AI_TYPES
+
 /*
 Copyright (c) 2023-present Péter Magyar
 Copyright (c) 2020-2023 GDQuest
@@ -23,3 +27,5 @@ SOFTWARE.
 
 void register_steering_ai_types();
 void unregister_steering_ai_types();
+
+#endif