Relintai/pandemonium_engine
1
0
Fork 0
mirror of https://github.com/Relintai/pandemonium_engine.git synced 2025-02-02 14:25:55 +01:00
Code Issues Packages Projects Releases Wiki Activity

Cleaned up GSAIUtils, and registered it as a singleton.

Browse Source
This commit is contained in:
Relintai 2023-01-13 21:59:21 +01:00
parent 402e8ff689
commit 7792c4f423
6 changed files with 113 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
modules/steering_ai/SCsub
View File

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

2
modules/steering_ai/config.py
View File

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

62
modules/steering_ai/gsai_utils.cpp
View File

@ -1,63 +1,21 @@
#include "gsai_utils.h"
// Math and vector utility functions.;
// @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 = NULL;
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);
}

104
modules/steering_ai/gsai_utils.h
View File

@ -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);
static float vector3_to_angle(const Vector3 &vector);
static float vector2_to_angle(const Vector2 &vector);
static Vector2 angle_to_vector2(const float angle);
static Vector2 to_vector2(const Vector3 &vector);
static Vector3 to_vector3(const Vector2 &vector);
// Returns the `vector` with its length capped to `limit`.
static _ALWAYS_INLINE_ Vector3 clampedv3(Vector3 vector, const float limit) {
float length_squared = vector.length_squared();
float limit_squared = limit * limit;
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.
// @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.
static GSAIUtils *_singleton;
};
#endif

12
modules/steering_ai/register_types.cpp
View File

@ -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);
}
}

6
modules/steering_ai/register_types.h
View File

@ -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