summaryrefslogtreecommitdiff
path: root/core
diff options
context:
space:
mode:
Diffstat (limited to 'core')
-rw-r--r--core/array.cpp18
-rw-r--r--core/array.h6
-rw-r--r--core/bind/core_bind.cpp2
-rw-r--r--core/dictionary.cpp15
-rw-r--r--core/globals.cpp6
-rw-r--r--core/io/packet_peer.cpp2
-rw-r--r--core/io/stream_peer.cpp299
-rw-r--r--core/io/stream_peer.h38
-rw-r--r--core/math/geometry.h31
-rw-r--r--core/object.cpp6
-rw-r--r--core/os/os.h2
-rw-r--r--core/resource.h2
-rw-r--r--core/typedefs.h12
-rw-r--r--core/undo_redo.cpp4
-rw-r--r--core/variant_call.cpp6
-rw-r--r--core/variant_op.cpp2
-rw-r--r--core/variant_parser.cpp13
17 files changed, 449 insertions, 15 deletions
diff --git a/core/array.cpp b/core/array.cpp
index ab9f19d6a0..41af460d83 100644
--- a/core/array.cpp
+++ b/core/array.cpp
@@ -222,6 +222,24 @@ void Array::invert(){
}
+void Array::push_front(const Variant& p_value) {
+
+ _p->array.insert(0,p_value);
+}
+
+void Array::pop_back(){
+
+ if (!_p->array.empty())
+ _p->array.resize( _p->array.size() -1 );
+
+}
+void Array::pop_front(){
+
+ if (!_p->array.empty())
+ _p->array.remove(0);
+
+}
+
Array::Array(const Array& p_from) {
diff --git a/core/array.h b/core/array.h
index 904309b257..c29b4355ca 100644
--- a/core/array.h
+++ b/core/array.h
@@ -53,7 +53,7 @@ public:
bool empty() const;
void clear();
- bool is_shared() const;
+ bool is_shared() const;
bool operator==(const Array& p_array) const;
@@ -75,6 +75,10 @@ public:
void erase(const Variant& p_value);
+ void push_front(const Variant& p_value);
+ void pop_back();
+ void pop_front();
+
Array(const Array& p_from);
Array(bool p_shared=false);
~Array();
diff --git a/core/bind/core_bind.cpp b/core/bind/core_bind.cpp
index 94557d149d..30c90bd71c 100644
--- a/core/bind/core_bind.cpp
+++ b/core/bind/core_bind.cpp
@@ -1977,7 +1977,7 @@ void _Thread::_bind_methods() {
ObjectTypeDB::bind_method(_MD("start:Error","instance","method","userdata","priority"),&_Thread::start,DEFVAL(Variant()),DEFVAL(PRIORITY_NORMAL));
ObjectTypeDB::bind_method(_MD("get_id"),&_Thread::get_id);
ObjectTypeDB::bind_method(_MD("is_active"),&_Thread::is_active);
- ObjectTypeDB::bind_method(_MD("wait_to_finish:var"),&_Thread::wait_to_finish);
+ ObjectTypeDB::bind_method(_MD("wait_to_finish:Variant"),&_Thread::wait_to_finish);
BIND_CONSTANT( PRIORITY_LOW );
BIND_CONSTANT( PRIORITY_NORMAL );
diff --git a/core/dictionary.cpp b/core/dictionary.cpp
index b2d31f230d..c544573629 100644
--- a/core/dictionary.cpp
+++ b/core/dictionary.cpp
@@ -160,7 +160,20 @@ void Dictionary::_unref() const {
}
uint32_t Dictionary::hash() const {
- return hash_djb2_one_64(make_uint64_t(_p));
+ uint32_t h=hash_djb2_one_32(Variant::DICTIONARY);
+
+ List<Variant> keys;
+ get_key_list(&keys);
+
+ for (List<Variant>::Element *E=keys.front();E;E=E->next()) {
+
+ h = hash_djb2_one_32( E->get().hash(), h);
+ h = hash_djb2_one_32( operator[](E->get()).hash(), h);
+
+ }
+
+
+ return h;
}
Array Dictionary::keys() const {
diff --git a/core/globals.cpp b/core/globals.cpp
index aee708d0cd..0a6a1876b3 100644
--- a/core/globals.cpp
+++ b/core/globals.cpp
@@ -309,7 +309,7 @@ Error Globals::setup(const String& p_path,const String & p_main_pack) {
print_line("has res dir: "+resource_path);
if (!_load_resource_pack("res://data.pck"))
- _load_resource_pack("res://data.pcz");
+ _load_resource_pack("res://data.zip");
// make sure this is load from the resource path
print_line("exists engine cfg? "+itos(FileAccess::exists("/engine.cfg")));
if (_load_settings("res://engine.cfg")==OK || _load_settings_binary("res://engine.cfb")==OK) {
@@ -340,7 +340,7 @@ Error Globals::setup(const String& p_path,const String & p_main_pack) {
//try to load settings in ascending through dirs shape!
//tries to open pack, but only first time
- if (first_time && (_load_resource_pack(current_dir+"/"+exec_name+".pck") || _load_resource_pack(current_dir+"/"+exec_name+".pcz") )) {
+ if (first_time && (_load_resource_pack(current_dir+"/"+exec_name+".pck") || _load_resource_pack(current_dir+"/"+exec_name+".zip") )) {
if (_load_settings("res://engine.cfg")==OK || _load_settings_binary("res://engine.cfb")==OK) {
_load_settings("res://override.cfg");
@@ -349,7 +349,7 @@ Error Globals::setup(const String& p_path,const String & p_main_pack) {
}
break;
- } else if (first_time && (_load_resource_pack(current_dir+"/data.pck") || _load_resource_pack(current_dir+"/data.pcz") )) {
+ } else if (first_time && (_load_resource_pack(current_dir+"/data.pck") || _load_resource_pack(current_dir+"/data.zip") )) {
if (_load_settings("res://engine.cfg")==OK || _load_settings_binary("res://engine.cfb")==OK) {
_load_settings("res://override.cfg");
diff --git a/core/io/packet_peer.cpp b/core/io/packet_peer.cpp
index f6d526b512..fc9e51f000 100644
--- a/core/io/packet_peer.cpp
+++ b/core/io/packet_peer.cpp
@@ -127,7 +127,7 @@ Error PacketPeer::_get_packet_error() const {
void PacketPeer::_bind_methods() {
ObjectTypeDB::bind_method(_MD("get_var"),&PacketPeer::_bnd_get_var);
- ObjectTypeDB::bind_method(_MD("put_var", "var:var"),&PacketPeer::put_var);
+ ObjectTypeDB::bind_method(_MD("put_var", "var:Variant"),&PacketPeer::put_var);
ObjectTypeDB::bind_method(_MD("get_packet"),&PacketPeer::_get_packet);
ObjectTypeDB::bind_method(_MD("put_packet:Error", "buffer"),&PacketPeer::_put_packet);
ObjectTypeDB::bind_method(_MD("get_packet_error:Error"),&PacketPeer::_get_packet_error);
diff --git a/core/io/stream_peer.cpp b/core/io/stream_peer.cpp
index b00b462eb6..1b39286bf7 100644
--- a/core/io/stream_peer.cpp
+++ b/core/io/stream_peer.cpp
@@ -27,7 +27,7 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "stream_peer.h"
-
+#include "io/marshalls.h"
Error StreamPeer::_put_data(const DVector<uint8_t>& p_data) {
@@ -115,6 +115,271 @@ Array StreamPeer::_get_partial_data(int p_bytes) {
}
+void StreamPeer::set_big_endian(bool p_enable) {
+
+ big_endian=p_enable;
+}
+
+bool StreamPeer::is_big_endian_enabled() const {
+
+ return big_endian;
+}
+
+
+void StreamPeer::put_u8(uint8_t p_val) {
+ put_data((const uint8_t*)&p_val,1);
+
+}
+
+void StreamPeer::put_8(int8_t p_val){
+
+ put_data((const uint8_t*)&p_val,1);
+}
+void StreamPeer::put_u16(uint16_t p_val){
+
+ if (big_endian) {
+ p_val=BSWAP16(p_val);
+ }
+ uint8_t buf[2];
+ encode_uint16(p_val,buf);
+ put_data(buf,2);
+
+}
+void StreamPeer::put_16(int16_t p_val){
+
+ if (big_endian) {
+ p_val=BSWAP16(p_val);
+ }
+ uint8_t buf[2];
+ encode_uint16(p_val,buf);
+ put_data(buf,2);
+
+}
+void StreamPeer::put_u32(uint32_t p_val){
+
+ if (big_endian) {
+ p_val=BSWAP32(p_val);
+ }
+ uint8_t buf[4];
+ encode_uint32(p_val,buf);
+ put_data(buf,4);
+
+}
+void StreamPeer::put_32(int32_t p_val){
+
+ if (big_endian) {
+ p_val=BSWAP32(p_val);
+ }
+ uint8_t buf[4];
+ encode_uint32(p_val,buf);
+ put_data(buf,4);
+
+}
+void StreamPeer::put_u64(uint64_t p_val){
+
+ if (big_endian) {
+ p_val=BSWAP64(p_val);
+ }
+ uint8_t buf[8];
+ encode_uint64(p_val,buf);
+ put_data(buf,8);
+
+}
+void StreamPeer::put_64(int64_t p_val){
+
+ if (big_endian) {
+ p_val=BSWAP64(p_val);
+ }
+ uint8_t buf[8];
+ encode_uint64(p_val,buf);
+ put_data(buf,8);
+
+}
+void StreamPeer::put_float(float p_val){
+
+ uint8_t buf[4];
+
+ encode_float(p_val,buf);
+ if (big_endian) {
+ uint32_t *p32=(uint32_t *)buf;
+ *p32=BSWAP32(*p32);
+ }
+
+ put_data(buf,4);
+
+}
+void StreamPeer::put_double(double p_val){
+
+ uint8_t buf[8];
+ encode_double(p_val,buf);
+ if (big_endian) {
+ uint64_t *p64=(uint64_t *)buf;
+ *p64=BSWAP64(*p64);
+ }
+ put_data(buf,8);
+
+}
+void StreamPeer::put_utf8_string(const String& p_string) {
+
+ CharString cs=p_string.utf8();
+ put_data((const uint8_t*)cs.get_data(),cs.length());
+
+}
+void StreamPeer::put_var(const Variant& p_variant){
+
+ int len=0;
+ Vector<uint8_t> buf;
+ encode_variant(p_variant,NULL,len);
+ buf.resize(len);
+ put_32(len);
+ encode_variant(p_variant,buf.ptr(),len);
+ put_data(buf.ptr(),buf.size());
+
+
+}
+
+uint8_t StreamPeer::get_u8(){
+
+ uint8_t buf[1];
+ get_data(buf,1);
+ return buf[0];
+}
+int8_t StreamPeer::get_8(){
+
+ uint8_t buf[1];
+ get_data(buf,1);
+ return buf[0];
+
+}
+uint16_t StreamPeer::get_u16(){
+
+ uint8_t buf[2];
+ get_data(buf,2);
+ uint16_t r = decode_uint16(buf);
+ if (big_endian) {
+ r=BSWAP16(r);
+ }
+ return r;
+
+}
+int16_t StreamPeer::get_16(){
+
+ uint8_t buf[2];
+ get_data(buf,2);
+ uint16_t r = decode_uint16(buf);
+ if (big_endian) {
+ r=BSWAP16(r);
+ }
+ return r;
+
+}
+uint32_t StreamPeer::get_u32(){
+
+ uint8_t buf[4];
+ get_data(buf,4);
+ uint32_t r = decode_uint32(buf);
+ if (big_endian) {
+ r=BSWAP32(r);
+ }
+ return r;
+
+}
+int32_t StreamPeer::get_32(){
+
+ uint8_t buf[4];
+ get_data(buf,4);
+ uint32_t r = decode_uint32(buf);
+ if (big_endian) {
+ r=BSWAP32(r);
+ }
+ return r;
+
+}
+uint64_t StreamPeer::get_u64(){
+
+ uint8_t buf[8];
+ get_data(buf,8);
+ uint64_t r = decode_uint64(buf);
+ if (big_endian) {
+ r=BSWAP64(r);
+ }
+ return r;
+
+}
+int64_t StreamPeer::get_64(){
+
+ uint8_t buf[8];
+ get_data(buf,8);
+ uint64_t r = decode_uint64(buf);
+ if (big_endian) {
+ r=BSWAP64(r);
+ }
+ return r;
+
+}
+float StreamPeer::get_float(){
+
+ uint8_t buf[4];
+ get_data(buf,4);
+
+ if (big_endian) {
+ uint32_t *p32=(uint32_t *)buf;
+ *p32=BSWAP32(*p32);
+ }
+
+ return decode_float(buf);
+}
+
+float StreamPeer::get_double(){
+
+ uint8_t buf[8];
+ get_data(buf,8);
+
+ if (big_endian) {
+ uint64_t *p64=(uint64_t *)buf;
+ *p64=BSWAP64(*p64);
+ }
+
+ return decode_double(buf);
+
+}
+String StreamPeer::get_string(int p_bytes){
+
+ ERR_FAIL_COND_V(p_bytes<0,String());
+
+ Vector<char> buf;
+ buf.resize(p_bytes+1);
+ get_data((uint8_t*)&buf[0],p_bytes);
+ buf[p_bytes]=0;
+ return buf.ptr();
+
+}
+String StreamPeer::get_utf8_string(int p_bytes){
+
+ ERR_FAIL_COND_V(p_bytes<0,String());
+ ERR_FAIL_COND_V(p_bytes<0,String());
+
+ Vector<uint8_t> buf;
+ buf.resize(p_bytes);
+ get_data(buf.ptr(),p_bytes);
+
+ String ret;
+ ret.parse_utf8((const char*)buf.ptr(),buf.size());
+ return ret;
+
+}
+Variant StreamPeer::get_var(){
+
+ int len = get_32();
+ Vector<uint8_t> var;
+ var.resize(len);
+ get_data(var.ptr(),len);
+
+ Variant ret;
+ decode_variant(ret,var.ptr(),len);
+ return ret;
+}
+
void StreamPeer::_bind_methods() {
@@ -123,4 +388,36 @@ void StreamPeer::_bind_methods() {
ObjectTypeDB::bind_method(_MD("get_data","bytes"),&StreamPeer::_get_data);
ObjectTypeDB::bind_method(_MD("get_partial_data","bytes"),&StreamPeer::_get_partial_data);
+
+ ObjectTypeDB::bind_method(_MD("get_available_bytes"),&StreamPeer::get_available_bytes);
+
+ ObjectTypeDB::bind_method(_MD("set_big_endian","enable"),&StreamPeer::set_big_endian);
+ ObjectTypeDB::bind_method(_MD("is_big_endian_enabled"),&StreamPeer::is_big_endian_enabled);
+
+ ObjectTypeDB::bind_method(_MD("put_8","val"),&StreamPeer::put_8);
+ ObjectTypeDB::bind_method(_MD("put_u8","val"),&StreamPeer::put_u8);
+ ObjectTypeDB::bind_method(_MD("put_16","val"),&StreamPeer::put_16);
+ ObjectTypeDB::bind_method(_MD("put_u16","val"),&StreamPeer::put_u16);
+ ObjectTypeDB::bind_method(_MD("put_32","val"),&StreamPeer::put_32);
+ ObjectTypeDB::bind_method(_MD("put_u32","val"),&StreamPeer::put_u32);
+ ObjectTypeDB::bind_method(_MD("put_64","val"),&StreamPeer::put_64);
+ ObjectTypeDB::bind_method(_MD("put_u64","val"),&StreamPeer::put_u64);
+ ObjectTypeDB::bind_method(_MD("put_float","val"),&StreamPeer::put_float);
+ ObjectTypeDB::bind_method(_MD("put_double","val"),&StreamPeer::put_double);
+ ObjectTypeDB::bind_method(_MD("put_utf8_string","val"),&StreamPeer::put_utf8_string);
+ ObjectTypeDB::bind_method(_MD("put_var","val:Variant"),&StreamPeer::put_var);
+
+ ObjectTypeDB::bind_method(_MD("get_8"),&StreamPeer::get_8);
+ ObjectTypeDB::bind_method(_MD("get_u8"),&StreamPeer::get_u8);
+ ObjectTypeDB::bind_method(_MD("get_16"),&StreamPeer::get_16);
+ ObjectTypeDB::bind_method(_MD("get_u16"),&StreamPeer::get_u16);
+ ObjectTypeDB::bind_method(_MD("get_32"),&StreamPeer::get_32);
+ ObjectTypeDB::bind_method(_MD("get_u32"),&StreamPeer::get_u32);
+ ObjectTypeDB::bind_method(_MD("get_64"),&StreamPeer::get_64);
+ ObjectTypeDB::bind_method(_MD("get_u64"),&StreamPeer::get_u64);
+ ObjectTypeDB::bind_method(_MD("get_float"),&StreamPeer::get_float);
+ ObjectTypeDB::bind_method(_MD("get_double"),&StreamPeer::get_double);
+ ObjectTypeDB::bind_method(_MD("get_string","bytes"),&StreamPeer::get_string);
+ ObjectTypeDB::bind_method(_MD("get_utf8_string","bytes"),&StreamPeer::get_utf8_string);
+ ObjectTypeDB::bind_method(_MD("get_var:Variant"),&StreamPeer::get_var);
}
diff --git a/core/io/stream_peer.h b/core/io/stream_peer.h
index e83fc71b93..2bb8f731b2 100644
--- a/core/io/stream_peer.h
+++ b/core/io/stream_peer.h
@@ -44,6 +44,8 @@ protected:
Array _get_data(int p_bytes);
Array _get_partial_data(int p_bytes);
+ bool big_endian;
+
public:
virtual Error put_data(const uint8_t* p_data,int p_bytes)=0; ///< put a whole chunk of data, blocking until it sent
@@ -52,7 +54,41 @@ public:
virtual Error get_data(uint8_t* p_buffer, int p_bytes)=0; ///< read p_bytes of data, if p_bytes > available, it will block
virtual Error get_partial_data(uint8_t* p_buffer, int p_bytes,int &r_received)=0; ///< read as much data as p_bytes into buffer, if less was read, return in r_received
- StreamPeer() {}
+ virtual int get_available_bytes() const=0;
+
+ void set_big_endian(bool p_enable);
+ bool is_big_endian_enabled() const;
+
+ void put_8(int8_t p_val);
+ void put_u8(uint8_t p_val);
+ void put_16(int16_t p_val);
+ void put_u16(uint16_t p_val);
+ void put_32(int32_t p_val);
+ void put_u32(uint32_t p_val);
+ void put_64(int64_t p_val);
+ void put_u64(uint64_t p_val);
+ void put_float(float p_val);
+ void put_double(double p_val);
+ void put_utf8_string(const String& p_string);
+ void put_var(const Variant& p_variant);
+
+ uint8_t get_u8();
+ int8_t get_8();
+ uint16_t get_u16();
+ int16_t get_16();
+ uint32_t get_u32();
+ int32_t get_32();
+ uint64_t get_u64();
+ int64_t get_64();
+ float get_float();
+ float get_double();
+ String get_string(int p_bytes);
+ String get_utf8_string(int p_bytes);
+ Variant get_var();
+
+
+
+ StreamPeer() { big_endian=false; }
};
#endif // STREAM_PEER_H
diff --git a/core/math/geometry.h b/core/math/geometry.h
index b438b41d61..8214895676 100644
--- a/core/math/geometry.h
+++ b/core/math/geometry.h
@@ -886,7 +886,38 @@ public:
}
+ static double vec2_cross(const Point2 &O, const Point2 &A, const Point2 &B)
+ {
+ return (double)(A.x - O.x) * (B.y - O.y) - (double)(A.y - O.y) * (B.x - O.x);
+ }
+
+ // Returns a list of points on the convex hull in counter-clockwise order.
+ // Note: the last point in the returned list is the same as the first one.
+ static Vector<Point2> convex_hull_2d(Vector<Point2> P)
+ {
+ int n = P.size(), k = 0;
+ Vector<Point2> H;
+ H.resize(2*n);
+
+ // Sort points lexicographically
+ P.sort();
+
+ // Build lower hull
+ for (int i = 0; i < n; ++i) {
+ while (k >= 2 && vec2_cross(H[k-2], H[k-1], P[i]) <= 0) k--;
+ H[k++] = P[i];
+ }
+
+ // Build upper hull
+ for (int i = n-2, t = k+1; i >= 0; i--) {
+ while (k >= t && vec2_cross(H[k-2], H[k-1], P[i]) <= 0) k--;
+ H[k++] = P[i];
+ }
+
+ H.resize(k);
+ return H;
+ }
static MeshData build_convex_mesh(const DVector<Plane> &p_planes);
static DVector<Plane> build_sphere_planes(float p_radius, int p_lats, int p_lons, Vector3::Axis p_axis=Vector3::AXIS_Z);
diff --git a/core/object.cpp b/core/object.cpp
index 96f0c86832..9fdd11eb2e 100644
--- a/core/object.cpp
+++ b/core/object.cpp
@@ -1405,6 +1405,10 @@ bool Object::is_connected(const StringName& p_signal, Object *p_to_object, const
bool signal_is_valid = ObjectTypeDB::has_signal(get_type_name(),p_signal);
if (signal_is_valid)
return false;
+
+ if (!script.is_null() && Ref<Script>(script)->has_script_signal(p_signal))
+ return false;
+
ERR_EXPLAIN("Nonexistent signal: "+p_signal);
ERR_FAIL_COND_V(!s,false);
}
@@ -1609,7 +1613,7 @@ void Object::_bind_methods() {
ObjectTypeDB::bind_native_method(METHOD_FLAGS_DEFAULT,"call_deferred",&Object::_call_deferred_bind,mi,defargs);
}
- ObjectTypeDB::bind_method(_MD("callv:var","method","arg_array"),&Object::callv);
+ ObjectTypeDB::bind_method(_MD("callv:Variant","method","arg_array"),&Object::callv);
ObjectTypeDB::bind_method(_MD("has_method"),&Object::has_method);
diff --git a/core/os/os.h b/core/os/os.h
index e908177df7..ab1a07276c 100644
--- a/core/os/os.h
+++ b/core/os/os.h
@@ -75,7 +75,7 @@ public:
bool fullscreen;
bool resizable;
float get_aspect() const { return (float)width/(float)height; }
- VideoMode(int p_width=640,int p_height=480,bool p_fullscreen=false, bool p_resizable = true) {width=p_width; height=p_height; fullscreen=p_fullscreen; resizable = p_resizable; }
+ VideoMode(int p_width=1280,int p_height=720,bool p_fullscreen=false, bool p_resizable = true) {width=p_width; height=p_height; fullscreen=p_fullscreen; resizable = p_resizable; }
};
protected:
friend class Main;
diff --git a/core/resource.h b/core/resource.h
index 3596abe673..cd28a51755 100644
--- a/core/resource.h
+++ b/core/resource.h
@@ -144,7 +144,7 @@ public:
#ifdef TOOLS_ENABLED
- void set_last_modified_time(uint64_t p_time) { last_modified_time=p_time; }
+ virtual void set_last_modified_time(uint64_t p_time) { last_modified_time=p_time; }
uint64_t get_last_modified_time() const { return last_modified_time; }
#endif
diff --git a/core/typedefs.h b/core/typedefs.h
index 6ca31fd137..460b2e2110 100644
--- a/core/typedefs.h
+++ b/core/typedefs.h
@@ -197,10 +197,22 @@ static inline int get_shift_from_power_of_2( unsigned int p_pixel ) {
return -1;
}
+/** Swap 16 bits value for endianness */
+static inline uint16_t BSWAP16(uint16_t x) {
+ return (x>>8)|(x<<8);
+}
/** Swap 32 bits value for endianness */
static inline uint32_t BSWAP32(uint32_t x) {
return((x<<24)|((x<<8)&0x00FF0000)|((x>>8)&0x0000FF00)|(x>>24));
}
+/** Swap 64 bits value for endianness */
+
+static inline uint64_t BSWAP64(uint64_t x) {
+ x = (x & 0x00000000FFFFFFFF) << 32 | (x & 0xFFFFFFFF00000000) >> 32;
+ x = (x & 0x0000FFFF0000FFFF) << 16 | (x & 0xFFFF0000FFFF0000) >> 16;
+ x = (x & 0x00FF00FF00FF00FF) << 8 | (x & 0xFF00FF00FF00FF00) >> 8;
+ return x;
+}
/** When compiling with RTTI, we can add an "extra"
* layer of safeness in many operations, so dynamic_cast
diff --git a/core/undo_redo.cpp b/core/undo_redo.cpp
index 85cc2bbc7f..ece9a02e24 100644
--- a/core/undo_redo.cpp
+++ b/core/undo_redo.cpp
@@ -482,8 +482,8 @@ void UndoRedo::_bind_methods() {
ObjectTypeDB::bind_native_method(METHOD_FLAGS_DEFAULT,"add_undo_method",&UndoRedo::_add_undo_method,mi,defargs);
}
- ObjectTypeDB::bind_method(_MD("add_do_property","object", "property", "value:var"),&UndoRedo::add_do_property);
- ObjectTypeDB::bind_method(_MD("add_undo_property","object", "property", "value:var"),&UndoRedo::add_undo_property);
+ ObjectTypeDB::bind_method(_MD("add_do_property","object", "property", "value:Variant"),&UndoRedo::add_do_property);
+ ObjectTypeDB::bind_method(_MD("add_undo_property","object", "property", "value:Variant"),&UndoRedo::add_undo_property);
ObjectTypeDB::bind_method(_MD("add_do_reference","object"),&UndoRedo::add_do_reference);
ObjectTypeDB::bind_method(_MD("add_undo_reference","object"),&UndoRedo::add_undo_reference);
ObjectTypeDB::bind_method(_MD("clear_history"),&UndoRedo::clear_history);
diff --git a/core/variant_call.cpp b/core/variant_call.cpp
index 2d10cf4d44..2ac876c8f4 100644
--- a/core/variant_call.cpp
+++ b/core/variant_call.cpp
@@ -450,6 +450,9 @@ static void _call_##m_type##_##m_method(Variant& r_ret,Variant& p_self,const Var
VCALL_LOCALMEM0(Array,clear);
VCALL_LOCALMEM0R(Array,hash);
VCALL_LOCALMEM1(Array,push_back);
+ VCALL_LOCALMEM1(Array,push_front);
+ VCALL_LOCALMEM0(Array,pop_back);
+ VCALL_LOCALMEM0(Array,pop_front);
VCALL_LOCALMEM1(Array,append);
VCALL_LOCALMEM1(Array,resize);
VCALL_LOCALMEM2(Array,insert);
@@ -1426,12 +1429,15 @@ _VariantCall::addfunc(Variant::m_vtype,Variant::m_ret,_SCS(#m_method),VCALL(m_cl
ADDFUNC0(ARRAY,NIL,Array,clear,varray());
ADDFUNC0(ARRAY,INT,Array,hash,varray());
ADDFUNC1(ARRAY,NIL,Array,push_back,NIL,"value",varray());
+ ADDFUNC1(ARRAY,NIL,Array,push_front,NIL,"value",varray());
ADDFUNC1(ARRAY,NIL,Array,append,NIL,"value",varray());
ADDFUNC1(ARRAY,NIL,Array,resize,INT,"pos",varray());
ADDFUNC2(ARRAY,NIL,Array,insert,INT,"pos",NIL,"value",varray());
ADDFUNC1(ARRAY,NIL,Array,remove,INT,"pos",varray());
ADDFUNC1(ARRAY,NIL,Array,erase,NIL,"value",varray());
ADDFUNC1(ARRAY,INT,Array,find,NIL,"value",varray());
+ ADDFUNC0(ARRAY,NIL,Array,pop_back,varray());
+ ADDFUNC0(ARRAY,NIL,Array,pop_front,varray());
ADDFUNC0(ARRAY,NIL,Array,sort,varray());
ADDFUNC2(ARRAY,NIL,Array,sort_custom,OBJECT,"obj",STRING,"func",varray());
ADDFUNC0(ARRAY,NIL,Array,invert,varray());
diff --git a/core/variant_op.cpp b/core/variant_op.cpp
index 1bcfa7d2ae..e33b79e63c 100644
--- a/core/variant_op.cpp
+++ b/core/variant_op.cpp
@@ -2635,7 +2635,7 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const {
if (l) {
for(int i=0;i<l;i++) {
- if ((*arr)[i]==p_index)
+ if (evaluate(OP_EQUAL,(*arr)[i],p_index))
return true;
}
diff --git a/core/variant_parser.cpp b/core/variant_parser.cpp
index fed8c28740..239b129388 100644
--- a/core/variant_parser.cpp
+++ b/core/variant_parser.cpp
@@ -460,6 +460,19 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in
value=Vector2(args[0],args[1]);
return OK;
+ } else if (id=="Rect2"){
+
+ Vector<float> args;
+ Error err = _parse_construct<float>(p_stream,args,line,r_err_str);
+ if (err)
+ return err;
+
+ if (args.size()!=4) {
+ r_err_str="Expected 4 arguments for constructor";
+ }
+
+ value=Rect2(args[0],args[1],args[2],args[3]);
+ return OK;
} else if (id=="Vector3"){
Vector<float> args;
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-10 06:20:00 +0000