summaryrefslogtreecommitdiff
path: root/core/math
diff options
context:
space:
mode:
Diffstat (limited to 'core/math')
-rw-r--r--core/math/SCsub35
-rw-r--r--core/math/a_star.cpp175
-rw-r--r--core/math/a_star.h42
-rw-r--r--core/math/basis.cpp2
-rw-r--r--core/math/basis.h2
-rw-r--r--core/math/bsp_tree.cpp6
-rw-r--r--core/math/camera_matrix.cpp60
-rw-r--r--core/math/crypto_core.cpp157
-rw-r--r--core/math/crypto_core.h90
-rw-r--r--core/math/expression.cpp19
-rw-r--r--core/math/expression.h5
-rw-r--r--core/math/geometry.h32
-rw-r--r--core/math/math_funcs.cpp2
-rw-r--r--core/math/math_funcs.h9
-rw-r--r--core/math/random_number_generator.cpp3
-rw-r--r--core/math/random_number_generator.h7
-rw-r--r--core/math/random_pcg.cpp8
-rw-r--r--core/math/random_pcg.h62
-rw-r--r--core/math/triangle_mesh.cpp4
-rw-r--r--core/math/triangle_mesh.h2
-rw-r--r--core/math/vector2.cpp7
-rw-r--r--core/math/vector2.h1
-rw-r--r--core/math/vector3.cpp7
-rw-r--r--core/math/vector3.h7
24 files changed, 653 insertions, 91 deletions
diff --git a/core/math/SCsub b/core/math/SCsub
index 1c5f954470..0995298a4b 100644
--- a/core/math/SCsub
+++ b/core/math/SCsub
@@ -2,4 +2,37 @@
Import('env')
-env.add_source_files(env.core_sources, "*.cpp")
+env_math = env.Clone() # Maybe make one specific for crypto?
+
+is_builtin = env["builtin_mbedtls"]
+has_module = env["module_mbedtls_enabled"]
+
+if is_builtin or not has_module:
+ # Use our headers for builtin or if the module is not going to be compiled.
+ # We decided not to depend on system mbedtls just for these few files that can
+ # be easily extracted.
+ env_math.Prepend(CPPPATH=["#thirdparty/mbedtls/include"])
+
+# MbedTLS core functions (for CryptoCore).
+# If the mbedtls module is compiled we don't need to add the .c files with our
+# custom config since they will be built by the module itself.
+# Only if the module is not enabled, we must compile here the required sources
+# to make a "light" build with only the necessary mbedtls files.
+if not has_module:
+ env_thirdparty = env_math.Clone()
+ env_thirdparty.disable_warnings()
+ # Custom config file
+ env_thirdparty.Append(CPPDEFINES=[('MBEDTLS_CONFIG_FILE', '\\"thirdparty/mbedtls/include/godot_core_mbedtls_config.h\\"')])
+ thirdparty_mbedtls_dir = "#thirdparty/mbedtls/library/"
+ thirdparty_mbedtls_sources = [
+ "aes.c",
+ "base64.c",
+ "md5.c",
+ "sha1.c",
+ "sha256.c",
+ "godot_core_mbedtls_platform.c"
+ ]
+ thirdparty_mbedtls_sources = [thirdparty_mbedtls_dir + file for file in thirdparty_mbedtls_sources]
+ env_thirdparty.add_source_files(env.core_sources, thirdparty_mbedtls_sources)
+
+env_math.add_source_files(env.core_sources, "*.cpp")
diff --git a/core/math/a_star.cpp b/core/math/a_star.cpp
index 3d71e66f80..b61119d8df 100644
--- a/core/math/a_star.cpp
+++ b/core/math/a_star.cpp
@@ -99,14 +99,22 @@ void AStar::remove_point(int p_id) {
Point *p = points[p_id];
- Map<int, Point *>::Element *PE = points.front();
- while (PE) {
- for (Set<Point *>::Element *E = PE->get()->neighbours.front(); E; E = E->next()) {
- Segment s(p_id, E->get()->id);
- segments.erase(s);
- E->get()->neighbours.erase(p);
- }
- PE = PE->next();
+ for (Set<Point *>::Element *E = p->neighbours.front(); E; E = E->next()) {
+
+ Segment s(p_id, E->get()->id);
+ segments.erase(s);
+
+ E->get()->neighbours.erase(p);
+ E->get()->unlinked_neighbours.erase(p);
+ }
+
+ for (Set<Point *>::Element *E = p->unlinked_neighbours.front(); E; E = E->next()) {
+
+ Segment s(p_id, E->get()->id);
+ segments.erase(s);
+
+ E->get()->neighbours.erase(p);
+ E->get()->unlinked_neighbours.erase(p);
}
memdelete(p);
@@ -125,6 +133,8 @@ void AStar::connect_points(int p_id, int p_with_id, bool bidirectional) {
if (bidirectional)
b->neighbours.insert(a);
+ else
+ b->unlinked_neighbours.insert(a);
Segment s(p_id, p_with_id);
if (s.from == p_id) {
@@ -147,7 +157,9 @@ void AStar::disconnect_points(int p_id, int p_with_id) {
Point *a = points[p_id];
Point *b = points[p_with_id];
a->neighbours.erase(b);
+ a->unlinked_neighbours.erase(b);
b->neighbours.erase(a);
+ b->unlinked_neighbours.erase(a);
}
bool AStar::has_point(int p_id) const {
@@ -204,6 +216,8 @@ int AStar::get_closest_point(const Vector3 &p_point) const {
for (const Map<int, Point *>::Element *E = points.front(); E; E = E->next()) {
+ if (!E->get()->enabled)
+ continue; //Disabled points should not be considered
real_t d = p_point.distance_squared_to(E->get()->pos);
if (closest_id < 0 || d < closest_dist) {
closest_dist = d;
@@ -222,6 +236,10 @@ Vector3 AStar::get_closest_position_in_segment(const Vector3 &p_point) const {
for (const Set<Segment>::Element *E = segments.front(); E; E = E->next()) {
+ if (!(E->get().from_point->enabled && E->get().to_point->enabled)) {
+ continue;
+ }
+
Vector3 segment[2] = {
E->get().from_point->pos,
E->get().to_point->pos,
@@ -423,10 +441,16 @@ PoolVector<int> AStar::get_id_path(int p_from_id, int p_to_id) {
}
void AStar::set_point_disabled(int p_id, bool p_disabled) {
+
+ ERR_FAIL_COND(!points.has(p_id));
+
points[p_id]->enabled = !p_disabled;
}
bool AStar::is_point_disabled(int p_id) const {
+
+ ERR_FAIL_COND_V(!points.has(p_id), false);
+
return !points[p_id]->enabled;
}
@@ -440,13 +464,12 @@ void AStar::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_point_weight_scale", "id", "weight_scale"), &AStar::set_point_weight_scale);
ClassDB::bind_method(D_METHOD("remove_point", "id"), &AStar::remove_point);
ClassDB::bind_method(D_METHOD("has_point", "id"), &AStar::has_point);
+ ClassDB::bind_method(D_METHOD("get_point_connections", "id"), &AStar::get_point_connections);
ClassDB::bind_method(D_METHOD("get_points"), &AStar::get_points);
ClassDB::bind_method(D_METHOD("set_point_disabled", "id", "disabled"), &AStar::set_point_disabled, DEFVAL(true));
ClassDB::bind_method(D_METHOD("is_point_disabled", "id"), &AStar::is_point_disabled);
- ClassDB::bind_method(D_METHOD("get_point_connections", "id"), &AStar::get_point_connections);
-
ClassDB::bind_method(D_METHOD("connect_points", "id", "to_id", "bidirectional"), &AStar::connect_points, DEFVAL(true));
ClassDB::bind_method(D_METHOD("disconnect_points", "id", "to_id"), &AStar::disconnect_points);
ClassDB::bind_method(D_METHOD("are_points_connected", "id", "to_id"), &AStar::are_points_connected);
@@ -473,3 +496,135 @@ AStar::~AStar() {
pass = 1;
clear();
}
+
+/////////////////////////////////////////////////////////////
+
+int AStar2D::get_available_point_id() const {
+ return astar.get_available_point_id();
+}
+
+void AStar2D::add_point(int p_id, const Vector2 &p_pos, real_t p_weight_scale) {
+ astar.add_point(p_id, Vector3(p_pos.x, p_pos.y, 0), p_weight_scale);
+}
+
+Vector2 AStar2D::get_point_position(int p_id) const {
+ Vector3 p = astar.get_point_position(p_id);
+ return Vector2(p.x, p.y);
+}
+
+void AStar2D::set_point_position(int p_id, const Vector2 &p_pos) {
+ astar.set_point_position(p_id, Vector3(p_pos.x, p_pos.y, 0));
+}
+
+real_t AStar2D::get_point_weight_scale(int p_id) const {
+ return astar.get_point_weight_scale(p_id);
+}
+
+void AStar2D::set_point_weight_scale(int p_id, real_t p_weight_scale) {
+ astar.set_point_weight_scale(p_id, p_weight_scale);
+}
+
+void AStar2D::remove_point(int p_id) {
+ astar.remove_point(p_id);
+}
+
+bool AStar2D::has_point(int p_id) const {
+ return astar.has_point(p_id);
+}
+
+PoolVector<int> AStar2D::get_point_connections(int p_id) {
+ return astar.get_point_connections(p_id);
+}
+
+Array AStar2D::get_points() {
+ return astar.get_points();
+}
+
+void AStar2D::set_point_disabled(int p_id, bool p_disabled) {
+ astar.set_point_disabled(p_id, p_disabled);
+}
+
+bool AStar2D::is_point_disabled(int p_id) const {
+ return astar.is_point_disabled(p_id);
+}
+
+void AStar2D::connect_points(int p_id, int p_with_id, bool p_bidirectional) {
+ astar.connect_points(p_id, p_with_id, p_bidirectional);
+}
+
+void AStar2D::disconnect_points(int p_id, int p_with_id) {
+ astar.disconnect_points(p_id, p_with_id);
+}
+
+bool AStar2D::are_points_connected(int p_id, int p_with_id) const {
+ return astar.are_points_connected(p_id, p_with_id);
+}
+
+void AStar2D::clear() {
+ astar.clear();
+}
+
+int AStar2D::get_closest_point(const Vector2 &p_point) const {
+ return astar.get_closest_point(Vector3(p_point.x, p_point.y, 0));
+}
+
+Vector2 AStar2D::get_closest_position_in_segment(const Vector2 &p_point) const {
+ Vector3 p = astar.get_closest_position_in_segment(Vector3(p_point.x, p_point.y, 0));
+ return Vector2(p.x, p.y);
+}
+
+PoolVector<Vector2> AStar2D::get_point_path(int p_from_id, int p_to_id) {
+
+ PoolVector3Array pv = astar.get_point_path(p_from_id, p_to_id);
+ int size = pv.size();
+ PoolVector2Array path;
+ path.resize(size);
+ {
+ PoolVector<Vector3>::Read r = pv.read();
+ PoolVector<Vector2>::Write w = path.write();
+ for (int i = 0; i < size; i++) {
+ Vector3 p = r[i];
+ w[i] = Vector2(p.x, p.y);
+ }
+ }
+ return path;
+}
+
+PoolVector<int> AStar2D::get_id_path(int p_from_id, int p_to_id) {
+ return astar.get_id_path(p_from_id, p_to_id);
+}
+
+void AStar2D::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("get_available_point_id"), &AStar2D::get_available_point_id);
+ ClassDB::bind_method(D_METHOD("add_point", "id", "position", "weight_scale"), &AStar2D::add_point, DEFVAL(1.0));
+ ClassDB::bind_method(D_METHOD("get_point_position", "id"), &AStar2D::get_point_position);
+ ClassDB::bind_method(D_METHOD("set_point_position", "id", "position"), &AStar2D::set_point_position);
+ ClassDB::bind_method(D_METHOD("get_point_weight_scale", "id"), &AStar2D::get_point_weight_scale);
+ ClassDB::bind_method(D_METHOD("set_point_weight_scale", "id", "weight_scale"), &AStar2D::set_point_weight_scale);
+ ClassDB::bind_method(D_METHOD("remove_point", "id"), &AStar2D::remove_point);
+ ClassDB::bind_method(D_METHOD("has_point", "id"), &AStar2D::has_point);
+ ClassDB::bind_method(D_METHOD("get_point_connections", "id"), &AStar2D::get_point_connections);
+ ClassDB::bind_method(D_METHOD("get_points"), &AStar2D::get_points);
+
+ ClassDB::bind_method(D_METHOD("set_point_disabled", "id", "disabled"), &AStar2D::set_point_disabled, DEFVAL(true));
+ ClassDB::bind_method(D_METHOD("is_point_disabled", "id"), &AStar2D::is_point_disabled);
+
+ ClassDB::bind_method(D_METHOD("connect_points", "id", "to_id", "bidirectional"), &AStar2D::connect_points, DEFVAL(true));
+ ClassDB::bind_method(D_METHOD("disconnect_points", "id", "to_id"), &AStar2D::disconnect_points);
+ ClassDB::bind_method(D_METHOD("are_points_connected", "id", "to_id"), &AStar2D::are_points_connected);
+
+ ClassDB::bind_method(D_METHOD("clear"), &AStar2D::clear);
+
+ ClassDB::bind_method(D_METHOD("get_closest_point", "to_position"), &AStar2D::get_closest_point);
+ ClassDB::bind_method(D_METHOD("get_closest_position_in_segment", "to_position"), &AStar2D::get_closest_position_in_segment);
+
+ ClassDB::bind_method(D_METHOD("get_point_path", "from_id", "to_id"), &AStar2D::get_point_path);
+ ClassDB::bind_method(D_METHOD("get_id_path", "from_id", "to_id"), &AStar2D::get_id_path);
+}
+
+AStar2D::AStar2D() {
+}
+
+AStar2D::~AStar2D() {
+}
diff --git a/core/math/a_star.h b/core/math/a_star.h
index fac8a9d312..ec333efc1d 100644
--- a/core/math/a_star.h
+++ b/core/math/a_star.h
@@ -42,7 +42,7 @@
class AStar : public Reference {
- GDCLASS(AStar, Reference)
+ GDCLASS(AStar, Reference);
uint64_t pass;
@@ -54,6 +54,7 @@ class AStar : public Reference {
bool enabled;
Set<Point *> neighbours;
+ Set<Point *> unlinked_neighbours;
// Used for pathfinding
Point *prev_point;
@@ -142,4 +143,43 @@ public:
~AStar();
};
+class AStar2D : public Reference {
+ GDCLASS(AStar2D, Reference);
+ AStar astar;
+
+protected:
+ static void _bind_methods();
+
+public:
+ int get_available_point_id() const;
+
+ void add_point(int p_id, const Vector2 &p_pos, real_t p_weight_scale = 1);
+ Vector2 get_point_position(int p_id) const;
+ void set_point_position(int p_id, const Vector2 &p_pos);
+ real_t get_point_weight_scale(int p_id) const;
+ void set_point_weight_scale(int p_id, real_t p_weight_scale);
+ void remove_point(int p_id);
+ bool has_point(int p_id) const;
+ PoolVector<int> get_point_connections(int p_id);
+ Array get_points();
+
+ void set_point_disabled(int p_id, bool p_disabled = true);
+ bool is_point_disabled(int p_id) const;
+
+ void connect_points(int p_id, int p_with_id, bool p_bidirectional = true);
+ void disconnect_points(int p_id, int p_with_id);
+ bool are_points_connected(int p_id, int p_with_id) const;
+
+ void clear();
+
+ int get_closest_point(const Vector2 &p_point) const;
+ Vector2 get_closest_position_in_segment(const Vector2 &p_point) const;
+
+ PoolVector<Vector2> get_point_path(int p_from_id, int p_to_id);
+ PoolVector<int> get_id_path(int p_from_id, int p_to_id);
+
+ AStar2D();
+ ~AStar2D();
+};
+
#endif // ASTAR_H
diff --git a/core/math/basis.cpp b/core/math/basis.cpp
index 1540bc8fe1..400f342018 100644
--- a/core/math/basis.cpp
+++ b/core/math/basis.cpp
@@ -852,7 +852,7 @@ void Basis::set_quat_scale(const Quat &p_quat, const Vector3 &p_scale) {
rotate(p_quat);
}
-void Basis::set_diagonal(const Vector3 p_diag) {
+void Basis::set_diagonal(const Vector3 &p_diag) {
elements[0][0] = p_diag.x;
elements[0][1] = 0;
elements[0][2] = 0;
diff --git a/core/math/basis.h b/core/math/basis.h
index 75037c2c52..d3adad3d90 100644
--- a/core/math/basis.h
+++ b/core/math/basis.h
@@ -153,7 +153,7 @@ public:
int get_orthogonal_index() const;
void set_orthogonal_index(int p_index);
- void set_diagonal(const Vector3 p_diag);
+ void set_diagonal(const Vector3 &p_diag);
bool is_orthogonal() const;
bool is_diagonal() const;
diff --git a/core/math/bsp_tree.cpp b/core/math/bsp_tree.cpp
index d7e6e82cd9..a12f9fee2e 100644
--- a/core/math/bsp_tree.cpp
+++ b/core/math/bsp_tree.cpp
@@ -142,7 +142,7 @@ int BSP_Tree::_get_points_inside(int p_node, const Vector3 *p_points, int *p_ind
}
return _get_points_inside(node->over, p_points, p_indices, p_center, p_half_extents, p_indices_count);
- } else if (dist_min <= 0) { //all points behind plane
+ } else { //all points behind plane
if (node->under == UNDER_LEAF) {
@@ -150,8 +150,6 @@ int BSP_Tree::_get_points_inside(int p_node, const Vector3 *p_points, int *p_ind
}
return _get_points_inside(node->under, p_points, p_indices, p_center, p_half_extents, p_indices_count);
}
-
- return 0;
}
int BSP_Tree::get_points_inside(const Vector3 *p_points, int p_point_count) const {
@@ -271,8 +269,6 @@ bool BSP_Tree::point_is_inside(const Vector3 &p_point) const {
ERR_FAIL_COND_V(idx < MAX_NODES && idx >= node_count, false);
#endif
}
-
- return false;
}
static int _bsp_find_best_half_plane(const Face3 *p_faces, const Vector<int> &p_indices, real_t p_tolerance) {
diff --git a/core/math/camera_matrix.cpp b/core/math/camera_matrix.cpp
index f615cc8c65..8b3b6c82f3 100644
--- a/core/math/camera_matrix.cpp
+++ b/core/math/camera_matrix.cpp
@@ -507,21 +507,21 @@ void CameraMatrix::set_light_bias() {
real_t *m = &matrix[0][0];
- m[0] = 0.5,
- m[1] = 0.0,
- m[2] = 0.0,
- m[3] = 0.0,
- m[4] = 0.0,
- m[5] = 0.5,
- m[6] = 0.0,
- m[7] = 0.0,
- m[8] = 0.0,
- m[9] = 0.0,
- m[10] = 0.5,
- m[11] = 0.0,
- m[12] = 0.5,
- m[13] = 0.5,
- m[14] = 0.5,
+ m[0] = 0.5;
+ m[1] = 0.0;
+ m[2] = 0.0;
+ m[3] = 0.0;
+ m[4] = 0.0;
+ m[5] = 0.5;
+ m[6] = 0.0;
+ m[7] = 0.0;
+ m[8] = 0.0;
+ m[9] = 0.0;
+ m[10] = 0.5;
+ m[11] = 0.0;
+ m[12] = 0.5;
+ m[13] = 0.5;
+ m[14] = 0.5;
m[15] = 1.0;
}
@@ -529,21 +529,21 @@ void CameraMatrix::set_light_atlas_rect(const Rect2 &p_rect) {
real_t *m = &matrix[0][0];
- m[0] = p_rect.size.width,
- m[1] = 0.0,
- m[2] = 0.0,
- m[3] = 0.0,
- m[4] = 0.0,
- m[5] = p_rect.size.height,
- m[6] = 0.0,
- m[7] = 0.0,
- m[8] = 0.0,
- m[9] = 0.0,
- m[10] = 1.0,
- m[11] = 0.0,
- m[12] = p_rect.position.x,
- m[13] = p_rect.position.y,
- m[14] = 0.0,
+ m[0] = p_rect.size.width;
+ m[1] = 0.0;
+ m[2] = 0.0;
+ m[3] = 0.0;
+ m[4] = 0.0;
+ m[5] = p_rect.size.height;
+ m[6] = 0.0;
+ m[7] = 0.0;
+ m[8] = 0.0;
+ m[9] = 0.0;
+ m[10] = 1.0;
+ m[11] = 0.0;
+ m[12] = p_rect.position.x;
+ m[13] = p_rect.position.y;
+ m[14] = 0.0;
m[15] = 1.0;
}
diff --git a/core/math/crypto_core.cpp b/core/math/crypto_core.cpp
new file mode 100644
index 0000000000..d7ba54e469
--- /dev/null
+++ b/core/math/crypto_core.cpp
@@ -0,0 +1,157 @@
+/*************************************************************************/
+/* crypto_core.cpp */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/*************************************************************************/
+
+#include "crypto_core.h"
+
+#include <mbedtls/aes.h>
+#include <mbedtls/base64.h>
+#include <mbedtls/md5.h>
+#include <mbedtls/sha1.h>
+#include <mbedtls/sha256.h>
+
+// MD5
+CryptoCore::MD5Context::MD5Context() {
+ ctx = memalloc(sizeof(mbedtls_md5_context));
+ mbedtls_md5_init((mbedtls_md5_context *)ctx);
+}
+
+CryptoCore::MD5Context::~MD5Context() {
+ mbedtls_md5_free((mbedtls_md5_context *)ctx);
+ memfree((mbedtls_md5_context *)ctx);
+}
+
+Error CryptoCore::MD5Context::start() {
+ int ret = mbedtls_md5_starts_ret((mbedtls_md5_context *)ctx);
+ return ret ? FAILED : OK;
+}
+
+Error CryptoCore::MD5Context::update(uint8_t *p_src, size_t p_len) {
+ int ret = mbedtls_md5_update_ret((mbedtls_md5_context *)ctx, p_src, p_len);
+ return ret ? FAILED : OK;
+}
+
+Error CryptoCore::MD5Context::finish(unsigned char r_hash[16]) {
+ int ret = mbedtls_md5_finish_ret((mbedtls_md5_context *)ctx, r_hash);
+ return ret ? FAILED : OK;
+}
+
+// SHA256
+CryptoCore::SHA256Context::SHA256Context() {
+ ctx = memalloc(sizeof(mbedtls_sha256_context));
+ mbedtls_sha256_init((mbedtls_sha256_context *)ctx);
+}
+
+CryptoCore::SHA256Context::~SHA256Context() {
+ mbedtls_sha256_free((mbedtls_sha256_context *)ctx);
+ memfree((mbedtls_sha256_context *)ctx);
+}
+
+Error CryptoCore::SHA256Context::start() {
+ int ret = mbedtls_sha256_starts_ret((mbedtls_sha256_context *)ctx, 0);
+ return ret ? FAILED : OK;
+}
+
+Error CryptoCore::SHA256Context::update(uint8_t *p_src, size_t p_len) {
+ int ret = mbedtls_sha256_update_ret((mbedtls_sha256_context *)ctx, p_src, p_len);
+ return ret ? FAILED : OK;
+}
+
+Error CryptoCore::SHA256Context::finish(unsigned char r_hash[16]) {
+ int ret = mbedtls_sha256_finish_ret((mbedtls_sha256_context *)ctx, r_hash);
+ return ret ? FAILED : OK;
+}
+
+// AES256
+CryptoCore::AESContext::AESContext() {
+ ctx = memalloc(sizeof(mbedtls_aes_context));
+ mbedtls_aes_init((mbedtls_aes_context *)ctx);
+}
+
+CryptoCore::AESContext::~AESContext() {
+ mbedtls_aes_free((mbedtls_aes_context *)ctx);
+ memfree((mbedtls_aes_context *)ctx);
+}
+
+Error CryptoCore::AESContext::set_encode_key(const uint8_t *p_key, size_t p_bits) {
+ int ret = mbedtls_aes_setkey_enc((mbedtls_aes_context *)ctx, p_key, p_bits);
+ return ret ? FAILED : OK;
+}
+
+Error CryptoCore::AESContext::set_decode_key(const uint8_t *p_key, size_t p_bits) {
+ int ret = mbedtls_aes_setkey_dec((mbedtls_aes_context *)ctx, p_key, p_bits);
+ return ret ? FAILED : OK;
+}
+
+Error CryptoCore::AESContext::encrypt_ecb(const uint8_t p_src[16], uint8_t r_dst[16]) {
+ int ret = mbedtls_aes_crypt_ecb((mbedtls_aes_context *)ctx, MBEDTLS_AES_ENCRYPT, p_src, r_dst);
+ return ret ? FAILED : OK;
+}
+
+Error CryptoCore::AESContext::decrypt_ecb(const uint8_t p_src[16], uint8_t r_dst[16]) {
+ int ret = mbedtls_aes_crypt_ecb((mbedtls_aes_context *)ctx, MBEDTLS_AES_DECRYPT, p_src, r_dst);
+ return ret ? FAILED : OK;
+}
+
+// CryptoCore
+String CryptoCore::b64_encode_str(const uint8_t *p_src, int p_src_len) {
+ int b64len = p_src_len / 3 * 4 + 4 + 1;
+ PoolVector<uint8_t> b64buff;
+ b64buff.resize(b64len);
+ PoolVector<uint8_t>::Write w64 = b64buff.write();
+ size_t strlen = 0;
+ int ret = b64_encode(&w64[0], b64len, &strlen, p_src, p_src_len);
+ w64[strlen] = 0;
+ return ret ? String() : (const char *)&w64[0];
+}
+
+Error CryptoCore::b64_encode(uint8_t *r_dst, int p_dst_len, size_t *r_len, const uint8_t *p_src, int p_src_len) {
+ int ret = mbedtls_base64_encode(r_dst, p_dst_len, r_len, p_src, p_src_len);
+ return ret ? FAILED : OK;
+}
+
+Error CryptoCore::b64_decode(uint8_t *r_dst, int p_dst_len, size_t *r_len, const uint8_t *p_src, int p_src_len) {
+ int ret = mbedtls_base64_decode(r_dst, p_dst_len, r_len, p_src, p_src_len);
+ return ret ? FAILED : OK;
+}
+
+Error CryptoCore::md5(const uint8_t *p_src, int p_src_len, unsigned char r_hash[16]) {
+ int ret = mbedtls_md5_ret(p_src, p_src_len, r_hash);
+ return ret ? FAILED : OK;
+}
+
+Error CryptoCore::sha1(const uint8_t *p_src, int p_src_len, unsigned char r_hash[20]) {
+ int ret = mbedtls_sha1_ret(p_src, p_src_len, r_hash);
+ return ret ? FAILED : OK;
+}
+
+Error CryptoCore::sha256(const uint8_t *p_src, int p_src_len, unsigned char r_hash[32]) {
+ int ret = mbedtls_sha256_ret(p_src, p_src_len, r_hash, 0);
+ return ret ? FAILED : OK;
+}
diff --git a/core/math/crypto_core.h b/core/math/crypto_core.h
new file mode 100644
index 0000000000..e28cb5a792
--- /dev/null
+++ b/core/math/crypto_core.h
@@ -0,0 +1,90 @@
+/*************************************************************************/
+/* crypto_core.h */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/*************************************************************************/
+
+#ifndef CRYPTO_CORE_H
+#define CRYPTO_CORE_H
+
+#include "core/reference.h"
+
+class CryptoCore {
+
+public:
+ class MD5Context {
+
+ private:
+ void *ctx; // To include, or not to include...
+
+ public:
+ MD5Context();
+ ~MD5Context();
+
+ Error start();
+ Error update(uint8_t *p_src, size_t p_len);
+ Error finish(unsigned char r_hash[16]);
+ };
+
+ class SHA256Context {
+
+ private:
+ void *ctx; // To include, or not to include...
+
+ public:
+ SHA256Context();
+ ~SHA256Context();
+
+ Error start();
+ Error update(uint8_t *p_src, size_t p_len);
+ Error finish(unsigned char r_hash[16]);
+ };
+
+ class AESContext {
+
+ private:
+ void *ctx; // To include, or not to include...
+
+ public:
+ AESContext();
+ ~AESContext();
+
+ Error set_encode_key(const uint8_t *p_key, size_t p_bits);
+ Error set_decode_key(const uint8_t *p_key, size_t p_bits);
+ Error encrypt_ecb(const uint8_t p_src[16], uint8_t r_dst[16]);
+ Error decrypt_ecb(const uint8_t p_src[16], uint8_t r_dst[16]);
+ };
+
+ static String b64_encode_str(const uint8_t *p_src, int p_src_len);
+ static Error b64_encode(uint8_t *r_dst, int p_dst_len, size_t *r_len, const uint8_t *p_src, int p_src_len);
+ static Error b64_decode(uint8_t *r_dst, int p_dst_len, size_t *r_len, const uint8_t *p_src, int p_src_len);
+
+ static Error md5(const uint8_t *p_src, int p_src_len, unsigned char r_hash[16]);
+ static Error sha1(const uint8_t *p_src, int p_src_len, unsigned char r_hash[20]);
+ static Error sha256(const uint8_t *p_src, int p_src_len, unsigned char r_hash[32]);
+};
+#endif // CRYPTO_CORE_H
diff --git a/core/math/expression.cpp b/core/math/expression.cpp
index 079c9b524f..2786229cf3 100644
--- a/core/math/expression.cpp
+++ b/core/math/expression.cpp
@@ -52,6 +52,7 @@ const char *Expression::func_name[Expression::FUNC_MAX] = {
"sqrt",
"fmod",
"fposmod",
+ "posmod",
"floor",
"ceil",
"round",
@@ -70,6 +71,7 @@ const char *Expression::func_name[Expression::FUNC_MAX] = {
"inverse_lerp",
"range_lerp",
"smoothstep",
+ "move_toward",
"dectime",
"randomize",
"randi",
@@ -174,6 +176,7 @@ int Expression::get_func_argument_count(BuiltinFunc p_func) {
case MATH_ATAN2:
case MATH_FMOD:
case MATH_FPOSMOD:
+ case MATH_POSMOD:
case MATH_POW:
case MATH_EASE:
case MATH_STEPIFY:
@@ -189,6 +192,7 @@ int Expression::get_func_argument_count(BuiltinFunc p_func) {
case MATH_LERP:
case MATH_INVERSE_LERP:
case MATH_SMOOTHSTEP:
+ case MATH_MOVE_TOWARD:
case MATH_DECTIME:
case MATH_WRAP:
case MATH_WRAPF:
@@ -281,6 +285,12 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
VALIDATE_ARG_NUM(1);
*r_return = Math::fposmod((double)*p_inputs[0], (double)*p_inputs[1]);
} break;
+ case MATH_POSMOD: {
+
+ VALIDATE_ARG_NUM(0);
+ VALIDATE_ARG_NUM(1);
+ *r_return = Math::posmod((int)*p_inputs[0], (int)*p_inputs[1]);
+ } break;
case MATH_FLOOR: {
VALIDATE_ARG_NUM(0);
@@ -407,6 +417,13 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
VALIDATE_ARG_NUM(2);
*r_return = Math::smoothstep((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
} break;
+ case MATH_MOVE_TOWARD: {
+
+ VALIDATE_ARG_NUM(0);
+ VALIDATE_ARG_NUM(1);
+ VALIDATE_ARG_NUM(2);
+ *r_return = Math::move_toward((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
+ } break;
case MATH_DECTIME: {
VALIDATE_ARG_NUM(0);
@@ -1785,7 +1802,7 @@ Expression::ENode *Expression::_parse_expression() {
if (next_op == -1) {
_set_error("Yet another parser bug....");
- ERR_FAIL_COND_V(next_op == -1, NULL);
+ ERR_FAIL_V(NULL);
}
// OK! create operator..
diff --git a/core/math/expression.h b/core/math/expression.h
index f20619f0b6..03a2bb70e6 100644
--- a/core/math/expression.h
+++ b/core/math/expression.h
@@ -34,7 +34,8 @@
#include "core/reference.h"
class Expression : public Reference {
- GDCLASS(Expression, Reference)
+ GDCLASS(Expression, Reference);
+
public:
enum BuiltinFunc {
MATH_SIN,
@@ -50,6 +51,7 @@ public:
MATH_SQRT,
MATH_FMOD,
MATH_FPOSMOD,
+ MATH_POSMOD,
MATH_FLOOR,
MATH_CEIL,
MATH_ROUND,
@@ -68,6 +70,7 @@ public:
MATH_INVERSE_LERP,
MATH_RANGE_LERP,
MATH_SMOOTHSTEP,
+ MATH_MOVE_TOWARD,
MATH_DECTIME,
MATH_RANDOMIZE,
MATH_RAND,
diff --git a/core/math/geometry.h b/core/math/geometry.h
index 0e144e491f..e4f3ff799e 100644
--- a/core/math/geometry.h
+++ b/core/math/geometry.h
@@ -455,16 +455,15 @@ public:
Vector3 p = p_point - p_segment[0];
Vector3 n = p_segment[1] - p_segment[0];
- real_t l = n.length();
- if (l < 1e-10)
+ real_t l2 = n.length_squared();
+ if (l2 < 1e-20)
return p_segment[0]; // both points are the same, just give any
- n /= l;
- real_t d = n.dot(p);
+ real_t d = n.dot(p) / l2;
if (d <= 0.0)
return p_segment[0]; // before first point
- else if (d >= l)
+ else if (d >= 1.0)
return p_segment[1]; // after first point
else
return p_segment[0] + n * d; // inside
@@ -474,12 +473,11 @@ public:
Vector3 p = p_point - p_segment[0];
Vector3 n = p_segment[1] - p_segment[0];
- real_t l = n.length();
- if (l < 1e-10)
+ real_t l2 = n.length_squared();
+ if (l2 < 1e-20)
return p_segment[0]; // both points are the same, just give any
- n /= l;
- real_t d = n.dot(p);
+ real_t d = n.dot(p) / l2;
return p_segment[0] + n * d; // inside
}
@@ -488,16 +486,15 @@ public:
Vector2 p = p_point - p_segment[0];
Vector2 n = p_segment[1] - p_segment[0];
- real_t l = n.length();
- if (l < 1e-10)
+ real_t l2 = n.length_squared();
+ if (l2 < 1e-20)
return p_segment[0]; // both points are the same, just give any
- n /= l;
- real_t d = n.dot(p);
+ real_t d = n.dot(p) / l2;
if (d <= 0.0)
return p_segment[0]; // before first point
- else if (d >= l)
+ else if (d >= 1.0)
return p_segment[1]; // after first point
else
return p_segment[0] + n * d; // inside
@@ -521,12 +518,11 @@ public:
Vector2 p = p_point - p_segment[0];
Vector2 n = p_segment[1] - p_segment[0];
- real_t l = n.length();
- if (l < 1e-10)
+ real_t l2 = n.length_squared();
+ if (l2 < 1e-20)
return p_segment[0]; // both points are the same, just give any
- n /= l;
- real_t d = n.dot(p);
+ real_t d = n.dot(p) / l2;
return p_segment[0] + n * d; // inside
}
diff --git a/core/math/math_funcs.cpp b/core/math/math_funcs.cpp
index 5b5fd8e283..7a2e74a413 100644
--- a/core/math/math_funcs.cpp
+++ b/core/math/math_funcs.cpp
@@ -161,8 +161,6 @@ uint32_t Math::larger_prime(uint32_t p_val) {
return primes[idx];
idx++;
}
-
- return 0;
}
double Math::random(double from, double to) {
diff --git a/core/math/math_funcs.h b/core/math/math_funcs.h
index 82b5b56c01..b6398712e4 100644
--- a/core/math/math_funcs.h
+++ b/core/math/math_funcs.h
@@ -198,6 +198,13 @@ public:
value += 0.0;
return value;
}
+ static _ALWAYS_INLINE_ int posmod(int p_x, int p_y) {
+ int value = p_x % p_y;
+ if ((value < 0 && p_y > 0) || (value > 0 && p_y < 0)) {
+ value += p_y;
+ }
+ return value;
+ }
static _ALWAYS_INLINE_ double deg2rad(double p_y) { return p_y * Math_PI / 180.0; }
static _ALWAYS_INLINE_ float deg2rad(float p_y) { return p_y * Math_PI / 180.0; }
@@ -224,6 +231,8 @@ public:
float x = CLAMP((p_weight - p_from) / (p_to - p_from), 0.0f, 1.0f);
return x * x * (3.0f - 2.0f * x);
}
+ static _ALWAYS_INLINE_ double move_toward(double p_from, double p_to, double p_delta) { return abs(p_to - p_from) <= p_delta ? p_to : p_from + SGN(p_to - p_from) * p_delta; }
+ static _ALWAYS_INLINE_ float move_toward(float p_from, float p_to, float p_delta) { return abs(p_to - p_from) <= p_delta ? p_to : p_from + SGN(p_to - p_from) * p_delta; }
static _ALWAYS_INLINE_ double linear2db(double p_linear) { return Math::log(p_linear) * 8.6858896380650365530225783783321; }
static _ALWAYS_INLINE_ float linear2db(float p_linear) { return Math::log(p_linear) * 8.6858896380650365530225783783321; }
diff --git a/core/math/random_number_generator.cpp b/core/math/random_number_generator.cpp
index 6add00c1d8..54a88d5cd8 100644
--- a/core/math/random_number_generator.cpp
+++ b/core/math/random_number_generator.cpp
@@ -30,8 +30,7 @@
#include "random_number_generator.h"
-RandomNumberGenerator::RandomNumberGenerator() :
- randbase() {}
+RandomNumberGenerator::RandomNumberGenerator() {}
void RandomNumberGenerator::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_seed", "seed"), &RandomNumberGenerator::set_seed);
diff --git a/core/math/random_number_generator.h b/core/math/random_number_generator.h
index 6b6bcdd2cd..9b54ea9b2e 100644
--- a/core/math/random_number_generator.h
+++ b/core/math/random_number_generator.h
@@ -47,7 +47,7 @@ public:
_FORCE_INLINE_ uint64_t get_seed() { return randbase.get_seed(); }
- _FORCE_INLINE_ void randomize() { return randbase.randomize(); }
+ _FORCE_INLINE_ void randomize() { randbase.randomize(); }
_FORCE_INLINE_ uint32_t randi() { return randbase.rand(); }
@@ -59,7 +59,10 @@ public:
_FORCE_INLINE_ int randi_range(int from, int to) {
unsigned int ret = randbase.rand();
- return ret % (to - from + 1) + from;
+ if (to < from)
+ return ret % (from - to + 1) + to;
+ else
+ return ret % (to - from + 1) + from;
}
RandomNumberGenerator();
diff --git a/core/math/random_pcg.cpp b/core/math/random_pcg.cpp
index 8351bd138e..00c0af515d 100644
--- a/core/math/random_pcg.cpp
+++ b/core/math/random_pcg.cpp
@@ -43,13 +43,9 @@ void RandomPCG::randomize() {
}
double RandomPCG::random(double p_from, double p_to) {
- unsigned int r = rand();
- double ret = (double)r / (double)RANDOM_MAX;
- return (ret) * (p_to - p_from) + p_from;
+ return randd() * (p_to - p_from) + p_from;
}
float RandomPCG::random(float p_from, float p_to) {
- unsigned int r = rand();
- float ret = (float)r / (float)RANDOM_MAX;
- return (ret) * (p_to - p_from) + p_from;
+ return randf() * (p_to - p_from) + p_from;
}
diff --git a/core/math/random_pcg.h b/core/math/random_pcg.h
index 0d1b311c0d..aa25914638 100644
--- a/core/math/random_pcg.h
+++ b/core/math/random_pcg.h
@@ -37,6 +37,28 @@
#include "thirdparty/misc/pcg.h"
+#if defined(__GNUC__) || (_llvm_has_builtin(__builtin_clz))
+#define CLZ32(x) __builtin_clz(x)
+#elif defined(_MSC_VER)
+#include "intrin.h"
+static int __bsr_clz32(uint32_t x) {
+ unsigned long index;
+ _BitScanReverse(&index, x);
+ return 31 - index;
+}
+#define CLZ32(x) __bsr_clz32(x)
+#else
+#endif
+
+#if defined(__GNUC__) || (_llvm_has_builtin(__builtin_ldexp) && _llvm_has_builtin(__builtin_ldexpf))
+#define LDEXP(s, e) __builtin_ldexp(s, e)
+#define LDEXPF(s, e) __builtin_ldexpf(s, e)
+#else
+#include "math.h"
+#define LDEXP(s, e) ldexp(s, e)
+#define LDEXPF(s, e) ldexp(s, e)
+#endif
+
class RandomPCG {
pcg32_random_t pcg;
uint64_t current_seed; // seed with this to get the same state
@@ -60,8 +82,44 @@ public:
current_seed = pcg.state;
return pcg32_random_r(&pcg);
}
- _FORCE_INLINE_ double randd() { return (double)rand() / (double)RANDOM_MAX; }
- _FORCE_INLINE_ float randf() { return (float)rand() / (float)RANDOM_MAX; }
+
+ // Obtaining floating point numbers in [0, 1] range with "good enough" uniformity.
+ // These functions sample the output of rand() as the fraction part of an infinite binary number,
+ // with some tricks applied to reduce ops and branching:
+ // 1. Instead of shifting to the first 1 and connecting random bits, we simply set the MSB and LSB to 1.
+ // Provided that the RNG is actually uniform bit by bit, this should have the exact same effect.
+ // 2. In order to compensate for exponent info loss, we count zeros from another random number,
+ // and just add that to the initial offset.
+ // This has the same probability as counting and shifting an actual bit stream: 2^-n for n zeroes.
+ // For all numbers above 2^-96 (2^-64 for floats), the functions should be uniform.
+ // However, all numbers below that threshold are floored to 0.
+ // The thresholds are chosen to minimize rand() calls while keeping the numbers within a totally subjective quality standard.
+ // If clz or ldexp isn't available, fall back to bit truncation for performance, sacrificing uniformity.
+ _FORCE_INLINE_ double randd() {
+#if defined(CLZ32)
+ uint32_t proto_exp_offset = rand();
+ if (unlikely(proto_exp_offset == 0)) {
+ return 0;
+ }
+ uint64_t significand = (((uint64_t)rand()) << 32) | rand() | 0x8000000000000001U;
+ return LDEXP((double)significand, -64 - CLZ32(proto_exp_offset));
+#else
+#pragma message("RandomPCG::randd - intrinsic clz is not available, falling back to bit truncation")
+ return (double)(((((uint64_t)rand()) << 32) | rand()) & 0x1FFFFFFFFFFFFFU) / (double)0x1FFFFFFFFFFFFFU;
+#endif
+ }
+ _FORCE_INLINE_ float randf() {
+#if defined(CLZ32)
+ uint32_t proto_exp_offset = rand();
+ if (unlikely(proto_exp_offset == 0)) {
+ return 0;
+ }
+ return LDEXPF((float)(rand() | 0x80000001), -32 - CLZ32(proto_exp_offset));
+#else
+#pragma message("RandomPCG::randf - intrinsic clz is not available, falling back to bit truncation")
+ return (float)(rand() & 0xFFFFFF) / (float)0xFFFFFF;
+#endif
+ }
_FORCE_INLINE_ double randfn(double p_mean, double p_deviation) {
return p_mean + p_deviation * (cos(Math_TAU * randd()) * sqrt(-2.0 * log(randd()))); // Box-Muller transform
diff --git a/core/math/triangle_mesh.cpp b/core/math/triangle_mesh.cpp
index 83784a1fa7..546981be44 100644
--- a/core/math/triangle_mesh.cpp
+++ b/core/math/triangle_mesh.cpp
@@ -182,7 +182,7 @@ void TriangleMesh::create(const PoolVector<Vector3> &p_faces) {
int max_alloc = fc;
_create_bvh(bw.ptr(), bwp.ptr(), 0, fc, 1, max_depth, max_alloc);
- bw = PoolVector<BVH>::Write(); //clearup
+ bw.release(); //clearup
bvh.resize(max_alloc); //resize back
valid = true;
@@ -751,7 +751,7 @@ PoolVector<Face3> TriangleMesh::get_faces() const {
}
}
- w = PoolVector<Face3>::Write();
+ w.release();
return faces;
}
diff --git a/core/math/triangle_mesh.h b/core/math/triangle_mesh.h
index ee7bf0f6b5..8b01080852 100644
--- a/core/math/triangle_mesh.h
+++ b/core/math/triangle_mesh.h
@@ -97,7 +97,7 @@ public:
PoolVector<Triangle> get_triangles() const { return triangles; }
PoolVector<Vector3> get_vertices() const { return vertices; }
- void get_indices(PoolVector<int> *p_triangles_indices) const;
+ void get_indices(PoolVector<int> *r_triangles_indices) const;
void create(const PoolVector<Vector3> &p_faces);
TriangleMesh();
diff --git a/core/math/vector2.cpp b/core/math/vector2.cpp
index 5c1ea5943d..779a28be66 100644
--- a/core/math/vector2.cpp
+++ b/core/math/vector2.cpp
@@ -164,6 +164,13 @@ Vector2 Vector2::cubic_interpolate(const Vector2 &p_b, const Vector2 &p_pre_a, c
return out;
}
+Vector2 Vector2::move_toward(const Vector2 &p_to, const real_t p_delta) const {
+ Vector2 v = *this;
+ Vector2 vd = p_to - v;
+ real_t len = vd.length();
+ return len <= p_delta || len < CMP_EPSILON ? p_to : v + vd / len * p_delta;
+}
+
// slide returns the component of the vector along the given plane, specified by its normal vector.
Vector2 Vector2::slide(const Vector2 &p_normal) const {
#ifdef MATH_CHECKS
diff --git a/core/math/vector2.h b/core/math/vector2.h
index a0c6024c9f..78a1641c1e 100644
--- a/core/math/vector2.h
+++ b/core/math/vector2.h
@@ -79,6 +79,7 @@ struct Vector2 {
_FORCE_INLINE_ Vector2 linear_interpolate(const Vector2 &p_b, real_t p_t) const;
_FORCE_INLINE_ Vector2 slerp(const Vector2 &p_b, real_t p_t) const;
Vector2 cubic_interpolate(const Vector2 &p_b, const Vector2 &p_pre_a, const Vector2 &p_post_b, real_t p_t) const;
+ Vector2 move_toward(const Vector2 &p_to, const real_t p_delta) const;
Vector2 slide(const Vector2 &p_normal) const;
Vector2 bounce(const Vector2 &p_normal) const;
diff --git a/core/math/vector3.cpp b/core/math/vector3.cpp
index 1c28934422..73927821cf 100644
--- a/core/math/vector3.cpp
+++ b/core/math/vector3.cpp
@@ -127,6 +127,13 @@ Vector3 Vector3::cubic_interpolate(const Vector3 &p_b, const Vector3 &p_pre_a, c
return out;
}
+Vector3 Vector3::move_toward(const Vector3 &p_to, const real_t p_delta) const {
+ Vector3 v = *this;
+ Vector3 vd = p_to - v;
+ real_t len = vd.length();
+ return len <= p_delta || len < CMP_EPSILON ? p_to : v + vd / len * p_delta;
+}
+
Vector3::operator String() const {
return (rtos(x) + ", " + rtos(y) + ", " + rtos(z));
diff --git a/core/math/vector3.h b/core/math/vector3.h
index 21fc09653f..45bdfee487 100644
--- a/core/math/vector3.h
+++ b/core/math/vector3.h
@@ -94,6 +94,7 @@ struct Vector3 {
_FORCE_INLINE_ Vector3 slerp(const Vector3 &p_b, real_t p_t) const;
Vector3 cubic_interpolate(const Vector3 &p_b, const Vector3 &p_pre_a, const Vector3 &p_post_b, real_t p_t) const;
Vector3 cubic_interpolaten(const Vector3 &p_b, const Vector3 &p_pre_a, const Vector3 &p_post_b, real_t p_t) const;
+ Vector3 move_toward(const Vector3 &p_to, const real_t p_delta) const;
_FORCE_INLINE_ Vector3 cross(const Vector3 &p_b) const;
_FORCE_INLINE_ real_t dot(const Vector3 &p_b) const;
@@ -218,12 +219,8 @@ Vector3 Vector3::linear_interpolate(const Vector3 &p_b, real_t p_t) const {
}
Vector3 Vector3::slerp(const Vector3 &p_b, real_t p_t) const {
-#ifdef MATH_CHECKS
- ERR_FAIL_COND_V(!is_normalized(), Vector3());
-#endif
-
real_t theta = angle_to(p_b);
- return rotated(cross(p_b), theta * p_t);
+ return rotated(cross(p_b).normalized(), theta * p_t);
}
real_t Vector3::distance_to(const Vector3 &p_b) const {
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-03 15:57:31 +0000