Sara.Sync
/
godot-cpp
mirror of https://github.com/godotengine/godot-cpp
0
1
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into container_leaks

pull/490/head
Marc 2021-01-31 20:06:56 +00:00 committed by GitHub
parent fb71edd45b 05ba977cc6
commit b400dba875
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
25 changed files with 281 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.github/dependabot.yml vendored Normal file
View File

@ -0,0 +1,6 @@
version: 2
updates:
- package-ecosystem: "github-actions"
directory: "/"
schedule:
interval: "daily"

126
.github/workflows/ci.yml vendored Normal file
View File

@ -0,0 +1,126 @@
name: Continuous integration
on: [push, pull_request]
jobs:
linux:
name: Build (Linux, GCC)
runs-on: ubuntu-16.04
steps:
- name: Checkout
uses: actions/checkout@v2.3.4
with:
submodules: recursive
- name: Set up Python (for SCons)
uses: actions/setup-python@v2
with:
python-version: '3.9.1'
- name: Install dependencies
run: |
sudo apt-get update -qq
sudo apt-get install -qqq build-essential pkg-config
python -m pip install scons
- name: Build godot-cpp
run: |
scons target=release generate_bindings=yes -j $(nproc)
- name: Upload artifact
uses: actions/upload-artifact@v2.2.1
with:
name: godot-cpp-linux-glibc2.23-x86_64-release
path: bin/libgodot-cpp.linux.release.64.a
if-no-files-found: error
windows-msvc:
name: Build (Windows, MSVC)
runs-on: windows-2019
steps:
- name: Checkout
uses: actions/checkout@v2.3.4
with:
submodules: recursive
- name: Set up Python (for SCons)
uses: actions/setup-python@v2
with:
python-version: '3.9.1'
- name: Install dependencies
run: |
python -m pip install scons
- name: Build godot-cpp
run: |
scons target=release generate_bindings=yes -j $env:NUMBER_OF_PROCESSORS
- name: Upload artifact
uses: actions/upload-artifact@v2.2.1
with:
name: godot-cpp-windows-msvc2019-x86_64-release
path: bin/libgodot-cpp.windows.release.64.lib
if-no-files-found: error
windows-mingw:
name: Build (Windows, MinGW)
runs-on: windows-2019
steps:
- name: Checkout
uses: actions/checkout@v2.3.4
with:
submodules: recursive
- name: Set up Python (for SCons)
uses: actions/setup-python@v2
with:
python-version: '3.9.1'
- name: Install dependencies
run: |
python -m pip install scons
- name: Build godot-cpp
# Install GCC from Scoop as the default supplied GCC doesn't work ("Error 1").
run: |
Invoke-Expression (New-Object System.Net.WebClient).DownloadString('https://get.scoop.sh')
scoop install gcc
g++ --version
gcc --version
scons target=release generate_bindings=yes use_mingw=yes -j $env:NUMBER_OF_PROCESSORS
- name: Upload artifact
uses: actions/upload-artifact@v2.2.1
with:
name: godot-cpp-linux-mingw-x86_64-release
path: bin/libgodot-cpp.windows.release.64.a
if-no-files-found: error
macos:
name: Build (macOS, Clang)
runs-on: macos-11.0
steps:
- name: Checkout
uses: actions/checkout@v2.3.4
with:
submodules: recursive
- name: Set up Python (for SCons)
uses: actions/setup-python@v2
with:
python-version: '3.9.1'
- name: Install dependencies
run: |
python -m pip install scons
- name: Build godot-cpp
run: |
scons target=release generate_bindings=yes -j $(sysctl -n hw.logicalcpu)
- name: Upload artifact
uses: actions/upload-artifact@v2.2.1
with:
name: godot-cpp-macos-x86_64-release
path: bin/libgodot-cpp.osx.release.64.a
if-no-files-found: error

75
.travis.yml
View File

@ -1,75 +0,0 @@
language: cpp
dist: xenial
osx_image: xcode10.1
env:
global:
- SCONS_CACHE="$HOME/.scons_cache"
- SCONS_CACHE_LIMIT=1024
cache:
directories:
- $SCONS_CACHE
matrix:
include:
- name: Linux Debug + Static Checks
os: linux
compiler: gcc
env: TARGET=debug STATIC_CHECKS=yes
addons:
apt:
packages:
- clang-format-8
- [scons, pkg-config, build-essential, p7zip-full]
- name: Linux Release
os: linux
compiler: gcc
addons:
apt:
packages:
- [scons, pkg-config, build-essential, p7zip-full]
env: TARGET=release
- name: macOS Debug
os: osx
compiler: clang
env: TARGET=debug
- name: macOS Release
os: osx
compiler: clang
env: TARGET=release
- name: Windows MSVC Debug
os: windows
env: TARGET=debug
- name: Windows MSVC Release
os: windows
env: TARGET=release
install:
- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
brew update;
brew install scons p7zip;
fi
- if [[ "$TRAVIS_OS_NAME" == "windows" ]]; then
curl -LO https://downloads.sourceforge.net/project/scons/scons-local/3.1.2/scons-local-3.1.2.zip;
unzip scons-local-3.1.2.zip;
fi
script:
- if [[ "$TRAVIS_OS_NAME" == "windows" ]]; then
export SCONS="./scons.bat";
else
export SCONS="scons";
fi
- $SCONS target="$TARGET" bits=64 generate_bindings=yes $SCONS_FLAGS;
- if [[ "$STATIC_CHECKS" == "yes" ]]; then
sh ./misc/travis/clang-format.sh;
fi

4
README.md
View File

@ -292,8 +292,8 @@ platform-independent manner.
Once your GDNative library is compiled and referenced in a `.gdns` file, you can use it in GDScript or C#. Here's an example with GDScript:
```gdscript
var simpleclass = load("res://simpleclass.gdns").new();
simpleclass.method("Test argument");
var simpleclass = load("res://simpleclass.gdns").new()
simpleclass.method("Test argument")
```
### Using Godot classes in C++

9
SConstruct
View File

@ -134,6 +134,11 @@ opts.Add(EnumVariable(
'armv7',
['armv7','arm64v8','x86','x86_64']
))
opts.Add(
'macos_deployment_target',
'macOS deployment target',
'default'
)
opts.Add(EnumVariable(
'ios_arch',
'Target iOS architecture',
@ -204,6 +209,10 @@ elif env['platform'] == 'osx':
)
env.Append(CCFLAGS=['-std=c++14', '-arch', 'x86_64'])
if env['macos_deployment_target'] != 'default':
env.Append(CCFLAGS=['-mmacosx-version-min=' + env['macos_deployment_target']])
env.Append(LINKFLAGS=[
'-arch',
'x86_64',

2
godot_headers

@ -1 +1 @@
Subproject commit ddf67cc7b8274c5fb77a71c828bab2991f1ee12a
Subproject commit f2122198d51f230d903f9585527248f6cf411494

6
include/core/Array.hpp
View File

@ -106,9 +106,9 @@ public:
Variant back() const;
int find(const Variant &what, const int from = 0);
int find(const Variant &what, const int from = 0) const;
int find_last(const Variant &what);
int find_last(const Variant &what) const;
bool has(const Variant &what) const;
@ -134,7 +134,7 @@ public:
void resize(const int size);
int rfind(const Variant &what, const int from = -1);
int rfind(const Variant &what, const int from = -1) const;
void sort();

5
include/core/Basis.hpp
View File

@ -13,6 +13,11 @@ class Quat;
class Basis {
private:
static const Basis IDENTITY;
static const Basis FLIP_X;
static const Basis FLIP_Y;
static const Basis FLIP_Z;
// This helper template is for mimicking the behavior difference between the engine
// and script interfaces that logically script sees matrices as column major, while
// the engine stores them in row major to efficiently take advantage of SIMD

7
include/core/Defs.hpp
View File

@ -70,9 +70,12 @@ enum class Error {
typedef float real_t;
#define CMP_EPSILON 0.00001
// This epsilon should match the one used by Godot for consistency.
// Using `f` when `real_t` is float.
#define CMP_EPSILON 0.00001f
#define CMP_EPSILON2 (CMP_EPSILON * CMP_EPSILON)
#define Math_PI 3.14159265358979323846
#define Math_PI 3.1415926535897932384626433833
#define Math_TAU 6.2831853071795864769252867666
#define _PLANE_EQ_DOT_EPSILON 0.999

22
include/core/Godot.hpp
View File

@ -149,7 +149,7 @@ struct _ArgCast<Variant> {
// instance and destroy funcs
template <class T>
void *_godot_class_instance_func(godot_object *p, void *method_data) {
void *_godot_class_instance_func(godot_object *p, void * /*method_data*/) {
T *d = new T();
d->_owner = p;
d->_type_tag = typeid(T).hash_code();
@ -158,7 +158,7 @@ void *_godot_class_instance_func(godot_object *p, void *method_data) {
}
template <class T>
void _godot_class_destroy_func(godot_object *p, void *method_data, void *data) {
void _godot_class_destroy_func(godot_object * /*p*/, void * /*method_data*/, void *data) {
T *d = (T *)data;
delete d;
}
@ -210,13 +210,13 @@ void register_tool_class() {
typedef godot_variant (*__godot_wrapper_method)(godot_object *, void *, void *, int, godot_variant **);
template <class T, class R, class... args>
const char *___get_method_class_name(R (T::*p)(args... a)) {
const char *___get_method_class_name(R (T::*/*p*/)(args... a)) {
static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes");
return T::___get_class_name();
}
template <class T, class R, class... args>
const char *___get_method_class_name(R (T::*p)(args... a) const) {
const char *___get_method_class_name(R (T::*/*p*/)(args... a) const) {
static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes");
return T::___get_class_name();
}
@ -256,13 +256,13 @@ struct _WrappedMethod<T, void, As...> {
void (T::*f)(As...);
template <int... I>
void apply(Variant *ret, T *obj, Variant **args, __Sequence<I...>) {
void apply(Variant * /*ret*/, T *obj, Variant **args, __Sequence<I...>) {
(obj->*f)(_ArgCast<As>::_arg_cast(*args[I])...);
}
};
template <class T, class R, class... As>
godot_variant __wrapped_method(godot_object *, void *method_data, void *user_data, int num_args, godot_variant **args) {
godot_variant __wrapped_method(godot_object *, void *method_data, void *user_data, int /*num_args*/, godot_variant **args) {
godot_variant v;
godot::api->godot_variant_new_nil(&v);
@ -286,7 +286,7 @@ void *___make_wrapper_function(R (T::*f)(As...)) {
}
template <class T, class R, class... As>
__godot_wrapper_method ___get_wrapper_function(R (T::*f)(As...)) {
__godot_wrapper_method ___get_wrapper_function(R (T::* /*f*/)(As...)) {
return (__godot_wrapper_method)&__wrapped_method<T, R, As...>;
}
@ -326,7 +326,7 @@ void register_method_explicit(const char *name, R (B::*method_ptr)(As...),
template <class T, class P>
struct _PropertySetFunc {
void (T::*f)(P);
static void _wrapped_setter(godot_object *object, void *method_data, void *user_data, godot_variant *value) {
static void _wrapped_setter(godot_object * /*object*/, void *method_data, void *user_data, godot_variant *value) {
_PropertySetFunc<T, P> *set_func = (_PropertySetFunc<T, P> *)method_data;
T *obj = (T *)user_data;
@ -340,7 +340,7 @@ template <class T, class P>
struct _PropertyGetFunc {
P(T::*f)
();
static godot_variant _wrapped_getter(godot_object *object, void *method_data, void *user_data) {
static godot_variant _wrapped_getter(godot_object * /*object*/, void *method_data, void *user_data) {
_PropertyGetFunc<T, P> *get_func = (_PropertyGetFunc<T, P> *)method_data;
T *obj = (T *)user_data;
@ -358,7 +358,7 @@ struct _PropertyGetFunc {
template <class T, class P>
struct _PropertyDefaultSetFunc {
P(T::*f);
static void _wrapped_setter(godot_object *object, void *method_data, void *user_data, godot_variant *value) {
static void _wrapped_setter(godot_object * /*object*/, void *method_data, void *user_data, godot_variant *value) {
_PropertyDefaultSetFunc<T, P> *set_func = (_PropertyDefaultSetFunc<T, P> *)method_data;
T *obj = (T *)user_data;
@ -371,7 +371,7 @@ struct _PropertyDefaultSetFunc {
template <class T, class P>
struct _PropertyDefaultGetFunc {
P(T::*f);
static godot_variant _wrapped_getter(godot_object *object, void *method_data, void *user_data) {
static godot_variant _wrapped_getter(godot_object * /*object*/, void *method_data, void *user_data) {
_PropertyDefaultGetFunc<T, P> *get_func = (_PropertyDefaultGetFunc<T, P> *)method_data;
T *obj = (T *)user_data;

26
include/core/Math.hpp
View File

@ -107,21 +107,21 @@ inline T max(T a, T b) {
template <typename T>
inline T sign(T x) {
return x < 0 ? -1 : 1;
return static_cast<T>(x < 0 ? -1 : 1);
}
inline double deg2rad(double p_y) {
return p_y * Math_PI / 180.0;
}
inline float deg2rad(float p_y) {
return p_y * Math_PI / 180.0;
return p_y * static_cast<float>(Math_PI) / 180.f;
}
inline double rad2deg(double p_y) {
return p_y * 180.0 / Math_PI;
}
inline float rad2deg(float p_y) {
return p_y * 180.0 / Math_PI;
return p_y * 180.f / static_cast<float>(Math_PI);
}
inline double inverse_lerp(double p_from, double p_to, double p_value) {
@ -165,7 +165,7 @@ inline bool is_zero_approx(real_t s) {
}
inline double smoothstep(double p_from, double p_to, double p_weight) {
if (is_equal_approx(p_from, p_to)) {
if (is_equal_approx(static_cast<real_t>(p_from), static_cast<real_t>(p_to))) {
return p_from;
}
double x = clamp((p_weight - p_from) / (p_to - p_from), 0.0, 1.0);
@ -205,7 +205,7 @@ inline double round(double p_val) {
return (p_val >= 0) ? floor(p_val + 0.5) : -floor(-p_val + 0.5);
}
inline float round(float p_val) {
return (p_val >= 0) ? floor(p_val + 0.5) : -floor(-p_val + 0.5);
return (p_val >= 0) ? floor(p_val + 0.5f) : -floor(-p_val + 0.5f);
}
inline int64_t wrapi(int64_t value, int64_t min, int64_t max) {
@ -213,16 +213,18 @@ inline int64_t wrapi(int64_t value, int64_t min, int64_t max) {
return range == 0 ? min : min + ((((value - min) % range) + range) % range);
}
inline double wrapf(double value, double min, double max) {
double range = max - min;
return is_zero_approx(range) ? min : value - (range * floor((value - min) / range));
}
inline float wrapf(float value, float min, float max) {
float range = max - min;
inline float wrapf(real_t value, real_t min, real_t max) {
const real_t range = max - min;
return is_zero_approx(range) ? min : value - (range * floor((value - min) / range));
}
inline real_t stepify(real_t p_value, real_t p_step) {
inline float stepify(float p_value, float p_step) {
if (p_step != 0) {
p_value = floor(p_value / p_step + 0.5f) * p_step;
}
return p_value;
}
inline double stepify(double p_value, double p_step) {
if (p_step != 0) {
p_value = floor(p_value / p_step + 0.5) * p_step;
}

2
include/core/Quat.hpp
View File

@ -11,6 +11,8 @@ namespace godot {
class Quat {
public:
static const Quat IDENTITY;
real_t x, y, z, w;
real_t length_squared() const;

40
include/core/Ref.hpp
View File

@ -11,6 +11,10 @@ namespace godot {
// Rewritten from f5234e70be7dec4930c2d5a0e829ff480d044b1d.
template <class T>
class Ref {
// TODO For this nice check to work, each class must actually #include Reference classes mentionned in its methods,
// which might be annoying for coders who prefer to forward-declare to reduce compile times
// static_assert(std::is_base_of<Reference, T>::value,
// "Ref<T> can only be used with classes deriving from Reference");
T *reference = nullptr;
@ -28,7 +32,7 @@ class Ref {
void ref_pointer(T *p_ref) {
ERR_FAIL_COND(!p_ref);
ERR_FAIL_COND(p_ref == nullptr);
if (p_ref->init_ref())
reference = p_ref;
@ -90,32 +94,25 @@ public:
template <class T_Other>
void operator=(const Ref<T_Other> &p_from) {
// TODO We need a safe cast
Reference *refb = const_cast<Reference *>(static_cast<const Reference *>(p_from.ptr()));
if (!refb) {
if (refb == nullptr) {
unref();
return;
}
Ref r;
//r.reference = Object::cast_to<T>(refb);
r.reference = (T *)refb;
r.reference = Object::cast_to<T>(refb);
ref(r);
r.reference = nullptr;
}
void operator=(const Variant &p_variant) {
// TODO We need a safe cast
Reference *refb = (Reference *)T::___get_from_variant(p_variant);
if (!refb) {
Object *refb = T::___get_from_variant(p_variant);
if (refb == nullptr) {
unref();
return;
}
Ref r;
// TODO We need a safe cast
//r.reference = Object::cast_to<T>(refb);
r.reference = (T *)refb;
r.reference = Object::cast_to<T>(refb);
ref(r);
r.reference = nullptr;
}
@ -128,18 +125,14 @@ public:
template <class T_Other>
Ref(const Ref<T_Other> &p_from) {
reference = nullptr;
// TODO We need a safe cast
Reference *refb = const_cast<Reference *>(static_cast<const Reference *>(p_from.ptr()));
if (!refb) {
if (refb == nullptr) {
unref();
return;
}
Ref r;
// TODO We need a safe cast
//r.reference = Object::cast_to<T>(refb);
r.reference = (T *)refb;
r.reference = Object::cast_to<T>(refb);
ref(r);
r.reference = nullptr;
}
@ -155,16 +148,13 @@ public:
Ref(const Variant &p_variant) {
reference = nullptr;
// TODO We need a safe cast
Reference *refb = (Reference *)T::___get_from_variant(p_variant);
if (!refb) {
Object *refb = T::___get_from_variant(p_variant);
if (refb == nullptr) {
unref();
return;
}
Ref r;
// TODO We need a safe cast
//r.reference = Object::cast_to<T>(refb);
r.reference = (T *)refb;
r.reference = Object::cast_to<T>(refb);
ref(r);
r.reference = nullptr;
}

5
include/core/Transform.hpp
View File

@ -10,6 +10,11 @@ namespace godot {
class Transform {
public:
static const Transform IDENTITY;
static const Transform FLIP_X;
static const Transform FLIP_Y;
static const Transform FLIP_Z;
Basis basis;
Vector3 origin;

4
include/core/Transform2D.hpp
View File

@ -10,6 +10,10 @@ typedef Vector2 Size2;
struct Rect2;
struct Transform2D {
static const Transform2D IDENTITY;
static const Transform2D FLIP_X;
static const Transform2D FLIP_Y;
// Warning #1: basis of Transform2D is stored differently from Basis. In terms of elements array, the basis matrix looks like "on paper":
// M = (elements[0][0] elements[1][0])
// (elements[0][1] elements[1][1])

15
include/core/Vector2.hpp
View File

@ -12,6 +12,21 @@ namespace godot {
class String;
struct Vector2 {
enum Axis {
AXIS_X = 0,
AXIS_Y,
AXIS_COUNT
};
static const Vector2 ZERO;
static const Vector2 ONE;
static const Vector2 INF;
// Coordinate system of the 2D engine
static const Vector2 LEFT;
static const Vector2 RIGHT;
static const Vector2 UP;
static const Vector2 DOWN;
union {
real_t x;

13
include/core/Vector3.hpp
View File

@ -19,8 +19,21 @@ struct Vector3 {
AXIS_X,
AXIS_Y,
AXIS_Z,
AXIS_COUNT
};
static const Vector3 ZERO;
static const Vector3 ONE;
static const Vector3 INF;
// Coordinate system of the 3D engine
static const Vector3 LEFT;
static const Vector3 RIGHT;
static const Vector3 UP;
static const Vector3 DOWN;
static const Vector3 FORWARD;
static const Vector3 BACK;
union {
struct {
real_t x;

6
src/core/Array.cpp
View File

@ -94,11 +94,11 @@ Variant Array::back() const {
return Variant(v);
}
int Array::find(const Variant &what, const int from) {
int Array::find(const Variant &what, const int from) const {
return godot::api->godot_array_find(&_godot_array, (godot_variant *)&what, from);
}
int Array::find_last(const Variant &what) {
int Array::find_last(const Variant &what) const {
return godot::api->godot_array_find_last(&_godot_array, (godot_variant *)&what);
}
@ -148,7 +148,7 @@ void Array::resize(const int size) {
godot::api->godot_array_resize(&_godot_array, size);
}
int Array::rfind(const Variant &what, const int from) {
int Array::rfind(const Variant &what, const int from) const {
return godot::api->godot_array_rfind(&_godot_array, (godot_variant *)&what, from);
}

5
src/core/Basis.cpp
View File

@ -7,6 +7,11 @@
namespace godot {
const Basis Basis::IDENTITY = Basis();
const Basis Basis::FLIP_X = Basis(-1, 0, 0, 0, 1, 0, 0, 0, 1);
const Basis Basis::FLIP_Y = Basis(1, 0, 0, 0, -1, 0, 0, 0, 1);
const Basis Basis::FLIP_Z = Basis(1, 0, 0, 0, 1, 0, 0, 0, -1);
Basis::Basis(const Vector3 &row0, const Vector3 &row1, const Vector3 &row2) {
elements[0] = row0;
elements[1] = row1;

2
src/core/Quat.cpp
View File

@ -7,6 +7,8 @@
namespace godot {
const Quat Quat::IDENTITY = Quat();
// set_euler_xyz expects a vector containing the Euler angles in the format
// (ax,ay,az), where ax is the angle of rotation around x axis,
// and similar for other axes.

9
src/core/String.cpp
View File

@ -392,17 +392,20 @@ float String::similarity(String text) const {
return godot::api->godot_string_similarity(&_godot_string, &text._godot_string);
}
PoolStringArray String::split(String divisor, bool allow_empty) const {
// TODO Suport allow_empty
PoolStringArray String::split(String divisor, bool /*allow_empty*/) const {
godot_array arr = godot::api->godot_string_split(&_godot_string, &divisor._godot_string);
return Array(arr);
}
PoolIntArray String::split_ints(String divisor, bool allow_empty) const {
// TODO Suport allow_empty
PoolIntArray String::split_ints(String divisor, bool /*allow_empty*/) const {
godot_array arr = godot::api->godot_string_split_floats(&_godot_string, &divisor._godot_string);
return Array(arr);
}
PoolRealArray String::split_floats(String divisor, bool allow_empty) const {
// TODO Suport allow_empty
PoolRealArray String::split_floats(String divisor, bool /*allow_empty*/) const {
// TODO The GDNative API returns godot_array, when according to the doc, it should have been godot_pool_real_array
godot_array arr = godot::api->godot_string_split_floats(&_godot_string, &divisor._godot_string);
Array wrapped_array(arr);

5
src/core/Transform.cpp
View File

@ -9,6 +9,11 @@
namespace godot {
const Transform Transform::IDENTITY = Transform();
const Transform Transform::FLIP_X = Transform(-1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0);
const Transform Transform::FLIP_Y = Transform(1, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0);
const Transform Transform::FLIP_Z = Transform(1, 0, 0, 0, 1, 0, 0, 0, -1, 0, 0, 0);
Transform Transform::inverse_xform(const Transform &t) const {
Vector3 v = t.origin - origin;

4
src/core/Transform2D.cpp
View File

@ -7,6 +7,10 @@
namespace godot {
const Transform2D Transform2D::IDENTITY;
const Transform2D Transform2D::FLIP_X = Transform2D(-1, 0, 0, 1, 0, 0);
const Transform2D Transform2D::FLIP_Y = Transform2D(1, 0, 0, -1, 0, 0);
Transform2D::Transform2D(real_t xx, real_t xy, real_t yx, real_t yy, real_t ox, real_t oy) {
elements[0][0] = xx;

9
src/core/Vector2.cpp
View File

@ -6,6 +6,15 @@
namespace godot {
const Vector2 Vector2::ZERO;
const Vector2 Vector2::ONE;
const Vector2 Vector2::INF;
const Vector2 Vector2::LEFT = Vector2(-1, 0);
const Vector2 Vector2::RIGHT = Vector2(1, 0);
const Vector2 Vector2::UP = Vector2(0, -1);
const Vector2 Vector2::DOWN = Vector2(0, 1);
bool Vector2::operator==(const Vector2 &p_vec2) const {
return x == p_vec2.x && y == p_vec2.y;
}

11
src/core/Vector3.cpp
View File

@ -8,6 +8,17 @@
namespace godot {
const Vector3 Vector3::ZERO = Vector3();
const Vector3 Vector3::ONE = Vector3();
const Vector3 Vector3::INF = Vector3(INFINITY, INFINITY, INFINITY);
const Vector3 Vector3::LEFT = Vector3(-1, 0, 0);
const Vector3 Vector3::RIGHT = Vector3(1, 0, 0);
const Vector3 Vector3::UP = Vector3(0, 1, 0);
const Vector3 Vector3::DOWN = Vector3(0, -1, 0);
const Vector3 Vector3::FORWARD = Vector3(0, 0, -1);
const Vector3 Vector3::BACK = Vector3(0, 0, 1);
bool Vector3::operator<(const Vector3 &p_v) const {
if (x == p_v.x) {
if (y == p_v.y)