diff options
| author | Juan Linietsky <reduzio@gmail.com> | 2017-01-11 00:52:51 -0300 |
|---|---|---|
| committer | Juan Linietsky <reduzio@gmail.com> | 2017-01-11 00:52:51 -0300 |
| commit | bc26f905817945300d397696330d1ab04a1af33c (patch) | |
| tree | d06338399c8ea410042f6631fb3db3efcc100b05 /core | |
| parent | 710692278d1353aad08bc7bceb655afc1d6c950c (diff) | |
Type renames:
Matrix32 -> Transform2D
Matrix3 -> Basis
AABB -> Rect3
RawArray -> PoolByteArray
IntArray -> PoolIntArray
FloatArray -> PoolFloatArray
Vector2Array -> PoolVector2Array
Vector3Array -> PoolVector3Array
ColorArray -> PoolColorArray
Diffstat (limited to 'core')
51 files changed, 1157 insertions, 1158 deletions
diff --git a/core/bind/core_bind.cpp b/core/bind/core_bind.cpp index 4b23761e4e..8f1c1779bd 100644 --- a/core/bind/core_bind.cpp +++ b/core/bind/core_bind.cpp @@ -87,12 +87,12 @@ void _ResourceLoader::set_abort_on_missing_resources(bool p_abort) { ResourceLoader::set_abort_on_missing_resources(p_abort); } -StringArray _ResourceLoader::get_dependencies(const String& p_path) { +PoolStringArray _ResourceLoader::get_dependencies(const String& p_path) { List<String> deps; ResourceLoader::get_dependencies(p_path, &deps); - StringArray ret; + PoolStringArray ret; for(List<String>::Element *E=deps.front();E;E=E->next()) { ret.push_back(E->get()); } @@ -2398,12 +2398,12 @@ _Thread::~_Thread() { ///////////////////////////////////// -StringArray _ClassDB::get_class_list() const { +PoolStringArray _ClassDB::get_class_list() const { List<StringName> classes; ClassDB::get_class_list(&classes); - StringArray ret; + PoolStringArray ret; ret.resize(classes.size()); int idx=0; for (List<StringName>::Element *E=classes.front();E;E=E->next()) { @@ -2413,12 +2413,12 @@ StringArray _ClassDB::get_class_list() const { return ret; } -StringArray _ClassDB::get_inheriters_from_class( const StringName& p_class) const { +PoolStringArray _ClassDB::get_inheriters_from_class( const StringName& p_class) const { List<StringName> classes; ClassDB::get_inheriters_from_class(p_class,&classes); - StringArray ret; + PoolStringArray ret; ret.resize(classes.size()); int idx=0; for (List<StringName>::Element *E=classes.front();E;E=E->next()) { @@ -2517,12 +2517,12 @@ Array _ClassDB::get_method_list(StringName p_class,bool p_no_inheritance) const return ret; } -StringArray _ClassDB::get_integer_constant_list(const StringName& p_class, bool p_no_inheritance) const { +PoolStringArray _ClassDB::get_integer_constant_list(const StringName& p_class, bool p_no_inheritance) const { List<String> constants; ClassDB::get_integer_constant_list(p_class,&constants,p_no_inheritance); - StringArray ret; + PoolStringArray ret; ret.resize(constants.size()); int idx=0; for (List<String>::Element *E=constants.front();E;E=E->next()) { diff --git a/core/bind/core_bind.h b/core/bind/core_bind.h index 59f243a0ee..d491483d82 100644 --- a/core/bind/core_bind.h +++ b/core/bind/core_bind.h @@ -52,7 +52,7 @@ public: RES load(const String &p_path,const String& p_type_hint="", bool p_no_cache = false); PoolVector<String> get_recognized_extensions_for_type(const String& p_type); void set_abort_on_missing_resources(bool p_abort); - StringArray get_dependencies(const String& p_path); + PoolStringArray get_dependencies(const String& p_path); bool has(const String& p_path); Ref<ResourceImportMetadata> load_import_metadata(const String& p_path); @@ -602,8 +602,8 @@ protected: static void _bind_methods(); public: - StringArray get_class_list() const; - StringArray get_inheriters_from_class( const StringName& p_class) const; + PoolStringArray get_class_list() const; + PoolStringArray get_inheriters_from_class( const StringName& p_class) const; StringName get_parent_class(const StringName& p_class) const; bool class_exists(const StringName &p_class) const; bool is_parent_class(const StringName &p_class,const StringName& p_inherits) const; @@ -621,7 +621,7 @@ public: Array get_method_list(StringName p_class,bool p_no_inheritance=false) const; - StringArray get_integer_constant_list(const StringName& p_class, bool p_no_inheritance=false) const; + PoolStringArray get_integer_constant_list(const StringName& p_class, bool p_no_inheritance=false) const; bool has_integer_constant(const StringName& p_class, const StringName &p_name) const; int get_integer_constant(const StringName& p_class, const StringName &p_name) const; StringName get_category(const StringName& p_node) const; diff --git a/core/compressed_translation.cpp b/core/compressed_translation.cpp index f8aa3915d4..71f810422a 100644 --- a/core/compressed_translation.cpp +++ b/core/compressed_translation.cpp @@ -518,9 +518,9 @@ StringName PHashTranslation::get_message(const StringName& p_src_text) const { void PHashTranslation::_get_property_list( List<PropertyInfo> *p_list) const{ - p_list->push_back( PropertyInfo(Variant::INT_ARRAY, "hash_table")); - p_list->push_back( PropertyInfo(Variant::INT_ARRAY, "bucket_table")); - p_list->push_back( PropertyInfo(Variant::RAW_ARRAY, "strings")); + p_list->push_back( PropertyInfo(Variant::POOL_INT_ARRAY, "hash_table")); + p_list->push_back( PropertyInfo(Variant::POOL_INT_ARRAY, "bucket_table")); + p_list->push_back( PropertyInfo(Variant::POOL_BYTE_ARRAY, "strings")); p_list->push_back( PropertyInfo(Variant::OBJECT, "load_from",PROPERTY_HINT_RESOURCE_TYPE,"Translation",PROPERTY_USAGE_EDITOR)); } diff --git a/core/global_constants.cpp b/core/global_constants.cpp index 88d986f60e..936facdd23 100644 --- a/core/global_constants.cpp +++ b/core/global_constants.cpp @@ -517,11 +517,11 @@ static _GlobalConstant _global_constants[]={ {"TYPE_VECTOR2",Variant::VECTOR2}, // 5 {"TYPE_RECT2",Variant::RECT2}, {"TYPE_VECTOR3",Variant::VECTOR3}, - {"TYPE_MATRIX32",Variant::MATRIX32}, + {"TYPE_TRANSFORM2D",Variant::TRANSFORM2D}, {"TYPE_PLANE",Variant::PLANE}, {"TYPE_QUAT",Variant::QUAT}, // 10 - {"TYPE_AABB",Variant::_AABB}, //sorry naming convention fail :( not like it's used often - {"TYPE_MATRIX3",Variant::MATRIX3}, + {"TYPE_RECT3",Variant::RECT3}, //sorry naming convention fail :( not like it's used often + {"TYPE_BASIS",Variant::BASIS}, {"TYPE_TRANSFORM",Variant::TRANSFORM}, {"TYPE_COLOR",Variant::COLOR}, {"TYPE_IMAGE",Variant::IMAGE}, // 15 @@ -531,13 +531,13 @@ static _GlobalConstant _global_constants[]={ {"TYPE_INPUT_EVENT",Variant::INPUT_EVENT}, {"TYPE_DICTIONARY",Variant::DICTIONARY}, // 20 {"TYPE_ARRAY",Variant::ARRAY}, - {"TYPE_RAW_ARRAY",Variant::RAW_ARRAY}, - {"TYPE_INT_ARRAY",Variant::INT_ARRAY}, - {"TYPE_REAL_ARRAY",Variant::REAL_ARRAY}, - {"TYPE_STRING_ARRAY",Variant::STRING_ARRAY}, // 25 - {"TYPE_VECTOR2_ARRAY",Variant::VECTOR2_ARRAY}, - {"TYPE_VECTOR3_ARRAY",Variant::VECTOR3_ARRAY}, - {"TYPE_COLOR_ARRAY",Variant::COLOR_ARRAY}, + {"TYPE_RAW_ARRAY",Variant::POOL_BYTE_ARRAY}, + {"TYPE_INT_ARRAY",Variant::POOL_INT_ARRAY}, + {"TYPE_REAL_ARRAY",Variant::POOL_REAL_ARRAY}, + {"TYPE_STRING_ARRAY",Variant::POOL_STRING_ARRAY}, // 25 + {"TYPE_VECTOR2_ARRAY",Variant::POOL_VECTOR2_ARRAY}, + {"TYPE_VECTOR3_ARRAY",Variant::POOL_VECTOR3_ARRAY}, + {"TYPE_COLOR_ARRAY",Variant::POOL_COLOR_ARRAY}, {"TYPE_MAX",Variant::VARIANT_MAX}, {NULL,0} diff --git a/core/globals.cpp b/core/globals.cpp index 0b5fe4a82e..0dd31e65d0 100644 --- a/core/globals.cpp +++ b/core/globals.cpp @@ -927,9 +927,9 @@ static String _encode_variant(const Variant& p_variant) { Color val = p_variant; return "#"+val.to_html(); } break; - case Variant::STRING_ARRAY: - case Variant::INT_ARRAY: - case Variant::REAL_ARRAY: + case Variant::POOL_STRING_ARRAY: + case Variant::POOL_INT_ARRAY: + case Variant::POOL_REAL_ARRAY: case Variant::ARRAY: { Array arr = p_variant; String str="["; diff --git a/core/io/config_file.cpp b/core/io/config_file.cpp index 6039a77337..a9de740806 100644 --- a/core/io/config_file.cpp +++ b/core/io/config_file.cpp @@ -31,11 +31,11 @@ #include "os/file_access.h" #include "variant_parser.h" -StringArray ConfigFile::_get_sections() const { +PoolStringArray ConfigFile::_get_sections() const { List<String> s; get_sections(&s); - StringArray arr; + PoolStringArray arr; arr.resize(s.size()); int idx=0; for(const List<String>::Element *E=s.front();E;E=E->next()) { @@ -46,11 +46,11 @@ StringArray ConfigFile::_get_sections() const { return arr; } -StringArray ConfigFile::_get_section_keys(const String& p_section) const{ +PoolStringArray ConfigFile::_get_section_keys(const String& p_section) const{ List<String> s; get_section_keys(p_section,&s); - StringArray arr; + PoolStringArray arr; arr.resize(s.size()); int idx=0; for(const List<String>::Element *E=s.front();E;E=E->next()) { diff --git a/core/io/config_file.h b/core/io/config_file.h index bd71fa62c6..397342f90f 100644 --- a/core/io/config_file.h +++ b/core/io/config_file.h @@ -38,8 +38,8 @@ class ConfigFile : public Reference { Map< String, Map<String, Variant> > values; - StringArray _get_sections() const; - StringArray _get_section_keys(const String& p_section) const; + PoolStringArray _get_sections() const; + PoolStringArray _get_section_keys(const String& p_section) const; protected: static void _bind_methods(); diff --git a/core/io/http_client.cpp b/core/io/http_client.cpp index b556d46105..5e57f55f87 100644 --- a/core/io/http_client.cpp +++ b/core/io/http_client.cpp @@ -193,7 +193,7 @@ Error HTTPClient::send_body_text(const String& p_body){ return OK; } -Error HTTPClient::send_body_data(const ByteArray& p_body){ +Error HTTPClient::send_body_data(const PoolByteArray& p_body){ return OK; } @@ -444,11 +444,11 @@ Dictionary HTTPClient::_get_response_headers_as_dictionary() { return ret; } -StringArray HTTPClient::_get_response_headers() { +PoolStringArray HTTPClient::_get_response_headers() { List<String> rh; get_response_headers(&rh); - StringArray ret; + PoolStringArray ret; ret.resize(rh.size()); int idx=0; for(const List<String>::Element *E=rh.front();E;E=E->next()) { @@ -463,9 +463,9 @@ int HTTPClient::get_response_body_length() const { return body_size; } -ByteArray HTTPClient::read_response_body_chunk() { +PoolByteArray HTTPClient::read_response_body_chunk() { - ERR_FAIL_COND_V( status !=STATUS_BODY, ByteArray() ); + ERR_FAIL_COND_V( status !=STATUS_BODY, PoolByteArray() ); Error err=OK; @@ -487,7 +487,7 @@ ByteArray HTTPClient::read_response_body_chunk() { if (chunk.size()>32) { ERR_PRINT("HTTP Invalid chunk hex len"); status=STATUS_CONNECTION_ERROR; - return ByteArray(); + return PoolByteArray(); } if (chunk.size()>2 && chunk[chunk.size()-2]=='\r' && chunk[chunk.size()-1]=='\n') { @@ -505,14 +505,14 @@ ByteArray HTTPClient::read_response_body_chunk() { else { ERR_PRINT("HTTP Chunk len not in hex!!"); status=STATUS_CONNECTION_ERROR; - return ByteArray(); + return PoolByteArray(); } len<<=4; len|=v; if (len>(1<<24)) { ERR_PRINT("HTTP Chunk too big!! >16mb"); status=STATUS_CONNECTION_ERROR; - return ByteArray(); + return PoolByteArray(); } } @@ -521,7 +521,7 @@ ByteArray HTTPClient::read_response_body_chunk() { //end! status=STATUS_CONNECTED; chunk.clear(); - return ByteArray(); + return PoolByteArray(); } chunk_left=len+2; @@ -542,13 +542,13 @@ ByteArray HTTPClient::read_response_body_chunk() { if (chunk[chunk.size()-2]!='\r' || chunk[chunk.size()-1]!='\n') { ERR_PRINT("HTTP Invalid chunk terminator (not \\r\\n)"); status=STATUS_CONNECTION_ERROR; - return ByteArray(); + return PoolByteArray(); } - ByteArray ret; + PoolByteArray ret; ret.resize(chunk.size()-2); { - ByteArray::Write w = ret.write(); + PoolByteArray::Write w = ret.write(); copymem(w.ptr(),chunk.ptr(),chunk.size()-2); } chunk.clear(); @@ -564,9 +564,9 @@ ByteArray HTTPClient::read_response_body_chunk() { } else { int to_read = MIN(body_left,read_chunk_size); - ByteArray ret; + PoolByteArray ret; ret.resize(to_read); - ByteArray::Write w = ret.write(); + PoolByteArray::Write w = ret.write(); int _offset = 0; while (to_read > 0) { int rec=0; @@ -603,7 +603,7 @@ ByteArray HTTPClient::read_response_body_chunk() { status=STATUS_CONNECTED; } - return ByteArray(); + return PoolByteArray(); } HTTPClient::Status HTTPClient::get_status() const { diff --git a/core/io/http_client.h b/core/io/http_client.h index 231475775f..c6f96db1d6 100644 --- a/core/io/http_client.h +++ b/core/io/http_client.h @@ -156,7 +156,7 @@ private: Vector<String> response_headers; static void _bind_methods(); - StringArray _get_response_headers(); + PoolStringArray _get_response_headers(); Dictionary _get_response_headers_as_dictionary(); int read_chunk_size; @@ -175,7 +175,7 @@ public: Error request_raw( Method p_method, const String& p_url, const Vector<String>& p_headers,const PoolVector<uint8_t>& p_body); Error request( Method p_method, const String& p_url, const Vector<String>& p_headers,const String& p_body=String()); Error send_body_text(const String& p_body); - Error send_body_data(const ByteArray& p_body); + Error send_body_data(const PoolByteArray& p_body); void close(); @@ -187,7 +187,7 @@ public: Error get_response_headers(List<String> *r_response); int get_response_body_length() const; - ByteArray read_response_body_chunk(); // can't get body as partial text because of most encodings UTF8, gzip, etc. + PoolByteArray read_response_body_chunk(); // can't get body as partial text because of most encodings UTF8, gzip, etc. void set_blocking_mode(bool p_enable); //useful mostly if running in a thread bool is_blocking_mode_enabled() const; diff --git a/core/io/json.cpp b/core/io/json.cpp index 3280f94750..ed1e74967b 100644 --- a/core/io/json.cpp +++ b/core/io/json.cpp @@ -52,9 +52,9 @@ String JSON::_print_var(const Variant& p_var) { case Variant::BOOL: return p_var.operator bool() ? "true": "false"; case Variant::INT: return itos(p_var); case Variant::REAL: return rtos(p_var); - case Variant::INT_ARRAY: - case Variant::REAL_ARRAY: - case Variant::STRING_ARRAY: + case Variant::POOL_INT_ARRAY: + case Variant::POOL_REAL_ARRAY: + case Variant::POOL_STRING_ARRAY: case Variant::ARRAY: { String s = "["; diff --git a/core/io/marshalls.cpp b/core/io/marshalls.cpp index 0765fc86c7..67baa117cb 100644 --- a/core/io/marshalls.cpp +++ b/core/io/marshalls.cpp @@ -164,10 +164,10 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * (*r_len)+=4*3; } break; - case Variant::MATRIX32: { + case Variant::TRANSFORM2D: { ERR_FAIL_COND_V(len<(int)4*6,ERR_INVALID_DATA); - Matrix32 val; + Transform2D val; for(int i=0;i<3;i++) { for(int j=0;j<2;j++) { @@ -209,10 +209,10 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * (*r_len)+=4*4; } break; - case Variant::_AABB: { + case Variant::RECT3: { ERR_FAIL_COND_V(len<(int)4*6,ERR_INVALID_DATA); - AABB val; + Rect3 val; val.pos.x=decode_float(&buf[0]); val.pos.y=decode_float(&buf[4]); val.pos.z=decode_float(&buf[8]); @@ -225,10 +225,10 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * (*r_len)+=4*6; } break; - case Variant::MATRIX3: { + case Variant::BASIS: { ERR_FAIL_COND_V(len<(int)4*9,ERR_INVALID_DATA); - Matrix3 val; + Basis val; for(int i=0;i<3;i++) { for(int j=0;j<3;j++) { @@ -548,7 +548,7 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * } break; // arrays - case Variant::RAW_ARRAY: { + case Variant::POOL_BYTE_ARRAY: { ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); uint32_t count = decode_uint32(buf); @@ -581,7 +581,7 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * } break; - case Variant::INT_ARRAY: { + case Variant::POOL_INT_ARRAY: { ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); uint32_t count = decode_uint32(buf); @@ -608,7 +608,7 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * } } break; - case Variant::REAL_ARRAY: { + case Variant::POOL_REAL_ARRAY: { ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); uint32_t count = decode_uint32(buf); @@ -637,7 +637,7 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * } break; - case Variant::STRING_ARRAY: { + case Variant::POOL_STRING_ARRAY: { ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); uint32_t count = decode_uint32(buf); @@ -687,7 +687,7 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * } break; - case Variant::VECTOR2_ARRAY: { + case Variant::POOL_VECTOR2_ARRAY: { ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); uint32_t count = decode_uint32(buf); @@ -725,7 +725,7 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * r_variant=varray; } break; - case Variant::VECTOR3_ARRAY: { + case Variant::POOL_VECTOR3_ARRAY: { ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); uint32_t count = decode_uint32(buf); @@ -764,7 +764,7 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * r_variant=varray; } break; - case Variant::COLOR_ARRAY: { + case Variant::POOL_COLOR_ARRAY: { ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); uint32_t count = decode_uint32(buf); @@ -1004,10 +1004,10 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { r_len+=3*4; } break; - case Variant::MATRIX32: { + case Variant::TRANSFORM2D: { if (buf) { - Matrix32 val=p_variant; + Transform2D val=p_variant; for(int i=0;i<3;i++) { for(int j=0;j<2;j++) { @@ -1046,10 +1046,10 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { r_len+=4*4; } break; - case Variant::_AABB: { + case Variant::RECT3: { if (buf) { - AABB aabb=p_variant; + Rect3 aabb=p_variant; encode_float(aabb.pos.x,&buf[0]); encode_float(aabb.pos.y,&buf[4]); encode_float(aabb.pos.z,&buf[8]); @@ -1062,10 +1062,10 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { } break; - case Variant::MATRIX3: { + case Variant::BASIS: { if (buf) { - Matrix3 val=p_variant; + Basis val=p_variant; for(int i=0;i<3;i++) { for(int j=0;j<3;j++) { @@ -1294,7 +1294,7 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { } break; // arrays - case Variant::RAW_ARRAY: { + case Variant::POOL_BYTE_ARRAY: { PoolVector<uint8_t> data = p_variant; int datalen=data.size(); @@ -1313,7 +1313,7 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { r_len++; } break; - case Variant::INT_ARRAY: { + case Variant::POOL_INT_ARRAY: { PoolVector<int> data = p_variant; int datalen=data.size(); @@ -1331,7 +1331,7 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { r_len+=4+datalen*datasize; } break; - case Variant::REAL_ARRAY: { + case Variant::POOL_REAL_ARRAY: { PoolVector<real_t> data = p_variant; int datalen=data.size(); @@ -1349,7 +1349,7 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { r_len+=4+datalen*datasize; } break; - case Variant::STRING_ARRAY: { + case Variant::POOL_STRING_ARRAY: { PoolVector<String> data = p_variant; @@ -1383,7 +1383,7 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { } } break; - case Variant::VECTOR2_ARRAY: { + case Variant::POOL_VECTOR2_ARRAY: { PoolVector<Vector2> data = p_variant; int len=data.size(); @@ -1411,7 +1411,7 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { r_len+=4*2*len; } break; - case Variant::VECTOR3_ARRAY: { + case Variant::POOL_VECTOR3_ARRAY: { PoolVector<Vector3> data = p_variant; int len=data.size(); @@ -1440,7 +1440,7 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { r_len+=4*3*len; } break; - case Variant::COLOR_ARRAY: { + case Variant::POOL_COLOR_ARRAY: { PoolVector<Color> data = p_variant; int len=data.size(); diff --git a/core/io/resource_format_binary.cpp b/core/io/resource_format_binary.cpp index 16da74fdf1..7383fd7f6d 100644 --- a/core/io/resource_format_binary.cpp +++ b/core/io/resource_format_binary.cpp @@ -180,7 +180,7 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant& r_v) { } break; case VARIANT_AABB: { - AABB v; + Rect3 v; v.pos.x=f->get_real(); v.pos.y=f->get_real(); v.pos.z=f->get_real(); @@ -192,7 +192,7 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant& r_v) { } break; case VARIANT_MATRIX32: { - Matrix32 v; + Transform2D v; v.elements[0].x=f->get_real(); v.elements[0].y=f->get_real(); v.elements[1].x=f->get_real(); @@ -204,7 +204,7 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant& r_v) { } break; case VARIANT_MATRIX3: { - Matrix3 v; + Basis v; v.elements[0].x=f->get_real(); v.elements[0].y=f->get_real(); v.elements[0].z=f->get_real(); @@ -1509,10 +1509,10 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, f->store_real(val.w); } break; - case Variant::_AABB: { + case Variant::RECT3: { f->store_32(VARIANT_AABB); - AABB val=p_property; + Rect3 val=p_property; f->store_real(val.pos.x); f->store_real(val.pos.y); f->store_real(val.pos.z); @@ -1521,10 +1521,10 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, f->store_real(val.size.z); } break; - case Variant::MATRIX32: { + case Variant::TRANSFORM2D: { f->store_32(VARIANT_MATRIX32); - Matrix32 val=p_property; + Transform2D val=p_property; f->store_real(val.elements[0].x); f->store_real(val.elements[0].y); f->store_real(val.elements[1].x); @@ -1533,10 +1533,10 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, f->store_real(val.elements[2].y); } break; - case Variant::MATRIX3: { + case Variant::BASIS: { f->store_32(VARIANT_MATRIX3); - Matrix3 val=p_property; + Basis val=p_property; f->store_real(val.elements[0].x); f->store_real(val.elements[0].y); f->store_real(val.elements[0].z); @@ -1728,7 +1728,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, } } break; - case Variant::RAW_ARRAY: { + case Variant::POOL_BYTE_ARRAY: { f->store_32(VARIANT_RAW_ARRAY); PoolVector<uint8_t> arr = p_property; @@ -1739,7 +1739,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, _pad_buffer(len); } break; - case Variant::INT_ARRAY: { + case Variant::POOL_INT_ARRAY: { f->store_32(VARIANT_INT_ARRAY); PoolVector<int> arr = p_property; @@ -1750,7 +1750,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, f->store_32(r[i]); } break; - case Variant::REAL_ARRAY: { + case Variant::POOL_REAL_ARRAY: { f->store_32(VARIANT_REAL_ARRAY); PoolVector<real_t> arr = p_property; @@ -1762,7 +1762,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, } } break; - case Variant::STRING_ARRAY: { + case Variant::POOL_STRING_ARRAY: { f->store_32(VARIANT_STRING_ARRAY); PoolVector<String> arr = p_property; @@ -1774,7 +1774,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, } } break; - case Variant::VECTOR3_ARRAY: { + case Variant::POOL_VECTOR3_ARRAY: { f->store_32(VARIANT_VECTOR3_ARRAY); PoolVector<Vector3> arr = p_property; @@ -1788,7 +1788,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, } } break; - case Variant::VECTOR2_ARRAY: { + case Variant::POOL_VECTOR2_ARRAY: { f->store_32(VARIANT_VECTOR2_ARRAY); PoolVector<Vector2> arr = p_property; @@ -1801,7 +1801,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property, } } break; - case Variant::COLOR_ARRAY: { + case Variant::POOL_COLOR_ARRAY: { f->store_32(VARIANT_COLOR_ARRAY); PoolVector<Color> arr = p_property; diff --git a/core/io/stream_peer_ssl.cpp b/core/io/stream_peer_ssl.cpp index 639d848110..aab42a2989 100644 --- a/core/io/stream_peer_ssl.cpp +++ b/core/io/stream_peer_ssl.cpp @@ -45,7 +45,7 @@ StreamPeerSSL::LoadCertsFromMemory StreamPeerSSL::load_certs_func=NULL; bool StreamPeerSSL::available=false; bool StreamPeerSSL::initialize_certs=true; -void StreamPeerSSL::load_certs_from_memory(const ByteArray& p_memory) { +void StreamPeerSSL::load_certs_from_memory(const PoolByteArray& p_memory) { if (load_certs_func) load_certs_func(p_memory); } diff --git a/core/io/stream_peer_ssl.h b/core/io/stream_peer_ssl.h index b36534fcfa..8675433a30 100644 --- a/core/io/stream_peer_ssl.h +++ b/core/io/stream_peer_ssl.h @@ -35,7 +35,7 @@ class StreamPeerSSL : public StreamPeer { GDCLASS(StreamPeerSSL,StreamPeer); public: - typedef void (*LoadCertsFromMemory)(const ByteArray& p_certs); + typedef void (*LoadCertsFromMemory)(const PoolByteArray& p_certs); protected: static StreamPeerSSL* (*_create)(); static void _bind_methods(); @@ -65,7 +65,7 @@ public: static StreamPeerSSL* create(); - static void load_certs_from_memory(const ByteArray& p_memory); + static void load_certs_from_memory(const PoolByteArray& p_memory); static bool is_available(); StreamPeerSSL(); diff --git a/core/math/aabb.cpp b/core/math/aabb.cpp index d304d3e092..3518eea7ac 100644 --- a/core/math/aabb.cpp +++ b/core/math/aabb.cpp @@ -30,24 +30,24 @@ #include "print_string.h" -float AABB::get_area() const { +float Rect3::get_area() const { return size.x*size.y*size.z; } -bool AABB::operator==(const AABB& p_rval) const { +bool Rect3::operator==(const Rect3& p_rval) const { return ((pos==p_rval.pos) && (size==p_rval.size)); } -bool AABB::operator!=(const AABB& p_rval) const { +bool Rect3::operator!=(const Rect3& p_rval) const { return ((pos!=p_rval.pos) || (size!=p_rval.size)); } -void AABB::merge_with(const AABB& p_aabb) { +void Rect3::merge_with(const Rect3& p_aabb) { Vector3 beg_1,beg_2; Vector3 end_1,end_2; @@ -70,7 +70,7 @@ void AABB::merge_with(const AABB& p_aabb) { size=max-min; } -AABB AABB::intersection(const AABB& p_aabb) const { +Rect3 Rect3::intersection(const Rect3& p_aabb) const { Vector3 src_min=pos; Vector3 src_max=pos+size; @@ -80,7 +80,7 @@ AABB AABB::intersection(const AABB& p_aabb) const { Vector3 min,max; if (src_min.x > dst_max.x || src_max.x < dst_min.x ) - return AABB(); + return Rect3(); else { min.x= ( src_min.x > dst_min.x ) ? src_min.x :dst_min.x; @@ -89,7 +89,7 @@ AABB AABB::intersection(const AABB& p_aabb) const { } if (src_min.y > dst_max.y || src_max.y < dst_min.y ) - return AABB(); + return Rect3(); else { min.y= ( src_min.y > dst_min.y ) ? src_min.y :dst_min.y; @@ -98,7 +98,7 @@ AABB AABB::intersection(const AABB& p_aabb) const { } if (src_min.z > dst_max.z || src_max.z < dst_min.z ) - return AABB(); + return Rect3(); else { min.z= ( src_min.z > dst_min.z ) ? src_min.z :dst_min.z; @@ -107,10 +107,10 @@ AABB AABB::intersection(const AABB& p_aabb) const { } - return AABB( min, max-min ); + return Rect3( min, max-min ); } -bool AABB::intersects_ray(const Vector3& p_from, const Vector3& p_dir,Vector3* r_clip,Vector3* r_normal) const { +bool Rect3::intersects_ray(const Vector3& p_from, const Vector3& p_dir,Vector3* r_clip,Vector3* r_normal) const { Vector3 c1, c2; Vector3 end = pos+size; @@ -155,7 +155,7 @@ bool AABB::intersects_ray(const Vector3& p_from, const Vector3& p_dir,Vector3* r } -bool AABB::intersects_segment(const Vector3& p_from, const Vector3& p_to,Vector3* r_clip,Vector3* r_normal) const { +bool Rect3::intersects_segment(const Vector3& p_from, const Vector3& p_to,Vector3* r_clip,Vector3* r_normal) const { real_t min=0,max=1; int axis=0; @@ -216,7 +216,7 @@ bool AABB::intersects_segment(const Vector3& p_from, const Vector3& p_to,Vector3 } -bool AABB::intersects_plane(const Plane &p_plane) const { +bool Rect3::intersects_plane(const Plane &p_plane) const { Vector3 points[8] = { Vector3( pos.x , pos.y , pos.z ), @@ -246,7 +246,7 @@ bool AABB::intersects_plane(const Plane &p_plane) const { -Vector3 AABB::get_longest_axis() const { +Vector3 Rect3::get_longest_axis() const { Vector3 axis(1,0,0); real_t max_size=size.x; @@ -263,7 +263,7 @@ Vector3 AABB::get_longest_axis() const { return axis; } -int AABB::get_longest_axis_index() const { +int Rect3::get_longest_axis_index() const { int axis=0; real_t max_size=size.x; @@ -282,7 +282,7 @@ int AABB::get_longest_axis_index() const { } -Vector3 AABB::get_shortest_axis() const { +Vector3 Rect3::get_shortest_axis() const { Vector3 axis(1,0,0); real_t max_size=size.x; @@ -299,7 +299,7 @@ Vector3 AABB::get_shortest_axis() const { return axis; } -int AABB::get_shortest_axis_index() const { +int Rect3::get_shortest_axis_index() const { int axis=0; real_t max_size=size.x; @@ -317,26 +317,26 @@ int AABB::get_shortest_axis_index() const { return axis; } -AABB AABB::merge(const AABB& p_with) const { +Rect3 Rect3::merge(const Rect3& p_with) const { - AABB aabb=*this; + Rect3 aabb=*this; aabb.merge_with(p_with); return aabb; } -AABB AABB::expand(const Vector3& p_vector) const { - AABB aabb=*this; +Rect3 Rect3::expand(const Vector3& p_vector) const { + Rect3 aabb=*this; aabb.expand_to(p_vector); return aabb; } -AABB AABB::grow(real_t p_by) const { +Rect3 Rect3::grow(real_t p_by) const { - AABB aabb=*this; + Rect3 aabb=*this; aabb.grow_by(p_by); return aabb; } -void AABB::get_edge(int p_edge,Vector3& r_from,Vector3& r_to) const { +void Rect3::get_edge(int p_edge,Vector3& r_from,Vector3& r_to) const { ERR_FAIL_INDEX(p_edge,12); switch(p_edge) { @@ -412,7 +412,7 @@ void AABB::get_edge(int p_edge,Vector3& r_from,Vector3& r_to) const { } -AABB::operator String() const { +Rect3::operator String() const { return String()+pos +" - "+ size; } diff --git a/core/math/aabb.h b/core/math/aabb.h index 1c0adf9012..2816d1f012 100644 --- a/core/math/aabb.h +++ b/core/math/aabb.h @@ -40,7 +40,7 @@ -class AABB { +class Rect3 { public: Vector3 pos; Vector3 size; @@ -62,16 +62,16 @@ public: void set_size(const Vector3& p_size) { size=p_size; } - bool operator==(const AABB& p_rval) const; - bool operator!=(const AABB& p_rval) const; + bool operator==(const Rect3& p_rval) const; + bool operator!=(const Rect3& p_rval) const; - _FORCE_INLINE_ bool intersects(const AABB& p_aabb) const; /// Both AABBs overlap - _FORCE_INLINE_ bool intersects_inclusive(const AABB& p_aabb) const; /// Both AABBs (or their faces) overlap - _FORCE_INLINE_ bool encloses(const AABB & p_aabb) const; /// p_aabb is completely inside this + _FORCE_INLINE_ bool intersects(const Rect3& p_aabb) const; /// Both AABBs overlap + _FORCE_INLINE_ bool intersects_inclusive(const Rect3& p_aabb) const; /// Both AABBs (or their faces) overlap + _FORCE_INLINE_ bool encloses(const Rect3 & p_aabb) const; /// p_aabb is completely inside this - AABB merge(const AABB& p_with) const; - void merge_with(const AABB& p_aabb); ///merge with another AABB - AABB intersection(const AABB& p_aabb) const; ///get box where two intersect, empty if no intersection occurs + Rect3 merge(const Rect3& p_with) const; + void merge_with(const Rect3& p_aabb); ///merge with another AABB + Rect3 intersection(const Rect3& p_aabb) const; ///get box where two intersect, empty if no intersection occurs bool intersects_segment(const Vector3& p_from, const Vector3& p_to,Vector3* r_clip=NULL,Vector3* r_normal=NULL) const; bool intersects_ray(const Vector3& p_from, const Vector3& p_dir,Vector3* r_clip=NULL,Vector3* r_normal=NULL) const; _FORCE_INLINE_ bool smits_intersect_ray(const Vector3 &from,const Vector3& p_dir, float t0, float t1) const; @@ -91,25 +91,25 @@ public: int get_shortest_axis_index() const; _FORCE_INLINE_ real_t get_shortest_axis_size() const; - AABB grow(real_t p_by) const; + Rect3 grow(real_t p_by) const; _FORCE_INLINE_ void grow_by(real_t p_amount); void get_edge(int p_edge,Vector3& r_from,Vector3& r_to) const; _FORCE_INLINE_ Vector3 get_endpoint(int p_point) const; - AABB expand(const Vector3& p_vector) const; + Rect3 expand(const Vector3& p_vector) const; _FORCE_INLINE_ void project_range_in_plane(const Plane& p_plane,float &r_min,float& r_max) const; _FORCE_INLINE_ void expand_to(const Vector3& p_vector); /** expand to contain a point if necesary */ operator String() const; - _FORCE_INLINE_ AABB() {} - inline AABB(const Vector3 &p_pos,const Vector3& p_size) { pos=p_pos; size=p_size; } + _FORCE_INLINE_ Rect3() {} + inline Rect3(const Vector3 &p_pos,const Vector3& p_size) { pos=p_pos; size=p_size; } }; -inline bool AABB::intersects(const AABB& p_aabb) const { +inline bool Rect3::intersects(const Rect3& p_aabb) const { if ( pos.x >= (p_aabb.pos.x + p_aabb.size.x) ) return false; @@ -127,7 +127,7 @@ inline bool AABB::intersects(const AABB& p_aabb) const { return true; } -inline bool AABB::intersects_inclusive(const AABB& p_aabb) const { +inline bool Rect3::intersects_inclusive(const Rect3& p_aabb) const { if ( pos.x > (p_aabb.pos.x + p_aabb.size.x) ) return false; @@ -145,7 +145,7 @@ inline bool AABB::intersects_inclusive(const AABB& p_aabb) const { return true; } -inline bool AABB::encloses(const AABB & p_aabb) const { +inline bool Rect3::encloses(const Rect3 & p_aabb) const { Vector3 src_min=pos; Vector3 src_max=pos+size; @@ -162,7 +162,7 @@ inline bool AABB::encloses(const AABB & p_aabb) const { } -Vector3 AABB::get_support(const Vector3& p_normal) const { +Vector3 Rect3::get_support(const Vector3& p_normal) const { Vector3 half_extents = size * 0.5; Vector3 ofs = pos + half_extents; @@ -175,7 +175,7 @@ Vector3 AABB::get_support(const Vector3& p_normal) const { } -Vector3 AABB::get_endpoint(int p_point) const { +Vector3 Rect3::get_endpoint(int p_point) const { switch(p_point) { case 0: return Vector3( pos.x , pos.y , pos.z ); @@ -191,7 +191,7 @@ Vector3 AABB::get_endpoint(int p_point) const { ERR_FAIL_V(Vector3()); } -bool AABB::intersects_convex_shape(const Plane *p_planes, int p_plane_count) const { +bool Rect3::intersects_convex_shape(const Plane *p_planes, int p_plane_count) const { #if 1 @@ -251,7 +251,7 @@ bool AABB::intersects_convex_shape(const Plane *p_planes, int p_plane_count) con #endif } -bool AABB::has_point(const Vector3& p_point) const { +bool Rect3::has_point(const Vector3& p_point) const { if (p_point.x<pos.x) return false; @@ -270,7 +270,7 @@ bool AABB::has_point(const Vector3& p_point) const { } -inline void AABB::expand_to(const Vector3& p_vector) { +inline void Rect3::expand_to(const Vector3& p_vector) { Vector3 begin=pos; Vector3 end=pos+size; @@ -293,7 +293,7 @@ inline void AABB::expand_to(const Vector3& p_vector) { size=end-begin; } -void AABB::project_range_in_plane(const Plane& p_plane,float &r_min,float& r_max) const { +void Rect3::project_range_in_plane(const Plane& p_plane,float &r_min,float& r_max) const { Vector3 half_extents( size.x * 0.5, size.y * 0.5, size.z * 0.5 ); Vector3 center( pos.x + half_extents.x, pos.y + half_extents.y, pos.z + half_extents.z ); @@ -304,7 +304,7 @@ void AABB::project_range_in_plane(const Plane& p_plane,float &r_min,float& r_max r_max = distance + length; } -inline real_t AABB::get_longest_axis_size() const { +inline real_t Rect3::get_longest_axis_size() const { real_t max_size=size.x; @@ -319,7 +319,7 @@ inline real_t AABB::get_longest_axis_size() const { return max_size; } -inline real_t AABB::get_shortest_axis_size() const { +inline real_t Rect3::get_shortest_axis_size() const { real_t max_size=size.x; @@ -334,7 +334,7 @@ inline real_t AABB::get_shortest_axis_size() const { return max_size; } -bool AABB::smits_intersect_ray(const Vector3 &from,const Vector3& dir, float t0, float t1) const { +bool Rect3::smits_intersect_ray(const Vector3 &from,const Vector3& dir, float t0, float t1) const { float divx=1.0/dir.x; float divy=1.0/dir.y; @@ -381,7 +381,7 @@ bool AABB::smits_intersect_ray(const Vector3 &from,const Vector3& dir, float t0, return ( (tmin < t1) && (tmax > t0) ); } -void AABB::grow_by(real_t p_amount) { +void Rect3::grow_by(real_t p_amount) { pos.x-=p_amount; pos.y-=p_amount; @@ -391,6 +391,5 @@ void AABB::grow_by(real_t p_amount) { size.z+=2.0*p_amount; } -typedef AABB Rect3; #endif // AABB_H diff --git a/core/math/bsp_tree.cpp b/core/math/bsp_tree.cpp index b7194d7ffb..b888b6b56c 100644 --- a/core/math/bsp_tree.cpp +++ b/core/math/bsp_tree.cpp @@ -31,7 +31,7 @@ #include "print_string.h" -void BSP_Tree::from_aabb(const AABB& p_aabb) { +void BSP_Tree::from_aabb(const Rect3& p_aabb) { planes.clear(); @@ -67,7 +67,7 @@ Vector<Plane> BSP_Tree::get_planes() const { return planes; } -AABB BSP_Tree::get_aabb() const { +Rect3 BSP_Tree::get_aabb() const { return aabb; } @@ -518,7 +518,7 @@ BSP_Tree::BSP_Tree(const Variant& p_variant) { ERR_FAIL_COND(src_nodes.size()%3); - if (d["planes"].get_type()==Variant::REAL_ARRAY) { + if (d["planes"].get_type()==Variant::POOL_REAL_ARRAY) { PoolVector<float> src_planes=d["planes"]; int plane_count=src_planes.size(); @@ -613,7 +613,7 @@ BSP_Tree::BSP_Tree(const PoolVector<Face3>& p_faces,float p_error_radius) { error_radius=p_error_radius; } -BSP_Tree::BSP_Tree(const Vector<Node> &p_nodes, const Vector<Plane> &p_planes, const AABB& p_aabb,float p_error_radius) { +BSP_Tree::BSP_Tree(const Vector<Node> &p_nodes, const Vector<Plane> &p_planes, const Rect3& p_aabb,float p_error_radius) { nodes=p_nodes; planes=p_planes; diff --git a/core/math/bsp_tree.h b/core/math/bsp_tree.h index 236b6e5ac2..e01df96555 100644 --- a/core/math/bsp_tree.h +++ b/core/math/bsp_tree.h @@ -65,7 +65,7 @@ private: Vector<Node> nodes; Vector<Plane> planes; - AABB aabb; + Rect3 aabb; float error_radius; int _get_points_inside(int p_node,const Vector3* p_points,int *p_indices, const Vector3& p_center,const Vector3& p_half_extents,int p_indices_count) const; @@ -78,7 +78,7 @@ public: bool is_empty() const { return nodes.size()==0; } Vector<Node> get_nodes() const; Vector<Plane> get_planes() const; - AABB get_aabb() const; + Rect3 get_aabb() const; bool point_is_inside(const Vector3& p_point) const; int get_points_inside(const Vector3* p_points, int p_point_count) const; @@ -87,12 +87,12 @@ public: operator Variant() const; - void from_aabb(const AABB& p_aabb); + void from_aabb(const Rect3& p_aabb); BSP_Tree(); BSP_Tree(const Variant& p_variant); BSP_Tree(const PoolVector<Face3>& p_faces,float p_error_radius=0); - BSP_Tree(const Vector<Node> &p_nodes, const Vector<Plane> &p_planes, const AABB& p_aabb,float p_error_radius=0); + BSP_Tree(const Vector<Node> &p_nodes, const Vector<Plane> &p_planes, const Rect3& p_aabb,float p_error_radius=0); ~BSP_Tree(); }; diff --git a/core/math/camera_matrix.cpp b/core/math/camera_matrix.cpp index 7910f5fafc..c44ff4682a 100644 --- a/core/math/camera_matrix.cpp +++ b/core/math/camera_matrix.cpp @@ -564,7 +564,7 @@ void CameraMatrix::make_scale(const Vector3 &p_scale) { } -void CameraMatrix::scale_translate_to_fit(const AABB& p_aabb) { +void CameraMatrix::scale_translate_to_fit(const Rect3& p_aabb) { Vector3 min = p_aabb.pos; Vector3 max = p_aabb.pos+p_aabb.size; diff --git a/core/math/camera_matrix.h b/core/math/camera_matrix.h index f9fb4837f1..952f1e8fb2 100644 --- a/core/math/camera_matrix.h +++ b/core/math/camera_matrix.h @@ -85,7 +85,7 @@ struct CameraMatrix { operator String() const; - void scale_translate_to_fit(const AABB& p_aabb); + void scale_translate_to_fit(const Rect3& p_aabb); void make_scale(const Vector3 &p_scale); int get_pixels_per_meter(int p_for_pixel_width) const; operator Transform() const; diff --git a/core/math/face3.cpp b/core/math/face3.cpp index 1024143ba1..faf124593e 100644 --- a/core/math/face3.cpp +++ b/core/math/face3.cpp @@ -205,7 +205,7 @@ ClockDirection Face3::get_clock_dir() const { } -bool Face3::intersects_aabb(const AABB& p_aabb) const { +bool Face3::intersects_aabb(const Rect3& p_aabb) const { /** TEST PLANE **/ if (!p_aabb.intersects_plane( get_plane() )) diff --git a/core/math/face3.h b/core/math/face3.h index 4eade1217d..f08eb227b1 100644 --- a/core/math/face3.h +++ b/core/math/face3.h @@ -78,16 +78,16 @@ public: void get_support(const Vector3& p_normal,const Transform& p_transform,Vector3 *p_vertices,int* p_count,int p_max) const; void project_range(const Vector3& p_normal,const Transform& p_transform,float& r_min, float& r_max) const; - AABB get_aabb() const { + Rect3 get_aabb() const { - AABB aabb( vertex[0], Vector3() ); + Rect3 aabb( vertex[0], Vector3() ); aabb.expand_to( vertex[1] ); aabb.expand_to( vertex[2] ); return aabb; } - bool intersects_aabb(const AABB& p_aabb) const; - _FORCE_INLINE_ bool intersects_aabb2(const AABB& p_aabb) const; + bool intersects_aabb(const Rect3& p_aabb) const; + _FORCE_INLINE_ bool intersects_aabb2(const Rect3& p_aabb) const; operator String() const; inline Face3() {} @@ -96,7 +96,7 @@ public: }; -bool Face3::intersects_aabb2(const AABB& p_aabb) const { +bool Face3::intersects_aabb2(const Rect3& p_aabb) const { Vector3 perp = (vertex[0]-vertex[2]).cross(vertex[0]-vertex[1]); diff --git a/core/math/geometry.cpp b/core/math/geometry.cpp index 3232d36262..bf3364a052 100644 --- a/core/math/geometry.cpp +++ b/core/math/geometry.cpp @@ -304,7 +304,7 @@ enum _CellFlags { static inline void _plot_face(uint8_t*** p_cell_status,int x,int y,int z,int len_x,int len_y,int len_z,const Vector3& voxelsize,const Face3& p_face) { - AABB aabb( Vector3(x,y,z),Vector3(len_x,len_y,len_z)); + Rect3 aabb( Vector3(x,y,z),Vector3(len_x,len_y,len_z)); aabb.pos=aabb.pos*voxelsize; aabb.size=aabb.size*voxelsize; @@ -589,7 +589,7 @@ PoolVector< Face3 > Geometry::wrap_geometry( PoolVector< Face3 > p_array,float * PoolVector<Face3>::Read facesr=p_array.read(); const Face3 *faces = facesr.ptr(); - AABB global_aabb; + Rect3 global_aabb; for(int i=0;i<face_count;i++) { diff --git a/core/math/math_2d.cpp b/core/math/math_2d.cpp index df9383ed1b..c6860ba2e8 100644 --- a/core/math/math_2d.cpp +++ b/core/math/math_2d.cpp @@ -408,22 +408,22 @@ bool Point2i::operator!=(const Point2i& p_vec2) const { return x!=p_vec2.x || y!=p_vec2.y; } -void Matrix32::invert() { +void Transform2D::invert() { // FIXME: this function assumes the basis is a rotation matrix, with no scaling. - // Matrix32::affine_inverse can handle matrices with scaling, so GDScript should eventually use that. + // Transform2D::affine_inverse can handle matrices with scaling, so GDScript should eventually use that. SWAP(elements[0][1],elements[1][0]); elements[2] = basis_xform(-elements[2]); } -Matrix32 Matrix32::inverse() const { +Transform2D Transform2D::inverse() const { - Matrix32 inv=*this; + Transform2D inv=*this; inv.invert(); return inv; } -void Matrix32::affine_invert() { +void Transform2D::affine_invert() { real_t det = basis_determinant(); ERR_FAIL_COND(det==0); @@ -437,27 +437,27 @@ void Matrix32::affine_invert() { } -Matrix32 Matrix32::affine_inverse() const { +Transform2D Transform2D::affine_inverse() const { - Matrix32 inv=*this; + Transform2D inv=*this; inv.affine_invert(); return inv; } -void Matrix32::rotate(real_t p_phi) { - *this = Matrix32(p_phi,Vector2()) * (*this); +void Transform2D::rotate(real_t p_phi) { + *this = Transform2D(p_phi,Vector2()) * (*this); } -real_t Matrix32::get_rotation() const { +real_t Transform2D::get_rotation() const { real_t det = basis_determinant(); - Matrix32 m = orthonormalized(); + Transform2D m = orthonormalized(); if (det < 0) { m.scale_basis(Size2(-1,-1)); } return Math::atan2(m[0].y,m[0].x); } -void Matrix32::set_rotation(real_t p_rot) { +void Transform2D::set_rotation(real_t p_rot) { real_t cr = Math::cos(p_rot); real_t sr = Math::sin(p_rot); @@ -467,7 +467,7 @@ void Matrix32::set_rotation(real_t p_rot) { elements[1][1]=cr; } -Matrix32::Matrix32(real_t p_rot, const Vector2& p_pos) { +Transform2D::Transform2D(real_t p_rot, const Vector2& p_pos) { real_t cr = Math::cos(p_rot); real_t sr = Math::sin(p_rot); @@ -478,16 +478,16 @@ Matrix32::Matrix32(real_t p_rot, const Vector2& p_pos) { elements[2]=p_pos; } -Size2 Matrix32::get_scale() const { +Size2 Transform2D::get_scale() const { real_t det_sign = basis_determinant() > 0 ? 1 : -1; return det_sign * Size2( elements[0].length(), elements[1].length() ); } -void Matrix32::scale(const Size2& p_scale) { +void Transform2D::scale(const Size2& p_scale) { scale_basis(p_scale); elements[2]*=p_scale; } -void Matrix32::scale_basis(const Size2& p_scale) { +void Transform2D::scale_basis(const Size2& p_scale) { elements[0][0]*=p_scale.x; elements[0][1]*=p_scale.y; @@ -495,16 +495,16 @@ void Matrix32::scale_basis(const Size2& p_scale) { elements[1][1]*=p_scale.y; } -void Matrix32::translate( real_t p_tx, real_t p_ty) { +void Transform2D::translate( real_t p_tx, real_t p_ty) { translate(Vector2(p_tx,p_ty)); } -void Matrix32::translate( const Vector2& p_translation ) { +void Transform2D::translate( const Vector2& p_translation ) { elements[2]+=basis_xform(p_translation); } -void Matrix32::orthonormalize() { +void Transform2D::orthonormalize() { // Gram-Schmidt Process @@ -518,15 +518,15 @@ void Matrix32::orthonormalize() { elements[0]=x; elements[1]=y; } -Matrix32 Matrix32::orthonormalized() const { +Transform2D Transform2D::orthonormalized() const { - Matrix32 on=*this; + Transform2D on=*this; on.orthonormalize(); return on; } -bool Matrix32::operator==(const Matrix32& p_transform) const { +bool Transform2D::operator==(const Transform2D& p_transform) const { for(int i=0;i<3;i++) { if (elements[i]!=p_transform.elements[i]) @@ -536,7 +536,7 @@ bool Matrix32::operator==(const Matrix32& p_transform) const { return true; } -bool Matrix32::operator!=(const Matrix32& p_transform) const { +bool Transform2D::operator!=(const Transform2D& p_transform) const { for(int i=0;i<3;i++) { if (elements[i]!=p_transform.elements[i]) @@ -547,7 +547,7 @@ bool Matrix32::operator!=(const Matrix32& p_transform) const { } -void Matrix32::operator*=(const Matrix32& p_transform) { +void Transform2D::operator*=(const Transform2D& p_transform) { elements[2] = xform(p_transform.elements[2]); @@ -565,59 +565,59 @@ void Matrix32::operator*=(const Matrix32& p_transform) { } -Matrix32 Matrix32::operator*(const Matrix32& p_transform) const { +Transform2D Transform2D::operator*(const Transform2D& p_transform) const { - Matrix32 t = *this; + Transform2D t = *this; t*=p_transform; return t; } -Matrix32 Matrix32::scaled(const Size2& p_scale) const { +Transform2D Transform2D::scaled(const Size2& p_scale) const { - Matrix32 copy=*this; + Transform2D copy=*this; copy.scale(p_scale); return copy; } -Matrix32 Matrix32::basis_scaled(const Size2& p_scale) const { +Transform2D Transform2D::basis_scaled(const Size2& p_scale) const { - Matrix32 copy=*this; + Transform2D copy=*this; copy.scale_basis(p_scale); return copy; } -Matrix32 Matrix32::untranslated() const { +Transform2D Transform2D::untranslated() const { - Matrix32 copy=*this; + Transform2D copy=*this; copy.elements[2]=Vector2(); return copy; } -Matrix32 Matrix32::translated(const Vector2& p_offset) const { +Transform2D Transform2D::translated(const Vector2& p_offset) const { - Matrix32 copy=*this; + Transform2D copy=*this; copy.translate(p_offset); return copy; } -Matrix32 Matrix32::rotated(real_t p_phi) const { +Transform2D Transform2D::rotated(real_t p_phi) const { - Matrix32 copy=*this; + Transform2D copy=*this; copy.rotate(p_phi); return copy; } -real_t Matrix32::basis_determinant() const { +real_t Transform2D::basis_determinant() const { return elements[0].x * elements[1].y - elements[0].y * elements[1].x; } -Matrix32 Matrix32::interpolate_with(const Matrix32& p_transform, real_t p_c) const { +Transform2D Transform2D::interpolate_with(const Transform2D& p_transform, real_t p_c) const { //extract parameters Vector2 p1 = get_origin(); @@ -648,12 +648,12 @@ Matrix32 Matrix32::interpolate_with(const Matrix32& p_transform, real_t p_c) con } //construct matrix - Matrix32 res(Math::atan2(v.y, v.x), Vector2::linear_interpolate(p1, p2, p_c)); + Transform2D res(Math::atan2(v.y, v.x), Vector2::linear_interpolate(p1, p2, p_c)); res.scale_basis(Vector2::linear_interpolate(s1, s2, p_c)); return res; } -Matrix32::operator String() const { +Transform2D::operator String() const { return String(String()+elements[0]+", "+elements[1]+", "+elements[2]); } diff --git a/core/math/math_2d.h b/core/math/math_2d.h index adc23f01b1..7896299c24 100644 --- a/core/math/math_2d.h +++ b/core/math/math_2d.h @@ -198,7 +198,7 @@ Vector2 Vector2::linear_interpolate(const Vector2& p_a, const Vector2& p_b,real_ typedef Vector2 Size2; typedef Vector2 Point2; -struct Matrix32; +struct Transform2D; struct Rect2 { @@ -249,7 +249,7 @@ struct Rect2 { return dist; } - _FORCE_INLINE_ bool intersects_transformed(const Matrix32& p_xform, const Rect2& p_rect) const; + _FORCE_INLINE_ bool intersects_transformed(const Transform2D& p_xform, const Rect2& p_rect) const; bool intersects_segment(const Point2& p_from, const Point2& p_to, Point2* r_pos=NULL, Point2* r_normal=NULL) const; @@ -551,8 +551,8 @@ struct Rect2i { -struct Matrix32 { - // Warning #1: basis of Matrix32 is stored differently from Matrix3. In terms of elements array, the basis matrix looks like "on paper": +struct Transform2D { + // 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]) // This is such that the columns, which can be interpreted as basis vectors of the coordinate system "painted" on the object, can be accessed as elements[i]. @@ -575,10 +575,10 @@ struct Matrix32 { _FORCE_INLINE_ void set_axis(int p_axis,const Vector2& p_vec) { ERR_FAIL_INDEX(p_axis,3); elements[p_axis]=p_vec; } void invert(); - Matrix32 inverse() const; + Transform2D inverse() const; void affine_invert(); - Matrix32 affine_inverse() const; + Transform2D affine_inverse() const; void set_rotation(real_t p_phi); real_t get_rotation() const; @@ -597,23 +597,23 @@ struct Matrix32 { _FORCE_INLINE_ const Vector2& get_origin() const { return elements[2]; } _FORCE_INLINE_ void set_origin(const Vector2& p_origin) { elements[2]=p_origin; } - Matrix32 scaled(const Size2& p_scale) const; - Matrix32 basis_scaled(const Size2& p_scale) const; - Matrix32 translated(const Vector2& p_offset) const; - Matrix32 rotated(real_t p_phi) const; + Transform2D scaled(const Size2& p_scale) const; + Transform2D basis_scaled(const Size2& p_scale) const; + Transform2D translated(const Vector2& p_offset) const; + Transform2D rotated(real_t p_phi) const; - Matrix32 untranslated() const; + Transform2D untranslated() const; void orthonormalize(); - Matrix32 orthonormalized() const; + Transform2D orthonormalized() const; - bool operator==(const Matrix32& p_transform) const; - bool operator!=(const Matrix32& p_transform) const; + bool operator==(const Transform2D& p_transform) const; + bool operator!=(const Transform2D& p_transform) const; - void operator*=(const Matrix32& p_transform); - Matrix32 operator*(const Matrix32& p_transform) const; + void operator*=(const Transform2D& p_transform); + Transform2D operator*(const Transform2D& p_transform) const; - Matrix32 interpolate_with(const Matrix32& p_transform, real_t p_c) const; + Transform2D interpolate_with(const Transform2D& p_transform, real_t p_c) const; _FORCE_INLINE_ Vector2 basis_xform(const Vector2& p_vec) const; _FORCE_INLINE_ Vector2 basis_xform_inv(const Vector2& p_vec) const; @@ -624,7 +624,7 @@ struct Matrix32 { operator String() const; - Matrix32(real_t xx, real_t xy, real_t yx, real_t yy, real_t ox, real_t oy) { + Transform2D(real_t xx, real_t xy, real_t yx, real_t yy, real_t ox, real_t oy) { elements[0][0] = xx; elements[0][1] = xy; @@ -634,11 +634,11 @@ struct Matrix32 { elements[2][1] = oy; } - Matrix32(real_t p_rot, const Vector2& p_pos); - Matrix32() { elements[0][0]=1.0; elements[1][1]=1.0; } + Transform2D(real_t p_rot, const Vector2& p_pos); + Transform2D() { elements[0][0]=1.0; elements[1][1]=1.0; } }; -bool Rect2::intersects_transformed(const Matrix32& p_xform, const Rect2& p_rect) const { +bool Rect2::intersects_transformed(const Transform2D& p_xform, const Rect2& p_rect) const { //SAT intersection between local and transformed rect2 @@ -793,7 +793,7 @@ bool Rect2::intersects_transformed(const Matrix32& p_xform, const Rect2& p_rect) } -Vector2 Matrix32::basis_xform(const Vector2& v) const { +Vector2 Transform2D::basis_xform(const Vector2& v) const { return Vector2( tdotx(v), @@ -801,7 +801,7 @@ Vector2 Matrix32::basis_xform(const Vector2& v) const { ); } -Vector2 Matrix32::basis_xform_inv(const Vector2& v) const{ +Vector2 Transform2D::basis_xform_inv(const Vector2& v) const{ return Vector2( elements[0].dot(v), @@ -809,14 +809,14 @@ Vector2 Matrix32::basis_xform_inv(const Vector2& v) const{ ); } -Vector2 Matrix32::xform(const Vector2& v) const { +Vector2 Transform2D::xform(const Vector2& v) const { return Vector2( tdotx(v), tdoty(v) ) + elements[2]; } -Vector2 Matrix32::xform_inv(const Vector2& p_vec) const { +Vector2 Transform2D::xform_inv(const Vector2& p_vec) const { Vector2 v = p_vec - elements[2]; @@ -826,7 +826,7 @@ Vector2 Matrix32::xform_inv(const Vector2& p_vec) const { ); } -Rect2 Matrix32::xform(const Rect2& p_rect) const { +Rect2 Transform2D::xform(const Rect2& p_rect) const { Vector2 x=elements[0]*p_rect.size.x; Vector2 y=elements[1]*p_rect.size.y; @@ -840,7 +840,7 @@ Rect2 Matrix32::xform(const Rect2& p_rect) const { return new_rect; } -void Matrix32::set_rotation_and_scale(real_t p_rot,const Size2& p_scale) { +void Transform2D::set_rotation_and_scale(real_t p_rot,const Size2& p_scale) { elements[0][0]=Math::cos(p_rot)*p_scale.x; elements[1][1]=Math::cos(p_rot)*p_scale.y; @@ -849,7 +849,7 @@ void Matrix32::set_rotation_and_scale(real_t p_rot,const Size2& p_scale) { } -Rect2 Matrix32::xform_inv(const Rect2& p_rect) const { +Rect2 Transform2D::xform_inv(const Rect2& p_rect) const { Vector2 ends[4]={ xform_inv( p_rect.pos ), diff --git a/core/math/matrix3.cpp b/core/math/matrix3.cpp index 44abf8cd36..e9c3442582 100644 --- a/core/math/matrix3.cpp +++ b/core/math/matrix3.cpp @@ -33,7 +33,7 @@ #define cofac(row1,col1, row2, col2)\ (elements[row1][col1] * elements[row2][col2] - elements[row1][col2] * elements[row2][col1]) -void Matrix3::from_z(const Vector3& p_z) { +void Basis::from_z(const Vector3& p_z) { if (Math::abs(p_z.z) > Math_SQRT12 ) { @@ -53,7 +53,7 @@ void Matrix3::from_z(const Vector3& p_z) { elements[2]=p_z; } -void Matrix3::invert() { +void Basis::invert() { real_t co[3]={ @@ -72,7 +72,7 @@ void Matrix3::invert() { } -void Matrix3::orthonormalize() { +void Basis::orthonormalize() { ERR_FAIL_COND(determinant() == 0); // Gram-Schmidt Process @@ -93,26 +93,26 @@ void Matrix3::orthonormalize() { } -Matrix3 Matrix3::orthonormalized() const { +Basis Basis::orthonormalized() const { - Matrix3 c = *this; + Basis c = *this; c.orthonormalize(); return c; } -bool Matrix3::is_orthogonal() const { - Matrix3 id; - Matrix3 m = (*this)*transposed(); +bool Basis::is_orthogonal() const { + Basis id; + Basis m = (*this)*transposed(); return isequal_approx(id,m); } -bool Matrix3::is_rotation() const { +bool Basis::is_rotation() const { return Math::isequal_approx(determinant(), 1) && is_orthogonal(); } -bool Matrix3::is_symmetric() const { +bool Basis::is_symmetric() const { if (Math::abs(elements[0][1] - elements[1][0]) > CMP_EPSILON) return false; @@ -125,19 +125,19 @@ bool Matrix3::is_symmetric() const { } -Matrix3 Matrix3::diagonalize() { +Basis Basis::diagonalize() { //NOTE: only implemented for symmetric matrices //with the Jacobi iterative method method - ERR_FAIL_COND_V(!is_symmetric(), Matrix3()); + ERR_FAIL_COND_V(!is_symmetric(), Basis()); const int ite_max = 1024; real_t off_matrix_norm_2 = elements[0][1] * elements[0][1] + elements[0][2] * elements[0][2] + elements[1][2] * elements[1][2]; int ite = 0; - Matrix3 acc_rot; + Basis acc_rot; while (off_matrix_norm_2 > CMP_EPSILON2 && ite++ < ite_max ) { real_t el01_2 = elements[0][1] * elements[0][1]; real_t el02_2 = elements[0][2] * elements[0][2]; @@ -171,7 +171,7 @@ Matrix3 Matrix3::diagonalize() { } // Compute the rotation matrix - Matrix3 rot; + Basis rot; rot.elements[i][i] = rot.elements[j][j] = Math::cos(angle); rot.elements[i][j] = - (rot.elements[j][i] = Math::sin(angle)); @@ -186,30 +186,30 @@ Matrix3 Matrix3::diagonalize() { return acc_rot; } -Matrix3 Matrix3::inverse() const { +Basis Basis::inverse() const { - Matrix3 inv=*this; + Basis inv=*this; inv.invert(); return inv; } -void Matrix3::transpose() { +void Basis::transpose() { SWAP(elements[0][1],elements[1][0]); SWAP(elements[0][2],elements[2][0]); SWAP(elements[1][2],elements[2][1]); } -Matrix3 Matrix3::transposed() const { +Basis Basis::transposed() const { - Matrix3 tr=*this; + Basis tr=*this; tr.transpose(); return tr; } // Multiplies the matrix from left by the scaling matrix: M -> S.M -// See the comment for Matrix3::rotated for further explanation. -void Matrix3::scale(const Vector3& p_scale) { +// See the comment for Basis::rotated for further explanation. +void Basis::scale(const Vector3& p_scale) { elements[0][0]*=p_scale.x; elements[0][1]*=p_scale.x; @@ -222,14 +222,14 @@ void Matrix3::scale(const Vector3& p_scale) { elements[2][2]*=p_scale.z; } -Matrix3 Matrix3::scaled( const Vector3& p_scale ) const { +Basis Basis::scaled( const Vector3& p_scale ) const { - Matrix3 m = *this; + Basis m = *this; m.scale(p_scale); return m; } -Vector3 Matrix3::get_scale() const { +Vector3 Basis::get_scale() const { // We are assuming M = R.S, and performing a polar decomposition to extract R and S. // FIXME: We eventually need a proper polar decomposition. // As a cheap workaround until then, to ensure that R is a proper rotation matrix with determinant +1 @@ -247,30 +247,30 @@ Vector3 Matrix3::get_scale() const { // Multiplies the matrix from left by the rotation matrix: M -> R.M // Note that this does *not* rotate the matrix itself. // -// The main use of Matrix3 is as Transform.basis, which is used a the transformation matrix +// The main use of Basis is as Transform.basis, which is used a the transformation matrix // of 3D object. Rotate here refers to rotation of the object (which is R * (*this)), // not the matrix itself (which is R * (*this) * R.transposed()). -Matrix3 Matrix3::rotated(const Vector3& p_axis, real_t p_phi) const { - return Matrix3(p_axis, p_phi) * (*this); +Basis Basis::rotated(const Vector3& p_axis, real_t p_phi) const { + return Basis(p_axis, p_phi) * (*this); } -void Matrix3::rotate(const Vector3& p_axis, real_t p_phi) { +void Basis::rotate(const Vector3& p_axis, real_t p_phi) { *this = rotated(p_axis, p_phi); } -Matrix3 Matrix3::rotated(const Vector3& p_euler) const { - return Matrix3(p_euler) * (*this); +Basis Basis::rotated(const Vector3& p_euler) const { + return Basis(p_euler) * (*this); } -void Matrix3::rotate(const Vector3& p_euler) { +void Basis::rotate(const Vector3& p_euler) { *this = rotated(p_euler); } -Vector3 Matrix3::get_rotation() const { +Vector3 Basis::get_rotation() const { // Assumes that the matrix can be decomposed into a proper rotation and scaling matrix as M = R.S, // and returns the Euler angles corresponding to the rotation part, complementing get_scale(). // See the comment in get_scale() for further information. - Matrix3 m = orthonormalized(); + Basis m = orthonormalized(); real_t det = m.determinant(); if (det < 0) { // Ensure that the determinant is 1, such that result is a proper rotation matrix which can be represented by Euler angles. @@ -290,7 +290,7 @@ Vector3 Matrix3::get_rotation() const { // And thus, assuming the matrix is a rotation matrix, this function returns // the angles in the decomposition R = X(a1).Y(a2).Z(a3) where Z(a) rotates // around the z-axis by a and so on. -Vector3 Matrix3::get_euler() const { +Vector3 Basis::get_euler() const { // Euler angles in XYZ convention. // See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix @@ -329,27 +329,27 @@ Vector3 Matrix3::get_euler() const { // set_euler expects a vector containing the Euler angles in the format // (c,b,a), where a is the angle of the first rotation, and c is the last. // The current implementation uses XYZ convention (Z is the first rotation). -void Matrix3::set_euler(const Vector3& p_euler) { +void Basis::set_euler(const Vector3& p_euler) { real_t c, s; c = Math::cos(p_euler.x); s = Math::sin(p_euler.x); - Matrix3 xmat(1.0,0.0,0.0,0.0,c,-s,0.0,s,c); + Basis xmat(1.0,0.0,0.0,0.0,c,-s,0.0,s,c); c = Math::cos(p_euler.y); s = Math::sin(p_euler.y); - Matrix3 ymat(c,0.0,s,0.0,1.0,0.0,-s,0.0,c); + Basis ymat(c,0.0,s,0.0,1.0,0.0,-s,0.0,c); c = Math::cos(p_euler.z); s = Math::sin(p_euler.z); - Matrix3 zmat(c,-s,0.0,s,c,0.0,0.0,0.0,1.0); + Basis zmat(c,-s,0.0,s,c,0.0,0.0,0.0,1.0); //optimizer will optimize away all this anyway *this = xmat*(ymat*zmat); } -bool Matrix3::isequal_approx(const Matrix3& a, const Matrix3& b) const { +bool Basis::isequal_approx(const Basis& a, const Basis& b) const { for (int i=0;i<3;i++) { for (int j=0;j<3;j++) { @@ -361,7 +361,7 @@ bool Matrix3::isequal_approx(const Matrix3& a, const Matrix3& b) const { return true; } -bool Matrix3::operator==(const Matrix3& p_matrix) const { +bool Basis::operator==(const Basis& p_matrix) const { for (int i=0;i<3;i++) { for (int j=0;j<3;j++) { @@ -373,12 +373,12 @@ bool Matrix3::operator==(const Matrix3& p_matrix) const { return true; } -bool Matrix3::operator!=(const Matrix3& p_matrix) const { +bool Basis::operator!=(const Basis& p_matrix) const { return (!(*this==p_matrix)); } -Matrix3::operator String() const { +Basis::operator String() const { String mtx; for (int i=0;i<3;i++) { @@ -395,7 +395,7 @@ Matrix3::operator String() const { return mtx; } -Matrix3::operator Quat() const { +Basis::operator Quat() const { ERR_FAIL_COND_V(is_rotation() == false, Quat()); real_t trace = elements[0][0] + elements[1][1] + elements[2][2]; @@ -432,37 +432,37 @@ Matrix3::operator Quat() const { } -static const Matrix3 _ortho_bases[24]={ - Matrix3(1, 0, 0, 0, 1, 0, 0, 0, 1), - Matrix3(0, -1, 0, 1, 0, 0, 0, 0, 1), - Matrix3(-1, 0, 0, 0, -1, 0, 0, 0, 1), - Matrix3(0, 1, 0, -1, 0, 0, 0, 0, 1), - Matrix3(1, 0, 0, 0, 0, -1, 0, 1, 0), - Matrix3(0, 0, 1, 1, 0, 0, 0, 1, 0), - Matrix3(-1, 0, 0, 0, 0, 1, 0, 1, 0), - Matrix3(0, 0, -1, -1, 0, 0, 0, 1, 0), - Matrix3(1, 0, 0, 0, -1, 0, 0, 0, -1), - Matrix3(0, 1, 0, 1, 0, 0, 0, 0, -1), - Matrix3(-1, 0, 0, 0, 1, 0, 0, 0, -1), - Matrix3(0, -1, 0, -1, 0, 0, 0, 0, -1), - Matrix3(1, 0, 0, 0, 0, 1, 0, -1, 0), - Matrix3(0, 0, -1, 1, 0, 0, 0, -1, 0), - Matrix3(-1, 0, 0, 0, 0, -1, 0, -1, 0), - Matrix3(0, 0, 1, -1, 0, 0, 0, -1, 0), - Matrix3(0, 0, 1, 0, 1, 0, -1, 0, 0), - Matrix3(0, -1, 0, 0, 0, 1, -1, 0, 0), - Matrix3(0, 0, -1, 0, -1, 0, -1, 0, 0), - Matrix3(0, 1, 0, 0, 0, -1, -1, 0, 0), - Matrix3(0, 0, 1, 0, -1, 0, 1, 0, 0), - Matrix3(0, 1, 0, 0, 0, 1, 1, 0, 0), - Matrix3(0, 0, -1, 0, 1, 0, 1, 0, 0), - Matrix3(0, -1, 0, 0, 0, -1, 1, 0, 0) +static const Basis _ortho_bases[24]={ + Basis(1, 0, 0, 0, 1, 0, 0, 0, 1), + Basis(0, -1, 0, 1, 0, 0, 0, 0, 1), + Basis(-1, 0, 0, 0, -1, 0, 0, 0, 1), + Basis(0, 1, 0, -1, 0, 0, 0, 0, 1), + Basis(1, 0, 0, 0, 0, -1, 0, 1, 0), + Basis(0, 0, 1, 1, 0, 0, 0, 1, 0), + Basis(-1, 0, 0, 0, 0, 1, 0, 1, 0), + Basis(0, 0, -1, -1, 0, 0, 0, 1, 0), + Basis(1, 0, 0, 0, -1, 0, 0, 0, -1), + Basis(0, 1, 0, 1, 0, 0, 0, 0, -1), + Basis(-1, 0, 0, 0, 1, 0, 0, 0, -1), + Basis(0, -1, 0, -1, 0, 0, 0, 0, -1), + Basis(1, 0, 0, 0, 0, 1, 0, -1, 0), + Basis(0, 0, -1, 1, 0, 0, 0, -1, 0), + Basis(-1, 0, 0, 0, 0, -1, 0, -1, 0), + Basis(0, 0, 1, -1, 0, 0, 0, -1, 0), + Basis(0, 0, 1, 0, 1, 0, -1, 0, 0), + Basis(0, -1, 0, 0, 0, 1, -1, 0, 0), + Basis(0, 0, -1, 0, -1, 0, -1, 0, 0), + Basis(0, 1, 0, 0, 0, -1, -1, 0, 0), + Basis(0, 0, 1, 0, -1, 0, 1, 0, 0), + Basis(0, 1, 0, 0, 0, 1, 1, 0, 0), + Basis(0, 0, -1, 0, 1, 0, 1, 0, 0), + Basis(0, -1, 0, 0, 0, -1, 1, 0, 0) }; -int Matrix3::get_orthogonal_index() const { +int Basis::get_orthogonal_index() const { //could be sped up if i come up with a way - Matrix3 orth=*this; + Basis orth=*this; for(int i=0;i<3;i++) { for(int j=0;j<3;j++) { @@ -489,7 +489,7 @@ int Matrix3::get_orthogonal_index() const { return 0; } -void Matrix3::set_orthogonal_index(int p_index){ +void Basis::set_orthogonal_index(int p_index){ //there only exist 24 orthogonal bases in r3 ERR_FAIL_INDEX(p_index,24); @@ -500,7 +500,7 @@ void Matrix3::set_orthogonal_index(int p_index){ } -void Matrix3::get_axis_and_angle(Vector3 &r_axis,real_t& r_angle) const { +void Basis::get_axis_and_angle(Vector3 &r_axis,real_t& r_angle) const { ERR_FAIL_COND(is_rotation() == false); @@ -581,13 +581,13 @@ void Matrix3::get_axis_and_angle(Vector3 &r_axis,real_t& r_angle) const { r_angle=angle; } -Matrix3::Matrix3(const Vector3& p_euler) { +Basis::Basis(const Vector3& p_euler) { set_euler( p_euler ); } -Matrix3::Matrix3(const Quat& p_quat) { +Basis::Basis(const Quat& p_quat) { real_t d = p_quat.length_squared(); real_t s = 2.0 / d; @@ -601,7 +601,7 @@ Matrix3::Matrix3(const Quat& p_quat) { } -Matrix3::Matrix3(const Vector3& p_axis, real_t p_phi) { +Basis::Basis(const Vector3& p_axis, real_t p_phi) { // Rotation matrix from axis and angle, see https://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle Vector3 axis_sq(p_axis.x*p_axis.x,p_axis.y*p_axis.y,p_axis.z*p_axis.z); diff --git a/core/math/matrix3.h b/core/math/matrix3.h index 0b61e3a56c..abce1ee45d 100644 --- a/core/math/matrix3.h +++ b/core/math/matrix3.h @@ -37,7 +37,7 @@ /** @author Juan Linietsky <reduzio@gmail.com> */ -class Matrix3 { +class Basis { public: Vector3 elements[3]; @@ -54,8 +54,8 @@ public: void invert(); void transpose(); - Matrix3 inverse() const; - Matrix3 transposed() const; + Basis inverse() const; + Basis transposed() const; _FORCE_INLINE_ real_t determinant() const; @@ -73,14 +73,14 @@ public: } void rotate(const Vector3& p_axis, real_t p_phi); - Matrix3 rotated(const Vector3& p_axis, real_t p_phi) const; + Basis rotated(const Vector3& p_axis, real_t p_phi) const; void rotate(const Vector3& p_euler); - Matrix3 rotated(const Vector3& p_euler) const; + Basis rotated(const Vector3& p_euler) const; Vector3 get_rotation() const; void scale( const Vector3& p_scale ); - Matrix3 scaled( const Vector3& p_scale ) const; + Basis scaled( const Vector3& p_scale ) const; Vector3 get_scale() const; Vector3 get_euler() const; @@ -97,21 +97,21 @@ public: return elements[0][2] * v[0] + elements[1][2] * v[1] + elements[2][2] * v[2]; } - bool isequal_approx(const Matrix3& a, const Matrix3& b) const; + bool isequal_approx(const Basis& a, const Basis& b) const; - bool operator==(const Matrix3& p_matrix) const; - bool operator!=(const Matrix3& p_matrix) const; + bool operator==(const Basis& p_matrix) const; + bool operator!=(const Basis& p_matrix) const; _FORCE_INLINE_ Vector3 xform(const Vector3& p_vector) const; _FORCE_INLINE_ Vector3 xform_inv(const Vector3& p_vector) const; - _FORCE_INLINE_ void operator*=(const Matrix3& p_matrix); - _FORCE_INLINE_ Matrix3 operator*(const Matrix3& p_matrix) const; - _FORCE_INLINE_ void operator+=(const Matrix3& p_matrix); - _FORCE_INLINE_ Matrix3 operator+(const Matrix3& p_matrix) const; - _FORCE_INLINE_ void operator-=(const Matrix3& p_matrix); - _FORCE_INLINE_ Matrix3 operator-(const Matrix3& p_matrix) const; + _FORCE_INLINE_ void operator*=(const Basis& p_matrix); + _FORCE_INLINE_ Basis operator*(const Basis& p_matrix) const; + _FORCE_INLINE_ void operator+=(const Basis& p_matrix); + _FORCE_INLINE_ Basis operator+(const Basis& p_matrix) const; + _FORCE_INLINE_ void operator-=(const Basis& p_matrix); + _FORCE_INLINE_ Basis operator-(const Basis& p_matrix) const; _FORCE_INLINE_ void operator*=(real_t p_val); - _FORCE_INLINE_ Matrix3 operator*(real_t p_val) const; + _FORCE_INLINE_ Basis operator*(real_t p_val) const; int get_orthogonal_index() const; void set_orthogonal_index(int p_index); @@ -163,9 +163,9 @@ public: elements[2].zero(); } - _FORCE_INLINE_ Matrix3 transpose_xform(const Matrix3& m) const + _FORCE_INLINE_ Basis transpose_xform(const Basis& m) const { - return Matrix3( + return Basis( elements[0].x * m[0].x + elements[1].x * m[1].x + elements[2].x * m[2].x, elements[0].x * m[0].y + elements[1].x * m[1].y + elements[2].x * m[2].y, elements[0].x * m[0].z + elements[1].x * m[1].z + elements[2].x * m[2].z, @@ -176,31 +176,31 @@ public: elements[0].z * m[0].y + elements[1].z * m[1].y + elements[2].z * m[2].y, elements[0].z * m[0].z + elements[1].z * m[1].z + elements[2].z * m[2].z); } - Matrix3(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz) { + Basis(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz) { set(xx, xy, xz, yx, yy, yz, zx, zy, zz); } void orthonormalize(); - Matrix3 orthonormalized() const; + Basis orthonormalized() const; bool is_symmetric() const; - Matrix3 diagonalize(); + Basis diagonalize(); operator Quat() const; - Matrix3(const Quat& p_quat); // euler - Matrix3(const Vector3& p_euler); // euler - Matrix3(const Vector3& p_axis, real_t p_phi); + Basis(const Quat& p_quat); // euler + Basis(const Vector3& p_euler); // euler + Basis(const Vector3& p_axis, real_t p_phi); - _FORCE_INLINE_ Matrix3(const Vector3& row0, const Vector3& row1, const Vector3& row2) + _FORCE_INLINE_ Basis(const Vector3& row0, const Vector3& row1, const Vector3& row2) { elements[0]=row0; elements[1]=row1; elements[2]=row2; } - _FORCE_INLINE_ Matrix3() { + _FORCE_INLINE_ Basis() { elements[0][0]=1; elements[0][1]=0; @@ -216,7 +216,7 @@ public: }; -_FORCE_INLINE_ void Matrix3::operator*=(const Matrix3& p_matrix) { +_FORCE_INLINE_ void Basis::operator*=(const Basis& p_matrix) { set( p_matrix.tdotx(elements[0]), p_matrix.tdoty(elements[0]), p_matrix.tdotz(elements[0]), @@ -225,9 +225,9 @@ _FORCE_INLINE_ void Matrix3::operator*=(const Matrix3& p_matrix) { } -_FORCE_INLINE_ Matrix3 Matrix3::operator*(const Matrix3& p_matrix) const { +_FORCE_INLINE_ Basis Basis::operator*(const Basis& p_matrix) const { - return Matrix3( + return Basis( p_matrix.tdotx(elements[0]), p_matrix.tdoty(elements[0]), p_matrix.tdotz(elements[0]), p_matrix.tdotx(elements[1]), p_matrix.tdoty(elements[1]), p_matrix.tdotz(elements[1]), p_matrix.tdotx(elements[2]), p_matrix.tdoty(elements[2]), p_matrix.tdotz(elements[2]) ); @@ -235,49 +235,49 @@ _FORCE_INLINE_ Matrix3 Matrix3::operator*(const Matrix3& p_matrix) const { } -_FORCE_INLINE_ void Matrix3::operator+=(const Matrix3& p_matrix) { +_FORCE_INLINE_ void Basis::operator+=(const Basis& p_matrix) { elements[0] += p_matrix.elements[0]; elements[1] += p_matrix.elements[1]; elements[2] += p_matrix.elements[2]; } -_FORCE_INLINE_ Matrix3 Matrix3::operator+(const Matrix3& p_matrix) const { +_FORCE_INLINE_ Basis Basis::operator+(const Basis& p_matrix) const { - Matrix3 ret(*this); + Basis ret(*this); ret += p_matrix; return ret; } -_FORCE_INLINE_ void Matrix3::operator-=(const Matrix3& p_matrix) { +_FORCE_INLINE_ void Basis::operator-=(const Basis& p_matrix) { elements[0] -= p_matrix.elements[0]; elements[1] -= p_matrix.elements[1]; elements[2] -= p_matrix.elements[2]; } -_FORCE_INLINE_ Matrix3 Matrix3::operator-(const Matrix3& p_matrix) const { +_FORCE_INLINE_ Basis Basis::operator-(const Basis& p_matrix) const { - Matrix3 ret(*this); + Basis ret(*this); ret -= p_matrix; return ret; } -_FORCE_INLINE_ void Matrix3::operator*=(real_t p_val) { +_FORCE_INLINE_ void Basis::operator*=(real_t p_val) { elements[0]*=p_val; elements[1]*=p_val; elements[2]*=p_val; } -_FORCE_INLINE_ Matrix3 Matrix3::operator*(real_t p_val) const { +_FORCE_INLINE_ Basis Basis::operator*(real_t p_val) const { - Matrix3 ret(*this); + Basis ret(*this); ret *= p_val; return ret; } -Vector3 Matrix3::xform(const Vector3& p_vector) const { +Vector3 Basis::xform(const Vector3& p_vector) const { return Vector3( elements[0].dot(p_vector), @@ -286,7 +286,7 @@ Vector3 Matrix3::xform(const Vector3& p_vector) const { ); } -Vector3 Matrix3::xform_inv(const Vector3& p_vector) const { +Vector3 Basis::xform_inv(const Vector3& p_vector) const { return Vector3( (elements[0][0]*p_vector.x ) + ( elements[1][0]*p_vector.y ) + ( elements[2][0]*p_vector.z ), @@ -295,7 +295,7 @@ Vector3 Matrix3::xform_inv(const Vector3& p_vector) const { ); } -real_t Matrix3::determinant() const { +real_t Basis::determinant() const { return elements[0][0]*(elements[1][1]*elements[2][2] - elements[2][1]*elements[1][2]) - elements[1][0]*(elements[0][1]*elements[2][2] - elements[2][1]*elements[0][2]) + diff --git a/core/math/octree.h b/core/math/octree.h index 189041cdc5..1a41413a76 100644 --- a/core/math/octree.h +++ b/core/math/octree.h @@ -107,7 +107,7 @@ private: struct Octant { // cached for FAST plane check - AABB aabb; + Rect3 aabb; uint64_t last_pass; Octant *parent; @@ -152,8 +152,8 @@ private: OctreeElementID _id; Octant *common_parent; - AABB aabb; - AABB container_aabb; + Rect3 aabb; + Rect3 container_aabb; List<PairData*,AL> pair_list; @@ -338,7 +338,7 @@ private: void _insert_element(Element *p_element,Octant *p_octant); - void _ensure_valid_root(const AABB& p_aabb); + void _ensure_valid_root(const Rect3& p_aabb); bool _remove_element_from_octant(Element *p_element,Octant *p_octant,Octant *p_limit=NULL); void _remove_element(Element *p_element); void _pair_element(Element *p_element,Octant *p_octant); @@ -356,7 +356,7 @@ private: }; void _cull_convex(Octant *p_octant,_CullConvexData *p_cull); - void _cull_AABB(Octant *p_octant,const AABB& p_aabb, T** p_result_array,int *p_result_idx,int p_result_max,int *p_subindex_array,uint32_t p_mask); + void _cull_AABB(Octant *p_octant,const Rect3& p_aabb, T** p_result_array,int *p_result_idx,int p_result_max,int *p_subindex_array,uint32_t p_mask); void _cull_segment(Octant *p_octant,const Vector3& p_from, const Vector3& p_to,T** p_result_array,int *p_result_idx,int p_result_max,int *p_subindex_array,uint32_t p_mask); void _cull_point(Octant *p_octant,const Vector3& p_point,T** p_result_array,int *p_result_idx,int p_result_max,int *p_subindex_array,uint32_t p_mask); @@ -375,8 +375,8 @@ private: } public: - OctreeElementID create(T* p_userdata, const AABB& p_aabb=AABB(), int p_subindex=0, bool p_pairable=false,uint32_t p_pairable_type=0,uint32_t pairable_mask=1); - void move(OctreeElementID p_id, const AABB& p_aabb); + OctreeElementID create(T* p_userdata, const Rect3& p_aabb=Rect3(), int p_subindex=0, bool p_pairable=false,uint32_t p_pairable_type=0,uint32_t pairable_mask=1); + void move(OctreeElementID p_id, const Rect3& p_aabb); void set_pairable(OctreeElementID p_id,bool p_pairable=false,uint32_t p_pairable_type=0,uint32_t pairable_mask=1); void erase(OctreeElementID p_id); @@ -385,7 +385,7 @@ public: int get_subindex(OctreeElementID p_id) const; int cull_convex(const Vector<Plane>& p_convex,T** p_result_array,int p_result_max,uint32_t p_mask=0xFFFFFFFF); - int cull_AABB(const AABB& p_aabb,T** p_result_array,int p_result_max,int *p_subindex_array=NULL,uint32_t p_mask=0xFFFFFFFF); + int cull_AABB(const Rect3& p_aabb,T** p_result_array,int p_result_max,int *p_subindex_array=NULL,uint32_t p_mask=0xFFFFFFFF); int cull_segment(const Vector3& p_from, const Vector3& p_to,T** p_result_array,int p_result_max,int *p_subindex_array=NULL,uint32_t p_mask=0xFFFFFFFF); int cull_point(const Vector3& p_point,T** p_result_array,int p_result_max,int *p_subindex_array=NULL,uint32_t p_mask=0xFFFFFFFF); @@ -487,7 +487,7 @@ void Octree<T,use_pairs,AL>::_insert_element(Element *p_element,Octant *p_octant } else { /* check againt AABB where child should be */ - AABB aabb=p_octant->aabb; + Rect3 aabb=p_octant->aabb; aabb.size*=0.5; if (i&1) @@ -549,12 +549,12 @@ void Octree<T,use_pairs,AL>::_insert_element(Element *p_element,Octant *p_octant template<class T,bool use_pairs,class AL> -void Octree<T,use_pairs,AL>::_ensure_valid_root(const AABB& p_aabb) { +void Octree<T,use_pairs,AL>::_ensure_valid_root(const Rect3& p_aabb) { if (!root) { // octre is empty - AABB base( Vector3(), Vector3(1.0,1.0,1.0) * unit_size); + Rect3 base( Vector3(), Vector3(1.0,1.0,1.0) * unit_size); while ( !base.encloses(p_aabb) ) { @@ -578,7 +578,7 @@ void Octree<T,use_pairs,AL>::_ensure_valid_root(const AABB& p_aabb) { } else { - AABB base=root->aabb; + Rect3 base=root->aabb; while( !base.encloses( p_aabb ) ) { @@ -814,7 +814,7 @@ void Octree<T,use_pairs,AL>::_remove_element(Element *p_element) { } template<class T,bool use_pairs,class AL> -OctreeElementID Octree<T,use_pairs,AL>::create(T* p_userdata, const AABB& p_aabb, int p_subindex,bool p_pairable,uint32_t p_pairable_type,uint32_t p_pairable_mask) { +OctreeElementID Octree<T,use_pairs,AL>::create(T* p_userdata, const Rect3& p_aabb, int p_subindex,bool p_pairable,uint32_t p_pairable_type,uint32_t p_pairable_mask) { // check for AABB validity #ifdef DEBUG_ENABLED @@ -857,7 +857,7 @@ OctreeElementID Octree<T,use_pairs,AL>::create(T* p_userdata, const AABB& p_aabb template<class T,bool use_pairs,class AL> -void Octree<T,use_pairs,AL>::move(OctreeElementID p_id, const AABB& p_aabb) { +void Octree<T,use_pairs,AL>::move(OctreeElementID p_id, const Rect3& p_aabb) { #ifdef DEBUG_ENABLED // check for AABB validity @@ -906,7 +906,7 @@ void Octree<T,use_pairs,AL>::move(OctreeElementID p_id, const AABB& p_aabb) { if (old_has_surf) { _remove_element(&e); // removing e.common_parent=NULL; - e.aabb=AABB(); + e.aabb=Rect3(); _optimize(); } else { _ensure_valid_root(p_aabb); // inserting @@ -935,7 +935,7 @@ void Octree<T,use_pairs,AL>::move(OctreeElementID p_id, const AABB& p_aabb) { return; } - AABB combined=e.aabb; + Rect3 combined=e.aabb; combined.merge_with(p_aabb); _ensure_valid_root(combined); @@ -1129,7 +1129,7 @@ void Octree<T,use_pairs,AL>::_cull_convex(Octant *p_octant,_CullConvexData *p_cu template<class T,bool use_pairs,class AL> -void Octree<T,use_pairs,AL>::_cull_AABB(Octant *p_octant,const AABB& p_aabb, T** p_result_array,int *p_result_idx,int p_result_max,int *p_subindex_array,uint32_t p_mask) { +void Octree<T,use_pairs,AL>::_cull_AABB(Octant *p_octant,const Rect3& p_aabb, T** p_result_array,int *p_result_idx,int p_result_max,int *p_subindex_array,uint32_t p_mask) { if (*p_result_idx==p_result_max) return; //pointless @@ -1376,7 +1376,7 @@ int Octree<T,use_pairs,AL>::cull_convex(const Vector<Plane>& p_convex,T** p_resu template<class T,bool use_pairs,class AL> -int Octree<T,use_pairs,AL>::cull_AABB(const AABB& p_aabb,T** p_result_array,int p_result_max,int *p_subindex_array,uint32_t p_mask) { +int Octree<T,use_pairs,AL>::cull_AABB(const Rect3& p_aabb,T** p_result_array,int p_result_max,int *p_subindex_array,uint32_t p_mask) { if (!root) diff --git a/core/math/quat.cpp b/core/math/quat.cpp index afe71100e1..055e2b7c35 100644 --- a/core/math/quat.cpp +++ b/core/math/quat.cpp @@ -59,7 +59,7 @@ void Quat::set_euler(const Vector3& p_euler) { // (a1,a2,a3), where a3 is the angle of the first rotation, and a1 is the last. // The current implementation uses XYZ convention (Z is the first rotation). Vector3 Quat::get_euler() const { - Matrix3 m(*this); + Basis m(*this); return m.get_euler(); } diff --git a/core/math/quick_hull.cpp b/core/math/quick_hull.cpp index ce6f726418..ab81a068d4 100644 --- a/core/math/quick_hull.cpp +++ b/core/math/quick_hull.cpp @@ -38,7 +38,7 @@ Error QuickHull::build(const Vector<Vector3>& p_points, Geometry::MeshData &r_me /* CREATE AABB VOLUME */ - AABB aabb; + Rect3 aabb; for(int i=0;i<p_points.size();i++) { if (i==0) { diff --git a/core/math/transform.cpp b/core/math/transform.cpp index 0dba121013..6d9324c176 100644 --- a/core/math/transform.cpp +++ b/core/math/transform.cpp @@ -69,7 +69,7 @@ void Transform::rotate(const Vector3& p_axis,real_t p_phi) { Transform Transform::rotated(const Vector3& p_axis,real_t p_phi) const{ - return Transform(Matrix3( p_axis, p_phi ), Vector3()) * (*this); + return Transform(Basis( p_axis, p_phi ), Vector3()) * (*this); } void Transform::rotate_basis(const Vector3& p_axis,real_t p_phi) { @@ -210,7 +210,7 @@ Transform::operator String() const { } -Transform::Transform(const Matrix3& p_basis, const Vector3& p_origin) { +Transform::Transform(const Basis& p_basis, const Vector3& p_origin) { basis=p_basis; origin=p_origin; diff --git a/core/math/transform.h b/core/math/transform.h index 5f069ab586..d65e87cc6a 100644 --- a/core/math/transform.h +++ b/core/math/transform.h @@ -38,7 +38,7 @@ class Transform { public: - Matrix3 basis; + Basis basis; Vector3 origin; void invert(); @@ -62,8 +62,8 @@ public: void translate( const Vector3& p_translation ); Transform translated( const Vector3& p_translation ) const; - const Matrix3& get_basis() const { return basis; } - void set_basis(const Matrix3& p_basis) { basis=p_basis; } + const Basis& get_basis() const { return basis; } + void set_basis(const Basis& p_basis) { basis=p_basis; } const Vector3& get_origin() const { return origin; } void set_origin(const Vector3& p_origin) { origin=p_origin; } @@ -80,8 +80,8 @@ public: _FORCE_INLINE_ Plane xform(const Plane& p_plane) const; _FORCE_INLINE_ Plane xform_inv(const Plane& p_plane) const; - _FORCE_INLINE_ AABB xform(const AABB& p_aabb) const; - _FORCE_INLINE_ AABB xform_inv(const AABB& p_aabb) const; + _FORCE_INLINE_ Rect3 xform(const Rect3& p_aabb) const; + _FORCE_INLINE_ Rect3 xform_inv(const Rect3& p_aabb) const; void operator*=(const Transform& p_transform); Transform operator*(const Transform& p_transform) const; @@ -113,7 +113,7 @@ public: operator String() const; - Transform(const Matrix3& p_basis, const Vector3& p_origin=Vector3()); + Transform(const Basis& p_basis, const Vector3& p_origin=Vector3()); Transform() {} }; @@ -168,7 +168,7 @@ _FORCE_INLINE_ Plane Transform::xform_inv(const Plane& p_plane) const { } -_FORCE_INLINE_ AABB Transform::xform(const AABB& p_aabb) const { +_FORCE_INLINE_ Rect3 Transform::xform(const Rect3& p_aabb) const { /* define vertices */ #if 1 Vector3 x=basis.get_axis(0)*p_aabb.size.x; @@ -176,7 +176,7 @@ _FORCE_INLINE_ AABB Transform::xform(const AABB& p_aabb) const { Vector3 z=basis.get_axis(2)*p_aabb.size.z; Vector3 pos = xform( p_aabb.pos ); //could be even further optimized - AABB new_aabb; + Rect3 new_aabb; new_aabb.pos=pos; new_aabb.expand_to( pos+x ); new_aabb.expand_to( pos+y ); @@ -214,7 +214,7 @@ _FORCE_INLINE_ AABB Transform::xform(const AABB& p_aabb) const { #endif } -_FORCE_INLINE_ AABB Transform::xform_inv(const AABB& p_aabb) const { +_FORCE_INLINE_ Rect3 Transform::xform_inv(const Rect3& p_aabb) const { /* define vertices */ Vector3 vertices[8]={ @@ -229,7 +229,7 @@ _FORCE_INLINE_ AABB Transform::xform_inv(const AABB& p_aabb) const { }; - AABB ret; + Rect3 ret; ret.pos=xform_inv(vertices[0]); diff --git a/core/math/triangle_mesh.cpp b/core/math/triangle_mesh.cpp index 101e164eae..fc5f55066b 100644 --- a/core/math/triangle_mesh.cpp +++ b/core/math/triangle_mesh.cpp @@ -48,7 +48,7 @@ int TriangleMesh::_create_bvh(BVH*p_bvh,BVH** p_bb,int p_from,int p_size,int p_d } - AABB aabb; + Rect3 aabb; aabb=p_bb[p_from]->aabb; for(int i=1;i<p_size;i++) { @@ -176,7 +176,7 @@ void TriangleMesh::create(const PoolVector<Vector3>& p_faces) { } -Vector3 TriangleMesh::get_area_normal(const AABB& p_aabb) const { +Vector3 TriangleMesh::get_area_normal(const Rect3& p_aabb) const { uint32_t* stack = (uint32_t*)alloca(sizeof(int)*max_depth); diff --git a/core/math/triangle_mesh.h b/core/math/triangle_mesh.h index 37d32bd7ec..65250c023d 100644 --- a/core/math/triangle_mesh.h +++ b/core/math/triangle_mesh.h @@ -46,7 +46,7 @@ class TriangleMesh : public Reference { struct BVH { - AABB aabb; + Rect3 aabb; Vector3 center; //used for sorting int left; int right; @@ -88,7 +88,7 @@ public: bool is_valid() const; bool intersect_segment(const Vector3& p_begin,const Vector3& p_end,Vector3 &r_point, Vector3 &r_normal) const; bool intersect_ray(const Vector3& p_begin,const Vector3& p_dir,Vector3 &r_point, Vector3 &r_normal) const; - Vector3 get_area_normal(const AABB& p_aabb) const; + Vector3 get_area_normal(const Rect3& p_aabb) const; PoolVector<Face3> get_faces() const; diff --git a/core/math/vector3.cpp b/core/math/vector3.cpp index 7c6cc5182d..3eb978333d 100644 --- a/core/math/vector3.cpp +++ b/core/math/vector3.cpp @@ -32,7 +32,7 @@ void Vector3::rotate(const Vector3& p_axis,float p_phi) { - *this=Matrix3(p_axis,p_phi).xform(*this); + *this=Basis(p_axis,p_phi).xform(*this); } Vector3 Vector3::rotated(const Vector3& p_axis,float p_phi) const { diff --git a/core/math/vector3.h b/core/math/vector3.h index f1f34ce318..9ae9b69dfa 100644 --- a/core/math/vector3.h +++ b/core/math/vector3.h @@ -34,7 +34,7 @@ #include "math_funcs.h" #include "ustring.h" -class Matrix3; +class Basis; struct Vector3 { @@ -93,8 +93,8 @@ struct Vector3 { _FORCE_INLINE_ Vector3 cross(const Vector3& p_b) const; _FORCE_INLINE_ real_t dot(const Vector3& p_b) const; - _FORCE_INLINE_ Matrix3 outer(const Vector3& p_b) const; - _FORCE_INLINE_ Matrix3 to_diagonal_matrix() const; + _FORCE_INLINE_ Basis outer(const Vector3& p_b) const; + _FORCE_INLINE_ Basis to_diagonal_matrix() const; _FORCE_INLINE_ Vector3 abs() const; _FORCE_INLINE_ Vector3 floor() const; @@ -165,17 +165,17 @@ real_t Vector3::dot(const Vector3& p_b) const { return x*p_b.x + y*p_b.y + z*p_b.z; } -Matrix3 Vector3::outer(const Vector3& p_b) const { +Basis Vector3::outer(const Vector3& p_b) const { Vector3 row0(x*p_b.x, x*p_b.y, x*p_b.z); Vector3 row1(y*p_b.x, y*p_b.y, y*p_b.z); Vector3 row2(z*p_b.x, z*p_b.y, z*p_b.z); - return Matrix3(row0, row1, row2); + return Basis(row0, row1, row2); } -Matrix3 Vector3::to_diagonal_matrix() const { - return Matrix3(x, 0, 0, +Basis Vector3::to_diagonal_matrix() const { + return Basis(x, 0, 0, 0, y, 0, 0, 0, z); } diff --git a/core/method_ptrcall.h b/core/method_ptrcall.h index 2e3959c3ab..36b42c84f3 100644 --- a/core/method_ptrcall.h +++ b/core/method_ptrcall.h @@ -71,11 +71,11 @@ MAKE_PTRARG(String); MAKE_PTRARG(Vector2); MAKE_PTRARG(Rect2); MAKE_PTRARG(Vector3); -MAKE_PTRARG(Matrix32); +MAKE_PTRARG(Transform2D); MAKE_PTRARG(Plane); MAKE_PTRARG(Quat); MAKE_PTRARG(AABB); -MAKE_PTRARG(Matrix3); +MAKE_PTRARG(Basis); MAKE_PTRARG(Transform); MAKE_PTRARG(Color); MAKE_PTRARG(Image); diff --git a/core/os/input_event.cpp b/core/os/input_event.cpp index 5c681f1a82..3cc595208f 100644 --- a/core/os/input_event.cpp +++ b/core/os/input_event.cpp @@ -249,7 +249,7 @@ uint32_t InputEventKey::get_scancode_with_modifiers() const { } -InputEvent InputEvent::xform_by(const Matrix32& p_xform) const { +InputEvent InputEvent::xform_by(const Transform2D& p_xform) const { InputEvent ev=*this; diff --git a/core/os/input_event.h b/core/os/input_event.h index a557de2bd7..3947d86285 100644 --- a/core/os/input_event.h +++ b/core/os/input_event.h @@ -298,7 +298,7 @@ struct InputEvent { void set_as_action(const String& p_action, bool p_pressed); - InputEvent xform_by(const Matrix32& p_xform) const; + InputEvent xform_by(const Transform2D& p_xform) const; bool operator==(const InputEvent &p_event) const; operator String() const; InputEvent() { zeromem(this,sizeof(InputEvent)); } diff --git a/core/os/main_loop.cpp b/core/os/main_loop.cpp index 600a61e93d..11396666d2 100644 --- a/core/os/main_loop.cpp +++ b/core/os/main_loop.cpp @@ -43,7 +43,7 @@ void MainLoop::_bind_methods() { BIND_VMETHOD( MethodInfo("_initialize") ); BIND_VMETHOD( MethodInfo("_iteration",PropertyInfo(Variant::REAL,"delta")) ); BIND_VMETHOD( MethodInfo("_idle",PropertyInfo(Variant::REAL,"delta")) ); - BIND_VMETHOD( MethodInfo("_drop_files",PropertyInfo(Variant::STRING_ARRAY,"files"),PropertyInfo(Variant::INT,"screen")) ); + BIND_VMETHOD( MethodInfo("_drop_files",PropertyInfo(Variant::POOL_STRING_ARRAY,"files"),PropertyInfo(Variant::INT,"screen")) ); BIND_VMETHOD( MethodInfo("_finalize") ); BIND_CONSTANT(NOTIFICATION_WM_MOUSE_ENTER); diff --git a/core/packed_data_container.cpp b/core/packed_data_container.cpp index 77afbfc214..5f3b877822 100644 --- a/core/packed_data_container.cpp +++ b/core/packed_data_container.cpp @@ -239,21 +239,21 @@ uint32_t PackedDataContainer::_pack(const Variant& p_data, Vector<uint8_t>& tmpd case Variant::VECTOR2: case Variant::RECT2: case Variant::VECTOR3: - case Variant::MATRIX32: + case Variant::TRANSFORM2D: case Variant::PLANE: case Variant::QUAT: - case Variant::_AABB: - case Variant::MATRIX3: + case Variant::RECT3: + case Variant::BASIS: case Variant::TRANSFORM: case Variant::IMAGE: case Variant::INPUT_EVENT: - case Variant::RAW_ARRAY: - case Variant::INT_ARRAY: - case Variant::REAL_ARRAY: - case Variant::STRING_ARRAY: - case Variant::VECTOR2_ARRAY: - case Variant::VECTOR3_ARRAY: - case Variant::COLOR_ARRAY: + case Variant::POOL_BYTE_ARRAY: + case Variant::POOL_INT_ARRAY: + case Variant::POOL_REAL_ARRAY: + case Variant::POOL_STRING_ARRAY: + case Variant::POOL_VECTOR2_ARRAY: + case Variant::POOL_VECTOR3_ARRAY: + case Variant::POOL_COLOR_ARRAY: case Variant::NODE_PATH: { uint32_t pos = tmpdata.size(); @@ -390,7 +390,7 @@ void PackedDataContainer::_bind_methods() { ClassDB::bind_method(_MD("pack:Error","value"),&PackedDataContainer::pack); ClassDB::bind_method(_MD("size"),&PackedDataContainer::size); - ADD_PROPERTY( PropertyInfo(Variant::RAW_ARRAY,"__data__"),_SCS("_set_data"),_SCS("_get_data")); + ADD_PROPERTY( PropertyInfo(Variant::POOL_BYTE_ARRAY,"__data__"),_SCS("_set_data"),_SCS("_get_data")); } diff --git a/core/path_remap.cpp b/core/path_remap.cpp index 980e8f76e7..fd5b38fa79 100644 --- a/core/path_remap.cpp +++ b/core/path_remap.cpp @@ -168,9 +168,9 @@ void PathRemap::load_remaps() { for(List<Variant>::Element *E=rk.front();E;E=E->next()) { String source = E->get(); - StringArray sa = remaps[E->get()]; + PoolStringArray sa = remaps[E->get()]; int sas = sa.size(); - StringArray::Read r = sa.read(); + PoolStringArray::Read r = sa.read(); for(int i=0;i<sas;i++) { diff --git a/core/resource.cpp b/core/resource.cpp index 9545d8c3da..db4d2ec0db 100644 --- a/core/resource.cpp +++ b/core/resource.cpp @@ -113,9 +113,9 @@ void ResourceImportMetadata::get_options(List<String> *r_options) const { } -StringArray ResourceImportMetadata::_get_options() const { +PoolStringArray ResourceImportMetadata::_get_options() const { - StringArray option_names; + PoolStringArray option_names; option_names.resize(options.size()); int i=0; for(Map<String,Variant>::Element *E=options.front();E;E=E->next()) { diff --git a/core/resource.h b/core/resource.h index 8b73bcdc57..284c59e1a8 100644 --- a/core/resource.h +++ b/core/resource.h @@ -60,7 +60,7 @@ class ResourceImportMetadata : public Reference { Map<String,Variant> options; - StringArray _get_options() const; + PoolStringArray _get_options() const; protected: diff --git a/core/script_language.h b/core/script_language.h index 8c38af47cb..fd96541b18 100644 --- a/core/script_language.h +++ b/core/script_language.h @@ -207,7 +207,7 @@ public: virtual Script *create_script() const=0; virtual bool has_named_classes() const=0; virtual int find_function(const String& p_function,const String& p_code) const=0; - virtual String make_function(const String& p_class,const String& p_name,const StringArray& p_args) const=0; + virtual String make_function(const String& p_class,const String& p_name,const PoolStringArray& p_args) const=0; virtual Error complete_code(const String& p_code, const String& p_base_path, Object*p_owner,List<String>* r_options,String& r_call_hint) { return ERR_UNAVAILABLE; } diff --git a/core/translation.cpp b/core/translation.cpp index dd0f59f343..5215e5f6d1 100644 --- a/core/translation.cpp +++ b/core/translation.cpp @@ -909,7 +909,7 @@ void Translation::_bind_methods() { ClassDB::bind_method(_MD("_set_messages"),&Translation::_set_messages); ClassDB::bind_method(_MD("_get_messages"),&Translation::_get_messages); - ADD_PROPERTY( PropertyInfo(Variant::STRING_ARRAY,"messages",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR), _SCS("_set_messages"), _SCS("_get_messages") ); + ADD_PROPERTY( PropertyInfo(Variant::POOL_STRING_ARRAY,"messages",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR), _SCS("_set_messages"), _SCS("_get_messages") ); ADD_PROPERTY( PropertyInfo(Variant::STRING,"locale"), _SCS("set_locale"), _SCS("get_locale") ); } diff --git a/core/variant.cpp b/core/variant.cpp index 69160fffa7..4ab46edf75 100644 --- a/core/variant.cpp +++ b/core/variant.cpp @@ -74,9 +74,9 @@ String Variant::get_type_name(Variant::Type p_type) { return "Rect2"; } break; - case MATRIX32: { + case TRANSFORM2D: { - return "Matrix32"; + return "Transform2D"; } break; case VECTOR3: { @@ -92,18 +92,18 @@ String Variant::get_type_name(Variant::Type p_type) { } break;*/ - case _AABB: { + case RECT3: { - return "AABB"; + return "Rect3"; } break; case QUAT: { return "Quat"; } break; - case MATRIX3: { + case BASIS: { - return "Matrix3"; + return "Basis"; } break; case TRANSFORM: { @@ -153,38 +153,38 @@ String Variant::get_type_name(Variant::Type p_type) { } break; // arrays - case RAW_ARRAY: { + case POOL_BYTE_ARRAY: { - return "RawArray"; + return "PoolByteArray"; } break; - case INT_ARRAY: { + case POOL_INT_ARRAY: { - return "IntArray"; + return "PoolIntArray"; } break; - case REAL_ARRAY: { + case POOL_REAL_ARRAY: { - return "RealArray"; + return "PoolFloatArray"; } break; - case STRING_ARRAY: { + case POOL_STRING_ARRAY: { - return "StringArray"; + return "PoolStringArray"; } break; - case VECTOR2_ARRAY: { + case POOL_VECTOR2_ARRAY: { - return "Vector2Array"; + return "PoolVector2Array"; } break; - case VECTOR3_ARRAY: { + case POOL_VECTOR3_ARRAY: { - return "Vector3Array"; + return "PoolVector3Array"; } break; - case COLOR_ARRAY: { + case POOL_COLOR_ARRAY: { - return "ColorArray"; + return "PoolColorArray"; } break; default: {} @@ -255,7 +255,7 @@ bool Variant::can_convert(Variant::Type p_type_from,Variant::Type p_type_to) { invalid_types=invalid; } break; - case MATRIX32: { + case TRANSFORM2D: { static const Type valid[]={ @@ -268,14 +268,14 @@ bool Variant::can_convert(Variant::Type p_type_from,Variant::Type p_type_to) { case QUAT: { static const Type valid[]={ - MATRIX3, + BASIS, NIL }; valid_types=valid; } break; - case MATRIX3: { + case BASIS: { static const Type valid[]={ QUAT, @@ -289,9 +289,9 @@ bool Variant::can_convert(Variant::Type p_type_from,Variant::Type p_type_to) { case TRANSFORM: { static const Type valid[]={ - MATRIX32, + TRANSFORM2D, QUAT, - MATRIX3, + BASIS, NIL }; @@ -341,20 +341,20 @@ bool Variant::can_convert(Variant::Type p_type_from,Variant::Type p_type_to) { static const Type valid[]={ - RAW_ARRAY, - INT_ARRAY, - STRING_ARRAY, - REAL_ARRAY, - COLOR_ARRAY, - VECTOR2_ARRAY, - VECTOR3_ARRAY, + POOL_BYTE_ARRAY, + POOL_INT_ARRAY, + POOL_STRING_ARRAY, + POOL_REAL_ARRAY, + POOL_COLOR_ARRAY, + POOL_VECTOR2_ARRAY, + POOL_VECTOR3_ARRAY, NIL }; valid_types=valid; } break; // arrays - case RAW_ARRAY: { + case POOL_BYTE_ARRAY: { static const Type valid[]={ ARRAY, @@ -363,7 +363,7 @@ bool Variant::can_convert(Variant::Type p_type_from,Variant::Type p_type_to) { valid_types=valid; } break; - case INT_ARRAY: { + case POOL_INT_ARRAY: { static const Type valid[]={ ARRAY, @@ -371,7 +371,7 @@ bool Variant::can_convert(Variant::Type p_type_from,Variant::Type p_type_to) { }; valid_types=valid; } break; - case REAL_ARRAY: { + case POOL_REAL_ARRAY: { static const Type valid[]={ ARRAY, @@ -380,7 +380,7 @@ bool Variant::can_convert(Variant::Type p_type_from,Variant::Type p_type_to) { valid_types=valid; } break; - case STRING_ARRAY: { + case POOL_STRING_ARRAY: { static const Type valid[]={ ARRAY, @@ -388,7 +388,7 @@ bool Variant::can_convert(Variant::Type p_type_from,Variant::Type p_type_to) { }; valid_types=valid; } break; - case VECTOR2_ARRAY: { + case POOL_VECTOR2_ARRAY: { static const Type valid[]={ ARRAY, @@ -397,7 +397,7 @@ bool Variant::can_convert(Variant::Type p_type_from,Variant::Type p_type_to) { valid_types=valid; } break; - case VECTOR3_ARRAY: { + case POOL_VECTOR3_ARRAY: { static const Type valid[]={ ARRAY, @@ -406,7 +406,7 @@ bool Variant::can_convert(Variant::Type p_type_from,Variant::Type p_type_to) { valid_types=valid; } break; - case COLOR_ARRAY: { + case POOL_COLOR_ARRAY: { static const Type valid[]={ ARRAY, @@ -507,7 +507,7 @@ bool Variant::can_convert_strict(Variant::Type p_type_from,Variant::Type p_type_ valid_types=valid; } break; - case MATRIX32: { + case TRANSFORM2D: { static const Type valid[]={ @@ -520,14 +520,14 @@ bool Variant::can_convert_strict(Variant::Type p_type_from,Variant::Type p_type_ case QUAT: { static const Type valid[]={ - MATRIX3, + BASIS, NIL }; valid_types=valid; } break; - case MATRIX3: { + case BASIS: { static const Type valid[]={ QUAT, @@ -541,9 +541,9 @@ bool Variant::can_convert_strict(Variant::Type p_type_from,Variant::Type p_type_ case TRANSFORM: { static const Type valid[]={ - MATRIX32, + TRANSFORM2D, QUAT, - MATRIX3, + BASIS, NIL }; @@ -593,20 +593,20 @@ bool Variant::can_convert_strict(Variant::Type p_type_from,Variant::Type p_type_ static const Type valid[]={ - RAW_ARRAY, - INT_ARRAY, - STRING_ARRAY, - REAL_ARRAY, - COLOR_ARRAY, - VECTOR2_ARRAY, - VECTOR3_ARRAY, + POOL_BYTE_ARRAY, + POOL_INT_ARRAY, + POOL_STRING_ARRAY, + POOL_REAL_ARRAY, + POOL_COLOR_ARRAY, + POOL_VECTOR2_ARRAY, + POOL_VECTOR3_ARRAY, NIL }; valid_types=valid; } break; // arrays - case RAW_ARRAY: { + case POOL_BYTE_ARRAY: { static const Type valid[]={ ARRAY, @@ -615,7 +615,7 @@ bool Variant::can_convert_strict(Variant::Type p_type_from,Variant::Type p_type_ valid_types=valid; } break; - case INT_ARRAY: { + case POOL_INT_ARRAY: { static const Type valid[]={ ARRAY, @@ -623,7 +623,7 @@ bool Variant::can_convert_strict(Variant::Type p_type_from,Variant::Type p_type_ }; valid_types=valid; } break; - case REAL_ARRAY: { + case POOL_REAL_ARRAY: { static const Type valid[]={ ARRAY, @@ -632,7 +632,7 @@ bool Variant::can_convert_strict(Variant::Type p_type_from,Variant::Type p_type_ valid_types=valid; } break; - case STRING_ARRAY: { + case POOL_STRING_ARRAY: { static const Type valid[]={ ARRAY, @@ -640,7 +640,7 @@ bool Variant::can_convert_strict(Variant::Type p_type_from,Variant::Type p_type_ }; valid_types=valid; } break; - case VECTOR2_ARRAY: { + case POOL_VECTOR2_ARRAY: { static const Type valid[]={ ARRAY, @@ -649,7 +649,7 @@ bool Variant::can_convert_strict(Variant::Type p_type_from,Variant::Type p_type_ valid_types=valid; } break; - case VECTOR3_ARRAY: { + case POOL_VECTOR3_ARRAY: { static const Type valid[]={ ARRAY, @@ -658,7 +658,7 @@ bool Variant::can_convert_strict(Variant::Type p_type_from,Variant::Type p_type_ valid_types=valid; } break; - case COLOR_ARRAY: { + case POOL_COLOR_ARRAY: { static const Type valid[]={ ARRAY, @@ -759,9 +759,9 @@ bool Variant::is_zero() const { return *reinterpret_cast<const Rect2*>(_data._mem)==Rect2(); } break; - case MATRIX32: { + case TRANSFORM2D: { - return *_data._matrix32==Matrix32(); + return *_data._transform2d==Transform2D(); } break; case VECTOR3: { @@ -779,18 +779,18 @@ bool Variant::is_zero() const { } break;*/ - case _AABB: { + case RECT3: { - return *_data._aabb==AABB(); + return *_data._rect3==Rect3(); } break; case QUAT: { return *reinterpret_cast<const Quat*>(_data._mem)==Quat(); } break; - case MATRIX3: { + case BASIS: { - return *_data._matrix3==Matrix3(); + return *_data._basis==Basis(); } break; case TRANSFORM: { @@ -840,37 +840,37 @@ bool Variant::is_zero() const { } break; // arrays - case RAW_ARRAY: { + case POOL_BYTE_ARRAY: { return reinterpret_cast<const PoolVector<uint8_t>*>(_data._mem)->size()==0; } break; - case INT_ARRAY: { + case POOL_INT_ARRAY: { return reinterpret_cast<const PoolVector<int>*>(_data._mem)->size()==0; } break; - case REAL_ARRAY: { + case POOL_REAL_ARRAY: { return reinterpret_cast<const PoolVector<real_t>*>(_data._mem)->size()==0; } break; - case STRING_ARRAY: { + case POOL_STRING_ARRAY: { return reinterpret_cast<const PoolVector<String>*>(_data._mem)->size()==0; } break; - case VECTOR2_ARRAY: { + case POOL_VECTOR2_ARRAY: { return reinterpret_cast<const PoolVector<Vector2>*>(_data._mem)->size()==0; } break; - case VECTOR3_ARRAY: { + case POOL_VECTOR3_ARRAY: { return reinterpret_cast<const PoolVector<Vector3>*>(_data._mem)->size()==0; } break; - case COLOR_ARRAY: { + case POOL_COLOR_ARRAY: { return reinterpret_cast<const PoolVector<Color>*>(_data._mem)->size()==0; @@ -987,9 +987,9 @@ void Variant::reference(const Variant& p_variant) { memnew_placement( _data._mem, Rect2( *reinterpret_cast<const Rect2*>(p_variant._data._mem) ) ); } break; - case MATRIX32: { + case TRANSFORM2D: { - _data._matrix32 = memnew( Matrix32( *p_variant._data._matrix32 ) ); + _data._transform2d = memnew( Transform2D( *p_variant._data._transform2d ) ); } break; case VECTOR3: { @@ -1007,18 +1007,18 @@ void Variant::reference(const Variant& p_variant) { } break;*/ - case _AABB: { + case RECT3: { - _data._aabb = memnew( AABB( *p_variant._data._aabb ) ); + _data._rect3 = memnew( Rect3( *p_variant._data._rect3 ) ); } break; case QUAT: { memnew_placement( _data._mem, Quat( *reinterpret_cast<const Quat*>(p_variant._data._mem) ) ); } break; - case MATRIX3: { + case BASIS: { - _data._matrix3 = memnew( Matrix3( *p_variant._data._matrix3 ) ); + _data._basis = memnew( Basis( *p_variant._data._basis ) ); } break; case TRANSFORM: { @@ -1068,37 +1068,37 @@ void Variant::reference(const Variant& p_variant) { } break; // arrays - case RAW_ARRAY: { + case POOL_BYTE_ARRAY: { memnew_placement( _data._mem, PoolVector<uint8_t> ( *reinterpret_cast<const PoolVector<uint8_t>*>(p_variant._data._mem) ) ); } break; - case INT_ARRAY: { + case POOL_INT_ARRAY: { memnew_placement( _data._mem, PoolVector<int> ( *reinterpret_cast<const PoolVector<int>*>(p_variant._data._mem) ) ); } break; - case REAL_ARRAY: { + case POOL_REAL_ARRAY: { memnew_placement( _data._mem, PoolVector<real_t> ( *reinterpret_cast<const PoolVector<real_t>*>(p_variant._data._mem) ) ); } break; - case STRING_ARRAY: { + case POOL_STRING_ARRAY: { memnew_placement( _data._mem, PoolVector<String> ( *reinterpret_cast<const PoolVector<String>*>(p_variant._data._mem) ) ); } break; - case VECTOR2_ARRAY: { + case POOL_VECTOR2_ARRAY: { memnew_placement( _data._mem, PoolVector<Vector2> ( *reinterpret_cast<const PoolVector<Vector2>*>(p_variant._data._mem) ) ); } break; - case VECTOR3_ARRAY: { + case POOL_VECTOR3_ARRAY: { memnew_placement( _data._mem, PoolVector<Vector3> ( *reinterpret_cast<const PoolVector<Vector3>*>(p_variant._data._mem) ) ); } break; - case COLOR_ARRAY: { + case POOL_COLOR_ARRAY: { memnew_placement( _data._mem, PoolVector<Color> ( *reinterpret_cast<const PoolVector<Color>*>(p_variant._data._mem) ) ); @@ -1139,19 +1139,19 @@ void Variant::clear() { VECTOR2, RECT2 */ - case MATRIX32: { + case TRANSFORM2D: { - memdelete( _data._matrix32 ); + memdelete( _data._transform2d ); } break; - case _AABB: { + case RECT3: { - memdelete( _data._aabb ); + memdelete( _data._rect3 ); } break; - case MATRIX3: { + case BASIS: { - memdelete( _data._matrix3 ); + memdelete( _data._basis ); } break; case TRANSFORM: { @@ -1196,37 +1196,37 @@ void Variant::clear() { } break; // arrays - case RAW_ARRAY: { + case POOL_BYTE_ARRAY: { reinterpret_cast< PoolVector<uint8_t>* >(_data._mem)->~PoolVector<uint8_t>(); } break; - case INT_ARRAY: { + case POOL_INT_ARRAY: { reinterpret_cast< PoolVector<int>* >(_data._mem)->~PoolVector<int>(); } break; - case REAL_ARRAY: { + case POOL_REAL_ARRAY: { reinterpret_cast< PoolVector<real_t>* >(_data._mem)->~PoolVector<real_t>(); } break; - case STRING_ARRAY: { + case POOL_STRING_ARRAY: { reinterpret_cast< PoolVector<String>* >(_data._mem)->~PoolVector<String>(); } break; - case VECTOR2_ARRAY: { + case POOL_VECTOR2_ARRAY: { reinterpret_cast< PoolVector<Vector2>* >(_data._mem)->~PoolVector<Vector2>(); } break; - case VECTOR3_ARRAY: { + case POOL_VECTOR3_ARRAY: { reinterpret_cast< PoolVector<Vector3>* >(_data._mem)->~PoolVector<Vector3>(); } break; - case COLOR_ARRAY: { + case POOL_COLOR_ARRAY: { reinterpret_cast< PoolVector<Color>* >(_data._mem)->~PoolVector<Color>(); @@ -1509,19 +1509,19 @@ Variant::operator String() const { case STRING: return *reinterpret_cast<const String*>(_data._mem); case VECTOR2: return "("+operator Vector2()+")"; case RECT2: return "("+operator Rect2()+")"; - case MATRIX32: { + case TRANSFORM2D: { - Matrix32 mat32 = operator Matrix32(); + Transform2D mat32 = operator Transform2D(); return "("+Variant(mat32.elements[0]).operator String()+", "+Variant(mat32.elements[1]).operator String()+", "+Variant(mat32.elements[2]).operator String()+")"; } break; case VECTOR3: return "("+operator Vector3()+")"; case PLANE: return operator Plane(); //case QUAT: - case _AABB: return operator AABB(); + case RECT3: return operator Rect3(); case QUAT: return "("+operator Quat()+")"; - case MATRIX3: { + case BASIS: { - Matrix3 mat3 = operator Matrix3(); + Basis mat3 = operator Basis(); String mtx("("); for (int i=0;i<3;i++) { @@ -1576,7 +1576,7 @@ Variant::operator String() const { return str; } break; - case VECTOR2_ARRAY: { + case POOL_VECTOR2_ARRAY: { PoolVector<Vector2> vec = operator PoolVector<Vector2>(); String str("["); @@ -1589,7 +1589,7 @@ Variant::operator String() const { str += "]"; return str; } break; - case VECTOR3_ARRAY: { + case POOL_VECTOR3_ARRAY: { PoolVector<Vector3> vec = operator PoolVector<Vector3>(); String str("["); @@ -1602,7 +1602,7 @@ Variant::operator String() const { str += "]"; return str; } break; - case STRING_ARRAY: { + case POOL_STRING_ARRAY: { PoolVector<String> vec = operator PoolVector<String>(); String str("["); @@ -1615,7 +1615,7 @@ Variant::operator String() const { str += "]"; return str; } break; - case INT_ARRAY: { + case POOL_INT_ARRAY: { PoolVector<int> vec = operator PoolVector<int>(); String str("["); @@ -1628,7 +1628,7 @@ Variant::operator String() const { str += "]"; return str; } break; - case REAL_ARRAY: { + case POOL_REAL_ARRAY: { PoolVector<real_t> vec = operator PoolVector<real_t>(); String str("["); @@ -1713,32 +1713,32 @@ Variant::operator Plane() const { return Plane(); } -Variant::operator AABB() const { +Variant::operator Rect3() const { - if (type==_AABB) - return *_data._aabb; + if (type==RECT3) + return *_data._rect3; else - return AABB(); + return Rect3(); } -Variant::operator Matrix3() const { +Variant::operator Basis() const { - if (type==MATRIX3) - return *_data._matrix3; + if (type==BASIS) + return *_data._basis; else if (type==QUAT) return *reinterpret_cast<const Quat*>(_data._mem); else if (type==TRANSFORM) return _data._transform->basis; else - return Matrix3(); + return Basis(); } Variant::operator Quat() const { if (type==QUAT) return *reinterpret_cast<const Quat*>(_data._mem); - else if (type==MATRIX3) - return *_data._matrix3; + else if (type==BASIS) + return *_data._basis; else if (type==TRANSFORM) return _data._transform->basis; else @@ -1751,21 +1751,21 @@ Variant::operator Transform() const { if (type==TRANSFORM) return *_data._transform; - else if (type==MATRIX3) - return Transform(*_data._matrix3,Vector3()); + else if (type==BASIS) + return Transform(*_data._basis,Vector3()); else if (type==QUAT) - return Transform(Matrix3(*reinterpret_cast<const Quat*>(_data._mem)),Vector3()); + return Transform(Basis(*reinterpret_cast<const Quat*>(_data._mem)),Vector3()); else return Transform(); } - Variant::operator Matrix32() const { + Variant::operator Transform2D() const { - if (type==MATRIX32) { - return *_data._matrix32; + if (type==TRANSFORM2D) { + return *_data._transform2d; } else if (type==TRANSFORM) { const Transform& t = *_data._transform;; - Matrix32 m; + Transform2D m; m.elements[0][0]=t.basis.elements[0][0]; m.elements[0][1]=t.basis.elements[1][0]; m.elements[1][0]=t.basis.elements[0][1]; @@ -1774,7 +1774,7 @@ Variant::operator Transform() const { m.elements[2][1]=t.origin[1]; return m; } else - return Matrix32(); + return Transform2D(); } @@ -1893,13 +1893,13 @@ inline DA _convert_array_from_variant(const Variant& p_variant) { case Variant::ARRAY: { return _convert_array<DA,Array >( p_variant.operator Array () ); } - case Variant::RAW_ARRAY: { return _convert_array<DA,PoolVector<uint8_t> >( p_variant.operator PoolVector<uint8_t> () ); } - case Variant::INT_ARRAY: { return _convert_array<DA,PoolVector<int> >( p_variant.operator PoolVector<int> () ); } - case Variant::REAL_ARRAY: { return _convert_array<DA,PoolVector<real_t> >( p_variant.operator PoolVector<real_t> () ); } - case Variant::STRING_ARRAY: { return _convert_array<DA,PoolVector<String> >( p_variant.operator PoolVector<String> () ); } - case Variant::VECTOR2_ARRAY: { return _convert_array<DA,PoolVector<Vector2> >( p_variant.operator PoolVector<Vector2> () ); } - case Variant::VECTOR3_ARRAY: { return _convert_array<DA,PoolVector<Vector3> >( p_variant.operator PoolVector<Vector3> () ); } - case Variant::COLOR_ARRAY: { return _convert_array<DA,PoolVector<Color> >( p_variant.operator PoolVector<Color>() ); } + case Variant::POOL_BYTE_ARRAY: { return _convert_array<DA,PoolVector<uint8_t> >( p_variant.operator PoolVector<uint8_t> () ); } + case Variant::POOL_INT_ARRAY: { return _convert_array<DA,PoolVector<int> >( p_variant.operator PoolVector<int> () ); } + case Variant::POOL_REAL_ARRAY: { return _convert_array<DA,PoolVector<real_t> >( p_variant.operator PoolVector<real_t> () ); } + case Variant::POOL_STRING_ARRAY: { return _convert_array<DA,PoolVector<String> >( p_variant.operator PoolVector<String> () ); } + case Variant::POOL_VECTOR2_ARRAY: { return _convert_array<DA,PoolVector<Vector2> >( p_variant.operator PoolVector<Vector2> () ); } + case Variant::POOL_VECTOR3_ARRAY: { return _convert_array<DA,PoolVector<Vector3> >( p_variant.operator PoolVector<Vector3> () ); } + case Variant::POOL_COLOR_ARRAY: { return _convert_array<DA,PoolVector<Color> >( p_variant.operator PoolVector<Color>() ); } default: { return DA(); } } @@ -1916,14 +1916,14 @@ Variant::operator Array() const { Variant::operator PoolVector<uint8_t>() const { - if (type==RAW_ARRAY) + if (type==POOL_BYTE_ARRAY) return *reinterpret_cast<const PoolVector<uint8_t>* >(_data._mem); else return _convert_array_from_variant<PoolVector<uint8_t> >(*this); } Variant::operator PoolVector<int>() const { - if (type==INT_ARRAY) + if (type==POOL_INT_ARRAY) return *reinterpret_cast<const PoolVector<int>* >(_data._mem); else return _convert_array_from_variant<PoolVector<int> >(*this); @@ -1931,7 +1931,7 @@ Variant::operator PoolVector<int>() const { } Variant::operator PoolVector<real_t>() const { - if (type==REAL_ARRAY) + if (type==POOL_REAL_ARRAY) return *reinterpret_cast<const PoolVector<real_t>* >(_data._mem); else return _convert_array_from_variant<PoolVector<real_t> >(*this); @@ -1940,7 +1940,7 @@ Variant::operator PoolVector<real_t>() const { Variant::operator PoolVector<String>() const { - if (type==STRING_ARRAY) + if (type==POOL_STRING_ARRAY) return *reinterpret_cast<const PoolVector<String>* >(_data._mem); else return _convert_array_from_variant<PoolVector<String> >(*this); @@ -1949,7 +1949,7 @@ Variant::operator PoolVector<String>() const { } Variant::operator PoolVector<Vector3>() const { - if (type==VECTOR3_ARRAY) + if (type==POOL_VECTOR3_ARRAY) return *reinterpret_cast<const PoolVector<Vector3>* >(_data._mem); else return _convert_array_from_variant<PoolVector<Vector3> >(*this); @@ -1958,7 +1958,7 @@ Variant::operator PoolVector<Vector3>() const { } Variant::operator PoolVector<Vector2>() const { - if (type==VECTOR2_ARRAY) + if (type==POOL_VECTOR2_ARRAY) return *reinterpret_cast<const PoolVector<Vector2>* >(_data._mem); else return _convert_array_from_variant<PoolVector<Vector2> >(*this); @@ -1968,7 +1968,7 @@ Variant::operator PoolVector<Vector2>() const { Variant::operator PoolVector<Color>() const { - if (type==COLOR_ARRAY) + if (type==POOL_COLOR_ARRAY) return *reinterpret_cast<const PoolVector<Color>* >(_data._mem); else return _convert_array_from_variant<PoolVector<Color> >(*this); @@ -2165,7 +2165,7 @@ Variant::operator Orientation() const { Variant::operator IP_Address() const { - if (type==REAL_ARRAY || type==INT_ARRAY || type==RAW_ARRAY) { + if (type==POOL_REAL_ARRAY || type==POOL_INT_ARRAY || type==POOL_BYTE_ARRAY) { PoolVector<int> addr=operator PoolVector<int>(); if (addr.size()==4) { @@ -2320,16 +2320,16 @@ Variant::Variant(const Plane& p_plane) { memnew_placement( _data._mem, Plane( p_plane ) ); } -Variant::Variant(const AABB& p_aabb) { +Variant::Variant(const Rect3& p_aabb) { - type=_AABB; - _data._aabb = memnew( AABB( p_aabb ) ); + type=RECT3; + _data._rect3 = memnew( Rect3( p_aabb ) ); } -Variant::Variant(const Matrix3& p_matrix) { +Variant::Variant(const Basis& p_matrix) { - type=MATRIX3; - _data._matrix3= memnew( Matrix3( p_matrix ) ); + type=BASIS; + _data._basis= memnew( Basis( p_matrix ) ); } @@ -2346,10 +2346,10 @@ Variant::Variant(const Transform& p_transform) { } -Variant::Variant(const Matrix32& p_transform) { +Variant::Variant(const Transform2D& p_transform) { - type=MATRIX32; - _data._matrix32 = memnew( Matrix32( p_transform ) ); + type=TRANSFORM2D; + _data._transform2d = memnew( Transform2D( p_transform ) ); } Variant::Variant(const Color& p_color) { @@ -2483,44 +2483,44 @@ Variant::Variant(const Vector<Vector2>& p_array) { Variant::Variant(const PoolVector<uint8_t>& p_raw_array) { - type=RAW_ARRAY; + type=POOL_BYTE_ARRAY; memnew_placement( _data._mem, PoolVector<uint8_t>(p_raw_array) ); } Variant::Variant(const PoolVector<int>& p_int_array) { - type=INT_ARRAY; + type=POOL_INT_ARRAY; memnew_placement( _data._mem, PoolVector<int>(p_int_array) ); } Variant::Variant(const PoolVector<real_t>& p_real_array) { - type=REAL_ARRAY; + type=POOL_REAL_ARRAY; memnew_placement( _data._mem, PoolVector<real_t>(p_real_array) ); } Variant::Variant(const PoolVector<String>& p_string_array) { - type=STRING_ARRAY; + type=POOL_STRING_ARRAY; memnew_placement( _data._mem, PoolVector<String>(p_string_array) ); } Variant::Variant(const PoolVector<Vector3>& p_vector3_array) { - type=VECTOR3_ARRAY; + type=POOL_VECTOR3_ARRAY; memnew_placement( _data._mem, PoolVector<Vector3>(p_vector3_array) ); } Variant::Variant(const PoolVector<Vector2>& p_vector2_array) { - type=VECTOR2_ARRAY; + type=POOL_VECTOR2_ARRAY; memnew_placement( _data._mem, PoolVector<Vector2>(p_vector2_array) ); } Variant::Variant(const PoolVector<Color>& p_color_array) { - type=COLOR_ARRAY; + type=POOL_COLOR_ARRAY; memnew_placement( _data._mem, PoolVector<Color>(p_color_array) ); } @@ -2700,13 +2700,13 @@ uint32_t Variant::hash() const { hash = hash_djb2_one_float(reinterpret_cast<const Rect2*>(_data._mem)->size.x,hash); return hash_djb2_one_float(reinterpret_cast<const Rect2*>(_data._mem)->size.y,hash); } break; - case MATRIX32: { + case TRANSFORM2D: { uint32_t hash = 5831; for(int i=0;i<3;i++) { for(int j=0;j<2;j++) { - hash = hash_djb2_one_float(_data._matrix32->elements[i][j],hash); + hash = hash_djb2_one_float(_data._transform2d->elements[i][j],hash); } } @@ -2731,13 +2731,13 @@ uint32_t Variant::hash() const { } break;*/ - case _AABB: { + case RECT3: { uint32_t hash = 5831; for(int i=0;i<3;i++) { - hash = hash_djb2_one_float(_data._aabb->pos[i],hash); - hash = hash_djb2_one_float(_data._aabb->size[i],hash); + hash = hash_djb2_one_float(_data._rect3->pos[i],hash); + hash = hash_djb2_one_float(_data._rect3->size[i],hash); } @@ -2752,13 +2752,13 @@ uint32_t Variant::hash() const { return hash_djb2_one_float(reinterpret_cast<const Quat*>(_data._mem)->w,hash); } break; - case MATRIX3: { + case BASIS: { uint32_t hash = 5831; for(int i=0;i<3;i++) { for(int j=0;j<3;j++) { - hash = hash_djb2_one_float(_data._matrix3->elements[i][j],hash); + hash = hash_djb2_one_float(_data._basis->elements[i][j],hash); } } @@ -2824,7 +2824,7 @@ uint32_t Variant::hash() const { return arr.hash(); } break; - case RAW_ARRAY: { + case POOL_BYTE_ARRAY: { const PoolVector<uint8_t>& arr = *reinterpret_cast<const PoolVector<uint8_t>* >(_data._mem); int len = arr.size(); @@ -2833,7 +2833,7 @@ uint32_t Variant::hash() const { return hash_djb2_buffer((uint8_t*)&r[0],len); } break; - case INT_ARRAY: { + case POOL_INT_ARRAY: { const PoolVector<int>& arr = *reinterpret_cast<const PoolVector<int>* >(_data._mem); int len = arr.size(); @@ -2842,7 +2842,7 @@ uint32_t Variant::hash() const { return hash_djb2_buffer((uint8_t*)&r[0],len*sizeof(int)); } break; - case REAL_ARRAY: { + case POOL_REAL_ARRAY: { const PoolVector<real_t>& arr = *reinterpret_cast<const PoolVector<real_t>* >(_data._mem); int len = arr.size(); @@ -2851,7 +2851,7 @@ uint32_t Variant::hash() const { return hash_djb2_buffer((uint8_t*)&r[0],len*sizeof(real_t)); } break; - case STRING_ARRAY: { + case POOL_STRING_ARRAY: { uint32_t hash=5831; const PoolVector<String>& arr = *reinterpret_cast<const PoolVector<String>* >(_data._mem); @@ -2864,7 +2864,7 @@ uint32_t Variant::hash() const { return hash; } break; - case VECTOR2_ARRAY: { + case POOL_VECTOR2_ARRAY: { uint32_t hash=5831; const PoolVector<Vector2>& arr = *reinterpret_cast<const PoolVector<Vector2>* >(_data._mem); @@ -2879,7 +2879,7 @@ uint32_t Variant::hash() const { return hash; } break; - case VECTOR3_ARRAY: { + case POOL_VECTOR3_ARRAY: { uint32_t hash=5831; const PoolVector<Vector3>& arr = *reinterpret_cast<const PoolVector<Vector3>* >(_data._mem); @@ -2895,7 +2895,7 @@ uint32_t Variant::hash() const { return hash; } break; - case COLOR_ARRAY: { + case POOL_COLOR_ARRAY: { uint32_t hash=5831; const PoolVector<Color>& arr = *reinterpret_cast<const PoolVector<Color>* >(_data._mem); diff --git a/core/variant.h b/core/variant.h index 764ba9ae60..9d29fd64c3 100644 --- a/core/variant.h +++ b/core/variant.h @@ -63,13 +63,13 @@ struct PropertyInfo; struct MethodInfo; -typedef PoolVector<uint8_t> ByteArray; -typedef PoolVector<int> IntArray; -typedef PoolVector<real_t> RealArray; -typedef PoolVector<String> StringArray; -typedef PoolVector<Vector2> Vector2Array; -typedef PoolVector<Vector3> Vector3Array; -typedef PoolVector<Color> ColorArray; +typedef PoolVector<uint8_t> PoolByteArray; +typedef PoolVector<int> PoolIntArray; +typedef PoolVector<real_t> PoolRealArray; +typedef PoolVector<String> PoolStringArray; +typedef PoolVector<Vector2> PoolVector2Array; +typedef PoolVector<Vector3> PoolVector3Array; +typedef PoolVector<Color> PoolColorArray; class Variant { public: @@ -89,11 +89,11 @@ public: VECTOR2, // 5 RECT2, VECTOR3, - MATRIX32, + TRANSFORM2D, PLANE, QUAT, // 10 - _AABB, //sorry naming convention fail :( not like it's used often - MATRIX3, + RECT3, //sorry naming convention fail :( not like it's used often + BASIS, TRANSFORM, // misc types @@ -107,13 +107,13 @@ public: ARRAY, // arrays - RAW_ARRAY, - INT_ARRAY, - REAL_ARRAY, - STRING_ARRAY, // 25 - VECTOR2_ARRAY, - VECTOR3_ARRAY, - COLOR_ARRAY, + POOL_BYTE_ARRAY, + POOL_INT_ARRAY, + POOL_REAL_ARRAY, + POOL_STRING_ARRAY, // 25 + POOL_VECTOR2_ARRAY, + POOL_VECTOR3_ARRAY, + POOL_COLOR_ARRAY, VARIANT_MAX @@ -143,9 +143,9 @@ private: bool _bool; int64_t _int; double _real; - Matrix32 *_matrix32; - AABB* _aabb; - Matrix3 *_matrix3; + Transform2D *_transform2d; + Rect3* _rect3; + Basis *_basis; Transform *_transform; RefPtr *_resource; InputEvent *_input_event; @@ -208,11 +208,11 @@ public: operator Rect2() const; operator Vector3() const; operator Plane() const; - operator AABB() const; + operator Rect3() const; operator Quat() const; - operator Matrix3() const; + operator Basis() const; operator Transform() const; - operator Matrix32() const; + operator Transform2D() const; operator Color() const; operator Image() const; @@ -280,10 +280,10 @@ public: Variant(const Rect2& p_rect2); Variant(const Vector3& p_vector3); Variant(const Plane& p_plane); - Variant(const AABB& p_aabb); + Variant(const Rect3& p_aabb); Variant(const Quat& p_quat); - Variant(const Matrix3& p_transform); - Variant(const Matrix32& p_transform); + Variant(const Basis& p_transform); + Variant(const Transform2D& p_transform); Variant(const Transform& p_transform); Variant(const Color& p_color); Variant(const Image& p_image); diff --git a/core/variant_call.cpp b/core/variant_call.cpp index d6fb78ee56..9a61dd73df 100644 --- a/core/variant_call.cpp +++ b/core/variant_call.cpp @@ -310,10 +310,10 @@ static void _call_##m_type##_##m_method(Variant& r_ret,Variant& p_self,const Var String *s = reinterpret_cast<String*>(p_self._data._mem); CharString charstr = s->ascii(); - ByteArray retval; + PoolByteArray retval; size_t len = charstr.length(); retval.resize(len); - ByteArray::Write w = retval.write(); + PoolByteArray::Write w = retval.write(); copymem(w.ptr(), charstr.ptr(), len); w = PoolVector<uint8_t>::Write(); @@ -325,10 +325,10 @@ static void _call_##m_type##_##m_method(Variant& r_ret,Variant& p_self,const Var String *s = reinterpret_cast<String*>(p_self._data._mem); CharString charstr = s->utf8(); - ByteArray retval; + PoolByteArray retval; size_t len = charstr.length(); retval.resize(len); - ByteArray::Write w = retval.write(); + PoolByteArray::Write w = retval.write(); copymem(w.ptr(), charstr.ptr(), len); w = PoolVector<uint8_t>::Write(); @@ -491,12 +491,12 @@ static void _call_##m_type##_##m_method(Variant& r_ret,Variant& p_self,const Var VCALL_LOCALMEM0(Array,invert); VCALL_LOCALMEM0R(Array,is_shared); - static void _call_ByteArray_get_string_from_ascii(Variant& r_ret,Variant& p_self,const Variant** p_args) { + static void _call_PoolByteArray_get_string_from_ascii(Variant& r_ret,Variant& p_self,const Variant** p_args) { - ByteArray* ba = reinterpret_cast<ByteArray*>(p_self._data._mem); + PoolByteArray* ba = reinterpret_cast<PoolByteArray*>(p_self._data._mem); String s; if (ba->size()>=0) { - ByteArray::Read r = ba->read(); + PoolByteArray::Read r = ba->read(); CharString cs; cs.resize(ba->size()+1); copymem(cs.ptr(),r.ptr(),ba->size()); @@ -507,94 +507,94 @@ static void _call_##m_type##_##m_method(Variant& r_ret,Variant& p_self,const Var r_ret=s; } - static void _call_ByteArray_get_string_from_utf8(Variant& r_ret,Variant& p_self,const Variant** p_args) { + static void _call_PoolByteArray_get_string_from_utf8(Variant& r_ret,Variant& p_self,const Variant** p_args) { - ByteArray* ba = reinterpret_cast<ByteArray*>(p_self._data._mem); + PoolByteArray* ba = reinterpret_cast<PoolByteArray*>(p_self._data._mem); String s; if (ba->size()>=0) { - ByteArray::Read r = ba->read(); + PoolByteArray::Read r = ba->read(); s.parse_utf8((const char*)r.ptr(),ba->size()); } r_ret=s; } - VCALL_LOCALMEM0R(ByteArray,size); - VCALL_LOCALMEM2(ByteArray,set); - VCALL_LOCALMEM1R(ByteArray,get); - VCALL_LOCALMEM1(ByteArray,push_back); - VCALL_LOCALMEM1(ByteArray,resize); - VCALL_LOCALMEM2R(ByteArray,insert); - VCALL_LOCALMEM1(ByteArray,remove); - VCALL_LOCALMEM1(ByteArray,append); - VCALL_LOCALMEM1(ByteArray,append_array); - VCALL_LOCALMEM0(ByteArray,invert); - VCALL_LOCALMEM2R(ByteArray,subarray); - - VCALL_LOCALMEM0R(IntArray,size); - VCALL_LOCALMEM2(IntArray,set); - VCALL_LOCALMEM1R(IntArray,get); - VCALL_LOCALMEM1(IntArray,push_back); - VCALL_LOCALMEM1(IntArray,resize); - VCALL_LOCALMEM2R(IntArray,insert); - VCALL_LOCALMEM1(IntArray,remove); - VCALL_LOCALMEM1(IntArray,append); - VCALL_LOCALMEM1(IntArray,append_array); - VCALL_LOCALMEM0(IntArray,invert); - - VCALL_LOCALMEM0R(RealArray,size); - VCALL_LOCALMEM2(RealArray,set); - VCALL_LOCALMEM1R(RealArray,get); - VCALL_LOCALMEM1(RealArray,push_back); - VCALL_LOCALMEM1(RealArray,resize); - VCALL_LOCALMEM2R(RealArray,insert); - VCALL_LOCALMEM1(RealArray,remove); - VCALL_LOCALMEM1(RealArray,append); - VCALL_LOCALMEM1(RealArray,append_array); - VCALL_LOCALMEM0(RealArray,invert); - - VCALL_LOCALMEM0R(StringArray,size); - VCALL_LOCALMEM2(StringArray,set); - VCALL_LOCALMEM1R(StringArray,get); - VCALL_LOCALMEM1(StringArray,push_back); - VCALL_LOCALMEM1(StringArray,resize); - VCALL_LOCALMEM2R(StringArray,insert); - VCALL_LOCALMEM1(StringArray,remove); - VCALL_LOCALMEM1(StringArray,append); - VCALL_LOCALMEM1(StringArray,append_array); - VCALL_LOCALMEM0(StringArray,invert); - - VCALL_LOCALMEM0R(Vector2Array,size); - VCALL_LOCALMEM2(Vector2Array,set); - VCALL_LOCALMEM1R(Vector2Array,get); - VCALL_LOCALMEM1(Vector2Array,push_back); - VCALL_LOCALMEM1(Vector2Array,resize); - VCALL_LOCALMEM2R(Vector2Array,insert); - VCALL_LOCALMEM1(Vector2Array,remove); - VCALL_LOCALMEM1(Vector2Array,append); - VCALL_LOCALMEM1(Vector2Array,append_array); - VCALL_LOCALMEM0(Vector2Array,invert); - - VCALL_LOCALMEM0R(Vector3Array,size); - VCALL_LOCALMEM2(Vector3Array,set); - VCALL_LOCALMEM1R(Vector3Array,get); - VCALL_LOCALMEM1(Vector3Array,push_back); - VCALL_LOCALMEM1(Vector3Array,resize); - VCALL_LOCALMEM2R(Vector3Array,insert); - VCALL_LOCALMEM1(Vector3Array,remove); - VCALL_LOCALMEM1(Vector3Array,append); - VCALL_LOCALMEM1(Vector3Array,append_array); - VCALL_LOCALMEM0(Vector3Array,invert); - - VCALL_LOCALMEM0R(ColorArray,size); - VCALL_LOCALMEM2(ColorArray,set); - VCALL_LOCALMEM1R(ColorArray,get); - VCALL_LOCALMEM1(ColorArray,push_back); - VCALL_LOCALMEM1(ColorArray,resize); - VCALL_LOCALMEM2R(ColorArray,insert); - VCALL_LOCALMEM1(ColorArray,remove); - VCALL_LOCALMEM1(ColorArray,append); - VCALL_LOCALMEM1(ColorArray,append_array); - VCALL_LOCALMEM0(ColorArray,invert); + VCALL_LOCALMEM0R(PoolByteArray,size); + VCALL_LOCALMEM2(PoolByteArray,set); + VCALL_LOCALMEM1R(PoolByteArray,get); + VCALL_LOCALMEM1(PoolByteArray,push_back); + VCALL_LOCALMEM1(PoolByteArray,resize); + VCALL_LOCALMEM2R(PoolByteArray,insert); + VCALL_LOCALMEM1(PoolByteArray,remove); + VCALL_LOCALMEM1(PoolByteArray,append); + VCALL_LOCALMEM1(PoolByteArray,append_array); + VCALL_LOCALMEM0(PoolByteArray,invert); + VCALL_LOCALMEM2R(PoolByteArray,subarray); + + VCALL_LOCALMEM0R(PoolIntArray,size); + VCALL_LOCALMEM2(PoolIntArray,set); + VCALL_LOCALMEM1R(PoolIntArray,get); + VCALL_LOCALMEM1(PoolIntArray,push_back); + VCALL_LOCALMEM1(PoolIntArray,resize); + VCALL_LOCALMEM2R(PoolIntArray,insert); + VCALL_LOCALMEM1(PoolIntArray,remove); + VCALL_LOCALMEM1(PoolIntArray,append); + VCALL_LOCALMEM1(PoolIntArray,append_array); + VCALL_LOCALMEM0(PoolIntArray,invert); + + VCALL_LOCALMEM0R(PoolRealArray,size); + VCALL_LOCALMEM2(PoolRealArray,set); + VCALL_LOCALMEM1R(PoolRealArray,get); + VCALL_LOCALMEM1(PoolRealArray,push_back); + VCALL_LOCALMEM1(PoolRealArray,resize); + VCALL_LOCALMEM2R(PoolRealArray,insert); + VCALL_LOCALMEM1(PoolRealArray,remove); + VCALL_LOCALMEM1(PoolRealArray,append); + VCALL_LOCALMEM1(PoolRealArray,append_array); + VCALL_LOCALMEM0(PoolRealArray,invert); + + VCALL_LOCALMEM0R(PoolStringArray,size); + VCALL_LOCALMEM2(PoolStringArray,set); + VCALL_LOCALMEM1R(PoolStringArray,get); + VCALL_LOCALMEM1(PoolStringArray,push_back); + VCALL_LOCALMEM1(PoolStringArray,resize); + VCALL_LOCALMEM2R(PoolStringArray,insert); + VCALL_LOCALMEM1(PoolStringArray,remove); + VCALL_LOCALMEM1(PoolStringArray,append); + VCALL_LOCALMEM1(PoolStringArray,append_array); + VCALL_LOCALMEM0(PoolStringArray,invert); + + VCALL_LOCALMEM0R(PoolVector2Array,size); + VCALL_LOCALMEM2(PoolVector2Array,set); + VCALL_LOCALMEM1R(PoolVector2Array,get); + VCALL_LOCALMEM1(PoolVector2Array,push_back); + VCALL_LOCALMEM1(PoolVector2Array,resize); + VCALL_LOCALMEM2R(PoolVector2Array,insert); + VCALL_LOCALMEM1(PoolVector2Array,remove); + VCALL_LOCALMEM1(PoolVector2Array,append); + VCALL_LOCALMEM1(PoolVector2Array,append_array); + VCALL_LOCALMEM0(PoolVector2Array,invert); + + VCALL_LOCALMEM0R(PoolVector3Array,size); + VCALL_LOCALMEM2(PoolVector3Array,set); + VCALL_LOCALMEM1R(PoolVector3Array,get); + VCALL_LOCALMEM1(PoolVector3Array,push_back); + VCALL_LOCALMEM1(PoolVector3Array,resize); + VCALL_LOCALMEM2R(PoolVector3Array,insert); + VCALL_LOCALMEM1(PoolVector3Array,remove); + VCALL_LOCALMEM1(PoolVector3Array,append); + VCALL_LOCALMEM1(PoolVector3Array,append_array); + VCALL_LOCALMEM0(PoolVector3Array,invert); + + VCALL_LOCALMEM0R(PoolColorArray,size); + VCALL_LOCALMEM2(PoolColorArray,set); + VCALL_LOCALMEM1R(PoolColorArray,get); + VCALL_LOCALMEM1(PoolColorArray,push_back); + VCALL_LOCALMEM1(PoolColorArray,resize); + VCALL_LOCALMEM2R(PoolColorArray,insert); + VCALL_LOCALMEM1(PoolColorArray,remove); + VCALL_LOCALMEM1(PoolColorArray,append); + VCALL_LOCALMEM1(PoolColorArray,append_array); + VCALL_LOCALMEM0(PoolColorArray,invert); #define VCALL_PTR0(m_type,m_method)\ static void _call_##m_type##_##m_method(Variant& r_ret,Variant& p_self,const Variant** p_args) { reinterpret_cast<m_type*>(p_self._data._ptr)->m_method(); } @@ -637,93 +637,93 @@ static void _call_##m_type##_##m_method(Variant& r_ret,Variant& p_self,const Var VCALL_PTR1R(Image, converted); VCALL_PTR0(Image, fix_alpha_edges); - VCALL_PTR0R( AABB, get_area ); - VCALL_PTR0R( AABB, has_no_area ); - VCALL_PTR0R( AABB, has_no_surface ); - VCALL_PTR1R( AABB, intersects ); - VCALL_PTR1R( AABB, encloses ); - VCALL_PTR1R( AABB, merge ); - VCALL_PTR1R( AABB, intersection ); - VCALL_PTR1R( AABB, intersects_plane ); - VCALL_PTR2R( AABB, intersects_segment ); - VCALL_PTR1R( AABB, has_point ); - VCALL_PTR1R( AABB, get_support ); - VCALL_PTR0R( AABB, get_longest_axis ); - VCALL_PTR0R( AABB, get_longest_axis_index ); - VCALL_PTR0R( AABB, get_longest_axis_size ); - VCALL_PTR0R( AABB, get_shortest_axis ); - VCALL_PTR0R( AABB, get_shortest_axis_index ); - VCALL_PTR0R( AABB, get_shortest_axis_size ); - VCALL_PTR1R( AABB, expand ); - VCALL_PTR1R( AABB, grow ); - VCALL_PTR1R( AABB, get_endpoint ); - - VCALL_PTR0R( Matrix32, inverse ); - VCALL_PTR0R( Matrix32, affine_inverse ); - VCALL_PTR0R( Matrix32, get_rotation ); - VCALL_PTR0R( Matrix32, get_origin ); - VCALL_PTR0R( Matrix32, get_scale ); - VCALL_PTR0R( Matrix32, orthonormalized ); - VCALL_PTR1R( Matrix32, rotated ); - VCALL_PTR1R( Matrix32, scaled ); - VCALL_PTR1R( Matrix32, translated ); - VCALL_PTR2R( Matrix32, interpolate_with ); - - static void _call_Matrix32_xform(Variant& r_ret,Variant& p_self,const Variant** p_args) { + VCALL_PTR0R( Rect3, get_area ); + VCALL_PTR0R( Rect3, has_no_area ); + VCALL_PTR0R( Rect3, has_no_surface ); + VCALL_PTR1R( Rect3, intersects ); + VCALL_PTR1R( Rect3, encloses ); + VCALL_PTR1R( Rect3, merge ); + VCALL_PTR1R( Rect3, intersection ); + VCALL_PTR1R( Rect3, intersects_plane ); + VCALL_PTR2R( Rect3, intersects_segment ); + VCALL_PTR1R( Rect3, has_point ); + VCALL_PTR1R( Rect3, get_support ); + VCALL_PTR0R( Rect3, get_longest_axis ); + VCALL_PTR0R( Rect3, get_longest_axis_index ); + VCALL_PTR0R( Rect3, get_longest_axis_size ); + VCALL_PTR0R( Rect3, get_shortest_axis ); + VCALL_PTR0R( Rect3, get_shortest_axis_index ); + VCALL_PTR0R( Rect3, get_shortest_axis_size ); + VCALL_PTR1R( Rect3, expand ); + VCALL_PTR1R( Rect3, grow ); + VCALL_PTR1R( Rect3, get_endpoint ); + + VCALL_PTR0R( Transform2D, inverse ); + VCALL_PTR0R( Transform2D, affine_inverse ); + VCALL_PTR0R( Transform2D, get_rotation ); + VCALL_PTR0R( Transform2D, get_origin ); + VCALL_PTR0R( Transform2D, get_scale ); + VCALL_PTR0R( Transform2D, orthonormalized ); + VCALL_PTR1R( Transform2D, rotated ); + VCALL_PTR1R( Transform2D, scaled ); + VCALL_PTR1R( Transform2D, translated ); + VCALL_PTR2R( Transform2D, interpolate_with ); + + static void _call_Transform2D_xform(Variant& r_ret,Variant& p_self,const Variant** p_args) { switch(p_args[0]->type) { - case Variant::VECTOR2: r_ret=reinterpret_cast<Matrix32*>(p_self._data._ptr)->xform( p_args[0]->operator Vector2()); return; - case Variant::RECT2: r_ret=reinterpret_cast<Matrix32*>(p_self._data._ptr)->xform( p_args[0]->operator Rect2()); return; + case Variant::VECTOR2: r_ret=reinterpret_cast<Transform2D*>(p_self._data._ptr)->xform( p_args[0]->operator Vector2()); return; + case Variant::RECT2: r_ret=reinterpret_cast<Transform2D*>(p_self._data._ptr)->xform( p_args[0]->operator Rect2()); return; default: r_ret=Variant(); } } - static void _call_Matrix32_xform_inv(Variant& r_ret,Variant& p_self,const Variant** p_args) { + static void _call_Transform2D_xform_inv(Variant& r_ret,Variant& p_self,const Variant** p_args) { switch(p_args[0]->type) { - case Variant::VECTOR2: r_ret=reinterpret_cast<Matrix32*>(p_self._data._ptr)->xform_inv( p_args[0]->operator Vector2()); return; - case Variant::RECT2: r_ret=reinterpret_cast<Matrix32*>(p_self._data._ptr)->xform_inv( p_args[0]->operator Rect2()); return; + case Variant::VECTOR2: r_ret=reinterpret_cast<Transform2D*>(p_self._data._ptr)->xform_inv( p_args[0]->operator Vector2()); return; + case Variant::RECT2: r_ret=reinterpret_cast<Transform2D*>(p_self._data._ptr)->xform_inv( p_args[0]->operator Rect2()); return; default: r_ret=Variant(); } } - static void _call_Matrix32_basis_xform(Variant& r_ret,Variant& p_self,const Variant** p_args) { + static void _call_Transform2D_basis_xform(Variant& r_ret,Variant& p_self,const Variant** p_args) { switch(p_args[0]->type) { - case Variant::VECTOR2: r_ret=reinterpret_cast<Matrix32*>(p_self._data._ptr)->basis_xform( p_args[0]->operator Vector2()); return; + case Variant::VECTOR2: r_ret=reinterpret_cast<Transform2D*>(p_self._data._ptr)->basis_xform( p_args[0]->operator Vector2()); return; default: r_ret=Variant(); } } - static void _call_Matrix32_basis_xform_inv(Variant& r_ret,Variant& p_self,const Variant** p_args) { + static void _call_Transform2D_basis_xform_inv(Variant& r_ret,Variant& p_self,const Variant** p_args) { switch(p_args[0]->type) { - case Variant::VECTOR2: r_ret=reinterpret_cast<Matrix32*>(p_self._data._ptr)->basis_xform_inv( p_args[0]->operator Vector2()); return; + case Variant::VECTOR2: r_ret=reinterpret_cast<Transform2D*>(p_self._data._ptr)->basis_xform_inv( p_args[0]->operator Vector2()); return; default: r_ret=Variant(); } } - VCALL_PTR0R( Matrix3, inverse ); - VCALL_PTR0R( Matrix3, transposed ); - VCALL_PTR0R( Matrix3, determinant ); - VCALL_PTR2R( Matrix3, rotated ); - VCALL_PTR1R( Matrix3, scaled ); - VCALL_PTR0R( Matrix3, get_scale ); - VCALL_PTR0R( Matrix3, get_euler ); - VCALL_PTR1R( Matrix3, tdotx ); - VCALL_PTR1R( Matrix3, tdoty ); - VCALL_PTR1R( Matrix3, tdotz ); - VCALL_PTR1R( Matrix3, xform ); - VCALL_PTR1R( Matrix3, xform_inv ); - VCALL_PTR0R( Matrix3, get_orthogonal_index ); - VCALL_PTR0R( Matrix3, orthonormalized ); + VCALL_PTR0R( Basis, inverse ); + VCALL_PTR0R( Basis, transposed ); + VCALL_PTR0R( Basis, determinant ); + VCALL_PTR2R( Basis, rotated ); + VCALL_PTR1R( Basis, scaled ); + VCALL_PTR0R( Basis, get_scale ); + VCALL_PTR0R( Basis, get_euler ); + VCALL_PTR1R( Basis, tdotx ); + VCALL_PTR1R( Basis, tdoty ); + VCALL_PTR1R( Basis, tdotz ); + VCALL_PTR1R( Basis, xform ); + VCALL_PTR1R( Basis, xform_inv ); + VCALL_PTR0R( Basis, get_orthogonal_index ); + VCALL_PTR0R( Basis, orthonormalized ); VCALL_PTR0R( Transform, inverse ); @@ -740,7 +740,7 @@ static void _call_##m_type##_##m_method(Variant& r_ret,Variant& p_self,const Var case Variant::VECTOR3: r_ret=reinterpret_cast<Transform*>(p_self._data._ptr)->xform( p_args[0]->operator Vector3()); return; case Variant::PLANE: r_ret=reinterpret_cast<Transform*>(p_self._data._ptr)->xform( p_args[0]->operator Plane()); return; - case Variant::_AABB: r_ret=reinterpret_cast<Transform*>(p_self._data._ptr)->xform( p_args[0]->operator AABB()); return; + case Variant::RECT3: r_ret=reinterpret_cast<Transform*>(p_self._data._ptr)->xform( p_args[0]->operator Rect3()); return; default: r_ret=Variant(); } @@ -752,7 +752,7 @@ static void _call_##m_type##_##m_method(Variant& r_ret,Variant& p_self,const Var case Variant::VECTOR3: r_ret=reinterpret_cast<Transform*>(p_self._data._ptr)->xform_inv( p_args[0]->operator Vector3()); return; case Variant::PLANE: r_ret=reinterpret_cast<Transform*>(p_self._data._ptr)->xform_inv( p_args[0]->operator Plane()); return; - case Variant::_AABB: r_ret=reinterpret_cast<Transform*>(p_self._data._ptr)->xform_inv( p_args[0]->operator AABB()); return; + case Variant::RECT3: r_ret=reinterpret_cast<Transform*>(p_self._data._ptr)->xform_inv( p_args[0]->operator Rect3()); return; default: r_ret=Variant(); } } @@ -804,15 +804,15 @@ static void _call_##m_type##_##m_method(Variant& r_ret,Variant& p_self,const Var r_ret=Rect2(*p_args[0],*p_args[1],*p_args[2],*p_args[3]); } - static void Matrix32_init2(Variant& r_ret,const Variant** p_args) { + static void Transform2D_init2(Variant& r_ret,const Variant** p_args) { - Matrix32 m(*p_args[0], *p_args[1]); + Transform2D m(*p_args[0], *p_args[1]); r_ret=m; } - static void Matrix32_init3(Variant& r_ret,const Variant** p_args) { + static void Transform2D_init3(Variant& r_ret,const Variant** p_args) { - Matrix32 m; + Transform2D m; m[0]=*p_args[0]; m[1]=*p_args[1]; m[2]=*p_args[2]; @@ -873,23 +873,23 @@ static void _call_##m_type##_##m_method(Variant& r_ret,Variant& p_self,const Var r_ret=Color::hex(*p_args[0]); } - static void AABB_init1(Variant& r_ret,const Variant** p_args) { + static void Rect3_init1(Variant& r_ret,const Variant** p_args) { - r_ret=AABB(*p_args[0],*p_args[1]); + r_ret=Rect3(*p_args[0],*p_args[1]); } - static void Matrix3_init1(Variant& r_ret,const Variant** p_args) { + static void Basis_init1(Variant& r_ret,const Variant** p_args) { - Matrix3 m; + Basis m; m.set_axis(0,*p_args[0]); m.set_axis(1,*p_args[1]); m.set_axis(2,*p_args[2]); r_ret=m; } - static void Matrix3_init2(Variant& r_ret,const Variant** p_args) { + static void Basis_init2(Variant& r_ret,const Variant** p_args) { - r_ret=Matrix3(p_args[0]->operator Vector3(),p_args[1]->operator real_t()); + r_ret=Basis(p_args[0]->operator Vector3(),p_args[1]->operator real_t()); } static void Transform_init1(Variant& r_ret,const Variant** p_args) { @@ -904,7 +904,7 @@ static void _call_##m_type##_##m_method(Variant& r_ret,Variant& p_self,const Var static void Transform_init2(Variant& r_ret,const Variant** p_args) { - r_ret=Transform(p_args[0]->operator Matrix3(),p_args[1]->operator Vector3()); + r_ret=Transform(p_args[0]->operator Basis(),p_args[1]->operator Vector3()); } static void Image_init1(Variant& r_ret, const Variant** p_args) { @@ -1054,11 +1054,11 @@ Variant Variant::construct(const Variant::Type p_type, const Variant** p_args, i case VECTOR2: return Vector2(); // 5 case RECT2: return Rect2(); case VECTOR3: return Vector3(); - case MATRIX32: return Matrix32(); + case TRANSFORM2D: return Transform2D(); case PLANE: return Plane(); case QUAT: return Quat(); - case _AABB: return AABB(); //sorry naming convention fail :( not like it's used often // 10 - case MATRIX3: return Matrix3(); + case RECT3: return Rect3(); //sorry naming convention fail :( not like it's used often // 10 + case BASIS: return Basis(); case TRANSFORM: return Transform(); // misc types @@ -1070,13 +1070,13 @@ Variant Variant::construct(const Variant::Type p_type, const Variant** p_args, i case INPUT_EVENT: return InputEvent();; case DICTIONARY: return Dictionary();; case ARRAY: return Array();; // 20 - case RAW_ARRAY: return ByteArray();; - case INT_ARRAY: return IntArray();; - case REAL_ARRAY: return RealArray();; - case STRING_ARRAY: return StringArray();; - case VECTOR2_ARRAY: return Vector2Array();; // 25 - case VECTOR3_ARRAY: return Vector3Array();; // 25 - case COLOR_ARRAY: return ColorArray();; + case POOL_BYTE_ARRAY: return PoolByteArray();; + case POOL_INT_ARRAY: return PoolIntArray();; + case POOL_REAL_ARRAY: return PoolRealArray();; + case POOL_STRING_ARRAY: return PoolStringArray();; + case POOL_VECTOR2_ARRAY: return PoolVector2Array();; // 25 + case POOL_VECTOR3_ARRAY: return PoolVector3Array();; // 25 + case POOL_COLOR_ARRAY: return PoolColorArray();; default: return Variant(); } @@ -1125,8 +1125,8 @@ Variant Variant::construct(const Variant::Type p_type, const Variant** p_args, i case VECTOR3: return (Vector3(*p_args[0])); case PLANE: return (Plane(*p_args[0])); case QUAT: return (Quat(*p_args[0])); - case _AABB: return (AABB(*p_args[0])); //sorry naming convention fail :( not like it's used often // 10 - case MATRIX3: return (Matrix3(p_args[0]->operator Matrix3())); + case RECT3: return (Rect3(*p_args[0])); //sorry naming convention fail :( not like it's used often // 10 + case BASIS: return (Basis(p_args[0]->operator Basis())); case TRANSFORM: return (Transform(p_args[0]->operator Transform())); // misc types @@ -1140,13 +1140,13 @@ Variant Variant::construct(const Variant::Type p_type, const Variant** p_args, i case ARRAY: return p_args[0]->operator Array(); // arrays - case RAW_ARRAY: return (ByteArray(*p_args[0])); - case INT_ARRAY: return (IntArray(*p_args[0])); - case REAL_ARRAY: return (RealArray(*p_args[0])); - case STRING_ARRAY: return (StringArray(*p_args[0])); - case VECTOR2_ARRAY: return (Vector2Array(*p_args[0])); // 25 - case VECTOR3_ARRAY: return (Vector3Array(*p_args[0])); // 25 - case COLOR_ARRAY: return (ColorArray(*p_args[0])); + case POOL_BYTE_ARRAY: return (PoolByteArray(*p_args[0])); + case POOL_INT_ARRAY: return (PoolIntArray(*p_args[0])); + case POOL_REAL_ARRAY: return (PoolRealArray(*p_args[0])); + case POOL_STRING_ARRAY: return (PoolStringArray(*p_args[0])); + case POOL_VECTOR2_ARRAY: return (PoolVector2Array(*p_args[0])); // 25 + case POOL_VECTOR3_ARRAY: return (PoolVector3Array(*p_args[0])); // 25 + case POOL_COLOR_ARRAY: return (PoolColorArray(*p_args[0])); default: return Variant(); } } @@ -1389,15 +1389,15 @@ _VariantCall::addfunc(Variant::m_vtype,Variant::m_ret,_SCS(#m_method),VCALL(m_cl ADDFUNC1(STRING,BOOL,String,ends_with,STRING,"text",varray()); ADDFUNC1(STRING,BOOL,String,is_subsequence_of,STRING,"text",varray()); ADDFUNC1(STRING,BOOL,String,is_subsequence_ofi,STRING,"text",varray()); - ADDFUNC0(STRING,STRING_ARRAY,String,bigrams,varray()); + ADDFUNC0(STRING,POOL_STRING_ARRAY,String,bigrams,varray()); ADDFUNC1(STRING,REAL,String,similarity,STRING,"text",varray()); ADDFUNC2(STRING,STRING,String,replace,STRING,"what",STRING,"forwhat",varray()); ADDFUNC2(STRING,STRING,String,replacen,STRING,"what",STRING,"forwhat",varray()); ADDFUNC2(STRING,STRING,String,insert,INT,"pos",STRING,"what",varray()); ADDFUNC0(STRING,STRING,String,capitalize,varray()); - ADDFUNC2(STRING,STRING_ARRAY,String,split,STRING,"divisor",BOOL,"allow_empty",varray(true)); - ADDFUNC2(STRING,REAL_ARRAY,String,split_floats,STRING,"divisor",BOOL,"allow_empty",varray(true)); + ADDFUNC2(STRING,POOL_STRING_ARRAY,String,split,STRING,"divisor",BOOL,"allow_empty",varray(true)); + ADDFUNC2(STRING,POOL_REAL_ARRAY,String,split_floats,STRING,"divisor",BOOL,"allow_empty",varray(true)); ADDFUNC0(STRING,STRING,String,to_upper,varray()); ADDFUNC0(STRING,STRING,String,to_lower,varray()); @@ -1413,8 +1413,8 @@ _VariantCall::addfunc(Variant::m_vtype,Variant::m_ret,_SCS(#m_method),VCALL(m_cl ADDFUNC0(STRING,INT,String,hash,varray()); ADDFUNC0(STRING,STRING,String,md5_text,varray()); ADDFUNC0(STRING,STRING,String,sha256_text,varray()); - ADDFUNC0(STRING,RAW_ARRAY,String,md5_buffer,varray()); - ADDFUNC0(STRING,RAW_ARRAY,String,sha256_buffer,varray()); + ADDFUNC0(STRING,POOL_BYTE_ARRAY,String,md5_buffer,varray()); + ADDFUNC0(STRING,POOL_BYTE_ARRAY,String,sha256_buffer,varray()); ADDFUNC0(STRING,BOOL,String,empty,varray()); ADDFUNC0(STRING,BOOL,String,is_abs_path,varray()); ADDFUNC0(STRING,BOOL,String,is_rel_path,varray()); @@ -1438,8 +1438,8 @@ _VariantCall::addfunc(Variant::m_vtype,Variant::m_ret,_SCS(#m_method),VCALL(m_cl ADDFUNC1(STRING,STRING,String,pad_decimals,INT,"digits",varray()); ADDFUNC1(STRING,STRING,String,pad_zeros,INT,"digits",varray()); - ADDFUNC0(STRING,RAW_ARRAY,String,to_ascii,varray()); - ADDFUNC0(STRING,RAW_ARRAY,String,to_utf8,varray()); + ADDFUNC0(STRING,POOL_BYTE_ARRAY,String,to_ascii,varray()); + ADDFUNC0(STRING,POOL_BYTE_ARRAY,String,to_utf8,varray()); @@ -1487,8 +1487,8 @@ _VariantCall::addfunc(Variant::m_vtype,Variant::m_ret,_SCS(#m_method),VCALL(m_cl ADDFUNC4(VECTOR3,VECTOR3,Vector3,cubic_interpolate,VECTOR3,"b",VECTOR3,"pre_a",VECTOR3,"post_b",REAL,"t",varray()); ADDFUNC1(VECTOR3,REAL,Vector3,dot,VECTOR3,"b",varray()); ADDFUNC1(VECTOR3,VECTOR3,Vector3,cross,VECTOR3,"b",varray()); - ADDFUNC1(VECTOR3,MATRIX3,Vector3,outer,VECTOR3,"b",varray()); - ADDFUNC0(VECTOR3,MATRIX3,Vector3,to_diagonal_matrix,varray()); + ADDFUNC1(VECTOR3,BASIS,Vector3,outer,VECTOR3,"b",varray()); + ADDFUNC0(VECTOR3,BASIS,Vector3,to_diagonal_matrix,varray()); ADDFUNC0(VECTOR3,VECTOR3,Vector3,abs,varray()); ADDFUNC0(VECTOR3,VECTOR3,Vector3,abs,varray()); ADDFUNC0(VECTOR3,VECTOR3,Vector3,floor,varray()); @@ -1540,7 +1540,7 @@ _VariantCall::addfunc(Variant::m_vtype,Variant::m_ret,_SCS(#m_method),VCALL(m_cl ADDFUNC1(IMAGE, IMAGE, Image, compressed, INT, "format", varray(0)); ADDFUNC0(IMAGE, IMAGE, Image, decompressed, varray(0)); ADDFUNC3(IMAGE, IMAGE, Image, resized, INT, "x", INT, "y", INT, "interpolation", varray(((int)Image::INTERPOLATE_BILINEAR))); - ADDFUNC0(IMAGE, RAW_ARRAY, Image, get_data, varray()); + ADDFUNC0(IMAGE, POOL_BYTE_ARRAY, Image, get_data, varray()); ADDFUNC3(IMAGE, NIL, Image, blit_rect, IMAGE, "src", RECT2, "src_rect", VECTOR2, "dest", varray(0)); ADDFUNC1(IMAGE, IMAGE, Image, converted, INT, "format", varray(0)); ADDFUNC0(IMAGE, NIL, Image, fix_alpha_edges, varray()); @@ -1590,133 +1590,133 @@ _VariantCall::addfunc(Variant::m_vtype,Variant::m_ret,_SCS(#m_method),VCALL(m_cl ADDFUNC0(ARRAY,NIL,Array,invert,varray()); ADDFUNC0(ARRAY,BOOL,Array,is_shared,varray()); - ADDFUNC0(RAW_ARRAY,INT,ByteArray,size,varray()); - ADDFUNC2(RAW_ARRAY,NIL,ByteArray,set,INT,"idx",INT,"byte",varray()); - ADDFUNC1(RAW_ARRAY,NIL,ByteArray,push_back,INT,"byte",varray()); - ADDFUNC1(RAW_ARRAY,NIL,ByteArray,append,INT,"byte",varray()); - ADDFUNC1(RAW_ARRAY,NIL,ByteArray,append_array,RAW_ARRAY,"array",varray()); - ADDFUNC1(RAW_ARRAY,NIL,ByteArray,remove,INT,"idx",varray()); - ADDFUNC2(RAW_ARRAY,INT,ByteArray,insert,INT,"idx",INT,"byte",varray()); - ADDFUNC1(RAW_ARRAY,NIL,ByteArray,resize,INT,"idx",varray()); - ADDFUNC0(RAW_ARRAY,NIL,ByteArray,invert,varray()); - ADDFUNC2(RAW_ARRAY,RAW_ARRAY,ByteArray,subarray,INT,"from",INT,"to",varray()); - - ADDFUNC0(RAW_ARRAY,STRING,ByteArray,get_string_from_ascii,varray()); - ADDFUNC0(RAW_ARRAY,STRING,ByteArray,get_string_from_utf8,varray()); - - - ADDFUNC0(INT_ARRAY,INT,IntArray,size,varray()); - ADDFUNC2(INT_ARRAY,NIL,IntArray,set,INT,"idx",INT,"integer",varray()); - ADDFUNC1(INT_ARRAY,NIL,IntArray,push_back,INT,"integer",varray()); - ADDFUNC1(INT_ARRAY,NIL,IntArray,append,INT,"integer",varray()); - ADDFUNC1(INT_ARRAY,NIL,IntArray,append_array,INT_ARRAY,"array",varray()); - ADDFUNC1(INT_ARRAY,NIL,IntArray,remove,INT,"idx",varray()); - ADDFUNC2(INT_ARRAY,INT,IntArray,insert,INT,"idx",INT,"integer",varray()); - ADDFUNC1(INT_ARRAY,NIL,IntArray,resize,INT,"idx",varray()); - ADDFUNC0(INT_ARRAY,NIL,IntArray,invert,varray()); - - ADDFUNC0(REAL_ARRAY,INT,RealArray,size,varray()); - ADDFUNC2(REAL_ARRAY,NIL,RealArray,set,INT,"idx",REAL,"value",varray()); - ADDFUNC1(REAL_ARRAY,NIL,RealArray,push_back,REAL,"value",varray()); - ADDFUNC1(REAL_ARRAY,NIL,RealArray,append,REAL,"value",varray()); - ADDFUNC1(REAL_ARRAY,NIL,RealArray,append_array,REAL_ARRAY,"array",varray()); - ADDFUNC1(REAL_ARRAY,NIL,RealArray,remove,INT,"idx",varray()); - ADDFUNC2(REAL_ARRAY,INT,RealArray,insert,INT,"idx",REAL,"value",varray()); - ADDFUNC1(REAL_ARRAY,NIL,RealArray,resize,INT,"idx",varray()); - ADDFUNC0(REAL_ARRAY,NIL,RealArray,invert,varray()); - - ADDFUNC0(STRING_ARRAY,INT,StringArray,size,varray()); - ADDFUNC2(STRING_ARRAY,NIL,StringArray,set,INT,"idx",STRING,"string",varray()); - ADDFUNC1(STRING_ARRAY,NIL,StringArray,push_back,STRING,"string",varray()); - ADDFUNC1(STRING_ARRAY,NIL,StringArray,append,STRING,"string",varray()); - ADDFUNC1(STRING_ARRAY,NIL,StringArray,append_array,STRING_ARRAY,"array",varray()); - ADDFUNC1(STRING_ARRAY,NIL,StringArray,remove,INT,"idx",varray()); - ADDFUNC2(STRING_ARRAY,INT,StringArray,insert,INT,"idx",STRING,"string",varray()); - ADDFUNC1(STRING_ARRAY,NIL,StringArray,resize,INT,"idx",varray()); - ADDFUNC0(STRING_ARRAY,NIL,StringArray,invert,varray()); - - ADDFUNC0(VECTOR2_ARRAY,INT,Vector2Array,size,varray()); - ADDFUNC2(VECTOR2_ARRAY,NIL,Vector2Array,set,INT,"idx",VECTOR2,"vector2",varray()); - ADDFUNC1(VECTOR2_ARRAY,NIL,Vector2Array,push_back,VECTOR2,"vector2",varray()); - ADDFUNC1(VECTOR2_ARRAY,NIL,Vector2Array,append,VECTOR2,"vector2",varray()); - ADDFUNC1(VECTOR2_ARRAY,NIL,Vector2Array,append_array,VECTOR2_ARRAY,"array",varray()); - ADDFUNC1(VECTOR2_ARRAY,NIL,Vector2Array,remove,INT,"idx",varray()); - ADDFUNC2(VECTOR2_ARRAY,INT,Vector2Array,insert,INT,"idx",VECTOR2,"vector2",varray()); - ADDFUNC1(VECTOR2_ARRAY,NIL,Vector2Array,resize,INT,"idx",varray()); - ADDFUNC0(VECTOR2_ARRAY,NIL,Vector2Array,invert,varray()); - - ADDFUNC0(VECTOR3_ARRAY,INT,Vector3Array,size,varray()); - ADDFUNC2(VECTOR3_ARRAY,NIL,Vector3Array,set,INT,"idx",VECTOR3,"vector3",varray()); - ADDFUNC1(VECTOR3_ARRAY,NIL,Vector3Array,push_back,VECTOR3,"vector3",varray()); - ADDFUNC1(VECTOR3_ARRAY,NIL,Vector3Array,append,VECTOR3,"vector3",varray()); - ADDFUNC1(VECTOR3_ARRAY,NIL,Vector3Array,append_array,VECTOR3_ARRAY,"array",varray()); - ADDFUNC1(VECTOR3_ARRAY,NIL,Vector3Array,remove,INT,"idx",varray()); - ADDFUNC2(VECTOR3_ARRAY,INT,Vector3Array,insert,INT,"idx",VECTOR3,"vector3",varray()); - ADDFUNC1(VECTOR3_ARRAY,NIL,Vector3Array,resize,INT,"idx",varray()); - ADDFUNC0(VECTOR3_ARRAY,NIL,Vector3Array,invert,varray()); - - ADDFUNC0(COLOR_ARRAY,INT,ColorArray,size,varray()); - ADDFUNC2(COLOR_ARRAY,NIL,ColorArray,set,INT,"idx",COLOR,"color",varray()); - ADDFUNC1(COLOR_ARRAY,NIL,ColorArray,push_back,COLOR,"color",varray()); - ADDFUNC1(COLOR_ARRAY,NIL,ColorArray,append,COLOR,"color",varray()); - ADDFUNC1(COLOR_ARRAY,NIL,ColorArray,append_array,COLOR_ARRAY,"array",varray()); - ADDFUNC1(COLOR_ARRAY,NIL,ColorArray,remove,INT,"idx",varray()); - ADDFUNC2(COLOR_ARRAY,INT,ColorArray,insert,INT,"idx",COLOR,"color",varray()); - ADDFUNC1(COLOR_ARRAY,NIL,ColorArray,resize,INT,"idx",varray()); - ADDFUNC0(COLOR_ARRAY,NIL,ColorArray,invert,varray()); + ADDFUNC0(POOL_BYTE_ARRAY,INT,PoolByteArray,size,varray()); + ADDFUNC2(POOL_BYTE_ARRAY,NIL,PoolByteArray,set,INT,"idx",INT,"byte",varray()); + ADDFUNC1(POOL_BYTE_ARRAY,NIL,PoolByteArray,push_back,INT,"byte",varray()); + ADDFUNC1(POOL_BYTE_ARRAY,NIL,PoolByteArray,append,INT,"byte",varray()); + ADDFUNC1(POOL_BYTE_ARRAY,NIL,PoolByteArray,append_array,POOL_BYTE_ARRAY,"array",varray()); + ADDFUNC1(POOL_BYTE_ARRAY,NIL,PoolByteArray,remove,INT,"idx",varray()); + ADDFUNC2(POOL_BYTE_ARRAY,INT,PoolByteArray,insert,INT,"idx",INT,"byte",varray()); + ADDFUNC1(POOL_BYTE_ARRAY,NIL,PoolByteArray,resize,INT,"idx",varray()); + ADDFUNC0(POOL_BYTE_ARRAY,NIL,PoolByteArray,invert,varray()); + ADDFUNC2(POOL_BYTE_ARRAY,POOL_BYTE_ARRAY,PoolByteArray,subarray,INT,"from",INT,"to",varray()); + + ADDFUNC0(POOL_BYTE_ARRAY,STRING,PoolByteArray,get_string_from_ascii,varray()); + ADDFUNC0(POOL_BYTE_ARRAY,STRING,PoolByteArray,get_string_from_utf8,varray()); + + + ADDFUNC0(POOL_INT_ARRAY,INT,PoolIntArray,size,varray()); + ADDFUNC2(POOL_INT_ARRAY,NIL,PoolIntArray,set,INT,"idx",INT,"integer",varray()); + ADDFUNC1(POOL_INT_ARRAY,NIL,PoolIntArray,push_back,INT,"integer",varray()); + ADDFUNC1(POOL_INT_ARRAY,NIL,PoolIntArray,append,INT,"integer",varray()); + ADDFUNC1(POOL_INT_ARRAY,NIL,PoolIntArray,append_array,POOL_INT_ARRAY,"array",varray()); + ADDFUNC1(POOL_INT_ARRAY,NIL,PoolIntArray,remove,INT,"idx",varray()); + ADDFUNC2(POOL_INT_ARRAY,INT,PoolIntArray,insert,INT,"idx",INT,"integer",varray()); + ADDFUNC1(POOL_INT_ARRAY,NIL,PoolIntArray,resize,INT,"idx",varray()); + ADDFUNC0(POOL_INT_ARRAY,NIL,PoolIntArray,invert,varray()); + + ADDFUNC0(POOL_REAL_ARRAY,INT,PoolRealArray,size,varray()); + ADDFUNC2(POOL_REAL_ARRAY,NIL,PoolRealArray,set,INT,"idx",REAL,"value",varray()); + ADDFUNC1(POOL_REAL_ARRAY,NIL,PoolRealArray,push_back,REAL,"value",varray()); + ADDFUNC1(POOL_REAL_ARRAY,NIL,PoolRealArray,append,REAL,"value",varray()); + ADDFUNC1(POOL_REAL_ARRAY,NIL,PoolRealArray,append_array,POOL_REAL_ARRAY,"array",varray()); + ADDFUNC1(POOL_REAL_ARRAY,NIL,PoolRealArray,remove,INT,"idx",varray()); + ADDFUNC2(POOL_REAL_ARRAY,INT,PoolRealArray,insert,INT,"idx",REAL,"value",varray()); + ADDFUNC1(POOL_REAL_ARRAY,NIL,PoolRealArray,resize,INT,"idx",varray()); + ADDFUNC0(POOL_REAL_ARRAY,NIL,PoolRealArray,invert,varray()); + + ADDFUNC0(POOL_STRING_ARRAY,INT,PoolStringArray,size,varray()); + ADDFUNC2(POOL_STRING_ARRAY,NIL,PoolStringArray,set,INT,"idx",STRING,"string",varray()); + ADDFUNC1(POOL_STRING_ARRAY,NIL,PoolStringArray,push_back,STRING,"string",varray()); + ADDFUNC1(POOL_STRING_ARRAY,NIL,PoolStringArray,append,STRING,"string",varray()); + ADDFUNC1(POOL_STRING_ARRAY,NIL,PoolStringArray,append_array,POOL_STRING_ARRAY,"array",varray()); + ADDFUNC1(POOL_STRING_ARRAY,NIL,PoolStringArray,remove,INT,"idx",varray()); + ADDFUNC2(POOL_STRING_ARRAY,INT,PoolStringArray,insert,INT,"idx",STRING,"string",varray()); + ADDFUNC1(POOL_STRING_ARRAY,NIL,PoolStringArray,resize,INT,"idx",varray()); + ADDFUNC0(POOL_STRING_ARRAY,NIL,PoolStringArray,invert,varray()); + + ADDFUNC0(POOL_VECTOR2_ARRAY,INT,PoolVector2Array,size,varray()); + ADDFUNC2(POOL_VECTOR2_ARRAY,NIL,PoolVector2Array,set,INT,"idx",VECTOR2,"vector2",varray()); + ADDFUNC1(POOL_VECTOR2_ARRAY,NIL,PoolVector2Array,push_back,VECTOR2,"vector2",varray()); + ADDFUNC1(POOL_VECTOR2_ARRAY,NIL,PoolVector2Array,append,VECTOR2,"vector2",varray()); + ADDFUNC1(POOL_VECTOR2_ARRAY,NIL,PoolVector2Array,append_array,POOL_VECTOR2_ARRAY,"array",varray()); + ADDFUNC1(POOL_VECTOR2_ARRAY,NIL,PoolVector2Array,remove,INT,"idx",varray()); + ADDFUNC2(POOL_VECTOR2_ARRAY,INT,PoolVector2Array,insert,INT,"idx",VECTOR2,"vector2",varray()); + ADDFUNC1(POOL_VECTOR2_ARRAY,NIL,PoolVector2Array,resize,INT,"idx",varray()); + ADDFUNC0(POOL_VECTOR2_ARRAY,NIL,PoolVector2Array,invert,varray()); + + ADDFUNC0(POOL_VECTOR3_ARRAY,INT,PoolVector3Array,size,varray()); + ADDFUNC2(POOL_VECTOR3_ARRAY,NIL,PoolVector3Array,set,INT,"idx",VECTOR3,"vector3",varray()); + ADDFUNC1(POOL_VECTOR3_ARRAY,NIL,PoolVector3Array,push_back,VECTOR3,"vector3",varray()); + ADDFUNC1(POOL_VECTOR3_ARRAY,NIL,PoolVector3Array,append,VECTOR3,"vector3",varray()); + ADDFUNC1(POOL_VECTOR3_ARRAY,NIL,PoolVector3Array,append_array,POOL_VECTOR3_ARRAY,"array",varray()); + ADDFUNC1(POOL_VECTOR3_ARRAY,NIL,PoolVector3Array,remove,INT,"idx",varray()); + ADDFUNC2(POOL_VECTOR3_ARRAY,INT,PoolVector3Array,insert,INT,"idx",VECTOR3,"vector3",varray()); + ADDFUNC1(POOL_VECTOR3_ARRAY,NIL,PoolVector3Array,resize,INT,"idx",varray()); + ADDFUNC0(POOL_VECTOR3_ARRAY,NIL,PoolVector3Array,invert,varray()); + + ADDFUNC0(POOL_COLOR_ARRAY,INT,PoolColorArray,size,varray()); + ADDFUNC2(POOL_COLOR_ARRAY,NIL,PoolColorArray,set,INT,"idx",COLOR,"color",varray()); + ADDFUNC1(POOL_COLOR_ARRAY,NIL,PoolColorArray,push_back,COLOR,"color",varray()); + ADDFUNC1(POOL_COLOR_ARRAY,NIL,PoolColorArray,append,COLOR,"color",varray()); + ADDFUNC1(POOL_COLOR_ARRAY,NIL,PoolColorArray,append_array,POOL_COLOR_ARRAY,"array",varray()); + ADDFUNC1(POOL_COLOR_ARRAY,NIL,PoolColorArray,remove,INT,"idx",varray()); + ADDFUNC2(POOL_COLOR_ARRAY,INT,PoolColorArray,insert,INT,"idx",COLOR,"color",varray()); + ADDFUNC1(POOL_COLOR_ARRAY,NIL,PoolColorArray,resize,INT,"idx",varray()); + ADDFUNC0(POOL_COLOR_ARRAY,NIL,PoolColorArray,invert,varray()); //pointerbased - ADDFUNC0(_AABB,REAL,AABB,get_area,varray()); - ADDFUNC0(_AABB,BOOL,AABB,has_no_area,varray()); - ADDFUNC0(_AABB,BOOL,AABB,has_no_surface,varray()); - ADDFUNC1(_AABB,BOOL,AABB,intersects,_AABB,"with",varray()); - ADDFUNC1(_AABB,BOOL,AABB,encloses,_AABB,"with",varray()); - ADDFUNC1(_AABB,_AABB,AABB,merge,_AABB,"with",varray()); - ADDFUNC1(_AABB,_AABB,AABB,intersection,_AABB,"with",varray()); - ADDFUNC1(_AABB,BOOL,AABB,intersects_plane,PLANE,"plane",varray()); - ADDFUNC2(_AABB,BOOL,AABB,intersects_segment,VECTOR3,"from",VECTOR3,"to",varray()); - ADDFUNC1(_AABB,BOOL,AABB,has_point,VECTOR3,"point",varray()); - ADDFUNC1(_AABB,VECTOR3,AABB,get_support,VECTOR3,"dir",varray()); - ADDFUNC0(_AABB,VECTOR3,AABB,get_longest_axis,varray()); - ADDFUNC0(_AABB,INT,AABB,get_longest_axis_index,varray()); - ADDFUNC0(_AABB,REAL,AABB,get_longest_axis_size,varray()); - ADDFUNC0(_AABB,VECTOR3,AABB,get_shortest_axis,varray()); - ADDFUNC0(_AABB,INT,AABB,get_shortest_axis_index,varray()); - ADDFUNC0(_AABB,REAL,AABB,get_shortest_axis_size,varray()); - ADDFUNC1(_AABB,_AABB,AABB,expand,VECTOR3,"to_point",varray()); - ADDFUNC1(_AABB,_AABB,AABB,grow,REAL,"by",varray()); - ADDFUNC1(_AABB,VECTOR3,AABB,get_endpoint,INT,"idx",varray()); - - ADDFUNC0(MATRIX32,MATRIX32,Matrix32,inverse,varray()); - ADDFUNC0(MATRIX32,MATRIX32,Matrix32,affine_inverse,varray()); - ADDFUNC0(MATRIX32,REAL,Matrix32,get_rotation,varray()); - ADDFUNC0(MATRIX32,VECTOR2,Matrix32,get_origin,varray()); - ADDFUNC0(MATRIX32,VECTOR2,Matrix32,get_scale,varray()); - ADDFUNC0(MATRIX32,MATRIX32,Matrix32,orthonormalized,varray()); - ADDFUNC1(MATRIX32,MATRIX32,Matrix32,rotated,REAL,"phi",varray()); - ADDFUNC1(MATRIX32,MATRIX32,Matrix32,scaled,VECTOR2,"scale",varray()); - ADDFUNC1(MATRIX32,MATRIX32,Matrix32,translated,VECTOR2,"offset",varray()); - ADDFUNC1(MATRIX32,MATRIX32,Matrix32,xform,NIL,"v",varray()); - ADDFUNC1(MATRIX32,MATRIX32,Matrix32,xform_inv,NIL,"v",varray()); - ADDFUNC1(MATRIX32,MATRIX32,Matrix32,basis_xform,NIL,"v",varray()); - ADDFUNC1(MATRIX32,MATRIX32,Matrix32,basis_xform_inv,NIL,"v",varray()); - ADDFUNC2(MATRIX32,MATRIX32,Matrix32,interpolate_with,MATRIX32,"m",REAL,"c",varray()); - - ADDFUNC0(MATRIX3,MATRIX3,Matrix3,inverse,varray()); - ADDFUNC0(MATRIX3,MATRIX3,Matrix3,transposed,varray()); - ADDFUNC0(MATRIX3,MATRIX3,Matrix3,orthonormalized,varray()); - ADDFUNC0(MATRIX3,REAL,Matrix3,determinant,varray()); - ADDFUNC2(MATRIX3,MATRIX3,Matrix3,rotated,VECTOR3,"axis",REAL,"phi",varray()); - ADDFUNC1(MATRIX3,MATRIX3,Matrix3,scaled,VECTOR3,"scale",varray()); - ADDFUNC0(MATRIX3,VECTOR3,Matrix3,get_scale,varray()); - ADDFUNC0(MATRIX3,VECTOR3,Matrix3,get_euler,varray()); - ADDFUNC1(MATRIX3,REAL,Matrix3,tdotx,VECTOR3,"with",varray()); - ADDFUNC1(MATRIX3,REAL,Matrix3,tdoty,VECTOR3,"with",varray()); - ADDFUNC1(MATRIX3,REAL,Matrix3,tdotz,VECTOR3,"with",varray()); - ADDFUNC1(MATRIX3,VECTOR3,Matrix3,xform,VECTOR3,"v",varray()); - ADDFUNC1(MATRIX3,VECTOR3,Matrix3,xform_inv,VECTOR3,"v",varray()); - ADDFUNC0(MATRIX3,INT,Matrix3,get_orthogonal_index,varray()); + ADDFUNC0(RECT3,REAL,Rect3,get_area,varray()); + ADDFUNC0(RECT3,BOOL,Rect3,has_no_area,varray()); + ADDFUNC0(RECT3,BOOL,Rect3,has_no_surface,varray()); + ADDFUNC1(RECT3,BOOL,Rect3,intersects,RECT3,"with",varray()); + ADDFUNC1(RECT3,BOOL,Rect3,encloses,RECT3,"with",varray()); + ADDFUNC1(RECT3,RECT3,Rect3,merge,RECT3,"with",varray()); + ADDFUNC1(RECT3,RECT3,Rect3,intersection,RECT3,"with",varray()); + ADDFUNC1(RECT3,BOOL,Rect3,intersects_plane,PLANE,"plane",varray()); + ADDFUNC2(RECT3,BOOL,Rect3,intersects_segment,VECTOR3,"from",VECTOR3,"to",varray()); + ADDFUNC1(RECT3,BOOL,Rect3,has_point,VECTOR3,"point",varray()); + ADDFUNC1(RECT3,VECTOR3,Rect3,get_support,VECTOR3,"dir",varray()); + ADDFUNC0(RECT3,VECTOR3,Rect3,get_longest_axis,varray()); + ADDFUNC0(RECT3,INT,Rect3,get_longest_axis_index,varray()); + ADDFUNC0(RECT3,REAL,Rect3,get_longest_axis_size,varray()); + ADDFUNC0(RECT3,VECTOR3,Rect3,get_shortest_axis,varray()); + ADDFUNC0(RECT3,INT,Rect3,get_shortest_axis_index,varray()); + ADDFUNC0(RECT3,REAL,Rect3,get_shortest_axis_size,varray()); + ADDFUNC1(RECT3,RECT3,Rect3,expand,VECTOR3,"to_point",varray()); + ADDFUNC1(RECT3,RECT3,Rect3,grow,REAL,"by",varray()); + ADDFUNC1(RECT3,VECTOR3,Rect3,get_endpoint,INT,"idx",varray()); + + ADDFUNC0(TRANSFORM2D,TRANSFORM2D,Transform2D,inverse,varray()); + ADDFUNC0(TRANSFORM2D,TRANSFORM2D,Transform2D,affine_inverse,varray()); + ADDFUNC0(TRANSFORM2D,REAL,Transform2D,get_rotation,varray()); + ADDFUNC0(TRANSFORM2D,VECTOR2,Transform2D,get_origin,varray()); + ADDFUNC0(TRANSFORM2D,VECTOR2,Transform2D,get_scale,varray()); + ADDFUNC0(TRANSFORM2D,TRANSFORM2D,Transform2D,orthonormalized,varray()); + ADDFUNC1(TRANSFORM2D,TRANSFORM2D,Transform2D,rotated,REAL,"phi",varray()); + ADDFUNC1(TRANSFORM2D,TRANSFORM2D,Transform2D,scaled,VECTOR2,"scale",varray()); + ADDFUNC1(TRANSFORM2D,TRANSFORM2D,Transform2D,translated,VECTOR2,"offset",varray()); + ADDFUNC1(TRANSFORM2D,TRANSFORM2D,Transform2D,xform,NIL,"v",varray()); + ADDFUNC1(TRANSFORM2D,TRANSFORM2D,Transform2D,xform_inv,NIL,"v",varray()); + ADDFUNC1(TRANSFORM2D,TRANSFORM2D,Transform2D,basis_xform,NIL,"v",varray()); + ADDFUNC1(TRANSFORM2D,TRANSFORM2D,Transform2D,basis_xform_inv,NIL,"v",varray()); + ADDFUNC2(TRANSFORM2D,TRANSFORM2D,Transform2D,interpolate_with,TRANSFORM2D,"m",REAL,"c",varray()); + + ADDFUNC0(BASIS,BASIS,Basis,inverse,varray()); + ADDFUNC0(BASIS,BASIS,Basis,transposed,varray()); + ADDFUNC0(BASIS,BASIS,Basis,orthonormalized,varray()); + ADDFUNC0(BASIS,REAL,Basis,determinant,varray()); + ADDFUNC2(BASIS,BASIS,Basis,rotated,VECTOR3,"axis",REAL,"phi",varray()); + ADDFUNC1(BASIS,BASIS,Basis,scaled,VECTOR3,"scale",varray()); + ADDFUNC0(BASIS,VECTOR3,Basis,get_scale,varray()); + ADDFUNC0(BASIS,VECTOR3,Basis,get_euler,varray()); + ADDFUNC1(BASIS,REAL,Basis,tdotx,VECTOR3,"with",varray()); + ADDFUNC1(BASIS,REAL,Basis,tdoty,VECTOR3,"with",varray()); + ADDFUNC1(BASIS,REAL,Basis,tdotz,VECTOR3,"with",varray()); + ADDFUNC1(BASIS,VECTOR3,Basis,xform,VECTOR3,"v",varray()); + ADDFUNC1(BASIS,VECTOR3,Basis,xform_inv,VECTOR3,"v",varray()); + ADDFUNC0(BASIS,INT,Basis,get_orthogonal_index,varray()); ADDFUNC0(TRANSFORM,TRANSFORM,Transform,inverse,varray()); ADDFUNC0(TRANSFORM,TRANSFORM,Transform,affine_inverse,varray()); @@ -1747,8 +1747,8 @@ _VariantCall::addfunc(Variant::m_vtype,Variant::m_ret,_SCS(#m_method),VCALL(m_cl _VariantCall::add_constructor(_VariantCall::Rect2_init1,Variant::RECT2,"pos",Variant::VECTOR2,"size",Variant::VECTOR2); _VariantCall::add_constructor(_VariantCall::Rect2_init2,Variant::RECT2,"x",Variant::REAL,"y",Variant::REAL,"width",Variant::REAL,"height",Variant::REAL); - _VariantCall::add_constructor(_VariantCall::Matrix32_init2,Variant::MATRIX32,"rot",Variant::REAL,"pos",Variant::VECTOR2); - _VariantCall::add_constructor(_VariantCall::Matrix32_init3,Variant::MATRIX32,"x_axis",Variant::VECTOR2,"y_axis",Variant::VECTOR2,"origin",Variant::VECTOR2); + _VariantCall::add_constructor(_VariantCall::Transform2D_init2,Variant::TRANSFORM2D,"rot",Variant::REAL,"pos",Variant::VECTOR2); + _VariantCall::add_constructor(_VariantCall::Transform2D_init3,Variant::TRANSFORM2D,"x_axis",Variant::VECTOR2,"y_axis",Variant::VECTOR2,"origin",Variant::VECTOR2); _VariantCall::add_constructor(_VariantCall::Vector3_init1,Variant::VECTOR3,"x",Variant::REAL,"y",Variant::REAL,"z",Variant::REAL); @@ -1762,13 +1762,13 @@ _VariantCall::addfunc(Variant::m_vtype,Variant::m_ret,_SCS(#m_method),VCALL(m_cl _VariantCall::add_constructor(_VariantCall::Color_init1,Variant::COLOR,"r",Variant::REAL,"g",Variant::REAL,"b",Variant::REAL,"a",Variant::REAL); _VariantCall::add_constructor(_VariantCall::Color_init2,Variant::COLOR,"r",Variant::REAL,"g",Variant::REAL,"b",Variant::REAL); - _VariantCall::add_constructor(_VariantCall::AABB_init1,Variant::_AABB,"pos",Variant::VECTOR3,"size",Variant::VECTOR3); + _VariantCall::add_constructor(_VariantCall::Rect3_init1,Variant::RECT3,"pos",Variant::VECTOR3,"size",Variant::VECTOR3); - _VariantCall::add_constructor(_VariantCall::Matrix3_init1,Variant::MATRIX3,"x_axis",Variant::VECTOR3,"y_axis",Variant::VECTOR3,"z_axis",Variant::VECTOR3); - _VariantCall::add_constructor(_VariantCall::Matrix3_init2,Variant::MATRIX3,"axis",Variant::VECTOR3,"phi",Variant::REAL); + _VariantCall::add_constructor(_VariantCall::Basis_init1,Variant::BASIS,"x_axis",Variant::VECTOR3,"y_axis",Variant::VECTOR3,"z_axis",Variant::VECTOR3); + _VariantCall::add_constructor(_VariantCall::Basis_init2,Variant::BASIS,"axis",Variant::VECTOR3,"phi",Variant::REAL); _VariantCall::add_constructor(_VariantCall::Transform_init1,Variant::TRANSFORM,"x_axis",Variant::VECTOR3,"y_axis",Variant::VECTOR3,"z_axis",Variant::VECTOR3,"origin",Variant::VECTOR3); - _VariantCall::add_constructor(_VariantCall::Transform_init2,Variant::TRANSFORM,"basis",Variant::MATRIX3,"origin",Variant::VECTOR3); + _VariantCall::add_constructor(_VariantCall::Transform_init2,Variant::TRANSFORM,"basis",Variant::BASIS,"origin",Variant::VECTOR3); _VariantCall::add_constructor(_VariantCall::Image_init1,Variant::IMAGE,"width",Variant::INT,"height",Variant::INT,"mipmaps",Variant::BOOL,"format",Variant::INT); diff --git a/core/variant_op.cpp b/core/variant_op.cpp index 00baffdd3b..1e67d81ae2 100644 --- a/core/variant_op.cpp +++ b/core/variant_op.cpp @@ -47,12 +47,12 @@ bool Variant::booleanize(bool &r_valid) const { case STRING: return (*reinterpret_cast<const String*>(_data._mem))!=""; case VECTOR2: case RECT2: - case MATRIX32: + case TRANSFORM2D: case VECTOR3: case PLANE: - case _AABB: + case RECT3: case QUAT: - case MATRIX3: + case BASIS: case TRANSFORM: case COLOR: case IMAGE: r_valid=false; return false; @@ -62,13 +62,13 @@ bool Variant::booleanize(bool &r_valid) const { case INPUT_EVENT: case DICTIONARY: case ARRAY: - case RAW_ARRAY: - case INT_ARRAY: - case REAL_ARRAY: - case STRING_ARRAY: - case VECTOR2_ARRAY: - case VECTOR3_ARRAY: - case COLOR_ARRAY: + case POOL_BYTE_ARRAY: + case POOL_INT_ARRAY: + case POOL_REAL_ARRAY: + case POOL_STRING_ARRAY: + case POOL_VECTOR2_ARRAY: + case POOL_VECTOR3_ARRAY: + case POOL_COLOR_ARRAY: r_valid=false; return false; default: {} @@ -262,12 +262,12 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_STR(==,STRING,String); DEFAULT_OP_LOCALMEM(==,VECTOR2,Vector2); DEFAULT_OP_LOCALMEM(==,RECT2,Rect2); - DEFAULT_OP_PTRREF(==,MATRIX32,_matrix32); + DEFAULT_OP_PTRREF(==,TRANSFORM2D,_transform2d); DEFAULT_OP_LOCALMEM(==,VECTOR3,Vector3); DEFAULT_OP_LOCALMEM(==,PLANE,Plane); DEFAULT_OP_LOCALMEM(==,QUAT,Quat); - DEFAULT_OP_PTRREF(==,_AABB,_aabb); - DEFAULT_OP_PTRREF(==,MATRIX3,_matrix3); + DEFAULT_OP_PTRREF(==,RECT3,_rect3); + DEFAULT_OP_PTRREF(==,BASIS,_basis); DEFAULT_OP_PTRREF(==,TRANSFORM,_transform); DEFAULT_OP_LOCALMEM(==,COLOR,Color); @@ -316,13 +316,13 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& } break; - DEFAULT_OP_ARRAY_EQ(RAW_ARRAY,uint8_t); - DEFAULT_OP_ARRAY_EQ(INT_ARRAY,int); - DEFAULT_OP_ARRAY_EQ(REAL_ARRAY,real_t); - DEFAULT_OP_ARRAY_EQ(STRING_ARRAY,String); - DEFAULT_OP_ARRAY_EQ(VECTOR2_ARRAY,Vector3); - DEFAULT_OP_ARRAY_EQ(VECTOR3_ARRAY,Vector3); - DEFAULT_OP_ARRAY_EQ(COLOR_ARRAY,Color); + DEFAULT_OP_ARRAY_EQ(POOL_BYTE_ARRAY,uint8_t); + DEFAULT_OP_ARRAY_EQ(POOL_INT_ARRAY,int); + DEFAULT_OP_ARRAY_EQ(POOL_REAL_ARRAY,real_t); + DEFAULT_OP_ARRAY_EQ(POOL_STRING_ARRAY,String); + DEFAULT_OP_ARRAY_EQ(POOL_VECTOR2_ARRAY,Vector3); + DEFAULT_OP_ARRAY_EQ(POOL_VECTOR3_ARRAY,Vector3); + DEFAULT_OP_ARRAY_EQ(POOL_COLOR_ARRAY,Color); case VARIANT_MAX: { r_valid=false; @@ -354,12 +354,12 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_STR(<,STRING,String); DEFAULT_OP_LOCALMEM(<,VECTOR2,Vector2); DEFAULT_OP_FAIL(RECT2); - DEFAULT_OP_FAIL(MATRIX32); + DEFAULT_OP_FAIL(TRANSFORM2D); DEFAULT_OP_LOCALMEM(<,VECTOR3,Vector3); DEFAULT_OP_FAIL(PLANE); DEFAULT_OP_FAIL(QUAT); - DEFAULT_OP_FAIL(_AABB); - DEFAULT_OP_FAIL(MATRIX3); + DEFAULT_OP_FAIL(RECT3); + DEFAULT_OP_FAIL(BASIS); DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_FAIL(COLOR); @@ -393,13 +393,13 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& _RETURN( false ); } break; - DEFAULT_OP_ARRAY_LT(RAW_ARRAY,uint8_t); - DEFAULT_OP_ARRAY_LT(INT_ARRAY,int); - DEFAULT_OP_ARRAY_LT(REAL_ARRAY,real_t); - DEFAULT_OP_ARRAY_LT(STRING_ARRAY,String); - DEFAULT_OP_ARRAY_LT(VECTOR2_ARRAY,Vector3); - DEFAULT_OP_ARRAY_LT(VECTOR3_ARRAY,Vector3); - DEFAULT_OP_ARRAY_LT(COLOR_ARRAY,Color); + DEFAULT_OP_ARRAY_LT(POOL_BYTE_ARRAY,uint8_t); + DEFAULT_OP_ARRAY_LT(POOL_INT_ARRAY,int); + DEFAULT_OP_ARRAY_LT(POOL_REAL_ARRAY,real_t); + DEFAULT_OP_ARRAY_LT(POOL_STRING_ARRAY,String); + DEFAULT_OP_ARRAY_LT(POOL_VECTOR2_ARRAY,Vector3); + DEFAULT_OP_ARRAY_LT(POOL_VECTOR3_ARRAY,Vector3); + DEFAULT_OP_ARRAY_LT(POOL_COLOR_ARRAY,Color); case VARIANT_MAX: { r_valid=false; return; @@ -420,12 +420,12 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_STR(<=,STRING,String); DEFAULT_OP_LOCALMEM(<=,VECTOR2,Vector2); DEFAULT_OP_FAIL(RECT2); - DEFAULT_OP_FAIL(MATRIX32); + DEFAULT_OP_FAIL(TRANSFORM2D); DEFAULT_OP_LOCALMEM(<=,VECTOR3,Vector3); DEFAULT_OP_FAIL(PLANE); DEFAULT_OP_FAIL(QUAT); - DEFAULT_OP_FAIL(_AABB); - DEFAULT_OP_FAIL(MATRIX3); + DEFAULT_OP_FAIL(RECT3); + DEFAULT_OP_FAIL(BASIS); DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_FAIL(COLOR); @@ -440,13 +440,13 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); - DEFAULT_OP_FAIL(RAW_ARRAY); - DEFAULT_OP_FAIL(INT_ARRAY); - DEFAULT_OP_FAIL(REAL_ARRAY); - DEFAULT_OP_FAIL(STRING_ARRAY); - DEFAULT_OP_FAIL(VECTOR2_ARRAY); - DEFAULT_OP_FAIL(VECTOR3_ARRAY); - DEFAULT_OP_FAIL(COLOR_ARRAY); + DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); + DEFAULT_OP_FAIL(POOL_INT_ARRAY); + DEFAULT_OP_FAIL(POOL_REAL_ARRAY); + DEFAULT_OP_FAIL(POOL_STRING_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR2_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR3_ARRAY); + DEFAULT_OP_FAIL(POOL_COLOR_ARRAY); case VARIANT_MAX: { r_valid=false; return; @@ -484,12 +484,12 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_STR(+,STRING,String); DEFAULT_OP_LOCALMEM(+,VECTOR2,Vector2); DEFAULT_OP_FAIL(RECT2); - DEFAULT_OP_FAIL(MATRIX32); + DEFAULT_OP_FAIL(TRANSFORM2D); DEFAULT_OP_LOCALMEM(+,VECTOR3,Vector3); DEFAULT_OP_FAIL(PLANE); DEFAULT_OP_LOCALMEM(+, QUAT, Quat); - DEFAULT_OP_FAIL(_AABB); - DEFAULT_OP_FAIL(MATRIX3); + DEFAULT_OP_FAIL(RECT3); + DEFAULT_OP_FAIL(BASIS); DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_FAIL(COLOR); @@ -517,13 +517,13 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& sum[i+asize]=array_b[i]; _RETURN( sum ); } - DEFAULT_OP_ARRAY_ADD(RAW_ARRAY,uint8_t); - DEFAULT_OP_ARRAY_ADD(INT_ARRAY,int); - DEFAULT_OP_ARRAY_ADD(REAL_ARRAY,real_t); - DEFAULT_OP_ARRAY_ADD(STRING_ARRAY,String); - DEFAULT_OP_ARRAY_ADD(VECTOR2_ARRAY,Vector2); - DEFAULT_OP_ARRAY_ADD(VECTOR3_ARRAY,Vector3); - DEFAULT_OP_ARRAY_ADD(COLOR_ARRAY,Color); + DEFAULT_OP_ARRAY_ADD(POOL_BYTE_ARRAY,uint8_t); + DEFAULT_OP_ARRAY_ADD(POOL_INT_ARRAY,int); + DEFAULT_OP_ARRAY_ADD(POOL_REAL_ARRAY,real_t); + DEFAULT_OP_ARRAY_ADD(POOL_STRING_ARRAY,String); + DEFAULT_OP_ARRAY_ADD(POOL_VECTOR2_ARRAY,Vector2); + DEFAULT_OP_ARRAY_ADD(POOL_VECTOR3_ARRAY,Vector3); + DEFAULT_OP_ARRAY_ADD(POOL_COLOR_ARRAY,Color); case VARIANT_MAX: { r_valid=false; return; @@ -542,12 +542,12 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(STRING); DEFAULT_OP_LOCALMEM(-,VECTOR2,Vector2); DEFAULT_OP_FAIL(RECT2); - DEFAULT_OP_FAIL(MATRIX32); + DEFAULT_OP_FAIL(TRANSFORM2D); DEFAULT_OP_LOCALMEM(-,VECTOR3,Vector3); DEFAULT_OP_FAIL(PLANE); DEFAULT_OP_LOCALMEM(-, QUAT, Quat); - DEFAULT_OP_FAIL(_AABB); - DEFAULT_OP_FAIL(MATRIX3); + DEFAULT_OP_FAIL(RECT3); + DEFAULT_OP_FAIL(BASIS); DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_FAIL(COLOR); @@ -558,13 +558,13 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); - DEFAULT_OP_FAIL(RAW_ARRAY); - DEFAULT_OP_FAIL(INT_ARRAY); - DEFAULT_OP_FAIL(REAL_ARRAY); - DEFAULT_OP_FAIL(STRING_ARRAY); - DEFAULT_OP_FAIL(VECTOR2_ARRAY); - DEFAULT_OP_FAIL(VECTOR3_ARRAY); - DEFAULT_OP_FAIL(COLOR_ARRAY); + DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); + DEFAULT_OP_FAIL(POOL_INT_ARRAY); + DEFAULT_OP_FAIL(POOL_REAL_ARRAY); + DEFAULT_OP_FAIL(POOL_STRING_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR2_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR3_ARRAY); + DEFAULT_OP_FAIL(POOL_COLOR_ARRAY); case VARIANT_MAX: { r_valid=false; return; @@ -583,13 +583,13 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(STRING); DEFAULT_OP_LOCALMEM_NUM(*,VECTOR2,Vector2); DEFAULT_OP_FAIL(RECT2); - case MATRIX32: { + case TRANSFORM2D: { - if (p_b.type==MATRIX32) { - _RETURN( *p_a._data._matrix32 * *p_b._data._matrix32 ); + if (p_b.type==TRANSFORM2D) { + _RETURN( *p_a._data._transform2d * *p_b._data._transform2d ); }; if (p_b.type==VECTOR2) { - _RETURN( p_a._data._matrix32->xform( *(const Vector2*)p_b._data._mem) ); + _RETURN( p_a._data._transform2d->xform( *(const Vector2*)p_b._data._mem) ); }; r_valid=false; return; @@ -615,18 +615,18 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& r_valid=false; return; } break; - DEFAULT_OP_FAIL(_AABB); - case MATRIX3: { + DEFAULT_OP_FAIL(RECT3); + case BASIS: { switch(p_b.type) { case VECTOR3: { - _RETURN( p_a._data._matrix3->xform( *(const Vector3*)p_b._data._mem) ); + _RETURN( p_a._data._basis->xform( *(const Vector3*)p_b._data._mem) ); } ; - case MATRIX3: { + case BASIS: { - _RETURN( *p_a._data._matrix3 * *p_b._data._matrix3 ); + _RETURN( *p_a._data._basis * *p_b._data._basis ); }; default: {} @@ -660,13 +660,13 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); - DEFAULT_OP_FAIL(RAW_ARRAY); - DEFAULT_OP_FAIL(INT_ARRAY); - DEFAULT_OP_FAIL(REAL_ARRAY); - DEFAULT_OP_FAIL(STRING_ARRAY); - DEFAULT_OP_FAIL(VECTOR2_ARRAY); - DEFAULT_OP_FAIL(VECTOR3_ARRAY); - DEFAULT_OP_FAIL(COLOR_ARRAY); + DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); + DEFAULT_OP_FAIL(POOL_INT_ARRAY); + DEFAULT_OP_FAIL(POOL_REAL_ARRAY); + DEFAULT_OP_FAIL(POOL_STRING_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR2_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR3_ARRAY); + DEFAULT_OP_FAIL(POOL_COLOR_ARRAY); case VARIANT_MAX: { r_valid=false; return; @@ -712,7 +712,7 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(STRING); DEFAULT_OP_LOCALMEM_NUM(/,VECTOR2,Vector2); DEFAULT_OP_FAIL(RECT2); - DEFAULT_OP_FAIL(MATRIX32); + DEFAULT_OP_FAIL(TRANSFORM2D); DEFAULT_OP_LOCALMEM_NUM(/,VECTOR3,Vector3); DEFAULT_OP_FAIL(PLANE); case QUAT: { @@ -722,8 +722,8 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& } _RETURN( *reinterpret_cast<const Quat*>(p_a._data._mem) / p_b._data._real); } break; - DEFAULT_OP_FAIL(_AABB); - DEFAULT_OP_FAIL(MATRIX3); + DEFAULT_OP_FAIL(RECT3); + DEFAULT_OP_FAIL(BASIS); DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_FAIL(COLOR); @@ -734,13 +734,13 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); - DEFAULT_OP_FAIL(RAW_ARRAY); - DEFAULT_OP_FAIL(INT_ARRAY); - DEFAULT_OP_FAIL(REAL_ARRAY); - DEFAULT_OP_FAIL(STRING_ARRAY); - DEFAULT_OP_FAIL(VECTOR2_ARRAY); - DEFAULT_OP_FAIL(VECTOR3_ARRAY); - DEFAULT_OP_FAIL(COLOR_ARRAY); + DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); + DEFAULT_OP_FAIL(POOL_INT_ARRAY); + DEFAULT_OP_FAIL(POOL_REAL_ARRAY); + DEFAULT_OP_FAIL(POOL_STRING_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR2_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR3_ARRAY); + DEFAULT_OP_FAIL(POOL_COLOR_ARRAY); case VARIANT_MAX: { r_valid=false; return; @@ -757,9 +757,9 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(NIL); DEFAULT_OP_FAIL(STRING); DEFAULT_OP_FAIL(RECT2); - DEFAULT_OP_FAIL(MATRIX32); - DEFAULT_OP_FAIL(_AABB); - DEFAULT_OP_FAIL(MATRIX3); + DEFAULT_OP_FAIL(TRANSFORM2D); + DEFAULT_OP_FAIL(RECT3); + DEFAULT_OP_FAIL(BASIS); DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_NUM_POS(BOOL,_bool); DEFAULT_OP_NUM_POS(INT,_int); @@ -777,13 +777,13 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); - DEFAULT_OP_FAIL(RAW_ARRAY); - DEFAULT_OP_FAIL(INT_ARRAY); - DEFAULT_OP_FAIL(REAL_ARRAY); - DEFAULT_OP_FAIL(STRING_ARRAY); - DEFAULT_OP_FAIL(VECTOR2_ARRAY); - DEFAULT_OP_FAIL(VECTOR3_ARRAY); - DEFAULT_OP_FAIL(COLOR_ARRAY); + DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); + DEFAULT_OP_FAIL(POOL_INT_ARRAY); + DEFAULT_OP_FAIL(POOL_REAL_ARRAY); + DEFAULT_OP_FAIL(POOL_STRING_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR2_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR3_ARRAY); + DEFAULT_OP_FAIL(POOL_COLOR_ARRAY); case VARIANT_MAX: { r_valid=false; return; @@ -802,12 +802,12 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(STRING); DEFAULT_OP_LOCALMEM_NEG(VECTOR2,Vector2); DEFAULT_OP_FAIL(RECT2); - DEFAULT_OP_FAIL(MATRIX32); + DEFAULT_OP_FAIL(TRANSFORM2D); DEFAULT_OP_LOCALMEM_NEG(VECTOR3,Vector3); DEFAULT_OP_LOCALMEM_NEG(PLANE,Plane); DEFAULT_OP_LOCALMEM_NEG(QUAT,Quat); - DEFAULT_OP_FAIL(_AABB); - DEFAULT_OP_FAIL(MATRIX3); + DEFAULT_OP_FAIL(RECT3); + DEFAULT_OP_FAIL(BASIS); DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_FAIL(COLOR); @@ -818,13 +818,13 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant& DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); - DEFAULT_OP_FAIL(RAW_ARRAY); - DEFAULT_OP_FAIL(INT_ARRAY); - DEFAULT_OP_FAIL(REAL_ARRAY); - DEFAULT_OP_FAIL(STRING_ARRAY); - DEFAULT_OP_FAIL(VECTOR2_ARRAY); - DEFAULT_OP_FAIL(VECTOR3_ARRAY); - DEFAULT_OP_FAIL(COLOR_ARRAY); + DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); + DEFAULT_OP_FAIL(POOL_INT_ARRAY); + DEFAULT_OP_FAIL(POOL_REAL_ARRAY); + DEFAULT_OP_FAIL(POOL_STRING_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR2_ARRAY); + DEFAULT_OP_FAIL(POOL_VECTOR3_ARRAY); + DEFAULT_OP_FAIL(POOL_COLOR_ARRAY); case VARIANT_MAX: { r_valid=false; return; @@ -1157,7 +1157,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) } } } break; - case MATRIX32: { + case TRANSFORM2D: { if (p_value.type!=Variant::VECTOR2) return; @@ -1169,7 +1169,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) if (index<0) index += 3; if (index>=0 && index<3) { - Matrix32 *v=_data._matrix32; + Transform2D *v=_data._transform2d; valid=true; v->elements[index]=p_value; @@ -1179,7 +1179,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) //scalar name const String *str=reinterpret_cast<const String*>(p_index._data._mem); - Matrix32 *v=_data._matrix32; + Transform2D *v=_data._transform2d; if (*str=="x") { valid=true; v->elements[0]=p_value; @@ -1305,7 +1305,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) } } break; - case _AABB: { + case RECT3: { if (p_value.type!=Variant::VECTOR3) return; @@ -1315,7 +1315,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) //scalar name const String *str=reinterpret_cast<const String*>(p_index._data._mem); - AABB *v=_data._aabb; + Rect3 *v=_data._rect3; if (*str=="pos") { valid=true; v->pos=p_value; @@ -1331,7 +1331,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) } } } break; //sorry naming convention fail :( not like it's used often // 10 - case MATRIX3: { + case BASIS: { if (p_value.type!=Variant::VECTOR3) return; @@ -1343,7 +1343,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) if (index<0) index += 3; if (index>=0 && index<3) { - Matrix3 *v=_data._matrix3; + Basis *v=_data._basis; valid=true; v->set_axis(index,p_value); @@ -1352,7 +1352,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) } else if (p_index.get_type()==Variant::STRING) { const String *str=reinterpret_cast<const String*>(p_index._data._mem); - Matrix3 *v=_data._matrix3; + Basis *v=_data._basis; if (*str=="x") { valid=true; @@ -1398,7 +1398,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) if (*str=="basis") { - if (p_value.type!=Variant::MATRIX3) + if (p_value.type!=Variant::BASIS) return; valid=true; v->basis=p_value; @@ -1887,13 +1887,13 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) return; } break; // 20 DEFAULT_OP_ARRAY_CMD(ARRAY, Array, ;, (*arr)[index]=p_value;return) - DEFAULT_OP_DVECTOR_SET(RAW_ARRAY, uint8_t, p_value.type != Variant::REAL && p_value.type != Variant::INT) - DEFAULT_OP_DVECTOR_SET(INT_ARRAY, int, p_value.type != Variant::REAL && p_value.type != Variant::INT) - DEFAULT_OP_DVECTOR_SET(REAL_ARRAY, real_t, p_value.type != Variant::REAL && p_value.type != Variant::INT) - DEFAULT_OP_DVECTOR_SET(STRING_ARRAY, String, p_value.type != Variant::STRING) // 25 - DEFAULT_OP_DVECTOR_SET(VECTOR2_ARRAY, Vector2, p_value.type != Variant::VECTOR2) - DEFAULT_OP_DVECTOR_SET(VECTOR3_ARRAY, Vector3, p_value.type != Variant::VECTOR3) - DEFAULT_OP_DVECTOR_SET(COLOR_ARRAY, Color, p_value.type != Variant::COLOR) + DEFAULT_OP_DVECTOR_SET(POOL_BYTE_ARRAY, uint8_t, p_value.type != Variant::REAL && p_value.type != Variant::INT) + DEFAULT_OP_DVECTOR_SET(POOL_INT_ARRAY, int, p_value.type != Variant::REAL && p_value.type != Variant::INT) + DEFAULT_OP_DVECTOR_SET(POOL_REAL_ARRAY, real_t, p_value.type != Variant::REAL && p_value.type != Variant::INT) + DEFAULT_OP_DVECTOR_SET(POOL_STRING_ARRAY, String, p_value.type != Variant::STRING) // 25 + DEFAULT_OP_DVECTOR_SET(POOL_VECTOR2_ARRAY, Vector2, p_value.type != Variant::VECTOR2) + DEFAULT_OP_DVECTOR_SET(POOL_VECTOR3_ARRAY, Vector3, p_value.type != Variant::VECTOR3) + DEFAULT_OP_DVECTOR_SET(POOL_COLOR_ARRAY, Color, p_value.type != Variant::COLOR) default: return; } @@ -2007,7 +2007,7 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const { } } break; - case MATRIX32: { + case TRANSFORM2D: { if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) { @@ -2016,7 +2016,7 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const { if (index<0) index += 3; if (index>=0 && index<3) { - const Matrix32 *v=_data._matrix32; + const Transform2D *v=_data._transform2d; valid=true; return v->elements[index]; @@ -2025,7 +2025,7 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const { //scalar name const String *str=reinterpret_cast<const String*>(p_index._data._mem); - const Matrix32 *v=_data._matrix32; + const Transform2D *v=_data._transform2d; if (*str=="x") { valid=true; return v->elements[0]; @@ -2086,13 +2086,13 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const { } } break; - case _AABB: { + case RECT3: { if (p_index.get_type()==Variant::STRING) { //scalar name const String *str=reinterpret_cast<const String*>(p_index._data._mem); - const AABB *v=_data._aabb; + const Rect3 *v=_data._rect3; if (*str=="pos") { valid=true; return v->pos; @@ -2105,7 +2105,7 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const { } } } break; //sorry naming convention fail :( not like it's used often // 10 - case MATRIX3: { + case BASIS: { if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) { @@ -2113,7 +2113,7 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const { if (index<0) index += 3; if (index>=0 && index<3) { - const Matrix3 *v=_data._matrix3; + const Basis *v=_data._basis; valid=true; return v->get_axis(index); @@ -2121,7 +2121,7 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const { } else if (p_index.get_type()==Variant::STRING) { const String *str=reinterpret_cast<const String*>(p_index._data._mem); - const Matrix3 *v=_data._matrix3; + const Basis *v=_data._basis; if (*str=="x") { valid=true; @@ -2471,13 +2471,13 @@ Variant Variant::get(const Variant& p_index, bool *r_valid) const { } } break; // 20 DEFAULT_OP_ARRAY_CMD(ARRAY, const Array, ;, return (*arr)[index]) - DEFAULT_OP_DVECTOR_GET(RAW_ARRAY, uint8_t) - DEFAULT_OP_DVECTOR_GET(INT_ARRAY, int) - DEFAULT_OP_DVECTOR_GET(REAL_ARRAY, real_t) - DEFAULT_OP_DVECTOR_GET(STRING_ARRAY, String) - DEFAULT_OP_DVECTOR_GET(VECTOR2_ARRAY, Vector2) - DEFAULT_OP_DVECTOR_GET(VECTOR3_ARRAY, Vector3) - DEFAULT_OP_DVECTOR_GET(COLOR_ARRAY, Color) + DEFAULT_OP_DVECTOR_GET(POOL_BYTE_ARRAY, uint8_t) + DEFAULT_OP_DVECTOR_GET(POOL_INT_ARRAY, int) + DEFAULT_OP_DVECTOR_GET(POOL_REAL_ARRAY, real_t) + DEFAULT_OP_DVECTOR_GET(POOL_STRING_ARRAY, String) + DEFAULT_OP_DVECTOR_GET(POOL_VECTOR2_ARRAY, Vector2) + DEFAULT_OP_DVECTOR_GET(POOL_VECTOR3_ARRAY, Vector3) + DEFAULT_OP_DVECTOR_GET(POOL_COLOR_ARRAY, Color) default: return Variant(); } @@ -2557,7 +2557,7 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { return false; } break; - case RAW_ARRAY: { + case POOL_BYTE_ARRAY: { if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) { int index = p_index; @@ -2576,7 +2576,7 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { } } break; - case INT_ARRAY: { + case POOL_INT_ARRAY: { if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) { int index = p_index; @@ -2594,7 +2594,7 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { return false; } } break; - case REAL_ARRAY: { + case POOL_REAL_ARRAY: { if (p_index.get_type()==Variant::INT || p_index.get_type()==Variant::REAL) { @@ -2614,7 +2614,7 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { } } break; - case STRING_ARRAY: { + case POOL_STRING_ARRAY: { if (p_index.get_type()==Variant::STRING) { String index = p_index; @@ -2634,7 +2634,7 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { } } break; //25 - case VECTOR2_ARRAY: { + case POOL_VECTOR2_ARRAY: { if (p_index.get_type()==Variant::VECTOR2) { Vector2 index = p_index; @@ -2654,7 +2654,7 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { } } break; - case VECTOR3_ARRAY: { + case POOL_VECTOR3_ARRAY: { if (p_index.get_type()==Variant::VECTOR3) { Vector3 index = p_index; @@ -2674,7 +2674,7 @@ bool Variant::in(const Variant& p_index, bool *r_valid) const { } } break; - case COLOR_ARRAY: { + case POOL_COLOR_ARRAY: { if (p_index.get_type()==Variant::COLOR) { @@ -2729,7 +2729,7 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { p_list->push_back( PropertyInfo(Variant::REAL,"z")); } break; - case MATRIX32: { + case TRANSFORM2D: { p_list->push_back( PropertyInfo(Variant::VECTOR2,"x")); p_list->push_back( PropertyInfo(Variant::VECTOR2,"y")); @@ -2753,12 +2753,12 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { p_list->push_back( PropertyInfo(Variant::REAL,"w")); } break; - case _AABB: { + case RECT3: { p_list->push_back( PropertyInfo(Variant::VECTOR3,"pos")); p_list->push_back( PropertyInfo(Variant::VECTOR3,"size")); p_list->push_back( PropertyInfo(Variant::VECTOR3,"end")); } break; //sorry naming convention fail :( not like it's used often // 10 - case MATRIX3: { + case BASIS: { p_list->push_back( PropertyInfo(Variant::VECTOR3,"x")); p_list->push_back( PropertyInfo(Variant::VECTOR3,"y")); @@ -2767,7 +2767,7 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { } break; case TRANSFORM: { - p_list->push_back( PropertyInfo(Variant::MATRIX3,"basis")); + p_list->push_back( PropertyInfo(Variant::BASIS,"basis")); p_list->push_back( PropertyInfo(Variant::VECTOR3,"origin")); } break; @@ -2914,12 +2914,12 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { } } break; // 20 case ARRAY: - case RAW_ARRAY: - case INT_ARRAY: - case REAL_ARRAY: - case STRING_ARRAY: - case VECTOR3_ARRAY: - case COLOR_ARRAY: { + case POOL_BYTE_ARRAY: + case POOL_INT_ARRAY: + case POOL_REAL_ARRAY: + case POOL_STRING_ARRAY: + case POOL_VECTOR3_ARRAY: + case POOL_COLOR_ARRAY: { //nothing } break; @@ -2991,7 +2991,7 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const { r_iter=0; return true; } break; - case RAW_ARRAY: { + case POOL_BYTE_ARRAY: { const PoolVector<uint8_t> *arr=reinterpret_cast<const PoolVector<uint8_t>*>(_data._mem); if (arr->size()==0) return false; @@ -2999,7 +2999,7 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const { return true; } break; - case INT_ARRAY: { + case POOL_INT_ARRAY: { const PoolVector<int> *arr=reinterpret_cast<const PoolVector<int>*>(_data._mem); if (arr->size()==0) return false; @@ -3007,7 +3007,7 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const { return true; } break; - case REAL_ARRAY: { + case POOL_REAL_ARRAY: { const PoolVector<real_t> *arr=reinterpret_cast<const PoolVector<real_t>*>(_data._mem); if (arr->size()==0) return false; @@ -3015,14 +3015,14 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const { return true; } break; - case STRING_ARRAY: { + case POOL_STRING_ARRAY: { const PoolVector<String> *arr=reinterpret_cast<const PoolVector<String>*>(_data._mem); if (arr->size()==0) return false; r_iter=0; return true; } break; - case VECTOR2_ARRAY: { + case POOL_VECTOR2_ARRAY: { const PoolVector<Vector2> *arr=reinterpret_cast<const PoolVector<Vector2>*>(_data._mem); if (arr->size()==0) @@ -3030,7 +3030,7 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const { r_iter=0; return true; } break; - case VECTOR3_ARRAY: { + case POOL_VECTOR3_ARRAY: { const PoolVector<Vector3> *arr=reinterpret_cast<const PoolVector<Vector3>*>(_data._mem); if (arr->size()==0) @@ -3038,7 +3038,7 @@ bool Variant::iter_init(Variant& r_iter,bool &valid) const { r_iter=0; return true; } break; - case COLOR_ARRAY: { + case POOL_COLOR_ARRAY: { const PoolVector<Color> *arr=reinterpret_cast<const PoolVector<Color>*>(_data._mem); if (arr->size()==0) @@ -3122,7 +3122,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { r_iter=idx; return true; } break; - case RAW_ARRAY: { + case POOL_BYTE_ARRAY: { const PoolVector<uint8_t> *arr=reinterpret_cast<const PoolVector<uint8_t>*>(_data._mem); int idx=r_iter; idx++; @@ -3132,7 +3132,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { return true; } break; - case INT_ARRAY: { + case POOL_INT_ARRAY: { const PoolVector<int> *arr=reinterpret_cast<const PoolVector<int>*>(_data._mem); int idx=r_iter; idx++; @@ -3142,7 +3142,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { return true; } break; - case REAL_ARRAY: { + case POOL_REAL_ARRAY: { const PoolVector<real_t> *arr=reinterpret_cast<const PoolVector<real_t>*>(_data._mem); int idx=r_iter; idx++; @@ -3152,7 +3152,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { return true; } break; - case STRING_ARRAY: { + case POOL_STRING_ARRAY: { const PoolVector<String> *arr=reinterpret_cast<const PoolVector<String>*>(_data._mem); int idx=r_iter; idx++; @@ -3161,7 +3161,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { r_iter=idx; return true; } break; - case VECTOR2_ARRAY: { + case POOL_VECTOR2_ARRAY: { const PoolVector<Vector2> *arr=reinterpret_cast<const PoolVector<Vector2>*>(_data._mem); int idx=r_iter; @@ -3171,7 +3171,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { r_iter=idx; return true; } break; - case VECTOR3_ARRAY: { + case POOL_VECTOR3_ARRAY: { const PoolVector<Vector3> *arr=reinterpret_cast<const PoolVector<Vector3>*>(_data._mem); int idx=r_iter; @@ -3181,7 +3181,7 @@ bool Variant::iter_next(Variant& r_iter,bool &valid) const { r_iter=idx; return true; } break; - case COLOR_ARRAY: { + case POOL_COLOR_ARRAY: { const PoolVector<Color> *arr=reinterpret_cast<const PoolVector<Color>*>(_data._mem); int idx=r_iter; @@ -3254,7 +3254,7 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { #endif return arr->get(idx); } break; - case RAW_ARRAY: { + case POOL_BYTE_ARRAY: { const PoolVector<uint8_t> *arr=reinterpret_cast<const PoolVector<uint8_t>*>(_data._mem); int idx=r_iter; #ifdef DEBUG_ENABLED @@ -3265,7 +3265,7 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { #endif return arr->get(idx); } break; - case INT_ARRAY: { + case POOL_INT_ARRAY: { const PoolVector<int> *arr=reinterpret_cast<const PoolVector<int>*>(_data._mem); int idx=r_iter; #ifdef DEBUG_ENABLED @@ -3276,7 +3276,7 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { #endif return arr->get(idx); } break; - case REAL_ARRAY: { + case POOL_REAL_ARRAY: { const PoolVector<real_t> *arr=reinterpret_cast<const PoolVector<real_t>*>(_data._mem); int idx=r_iter; #ifdef DEBUG_ENABLED @@ -3287,7 +3287,7 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { #endif return arr->get(idx); } break; - case STRING_ARRAY: { + case POOL_STRING_ARRAY: { const PoolVector<String> *arr=reinterpret_cast<const PoolVector<String>*>(_data._mem); int idx=r_iter; #ifdef DEBUG_ENABLED @@ -3298,7 +3298,7 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { #endif return arr->get(idx); } break; - case VECTOR2_ARRAY: { + case POOL_VECTOR2_ARRAY: { const PoolVector<Vector2> *arr=reinterpret_cast<const PoolVector<Vector2>*>(_data._mem); int idx=r_iter; @@ -3310,7 +3310,7 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { #endif return arr->get(idx); } break; - case VECTOR3_ARRAY: { + case POOL_VECTOR3_ARRAY: { const PoolVector<Vector3> *arr=reinterpret_cast<const PoolVector<Vector3>*>(_data._mem); int idx=r_iter; @@ -3322,7 +3322,7 @@ Variant Variant::iter_get(const Variant& r_iter,bool &r_valid) const { #endif return arr->get(idx); } break; - case COLOR_ARRAY: { + case POOL_COLOR_ARRAY: { const PoolVector<Color> *arr=reinterpret_cast<const PoolVector<Color>*>(_data._mem); int idx=r_iter; @@ -3374,10 +3374,10 @@ void Variant::blend(const Variant& a, const Variant& b, float c, Variant &r_dst) r_dst=Rect2(ra->pos + rb->pos * c, ra->size + rb->size * c); } return; case VECTOR3:{ r_dst=*reinterpret_cast<const Vector3*>(a._data._mem)+*reinterpret_cast<const Vector3*>(b._data._mem)*c; } return; - case _AABB:{ - const AABB *ra = reinterpret_cast<const AABB*>(a._data._mem); - const AABB *rb = reinterpret_cast<const AABB*>(b._data._mem); - r_dst=AABB(ra->pos + rb->pos * c, ra->size + rb->size * c); + case RECT3:{ + const Rect3 *ra = reinterpret_cast<const Rect3*>(a._data._mem); + const Rect3 *rb = reinterpret_cast<const Rect3*>(b._data._mem); + r_dst=Rect3(ra->pos + rb->pos * c, ra->size + rb->size * c); } return; case QUAT:{ Quat empty_rot; @@ -3476,11 +3476,11 @@ void Variant::interpolate(const Variant& a, const Variant& b, float c,Variant &r case VECTOR2:{ r_dst=reinterpret_cast<const Vector2*>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Vector2*>(b._data._mem),c); } return; case RECT2:{ r_dst = Rect2( reinterpret_cast<const Rect2*>(a._data._mem)->pos.linear_interpolate(reinterpret_cast<const Rect2*>(b._data._mem)->pos,c), reinterpret_cast<const Rect2*>(a._data._mem)->size.linear_interpolate(reinterpret_cast<const Rect2*>(b._data._mem)->size,c) ); } return; case VECTOR3:{ r_dst=reinterpret_cast<const Vector3*>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Vector3*>(b._data._mem),c); } return; - case MATRIX32:{ r_dst=a._data._matrix32->interpolate_with(*b._data._matrix32,c); } return; + case TRANSFORM2D:{ r_dst=a._data._transform2d->interpolate_with(*b._data._transform2d,c); } return; case PLANE:{ r_dst=a; } return; case QUAT:{ r_dst=reinterpret_cast<const Quat*>(a._data._mem)->slerp(*reinterpret_cast<const Quat*>(b._data._mem),c); } return; - case _AABB:{ r_dst=AABB( a._data._aabb->pos.linear_interpolate(b._data._aabb->pos,c), a._data._aabb->size.linear_interpolate(b._data._aabb->size,c) ); } return; - case MATRIX3:{ r_dst=Transform(*a._data._matrix3).interpolate_with(Transform(*b._data._matrix3),c).basis; } return; + case RECT3:{ r_dst=Rect3( a._data._rect3->pos.linear_interpolate(b._data._rect3->pos,c), a._data._rect3->size.linear_interpolate(b._data._rect3->size,c) ); } return; + case BASIS:{ r_dst=Transform(*a._data._basis).interpolate_with(Transform(*b._data._basis),c).basis; } return; case TRANSFORM:{ r_dst=a._data._transform->interpolate_with(*b._data._transform,c); } return; case COLOR:{ r_dst=reinterpret_cast<const Color*>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Color*>(b._data._mem),c); } return; case IMAGE:{ r_dst=a; } return; @@ -3490,11 +3490,11 @@ void Variant::interpolate(const Variant& a, const Variant& b, float c,Variant &r case INPUT_EVENT:{ r_dst=a; } return; case DICTIONARY:{ } return; case ARRAY:{ r_dst=a; } return; - case RAW_ARRAY:{ r_dst=a; } return; - case INT_ARRAY:{ r_dst=a; } return; - case REAL_ARRAY:{ r_dst=a; } return; - case STRING_ARRAY:{ r_dst=a; } return; - case VECTOR2_ARRAY:{ + case POOL_BYTE_ARRAY:{ r_dst=a; } return; + case POOL_INT_ARRAY:{ r_dst=a; } return; + case POOL_REAL_ARRAY:{ r_dst=a; } return; + case POOL_STRING_ARRAY:{ r_dst=a; } return; + case POOL_VECTOR2_ARRAY:{ const PoolVector<Vector2> *arr_a=reinterpret_cast<const PoolVector<Vector2>* >(a._data._mem); const PoolVector<Vector2> *arr_b=reinterpret_cast<const PoolVector<Vector2>* >(b._data._mem); int sz = arr_a->size(); @@ -3520,7 +3520,7 @@ void Variant::interpolate(const Variant& a, const Variant& b, float c,Variant &r } return; - case VECTOR3_ARRAY:{ + case POOL_VECTOR3_ARRAY:{ const PoolVector<Vector3> *arr_a=reinterpret_cast<const PoolVector<Vector3>* >(a._data._mem); @@ -3547,7 +3547,7 @@ void Variant::interpolate(const Variant& a, const Variant& b, float c,Variant &r } } return; - case COLOR_ARRAY:{ r_dst=a; } return; + case POOL_COLOR_ARRAY:{ r_dst=a; } return; default: { r_dst=a; diff --git a/core/variant_parser.cpp b/core/variant_parser.cpp index 1a11eb80d5..402c8d41da 100644 --- a/core/variant_parser.cpp +++ b/core/variant_parser.cpp @@ -614,7 +614,7 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in value=Vector3(args[0],args[1],args[2]); return OK; - } else if (id=="Matrix32"){ + } else if (id=="Transform2D" || id=="Matrix32"){ //compatibility Vector<float> args; Error err = _parse_construct<float>(p_stream,args,line,r_err_str); @@ -624,7 +624,7 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in if (args.size()!=6) { r_err_str="Expected 6 arguments for constructor"; } - Matrix32 m; + Transform2D m; m[0]=Vector2(args[0],args[1]); m[1]=Vector2(args[2],args[3]); m[2]=Vector2(args[4],args[5]); @@ -657,7 +657,7 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in value=Quat(args[0],args[1],args[2],args[3]); return OK; - } else if (id=="AABB"){ + } else if (id=="Rect3" || id=="AABB"){ Vector<float> args; Error err = _parse_construct<float>(p_stream,args,line,r_err_str); @@ -668,10 +668,10 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in r_err_str="Expected 6 arguments for constructor"; } - value=AABB(Vector3(args[0],args[1],args[2]),Vector3(args[3],args[4],args[5])); + value=Rect3(Vector3(args[0],args[1],args[2]),Vector3(args[3],args[4],args[5])); return OK; - } else if (id=="Matrix3"){ + } else if (id=="Basis" || id=="Matrix3"){ //compatibility Vector<float> args; Error err = _parse_construct<float>(p_stream,args,line,r_err_str); @@ -682,7 +682,7 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in r_err_str="Expected 9 arguments for constructor"; } - value=Matrix3(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8]); + value=Basis(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8]); return OK; } else if (id=="Transform"){ @@ -695,7 +695,7 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in r_err_str="Expected 12 arguments for constructor"; } - value=Transform(Matrix3(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8]),Vector3(args[9],args[10],args[11])); + value=Transform(Basis(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8]),Vector3(args[9],args[10],args[11])); return OK; } else if (id=="Color") { @@ -1149,7 +1149,7 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in return OK; - } else if (id=="ByteArray") { + } else if (id=="PoolByteArray"|| id=="ByteArray") { Vector<uint8_t> args; Error err = _parse_construct<uint8_t>(p_stream,args,line,r_err_str); @@ -1170,7 +1170,7 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in return OK; - } else if (id=="IntArray") { + } else if (id=="PoolIntArray"|| id=="IntArray") { Vector<int> args; Error err = _parse_construct<int>(p_stream,args,line,r_err_str); @@ -1191,7 +1191,7 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in return OK; - } else if (id=="FloatArray") { + } else if (id=="PoolFloatArray"|| id=="FloatArray") { Vector<float> args; Error err = _parse_construct<float>(p_stream,args,line,r_err_str); @@ -1211,7 +1211,7 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in value=arr; return OK; - } else if (id=="StringArray") { + } else if (id=="PoolStringArray"|| id=="StringArray") { get_token(p_stream,token,line,r_err_str); @@ -1266,7 +1266,7 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in return OK; - } else if (id=="Vector2Array") { + } else if (id=="PoolVector2Array"|| id=="Vector2Array") { Vector<float> args; Error err = _parse_construct<float>(p_stream,args,line,r_err_str); @@ -1287,7 +1287,7 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in return OK; - } else if (id=="Vector3Array") { + } else if (id=="PoolVector3Array"|| id=="Vector3Array") { Vector<float> args; Error err = _parse_construct<float>(p_stream,args,line,r_err_str); @@ -1308,7 +1308,7 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in return OK; - } else if (id=="ColorArray") { + } else if (id=="PoolColorArray"|| id=="ColorArray") { Vector<float> args; Error err = _parse_construct<float>(p_stream,args,line,r_err_str); @@ -1898,10 +1898,10 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str p_store_string_func(p_store_string_ud,"Plane( "+rtosfix(p.normal.x) +", "+rtosfix(p.normal.y)+", "+rtosfix(p.normal.z)+", "+rtosfix(p.d)+" )" ); } break; - case Variant::_AABB: { + case Variant::RECT3: { - AABB aabb = p_variant; - p_store_string_func(p_store_string_ud,"AABB( "+rtosfix(aabb.pos.x) +", "+rtosfix(aabb.pos.y) +", "+rtosfix(aabb.pos.z) +", "+rtosfix(aabb.size.x) +", "+rtosfix(aabb.size.y) +", "+rtosfix(aabb.size.z)+" )" ); + Rect3 aabb = p_variant; + p_store_string_func(p_store_string_ud,"Rect3( "+rtosfix(aabb.pos.x) +", "+rtosfix(aabb.pos.y) +", "+rtosfix(aabb.pos.z) +", "+rtosfix(aabb.size.x) +", "+rtosfix(aabb.size.y) +", "+rtosfix(aabb.size.z)+" )" ); } break; case Variant::QUAT: { @@ -1910,10 +1910,10 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str p_store_string_func(p_store_string_ud,"Quat( "+rtosfix(quat.x)+", "+rtosfix(quat.y)+", "+rtosfix(quat.z)+", "+rtosfix(quat.w)+" )"); } break; - case Variant::MATRIX32: { + case Variant::TRANSFORM2D: { - String s="Matrix32( "; - Matrix32 m3 = p_variant; + String s="Transform2D( "; + Transform2D m3 = p_variant; for (int i=0;i<3;i++) { for (int j=0;j<2;j++) { @@ -1926,10 +1926,10 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str p_store_string_func(p_store_string_ud,s+" )"); } break; - case Variant::MATRIX3: { + case Variant::BASIS: { - String s="Matrix3( "; - Matrix3 m3 = p_variant; + String s="Basis( "; + Basis m3 = p_variant; for (int i=0;i<3;i++) { for (int j=0;j<3;j++) { @@ -1946,7 +1946,7 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str String s="Transform( "; Transform t = p_variant; - Matrix3 &m3 = t.basis; + Basis &m3 = t.basis; for (int i=0;i<3;i++) { for (int j=0;j<3;j++) { @@ -2124,9 +2124,9 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str } break; - case Variant::RAW_ARRAY: { + case Variant::POOL_BYTE_ARRAY: { - p_store_string_func(p_store_string_ud,"ByteArray( "); + p_store_string_func(p_store_string_ud,"PoolByteArray( "); String s; PoolVector<uint8_t> data = p_variant; int len = data.size(); @@ -2144,9 +2144,9 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str p_store_string_func(p_store_string_ud," )"); } break; - case Variant::INT_ARRAY: { + case Variant::POOL_INT_ARRAY: { - p_store_string_func(p_store_string_ud,"IntArray( "); + p_store_string_func(p_store_string_ud,"PoolIntArray( "); PoolVector<int> data = p_variant; int len = data.size(); PoolVector<int>::Read r = data.read(); @@ -2164,9 +2164,9 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str p_store_string_func(p_store_string_ud," )"); } break; - case Variant::REAL_ARRAY: { + case Variant::POOL_REAL_ARRAY: { - p_store_string_func(p_store_string_ud,"FloatArray( "); + p_store_string_func(p_store_string_ud,"PoolFloatArray( "); PoolVector<real_t> data = p_variant; int len = data.size(); PoolVector<real_t>::Read r = data.read(); @@ -2182,9 +2182,9 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str p_store_string_func(p_store_string_ud," )"); } break; - case Variant::STRING_ARRAY: { + case Variant::POOL_STRING_ARRAY: { - p_store_string_func(p_store_string_ud,"StringArray( "); + p_store_string_func(p_store_string_ud,"PoolStringArray( "); PoolVector<String> data = p_variant; int len = data.size(); PoolVector<String>::Read r = data.read(); @@ -2205,9 +2205,9 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str p_store_string_func(p_store_string_ud," )"); } break; - case Variant::VECTOR2_ARRAY: { + case Variant::POOL_VECTOR2_ARRAY: { - p_store_string_func(p_store_string_ud,"Vector2Array( "); + p_store_string_func(p_store_string_ud,"PoolVector2Array( "); PoolVector<Vector2> data = p_variant; int len = data.size(); PoolVector<Vector2>::Read r = data.read(); @@ -2223,9 +2223,9 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str p_store_string_func(p_store_string_ud," )"); } break; - case Variant::VECTOR3_ARRAY: { + case Variant::POOL_VECTOR3_ARRAY: { - p_store_string_func(p_store_string_ud,"Vector3Array( "); + p_store_string_func(p_store_string_ud,"PoolVector3Array( "); PoolVector<Vector3> data = p_variant; int len = data.size(); PoolVector<Vector3>::Read r = data.read(); @@ -2241,9 +2241,9 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str p_store_string_func(p_store_string_ud," )"); } break; - case Variant::COLOR_ARRAY: { + case Variant::POOL_COLOR_ARRAY: { - p_store_string_func(p_store_string_ud,"ColorArray( "); + p_store_string_func(p_store_string_ud,"PoolColorArray( "); PoolVector<Color> data = p_variant; int len = data.size(); |