diff options
Diffstat (limited to 'modules')
47 files changed, 1013 insertions, 1936 deletions
diff --git a/modules/dds/texture_loader_dds.cpp b/modules/dds/texture_loader_dds.cpp index f80e6e501..4448c8038 100644 --- a/modules/dds/texture_loader_dds.cpp +++ b/modules/dds/texture_loader_dds.cpp @@ -144,12 +144,14 @@ RES ResourceFormatDDS::load(const String &p_path, const String &p_original_path, f->get_32(); f->get_32(); - /*print_line("DDS width: "+itos(width)); + /* + print_line("DDS width: "+itos(width)); print_line("DDS height: "+itos(height)); - print_line("DDS mipmaps: "+itos(mipmaps));*/ + print_line("DDS mipmaps: "+itos(mipmaps)); - //printf("fourcc: %x fflags: %x, rgbbits: %x, fsize: %x\n",format_fourcc,format_flags,format_rgb_bits,format_size); - //printf("rmask: %x gmask: %x, bmask: %x, amask: %x\n",format_red_mask,format_green_mask,format_blue_mask,format_alpha_mask); + printf("fourcc: %x fflags: %x, rgbbits: %x, fsize: %x\n",format_fourcc,format_flags,format_rgb_bits,format_size); + printf("rmask: %x gmask: %x, bmask: %x, amask: %x\n",format_red_mask,format_green_mask,format_blue_mask,format_alpha_mask); + */ //must avoid this later while (f->get_pos() < 128) @@ -439,7 +441,7 @@ RES ResourceFormatDDS::load(const String &p_path, const String &p_original_path, wb = PoolVector<uint8_t>::Write(); } - Image img(width, height, mipmaps - 1, info.format, src_data); + Ref<Image> img = memnew(Image(width, height, mipmaps - 1, info.format, src_data)); Ref<ImageTexture> texture = memnew(ImageTexture); texture->create_from_image(img); diff --git a/modules/etc1/image_etc.cpp b/modules/etc1/image_etc.cpp index 60544594f..121f50684 100644 --- a/modules/etc1/image_etc.cpp +++ b/modules/etc1/image_etc.cpp @@ -88,25 +88,26 @@ static void _decompress_etc(Image *p_img) { r = PoolVector<uint8_t>::Read(); //print_line("Re Creating ETC into regular image: w "+itos(p_img->get_width())+" h "+itos(p_img->get_height())+" mm "+itos(p_img->get_mipmaps())); - *p_img = Image(p_img->get_width(), p_img->get_height(), p_img->has_mipmaps(), Image::FORMAT_RGB8, dst); - if (p_img->has_mipmaps()) + bool needs_mipmaps = p_img->has_mipmaps(); + p_img->create(p_img->get_width(), p_img->get_height(), p_img->has_mipmaps(), Image::FORMAT_RGB8, dst); + if (needs_mipmaps) p_img->generate_mipmaps(); } static void _compress_etc(Image *p_img) { - Image img = *p_img; + Ref<Image> img = p_img->duplicate(); - int imgw = img.get_width(), imgh = img.get_height(); + int imgw = img->get_width(), imgh = img->get_height(); ERR_FAIL_COND(nearest_power_of_2(imgw) != imgw || nearest_power_of_2(imgh) != imgh); - if (img.get_format() != Image::FORMAT_RGB8) - img.convert(Image::FORMAT_RGB8); + if (img->get_format() != Image::FORMAT_RGB8) + img->convert(Image::FORMAT_RGB8); PoolVector<uint8_t> res_data; PoolVector<uint8_t> dst_data; - PoolVector<uint8_t>::Read r = img.get_data().read(); + PoolVector<uint8_t>::Read r = img->get_data().read(); int target_size = Image::get_image_data_size(p_img->get_width(), p_img->get_height(), Image::FORMAT_ETC, p_img->has_mipmaps() ? -1 : 0); int mmc = p_img->has_mipmaps() ? Image::get_image_required_mipmaps(p_img->get_width(), p_img->get_height(), Image::FORMAT_ETC) : 0; @@ -122,7 +123,7 @@ static void _compress_etc(Image *p_img) { int bw = MAX(imgw / 4, 1); int bh = MAX(imgh / 4, 1); - const uint8_t *src = &r[img.get_mipmap_offset(i)]; + const uint8_t *src = &r[img->get_mipmap_offset(i)]; int mmsize = MAX(bw, 1) * MAX(bh, 1) * 8; uint8_t *dst = &w[ofs]; @@ -171,7 +172,7 @@ static void _compress_etc(Image *p_img) { mc++; } - *p_img = Image(p_img->get_width(), p_img->get_height(), (mc - 1) ? true : false, Image::FORMAT_ETC, dst_data); + p_img->create(p_img->get_width(), p_img->get_height(), (mc - 1) ? true : false, Image::FORMAT_ETC, dst_data); } void _register_etc1_compress_func() { diff --git a/modules/etc1/texture_loader_pkm.cpp b/modules/etc1/texture_loader_pkm.cpp index 9817de3a0..c04528d2a 100644 --- a/modules/etc1/texture_loader_pkm.cpp +++ b/modules/etc1/texture_loader_pkm.cpp @@ -85,7 +85,7 @@ RES ResourceFormatPKM::load(const String &p_path, const String &p_original_path, int width = h.origWidth; int height = h.origHeight; - Image img(width, height, mipmaps, Image::FORMAT_ETC, src_data); + Ref<Image> img = memnew(Image(width, height, mipmaps, Image::FORMAT_ETC, src_data)); Ref<ImageTexture> texture = memnew(ImageTexture); texture->create_from_image(img); diff --git a/modules/gdnative/config.py b/modules/gdnative/config.py index 9f57b9bb7..4f89ca0d4 100644 --- a/modules/gdnative/config.py +++ b/modules/gdnative/config.py @@ -1,7 +1,7 @@ def can_build(platform): - return True + return False def configure(env): diff --git a/modules/gdnative/gdnative.cpp b/modules/gdnative/gdnative.cpp index b543a486d..9c8625c1e 100644 --- a/modules/gdnative/gdnative.cpp +++ b/modules/gdnative/gdnative.cpp @@ -99,15 +99,15 @@ Error NativeLibrary::terminate(NativeLibrary *&p_native_lib) { Error error = OK; void *library_terminate; error = OS::get_singleton()->get_dynamic_library_symbol_handle(p_native_lib->handle, GDNativeScriptLanguage::get_terminate_symbol_name(), library_terminate); - if (error) - return OK; // no terminate? okay, not that important lol + if (!error) { - void (*library_terminate_pointer)(godot_native_terminate_options *) = (void (*)(godot_native_terminate_options *))library_terminate; + void (*library_terminate_pointer)(godot_native_terminate_options *) = (void (*)(godot_native_terminate_options *))library_terminate; - godot_native_terminate_options options; - options.in_editor = SceneTree::get_singleton()->is_editor_hint(); + godot_native_terminate_options options; + options.in_editor = SceneTree::get_singleton()->is_editor_hint(); - library_terminate_pointer(&options); + library_terminate_pointer(&options); + } GDNativeScriptLanguage::get_singleton()->initialized_libraries.erase(p_native_lib->path); @@ -391,6 +391,54 @@ void GDNativeScript::get_script_signal_list(List<MethodInfo> *r_signals) const { } } +Variant GDNativeScript::_new(const Variant **p_args, int p_argcount, Variant::CallError &r_error) { + + /* STEP 1, CREATE */ + + if (!library.is_valid() || ((String)script_name).empty() || !script_data) { + r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD; + return Variant(); + } + + r_error.error = Variant::CallError::CALL_OK; + REF ref; + Object *owner = NULL; + + GDNativeScriptData *_baseptr = script_data; + while (_baseptr->base_data) { + _baseptr = _baseptr->base_data; + } + + if (!(_baseptr->base_native_type == "")) { + owner = ClassDB::instance(_baseptr->base_native_type); + } else { + owner = memnew(Reference); //by default, no base means use reference + } + + Reference *r = owner->cast_to<Reference>(); + if (r) { + ref = REF(r); + } + + // GDScript does it like this: _create_instance(p_args, p_argcount, owner, r != NULL, r_error); + // @Todo support varargs for constructors. + GDNativeInstance *instance = (GDNativeInstance *)instance_create(owner); + + owner->set_script_instance(instance); + if (!instance) { + if (ref.is_null()) { + memdelete(owner); //no owner, sorry + } + return Variant(); + } + + if (ref.is_valid()) { + return ref; + } else { + return owner; + } +} + Ref<GDNativeLibrary> GDNativeScript::get_library() const { return library; } @@ -438,6 +486,8 @@ void GDNativeScript::_bind_methods() { ClassDB::bind_method(D_METHOD("get_script_name"), &GDNativeScript::get_script_name); ClassDB::bind_method(D_METHOD("set_script_name", "script_name"), &GDNativeScript::set_script_name); + ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "new", &GDNativeScript::_new, MethodInfo(Variant::OBJECT, "new")); + ADD_PROPERTYNZ(PropertyInfo(Variant::OBJECT, "library", PROPERTY_HINT_RESOURCE_TYPE, "GDNativeLibrary"), "set_library", "get_library"); ADD_PROPERTYNZ(PropertyInfo(Variant::STRING, "script_name"), "set_script_name", "get_script_name"); } @@ -465,7 +515,6 @@ static const char *_dl_platforms_info[] = { "unix|x11|so|X11", "unix|server|so|Server", "unix|android|so|Android", - "unix|blackberry|so|Blackberry 10", "unix|haiku|so|Haiku", // Right? "|mac|dynlib|Mac", "mac|ios|dynlib|iOS", @@ -565,7 +614,6 @@ Error GDNativeLibrary::_terminate() { } Error ret = NativeLibrary::terminate(native_library); - native_library->scripts.clear(); return ret; @@ -1168,6 +1216,7 @@ void GDNativeReloadNode::_notification(int p_what) { Set<GDNativeScript *> scripts; for (Set<GDNativeScript *>::Element *S = GDNativeScriptLanguage::get_singleton()->script_list.front(); S; S = S->next()) { + if (lib->native_library->scripts.has(S->get()->get_script_name())) { GDNativeScript *script = S->get(); script->script_data = lib->get_script_data(script->get_script_name()); diff --git a/modules/gdnative/gdnative.h b/modules/gdnative/gdnative.h index 89270b4e2..27e0c3788 100644 --- a/modules/gdnative/gdnative.h +++ b/modules/gdnative/gdnative.h @@ -184,6 +184,8 @@ public: virtual void get_script_method_list(List<MethodInfo> *p_list) const; virtual void get_script_property_list(List<PropertyInfo> *p_list) const; + Variant _new(const Variant **p_args, int p_argcount, Variant::CallError &r_error); + Ref<GDNativeLibrary> get_library() const; void set_library(Ref<GDNativeLibrary> p_library); diff --git a/modules/gdnative/godot.cpp b/modules/gdnative/godot.cpp index 7477a28db..bc53eb93f 100644 --- a/modules/gdnative/godot.cpp +++ b/modules/gdnative/godot.cpp @@ -30,6 +30,7 @@ #include "godot.h" #include "class_db.h" +#include "error_macros.h" #include "gdnative.h" #include "global_config.h" #include "global_constants.h" @@ -115,6 +116,28 @@ void GDAPI godot_method_bind_ptrcall(godot_method_bind *p_method_bind, godot_obj mb->ptrcall(o, p_args, p_ret); } +godot_variant GDAPI godot_method_bind_call(godot_method_bind *p_method_bind, godot_object *p_instance, const godot_variant **p_args, const int p_arg_count, godot_variant_call_error *p_call_error) { + MethodBind *mb = (MethodBind *)p_method_bind; + Object *o = (Object *)p_instance; + const Variant **args = (const Variant **)p_args; + + godot_variant ret; + godot_variant_new_nil(&ret); + + Variant *ret_val = (Variant *)&ret; + + Variant::CallError r_error; + *ret_val = mb->call(o, args, p_arg_count, r_error); + + if (p_call_error) { + p_call_error->error = (godot_variant_call_error_error)r_error.error; + p_call_error->argument = r_error.argument; + p_call_error->expected = (godot_variant_type)r_error.expected; + } + + return ret; +} + // @Todo /* void GDAPI godot_method_bind_varcall(godot_method_bind *p_method_bind) @@ -215,6 +238,18 @@ void GDAPI godot_free(void *p_ptr) { memfree(p_ptr); } +void GDAPI godot_print_error(const char *p_description, const char *p_function, const char *p_file, int p_line) { + _err_print_error(p_function, p_file, p_line, p_description, ERR_HANDLER_ERROR); +} + +void GDAPI godot_print_warning(const char *p_description, const char *p_function, const char *p_file, int p_line) { + _err_print_error(p_function, p_file, p_line, p_description, ERR_HANDLER_WARNING); +} + +void GDAPI godot_print(const godot_string *p_message) { + print_line(*(String *)p_message); +} + #ifdef __cplusplus } #endif diff --git a/modules/gdnative/godot.h b/modules/gdnative/godot.h index 0d7aece23..7214ce62d 100644 --- a/modules/gdnative/godot.h +++ b/modules/gdnative/godot.h @@ -38,12 +38,26 @@ extern "C" { #define GDAPI_EXPORT #endif -#if !defined(_WIN32) && !defined(_MSC_VER) +#ifdef _WIN32 +#if defined(GDAPI_EXPORT) +#define GDCALLINGCONV +#define GDAPI __declspec(dllexport) GDCALLINGCONV +#else +#define GDCALLINGCONV +#define GDAPI __declspec(dllimport) GDCALLINGCONV +#endif +#elif defined(__APPLE__) +#include "TargetConditionals.h" +#if TARGET_OS_IPHONE +#define GDCALLINGCONV #define GDAPI -#elif defined(GDAPI_EXPORT) -#define GDAPI __declspec(dllexport) +#elif TARGET_OS_MAC +#define GDCALLINGCONV __attribute__((sysv_abi)) +#define GDAPI GDCALLINGCONV +#endif #else -#define GDAPI __declspec(dllimport) +#define GDCALLINGCONV __attribute__((sysv_abi)) +#define GDAPI GDCALLINGCONV #endif #include <stdbool.h> @@ -214,7 +228,7 @@ typedef struct godot_method_bind { godot_method_bind GDAPI *godot_method_bind_get_method(const char *p_classname, const char *p_methodname); void GDAPI godot_method_bind_ptrcall(godot_method_bind *p_method_bind, godot_object *p_instance, const void **p_args, void *p_ret); - +godot_variant GDAPI godot_method_bind_call(godot_method_bind *p_method_bind, godot_object *p_instance, const godot_variant **p_args, const int p_arg_count, godot_variant_call_error *p_call_error); ////// Script API typedef struct godot_native_init_options { @@ -314,16 +328,16 @@ typedef struct godot_property_attributes { typedef struct godot_instance_create_func { // instance pointer, method_data - return user data - void *(*create_func)(godot_object *, void *); + GDCALLINGCONV void *(*create_func)(godot_object *, void *); void *method_data; - void (*free_func)(void *); + GDCALLINGCONV void (*free_func)(void *); } godot_instance_create_func; typedef struct godot_instance_destroy_func { // instance pointer, method data, user data - void (*destroy_func)(godot_object *, void *, void *); + GDCALLINGCONV void (*destroy_func)(godot_object *, void *, void *); void *method_data; - void (*free_func)(void *); + GDCALLINGCONV void (*free_func)(void *); } godot_instance_destroy_func; void GDAPI godot_script_register_class(const char *p_name, const char *p_base, godot_instance_create_func p_create_func, godot_instance_destroy_func p_destroy_func); @@ -332,25 +346,25 @@ void GDAPI godot_script_register_tool_class(const char *p_name, const char *p_ba typedef struct godot_instance_method { // instance pointer, method data, user data, num args, args - return result as varaint - godot_variant (*method)(godot_object *, void *, void *, int, godot_variant **); + GDCALLINGCONV godot_variant (*method)(godot_object *, void *, void *, int, godot_variant **); void *method_data; - void (*free_func)(void *); + GDCALLINGCONV void (*free_func)(void *); } godot_instance_method; void GDAPI godot_script_register_method(const char *p_name, const char *p_function_name, godot_method_attributes p_attr, godot_instance_method p_method); typedef struct godot_property_set_func { // instance pointer, method data, user data, value - void (*set_func)(godot_object *, void *, void *, godot_variant); + GDCALLINGCONV void (*set_func)(godot_object *, void *, void *, godot_variant); void *method_data; - void (*free_func)(void *); + GDCALLINGCONV void (*free_func)(void *); } godot_property_set_func; typedef struct godot_property_get_func { // instance pointer, method data, user data, value - godot_variant (*get_func)(godot_object *, void *, void *); + GDCALLINGCONV godot_variant (*get_func)(godot_object *, void *, void *); void *method_data; - void (*free_func)(void *); + GDCALLINGCONV void (*free_func)(void *); } godot_property_get_func; void GDAPI godot_script_register_property(const char *p_name, const char *p_path, godot_property_attributes *p_attr, godot_property_set_func p_set_func, godot_property_get_func p_get_func); @@ -376,6 +390,7 @@ void GDAPI godot_script_register_signal(const char *p_name, const godot_signal * void GDAPI *godot_native_get_userdata(godot_object *p_instance); +// Calling convention? typedef godot_object *(*godot_class_constructor)(); godot_class_constructor GDAPI godot_get_class_constructor(const char *p_classname); @@ -389,6 +404,11 @@ void GDAPI *godot_alloc(int p_bytes); void GDAPI *godot_realloc(void *p_ptr, int p_bytes); void GDAPI godot_free(void *p_ptr); +//print using Godot's error handler list +void GDAPI godot_print_error(const char *p_description, const char *p_function, const char *p_file, int p_line); +void GDAPI godot_print_warning(const char *p_description, const char *p_function, const char *p_file, int p_line); +void GDAPI godot_print(const godot_string *p_message); + #ifdef __cplusplus } #endif diff --git a/modules/gdnative/godot/godot_basis.cpp b/modules/gdnative/godot/godot_basis.cpp index 4322acc40..474cd3d44 100644 --- a/modules/gdnative/godot/godot_basis.cpp +++ b/modules/gdnative/godot/godot_basis.cpp @@ -38,48 +38,176 @@ extern "C" { void _basis_api_anchor() { } -void GDAPI godot_basis_new(godot_basis *p_basis) { - Basis *basis = (Basis *)p_basis; - *basis = Basis(); +void GDAPI godot_basis_new(godot_basis *p_v) { + Basis *v = (Basis *)p_v; + *v = Basis(); } -void GDAPI godot_basis_new_with_euler_quat(godot_basis *p_basis, const godot_quat *p_euler) { - Basis *basis = (Basis *)p_basis; +void GDAPI godot_basis_new_with_euler_quat(godot_basis *p_v, const godot_quat *p_euler) { + Basis *v = (Basis *)p_v; Quat *euler = (Quat *)p_euler; - *basis = Basis(*euler); + *v = Basis(*euler); } -void GDAPI godot_basis_new_with_euler(godot_basis *p_basis, const godot_vector3 *p_euler) { - Basis *basis = (Basis *)p_basis; - Vector3 *euler = (Vector3 *)p_euler; - *basis = Basis(*euler); +void GDAPI godot_basis_new_with_euler(godot_basis *p_v, const godot_vector3 p_euler) { + Basis *v = (Basis *)p_v; + Vector3 *euler = (Vector3 *)&p_euler; + *v = Basis(*euler); } -godot_quat GDAPI godot_basis_as_quat(const godot_basis *p_basis) { - const Basis *basis = (const Basis *)p_basis; +void GDAPI godot_basis_new_with_axis_and_angle(godot_basis *p_v, const godot_vector3 p_axis, const godot_real p_phi) { + Basis *v = (Basis *)p_v; + const Vector3 *axis = (Vector3 *)&p_axis; + *v = Basis(*axis, p_phi); +} + +void GDAPI godot_basis_new_with_rows(godot_basis *p_v, const godot_vector3 p_row0, const godot_vector3 p_row1, const godot_vector3 p_row2) { + Basis *v = (Basis *)p_v; + const Vector3 *row0 = (Vector3 *)&p_row0; + const Vector3 *row1 = (Vector3 *)&p_row1; + const Vector3 *row2 = (Vector3 *)&p_row2; + *v = Basis(*row0, *row1, *row2); +} + +godot_quat GDAPI godot_basis_as_quat(const godot_basis *p_v) { + const Basis *v = (const Basis *)p_v; godot_quat quat; Quat *p_quat = (Quat *)&quat; - *p_quat = basis->operator Quat(); + *p_quat = v->operator Quat(); return quat; } -godot_vector3 GDAPI godot_basis_get_euler(const godot_basis *p_basis) { - const Basis *basis = (const Basis *)p_basis; - godot_vector3 euler; - Vector3 *p_euler = (Vector3 *)&euler; - *p_euler = basis->get_euler(); - return euler; -} - /* * p_elements is a pointer to an array of 3 (!!) vector3 */ -void GDAPI godot_basis_get_elements(godot_basis *p_basis, godot_vector3 *p_elements) { - Basis *basis = (Basis *)p_basis; +void GDAPI godot_basis_get_elements(godot_basis *p_v, godot_vector3 *p_elements) { + Basis *v = (Basis *)p_v; Vector3 *elements = (Vector3 *)p_elements; - elements[0] = basis->elements[0]; - elements[1] = basis->elements[1]; - elements[2] = basis->elements[2]; + elements[0] = v->elements[0]; + elements[1] = v->elements[1]; + elements[2] = v->elements[2]; +} + +godot_vector3 GDAPI godot_basis_get_axis(const godot_basis *p_v, const godot_int p_axis) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Basis *v = (Basis *)p_v; + *d = v->get_axis(p_axis); + return dest; +} + +void GDAPI godot_basis_set_axis(godot_basis *p_v, const godot_int p_axis, const godot_vector3 p_value) { + Basis *v = (Basis *)p_v; + const Vector3 *value = (Vector3 *)&p_value; + v->set_axis(p_axis, *value); +} + +godot_vector3 GDAPI godot_basis_get_row(const godot_basis *p_v, const godot_int p_row) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Basis *v = (Basis *)p_v; + *d = v->get_row(p_row); + return dest; +} + +void GDAPI godot_basis_set_row(godot_basis *p_v, const godot_int p_row, const godot_vector3 p_value) { + Basis *v = (Basis *)p_v; + const Vector3 *value = (Vector3 *)&p_value; + v->set_row(p_row, *value); +} + +godot_real godot_basis_determinant(const godot_basis *p_v) { + Basis *v = (Basis *)p_v; + return v->determinant(); +} + +godot_vector3 godot_basis_get_euler(const godot_basis *p_v) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Basis *v = (Basis *)p_v; + *d = v->get_euler(); + return dest; +} + +godot_int godot_basis_get_orthogonal_index(const godot_basis *p_v) { + const Basis *v = (Basis *)p_v; + return v->get_orthogonal_index(); +} + +godot_vector3 godot_basis_get_scale(const godot_basis *p_v) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Basis *v = (Basis *)p_v; + *d = v->get_scale(); + return dest; +} + +void godot_basis_inverse(godot_basis *p_dest, const godot_basis *p_v) { + Basis *d = (Basis *)p_dest; + const Basis *v = (Basis *)p_v; + *d = v->inverse(); +} + +void godot_basis_orthonormalized(godot_basis *p_dest, const godot_basis *p_v) { + Basis *d = (Basis *)p_dest; + const Basis *v = (Basis *)p_v; + *d = v->orthonormalized(); +} + +void godot_basis_rotated(godot_basis *p_dest, const godot_basis *p_v, const godot_vector3 p_axis, const godot_real p_phi) { + Basis *d = (Basis *)p_dest; + const Basis *v = (Basis *)p_v; + const Vector3 *axis = (Vector3 *)&p_axis; + *d = v->rotated(*axis, p_phi); +} + +void godot_basis_scaled(godot_basis *p_dest, const godot_basis *p_v, const godot_vector3 p_scale) { + Basis *d = (Basis *)p_dest; + const Basis *v = (Basis *)p_v; + const Vector3 *scale = (Vector3 *)&p_scale; + *d = v->scaled(*scale); +} + +godot_real godot_basis_tdotx(const godot_basis *p_v, const godot_vector3 p_with) { + const Basis *v = (Basis *)p_v; + const Vector3 *with = (Vector3 *)&p_with; + return v->tdotx(*with); +} + +godot_real godot_basis_tdoty(const godot_basis *p_v, const godot_vector3 p_with) { + const Basis *v = (Basis *)p_v; + const Vector3 *with = (Vector3 *)&p_with; + return v->tdoty(*with); +} + +godot_real godot_basis_tdotz(const godot_basis *p_v, const godot_vector3 p_with) { + const Basis *v = (Basis *)p_v; + const Vector3 *with = (Vector3 *)&p_with; + return v->tdotz(*with); +} + +void godot_basis_transposed(godot_basis *p_dest, const godot_basis *p_v) { + Basis *d = (Basis *)p_dest; + const Basis *v = (Basis *)p_v; + *d = v->transposed(); +} + +godot_vector3 godot_basis_xform(const godot_basis *p_v, const godot_vector3 p_vect) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Basis *v = (Basis *)p_v; + const Vector3 *vect = (Vector3 *)&p_vect; + *d = v->xform(*vect); + return dest; +} + +godot_vector3 godot_basis_xform_inv(const godot_basis *p_v, const godot_vector3 p_vect) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Basis *v = (Basis *)p_v; + const Vector3 *vect = (Vector3 *)&p_vect; + *d = v->xform_inv(*vect); + return dest; } #ifdef __cplusplus diff --git a/modules/gdnative/godot/godot_basis.h b/modules/gdnative/godot/godot_basis.h index e65e5b683..280339699 100644 --- a/modules/gdnative/godot/godot_basis.h +++ b/modules/gdnative/godot/godot_basis.h @@ -45,17 +45,37 @@ typedef struct godot_basis { #include "../godot.h" #include "godot_quat.h" -void GDAPI godot_basis_new(godot_basis *p_basis); -void GDAPI godot_basis_new_with_euler_quat(godot_basis *p_basis, const godot_quat *p_euler); -void GDAPI godot_basis_new_with_euler(godot_basis *p_basis, const godot_vector3 *p_euler); +void GDAPI godot_basis_new(godot_basis *p_v); +void GDAPI godot_basis_new_with_euler_quat(godot_basis *p_v, const godot_quat *p_euler); +void GDAPI godot_basis_new_with_euler(godot_basis *p_v, const godot_vector3 p_euler); +void GDAPI godot_basis_new_with_axis_and_angle(godot_basis *p_v, const godot_vector3 p_axis, const godot_real p_phi); +void GDAPI godot_basis_new_with_rows(godot_basis *p_v, const godot_vector3 p_row0, const godot_vector3 p_row1, const godot_vector3 p_row2); -godot_quat GDAPI godot_basis_as_quat(const godot_basis *p_basis); -godot_vector3 GDAPI godot_basis_get_euler(const godot_basis *p_basis); +godot_quat GDAPI godot_basis_as_quat(const godot_basis *p_v); /* * p_elements is a pointer to an array of 3 (!!) vector3 */ -void GDAPI godot_basis_get_elements(godot_basis *p_basis, godot_vector3 *p_elements); +void GDAPI godot_basis_get_elements(godot_basis *p_v, godot_vector3 *p_elements); +godot_vector3 GDAPI godot_basis_get_axis(const godot_basis *p_v, const godot_int p_axis); +void GDAPI godot_basis_set_axis(godot_basis *p_v, const godot_int p_axis, const godot_vector3 p_value); +godot_vector3 GDAPI godot_basis_get_row(const godot_basis *p_v, const godot_int p_row); +void GDAPI godot_basis_set_row(godot_basis *p_v, const godot_int p_row, const godot_vector3 p_value); + +godot_real godot_basis_determinant(const godot_basis *p_v); +godot_vector3 godot_basis_get_euler(const godot_basis *p_v); +godot_int godot_basis_get_orthogonal_index(const godot_basis *p_v); +godot_vector3 godot_basis_get_scale(const godot_basis *p_v); +void godot_basis_inverse(godot_basis *p_dest, const godot_basis *p_v); +void godot_basis_orthonormalized(godot_basis *p_dest, const godot_basis *p_v); +void godot_basis_rotated(godot_basis *p_dest, const godot_basis *p_v, const godot_vector3 p_axis, const godot_real p_phi); +void godot_basis_scaled(godot_basis *p_dest, const godot_basis *p_v, const godot_vector3 p_scale); +godot_real godot_basis_tdotx(const godot_basis *p_v, const godot_vector3 p_with); +godot_real godot_basis_tdoty(const godot_basis *p_v, const godot_vector3 p_with); +godot_real godot_basis_tdotz(const godot_basis *p_v, const godot_vector3 p_with); +void godot_basis_transposed(godot_basis *p_dest, const godot_basis *p_v); +godot_vector3 godot_basis_xform(const godot_basis *p_v, const godot_vector3 p_vect); +godot_vector3 godot_basis_xform_inv(const godot_basis *p_v, const godot_vector3 p_vect); #ifdef __cplusplus } diff --git a/modules/gdnative/godot/godot_string.cpp b/modules/gdnative/godot/godot_string.cpp index 757b8510c..92c0b0404 100644 --- a/modules/gdnative/godot/godot_string.cpp +++ b/modules/gdnative/godot/godot_string.cpp @@ -80,6 +80,11 @@ const char GDAPI *godot_string_c_str(const godot_string *p_str) { return s->utf8().get_data(); } +const wchar_t GDAPI *godot_string_unicode_str(const godot_string *p_str) { + const String *s = (const String *)p_str; + return s->c_str(); +} + godot_bool GDAPI godot_string_operator_equal(const godot_string *p_a, const godot_string *p_b) { String *a = (String *)p_a; String *b = (String *)p_b; diff --git a/modules/gdnative/godot/godot_string.h b/modules/gdnative/godot/godot_string.h index 9289531c5..83ed5d6ec 100644 --- a/modules/gdnative/godot/godot_string.h +++ b/modules/gdnative/godot/godot_string.h @@ -35,6 +35,7 @@ extern "C" { #endif #include <stdint.h> +#include <wchar.h> #ifndef GODOT_CORE_API_GODOT_STRING_TYPE_DEFINED typedef struct godot_string { @@ -53,6 +54,7 @@ void GDAPI godot_string_copy_string(const godot_string *p_dest, const godot_stri wchar_t GDAPI *godot_string_operator_index(godot_string *p_str, const godot_int p_idx); const char GDAPI *godot_string_c_str(const godot_string *p_str); +const wchar_t GDAPI *godot_string_unicode_str(const godot_string *p_str); godot_bool GDAPI godot_string_operator_equal(const godot_string *p_a, const godot_string *p_b); godot_bool GDAPI godot_string_operator_less(const godot_string *p_a, const godot_string *p_b); diff --git a/modules/gdnative/godot/godot_variant.cpp b/modules/gdnative/godot/godot_variant.cpp index 2214f8505..e9fa4eb8c 100644 --- a/modules/gdnative/godot/godot_variant.cpp +++ b/modules/gdnative/godot/godot_variant.cpp @@ -457,12 +457,22 @@ godot_pool_color_array GDAPI godot_variant_as_pool_color_array(const godot_varia return pba; } -godot_variant GDAPI godot_variant_call(godot_variant *p_v, const godot_string *p_method, const godot_variant **p_args, const godot_int p_argcount /*, godot_variant_call_error *r_error */) { +godot_variant GDAPI godot_variant_call(godot_variant *p_v, const godot_string *p_method, const godot_variant **p_args, const godot_int p_argcount, godot_variant_call_error *p_error) { Variant *v = (Variant *)p_v; String *method = (String *)p_method; - Variant **args = (Variant **)p_args; + const Variant **args = (const Variant **)p_args; godot_variant res; - memnew_placement_custom((Variant *)&res, Variant, Variant(v->call(*method, args, p_argcount))); + godot_variant_new_nil(&res); + + Variant *ret_val = (Variant *)&res; + + Variant::CallError r_error; + *ret_val = v->call(StringName(*method), args, p_argcount, r_error); + if (p_error) { + p_error->error = (godot_variant_call_error_error)r_error.error; + p_error->argument = r_error.argument; + p_error->expected = (godot_variant_type)r_error.expected; + } return res; } diff --git a/modules/gdnative/godot/godot_variant.h b/modules/gdnative/godot/godot_variant.h index 6f98b3236..bf0e2bf64 100644 --- a/modules/gdnative/godot/godot_variant.h +++ b/modules/gdnative/godot/godot_variant.h @@ -45,13 +45,6 @@ typedef struct godot_variant { struct godot_transform2d; typedef struct godot_transform2d godot_transform2d; -#include "godot_array.h" -#include "godot_dictionary.h" -#include "godot_input_event.h" -#include "godot_node_path.h" -#include "godot_rid.h" -#include "godot_transform2d.h" - typedef enum godot_variant_type { GODOT_VARIANT_TYPE_NIL, @@ -69,7 +62,7 @@ typedef enum godot_variant_type { GODOT_VARIANT_TYPE_TRANSFORM2D, GODOT_VARIANT_TYPE_PLANE, GODOT_VARIANT_TYPE_QUAT, // 10 - GODOT_VARIANT_TYPE_RECT3, //sorry naming convention fail :( not like it's used often + GODOT_VARIANT_TYPE_RECT3, GODOT_VARIANT_TYPE_BASIS, GODOT_VARIANT_TYPE_TRANSFORM, @@ -93,6 +86,28 @@ typedef enum godot_variant_type { GODOT_VARIANT_TYPE_POOL_COLOR_ARRAY, } godot_variant_type; +typedef enum godot_variant_call_error_error { + GODOT_CALL_ERROR_CALL_OK, + GODOT_CALL_ERROR_CALL_ERROR_INVALID_METHOD, + GODOT_CALL_ERROR_CALL_ERROR_INVALID_ARGUMENT, + GODOT_CALL_ERROR_CALL_ERROR_TOO_MANY_ARGUMENTS, + GODOT_CALL_ERROR_CALL_ERROR_TOO_FEW_ARGUMENTS, + GODOT_CALL_ERROR_CALL_ERROR_INSTANCE_IS_NULL, +} godot_variant_call_error_error; + +typedef struct godot_variant_call_error { + godot_variant_call_error_error error; + int argument; + godot_variant_type expected; +} godot_variant_call_error; + +#include "godot_array.h" +#include "godot_dictionary.h" +#include "godot_input_event.h" +#include "godot_node_path.h" +#include "godot_rid.h" +#include "godot_transform2d.h" + godot_variant_type GDAPI godot_variant_get_type(const godot_variant *p_v); void GDAPI godot_variant_copy(godot_variant *p_dest, const godot_variant *p_src); @@ -159,7 +174,7 @@ godot_pool_vector2_array GDAPI godot_variant_as_pool_vector2_array(const godot_v godot_pool_vector3_array GDAPI godot_variant_as_pool_vector3_array(const godot_variant *p_v); godot_pool_color_array GDAPI godot_variant_as_pool_color_array(const godot_variant *p_v); -godot_variant GDAPI godot_variant_call(godot_variant *p_v, const godot_string *p_method, const godot_variant **p_args, const godot_int p_argcount /*, godot_variant_call_error *r_error */); +godot_variant GDAPI godot_variant_call(godot_variant *p_v, const godot_string *p_method, const godot_variant **p_args, const godot_int p_argcount, godot_variant_call_error *p_error); godot_bool GDAPI godot_variant_has_method(godot_variant *p_v, const godot_string *p_method); diff --git a/modules/gdnative/godot/godot_vector2.cpp b/modules/gdnative/godot/godot_vector2.cpp index ad5107f9a..87e60b624 100644 --- a/modules/gdnative/godot/godot_vector2.cpp +++ b/modules/gdnative/godot/godot_vector2.cpp @@ -37,11 +37,12 @@ extern "C" { void _vector2_api_anchor() {} -void GDAPI godot_vector2_new(godot_vector2 *p_v, godot_real p_x, - godot_real p_y) { - Vector2 *v = (Vector2 *)p_v; +godot_vector2 GDAPI godot_vector2_new(const godot_real p_x, const godot_real p_y) { + godot_vector2 value; + Vector2 *v = (Vector2 *)&value; v->x = p_x; v->y = p_y; + return value; } void GDAPI godot_vector2_set_x(godot_vector2 *p_v, const godot_real p_x) { @@ -55,11 +56,11 @@ void GDAPI godot_vector2_set_y(godot_vector2 *p_v, const godot_real p_y) { } godot_real GDAPI godot_vector2_get_x(const godot_vector2 *p_v) { - Vector2 *v = (Vector2 *)p_v; + const Vector2 *v = (Vector2 *)p_v; return v->x; } godot_real GDAPI godot_vector2_get_y(const godot_vector2 *p_v) { - Vector2 *v = (Vector2 *)p_v; + const Vector2 *v = (Vector2 *)p_v; return v->y; } @@ -67,224 +68,227 @@ void GDAPI godot_vector2_normalize(godot_vector2 *p_v) { Vector2 *v = (Vector2 *)p_v; v->normalize(); } -void GDAPI godot_vector2_normalized(godot_vector2 *p_dest, - const godot_vector2 *p_src) { - Vector2 *v = (Vector2 *)p_src; - Vector2 *d = (Vector2 *)p_dest; +godot_vector2 GDAPI godot_vector2_normalized(const godot_vector2 *p_v) { + godot_vector2 dest; + const Vector2 *v = (Vector2 *)p_v; + Vector2 *d = (Vector2 *)&dest; *d = v->normalized(); + return dest; } godot_real GDAPI godot_vector2_length(const godot_vector2 *p_v) { - Vector2 *v = (Vector2 *)p_v; + const Vector2 *v = (Vector2 *)p_v; return v->length(); } godot_real GDAPI godot_vector2_length_squared(const godot_vector2 *p_v) { - Vector2 *v = (Vector2 *)p_v; + const Vector2 *v = (Vector2 *)p_v; return v->length_squared(); } -godot_real GDAPI godot_vector2_distance_to(const godot_vector2 *p_a, - const godot_vector2 *p_b) { - Vector2 *a = (Vector2 *)p_a; - Vector2 *b = (Vector2 *)p_b; - return a->distance_to(*b); +godot_real GDAPI godot_vector2_distance_to(const godot_vector2 *p_v, const godot_vector2 p_b) { + const Vector2 *v = (Vector2 *)p_v; + const Vector2 *b = (Vector2 *)&p_b; + return v->distance_to(*b); } -godot_real GDAPI godot_vector2_distance_squared_to(const godot_vector2 *p_a, - const godot_vector2 *p_b) { - Vector2 *a = (Vector2 *)p_a; - Vector2 *b = (Vector2 *)p_b; - return a->distance_squared_to(*b); +godot_real GDAPI godot_vector2_distance_squared_to(const godot_vector2 *p_v, const godot_vector2 p_b) { + const Vector2 *v = (Vector2 *)p_v; + const Vector2 *b = (Vector2 *)&p_b; + return v->distance_squared_to(*b); } -void GDAPI godot_vector2_operator_add(godot_vector2 *p_dest, - const godot_vector2 *p_a, - const godot_vector2 *p_b) { - Vector2 *dest = (Vector2 *)p_dest; - const Vector2 *a = (Vector2 *)p_a; - const Vector2 *b = (Vector2 *)p_b; - *dest = *a + *b; +godot_vector2 GDAPI godot_vector2_operator_add(const godot_vector2 *p_v, const godot_vector2 p_b) { + godot_vector2 dest; + Vector2 *d = (Vector2 *)&dest; + const Vector2 *v = (Vector2 *)p_v; + const Vector2 *b = (Vector2 *)&p_b; + *d = *v + *b; + return dest; } -void GDAPI godot_vector2_operator_subtract(godot_vector2 *p_dest, - const godot_vector2 *p_a, - const godot_vector2 *p_b) { - Vector2 *dest = (Vector2 *)p_dest; - const Vector2 *a = (Vector2 *)p_a; - const Vector2 *b = (Vector2 *)p_b; - *dest = *a - *b; +godot_vector2 GDAPI godot_vector2_operator_subtract(const godot_vector2 *p_v, const godot_vector2 p_b) { + godot_vector2 dest; + Vector2 *d = (Vector2 *)&dest; + const Vector2 *v = (Vector2 *)p_v; + const Vector2 *b = (Vector2 *)&p_b; + *d = *v - *b; + return dest; } -void GDAPI godot_vector2_operator_multiply_vector(godot_vector2 *p_dest, - const godot_vector2 *p_a, - const godot_vector2 *p_b) { - Vector2 *dest = (Vector2 *)p_dest; - const Vector2 *a = (Vector2 *)p_a; - const Vector2 *b = (Vector2 *)p_b; - *dest = *a * *b; +godot_vector2 GDAPI godot_vector2_operator_multiply_vector(const godot_vector2 *p_v, const godot_vector2 p_b) { + godot_vector2 dest; + Vector2 *d = (Vector2 *)&dest; + const Vector2 *v = (Vector2 *)p_v; + const Vector2 *b = (Vector2 *)&p_b; + *d = *v * *b; + return dest; } -void GDAPI godot_vector2_operator_multiply_scalar(godot_vector2 *p_dest, - const godot_vector2 *p_a, - const godot_real p_b) { - Vector2 *dest = (Vector2 *)p_dest; - const Vector2 *a = (Vector2 *)p_a; - *dest = *a * p_b; +godot_vector2 GDAPI godot_vector2_operator_multiply_scalar(const godot_vector2 *p_v, const godot_real p_b) { + godot_vector2 dest; + Vector2 *d = (Vector2 *)&dest; + const Vector2 *v = (Vector2 *)p_v; + *d = *v * p_b; + return dest; } -void GDAPI godot_vector2_operator_divide_vector(godot_vector2 *p_dest, - const godot_vector2 *p_a, - const godot_vector2 *p_b) { - Vector2 *dest = (Vector2 *)p_dest; - const Vector2 *a = (Vector2 *)p_a; - const Vector2 *b = (Vector2 *)p_b; - *dest = *a / *b; +godot_vector2 GDAPI godot_vector2_operator_divide_vector(const godot_vector2 *p_v, const godot_vector2 p_b) { + godot_vector2 dest; + Vector2 *d = (Vector2 *)&dest; + const Vector2 *v = (Vector2 *)p_v; + const Vector2 *b = (Vector2 *)&p_b; + *d = *v / *b; + return dest; } -void GDAPI godot_vector2_operator_divide_scalar(godot_vector2 *p_dest, - const godot_vector2 *p_a, - const godot_real p_b) { - Vector2 *dest = (Vector2 *)p_dest; - const Vector2 *a = (Vector2 *)p_a; - *dest = *a / p_b; +godot_vector2 GDAPI godot_vector2_operator_divide_scalar(const godot_vector2 *p_v, const godot_real p_b) { + godot_vector2 dest; + Vector2 *d = (Vector2 *)&dest; + const Vector2 *v = (Vector2 *)p_v; + *d = *v / p_b; + return dest; } -godot_bool GDAPI godot_vector2_operator_equal(const godot_vector2 *p_a, - const godot_vector2 *p_b) { - const Vector2 *a = (Vector2 *)p_a; - const Vector2 *b = (Vector2 *)p_b; - return *a == *b; +godot_bool GDAPI godot_vector2_operator_equal(const godot_vector2 *p_v, const godot_vector2 p_b) { + const Vector2 *v = (Vector2 *)p_v; + const Vector2 *b = (Vector2 *)&p_b; + return *v == *b; } -godot_bool GDAPI godot_vector2_operator_less(const godot_vector2 *p_a, - const godot_vector2 *p_b) { - const Vector2 *a = (Vector2 *)p_a; - const Vector2 *b = (Vector2 *)p_b; - return *a < *b; +godot_bool GDAPI godot_vector2_operator_less(const godot_vector2 *p_v, const godot_vector2 p_b) { + const Vector2 *v = (Vector2 *)p_v; + const Vector2 *b = (Vector2 *)&p_b; + return *v < *b; } -void GDAPI godot_vector2_abs(godot_vector2 *p_dest, - const godot_vector2 *p_src) { - const Vector2 *src = (Vector2 *)p_src; - Vector2 *dest = (Vector2 *)p_dest; - *dest = src->abs(); +godot_vector2 GDAPI godot_vector2_abs(const godot_vector2 *p_v) { + godot_vector2 dest; + Vector2 *d = (Vector2 *)&dest; + const Vector2 *v = (Vector2 *)p_v; + *d = v->abs(); + return dest; } -godot_real GDAPI godot_vector2_angle(const godot_vector2 *p_src) { - const Vector2 *src = (Vector2 *)p_src; - return src->angle(); +godot_real GDAPI godot_vector2_angle(const godot_vector2 *p_v) { + const Vector2 *v = (Vector2 *)p_v; + return v->angle(); } -godot_real GDAPI godot_vector2_angle_to(const godot_vector2 *p_src, - const godot_vector2 *p_to) { - const Vector2 *src = (Vector2 *)p_src; - const Vector2 *to = (Vector2 *)p_to; - return src->angle_to(*to); +godot_real GDAPI godot_vector2_angle_to(const godot_vector2 *p_v, const godot_vector2 p_to) { + const Vector2 *v = (Vector2 *)p_v; + const Vector2 *to = (Vector2 *)&p_to; + return v->angle_to(*to); } -godot_real GDAPI godot_vector2_angle_to_point(const godot_vector2 *p_src, - const godot_vector2 *p_to) { - const Vector2 *src = (Vector2 *)p_src; - const Vector2 *to = (Vector2 *)p_to; - return src->angle_to_point(*to); +godot_real GDAPI godot_vector2_angle_to_point(const godot_vector2 *p_v, const godot_vector2 p_to) { + const Vector2 *v = (Vector2 *)p_v; + const Vector2 *to = (Vector2 *)&p_to; + return v->angle_to_point(*to); } -void GDAPI godot_vector2_clamped(godot_vector2 *p_dest, - const godot_vector2 *p_src, - godot_real length) { - const Vector2 *src = (Vector2 *)p_src; - Vector2 *dest = (Vector2 *)p_dest; - *dest = src->clamped(length); +godot_vector2 GDAPI godot_vector2_clamped(const godot_vector2 *p_v, const godot_real length) { + godot_vector2 dest; + Vector2 *d = (Vector2 *)&dest; + const Vector2 *v = (Vector2 *)p_v; + *d = v->clamped(length); + return dest; } -void GDAPI godot_vector2_cubic_interpolate( - godot_vector2 *p_dest, const godot_vector2 *p_src, const godot_vector2 *p_b, - const godot_vector2 *p_pre_a, const godot_vector2 *p_post_b, godot_real t) { - Vector2 *dest = (Vector2 *)p_dest; - const Vector2 *src = (Vector2 *)p_src; - const Vector2 *b = (Vector2 *)p_b; - const Vector2 *pre_a = (Vector2 *)p_pre_a; - const Vector2 *post_b = (Vector2 *)p_post_b; - *dest = src->cubic_interpolate(*b, *pre_a, *post_b, t); +godot_vector2 GDAPI godot_vector2_cubic_interpolate( + const godot_vector2 *p_v, const godot_vector2 p_b, const godot_vector2 p_pre_a, + const godot_vector2 p_post_b, godot_real t) { + godot_vector2 dest; + Vector2 *d = (Vector2 *)&dest; + const Vector2 *v = (Vector2 *)p_v; + const Vector2 *b = (Vector2 *)&p_b; + const Vector2 *pre_a = (Vector2 *)&p_pre_a; + const Vector2 *post_b = (Vector2 *)&p_post_b; + *d = v->cubic_interpolate(*b, *pre_a, *post_b, t); + return dest; } -godot_real GDAPI godot_vector2_dot(const godot_vector2 *p_src, - const godot_vector2 *p_with) { - const Vector2 *src = (Vector2 *)p_src; - const Vector2 *with = (Vector2 *)p_with; - return src->dot(*with); +godot_real GDAPI godot_vector2_dot(const godot_vector2 *p_v, const godot_vector2 p_with) { + const Vector2 *v = (Vector2 *)p_v; + const Vector2 *with = (Vector2 *)&p_with; + return v->dot(*with); } -void GDAPI godot_vector2_floor(godot_vector2 *p_dest, - const godot_vector2 *p_src) { - const Vector2 *src = (Vector2 *)p_src; - Vector2 *dest = (Vector2 *)p_dest; - *dest = src->floor(); +godot_vector2 GDAPI godot_vector2_floor(const godot_vector2 *p_v) { + godot_vector2 dest; + Vector2 *d = (Vector2 *)&dest; + const Vector2 *v = (Vector2 *)p_v; + *d = v->floor(); + return dest; } -godot_real GDAPI godot_vector2_aspect(const godot_vector2 *p_src) { - const Vector2 *src = (Vector2 *)p_src; - return src->aspect(); +godot_real GDAPI godot_vector2_aspect(const godot_vector2 *p_v) { + const Vector2 *v = (Vector2 *)p_v; + return v->aspect(); } -void GDAPI godot_vector2_linear_interpolate(godot_vector2 *p_dest, - const godot_vector2 *p_src, - const godot_vector2 *p_b, +godot_vector2 GDAPI godot_vector2_linear_interpolate( + const godot_vector2 *p_v, + const godot_vector2 p_b, godot_real t) { - Vector2 *dest = (Vector2 *)p_dest; - const Vector2 *src = (Vector2 *)p_src; - const Vector2 *b = (Vector2 *)p_b; - *dest = src->linear_interpolate(*b, t); + godot_vector2 dest; + Vector2 *d = (Vector2 *)&dest; + const Vector2 *v = (Vector2 *)p_v; + const Vector2 *b = (Vector2 *)&p_b; + *d = v->linear_interpolate(*b, t); + return dest; } -void GDAPI godot_vector2_reflect(godot_vector2 *p_dest, - const godot_vector2 *p_src, - const godot_vector2 *p_vec) { - const Vector2 *src = (Vector2 *)p_src; - const Vector2 *vec = (Vector2 *)p_vec; - Vector2 *dest = (Vector2 *)p_dest; - *dest = src->reflect(*vec); +godot_vector2 GDAPI godot_vector2_reflect(const godot_vector2 *p_v, const godot_vector2 p_vec) { + const Vector2 *v = (Vector2 *)p_v; + const Vector2 *vec = (Vector2 *)&p_vec; + godot_vector2 dest; + Vector2 *d = (Vector2 *)&dest; + *d = v->reflect(*vec); + return dest; } -void GDAPI godot_vector2_rotated(godot_vector2 *p_dest, - const godot_vector2 *p_src, godot_real phi) { - const Vector2 *src = (Vector2 *)p_src; - Vector2 *dest = (Vector2 *)p_dest; - *dest = src->rotated(phi); +godot_vector2 GDAPI godot_vector2_rotated(const godot_vector2 *p_v, godot_real phi) { + const Vector2 *v = (Vector2 *)p_v; + godot_vector2 dest; + Vector2 *d = (Vector2 *)&dest; + *d = v->rotated(phi); + return dest; } -void GDAPI godot_vector2_slide(godot_vector2 *p_dest, - const godot_vector2 *p_src, - godot_vector2 *p_vec) { - const Vector2 *src = (Vector2 *)p_src; - const Vector2 *vec = (Vector2 *)p_vec; - Vector2 *dest = (Vector2 *)p_dest; - *dest = src->slide(*vec); +godot_vector2 GDAPI godot_vector2_slide(const godot_vector2 *p_v, godot_vector2 p_vec) { + godot_vector2 dest; + Vector2 *d = (Vector2 *)&dest; + const Vector2 *v = (Vector2 *)p_v; + const Vector2 *vec = (Vector2 *)&p_vec; + *d = v->slide(*vec); + return dest; } -void GDAPI godot_vector2_snapped(godot_vector2 *p_dest, - const godot_vector2 *p_src, - godot_vector2 *p_by) { - const Vector2 *src = (Vector2 *)p_src; - const Vector2 *by = (Vector2 *)p_by; - Vector2 *dest = (Vector2 *)p_dest; - *dest = src->snapped(*by); +godot_vector2 GDAPI godot_vector2_snapped(const godot_vector2 *p_v, godot_vector2 p_by) { + godot_vector2 dest; + Vector2 *d = (Vector2 *)&dest; + const Vector2 *v = (Vector2 *)p_v; + const Vector2 *by = (Vector2 *)&p_by; + *d = v->snapped(*by); + return dest; } -void GDAPI godot_vector2_tangent(godot_vector2 *p_dest, - const godot_vector2 *p_src) { - const Vector2 *src = (Vector2 *)p_src; - Vector2 *dest = (Vector2 *)p_dest; - *dest = src->tangent(); +godot_vector2 GDAPI godot_vector2_tangent(const godot_vector2 *p_v) { + godot_vector2 dest; + Vector2 *d = (Vector2 *)&dest; + const Vector2 *v = (Vector2 *)p_v; + *d = v->tangent(); + return dest; } -void GDAPI godot_vector2_to_string(godot_string *p_dest, - const godot_vector2 *p_src) { - const Vector2 *src = (Vector2 *)p_src; - String *dest = (String *)p_dest; - *dest = "(" + *src + ")"; +godot_string GDAPI godot_vector2_to_string(const godot_vector2 *p_v) { + godot_string dest; + String *d = (String *)&dest; + const Vector2 *v = (Vector2 *)p_v; + *d = "(" + *v + ")"; + return dest; } #ifdef __cplusplus diff --git a/modules/gdnative/godot/godot_vector2.h b/modules/gdnative/godot/godot_vector2.h index 4d957d4c7..36a4f01d0 100644 --- a/modules/gdnative/godot/godot_vector2.h +++ b/modules/gdnative/godot/godot_vector2.h @@ -45,7 +45,7 @@ typedef struct godot_vector2 { #include "../godot.h" -void GDAPI godot_vector2_new(godot_vector2 *p_v, const godot_real p_x, const godot_real p_y); +godot_vector2 GDAPI godot_vector2_new(const godot_real p_x, const godot_real p_y); void GDAPI godot_vector2_set_x(godot_vector2 *p_v, const godot_real p_x); void GDAPI godot_vector2_set_y(godot_vector2 *p_v, const godot_real p_y); @@ -53,43 +53,43 @@ godot_real GDAPI godot_vector2_get_x(const godot_vector2 *p_v); godot_real GDAPI godot_vector2_get_y(const godot_vector2 *p_v); void GDAPI godot_vector2_normalize(godot_vector2 *p_v); -void GDAPI godot_vector2_normalized(godot_vector2 *p_dest, const godot_vector2 *p_src); +godot_vector2 GDAPI godot_vector2_normalized(const godot_vector2 *p_v); godot_real GDAPI godot_vector2_length(const godot_vector2 *p_v); godot_real GDAPI godot_vector2_length_squared(const godot_vector2 *p_v); -godot_real GDAPI godot_vector2_distance_to(const godot_vector2 *p_a, const godot_vector2 *p_b); -godot_real GDAPI godot_vector2_distance_squared_to(const godot_vector2 *p_a, const godot_vector2 *p_b); +godot_real GDAPI godot_vector2_distance_to(const godot_vector2 *p_v, const godot_vector2 p_b); +godot_real GDAPI godot_vector2_distance_squared_to(const godot_vector2 *p_v, const godot_vector2 p_b); -void GDAPI godot_vector2_abs(godot_vector2 *p_dest, const godot_vector2 *p_src); -godot_real GDAPI godot_vector2_angle(const godot_vector2 *p_src); -godot_real GDAPI godot_vector2_angle_to(const godot_vector2 *p_src, const godot_vector2 *p_to); -godot_real GDAPI godot_vector2_angle_to_point(const godot_vector2 *p_src, const godot_vector2 *p_to); -void GDAPI godot_vector2_clamped(godot_vector2 *p_dest, const godot_vector2 *p_src, godot_real length); -void GDAPI godot_vector2_cubic_interpolate(godot_vector2 *p_dest, const godot_vector2 *p_src, - const godot_vector2 *p_b, const godot_vector2 *p_pre_a, - const godot_vector2 *p_post_b, godot_real t); -godot_real GDAPI godot_vector2_dot(const godot_vector2 *p_src, const godot_vector2 *p_with); -void GDAPI godot_vector2_floor(godot_vector2 *p_dest, const godot_vector2 *p_src); -godot_real GDAPI godot_vector2_aspect(const godot_vector2 *p_src); -void GDAPI godot_vector2_linear_interpolate(godot_vector2 *p_dest, const godot_vector2 *p_src, - const godot_vector2 *p_b, godot_real t); -void GDAPI godot_vector2_reflect(godot_vector2 *p_dest, const godot_vector2 *p_src, const godot_vector2 *p_vec); -void GDAPI godot_vector2_rotated(godot_vector2 *p_dest, const godot_vector2 *p_src, godot_real phi); -void GDAPI godot_vector2_slide(godot_vector2 *p_dest, const godot_vector2 *p_src, godot_vector2 *p_vec); -void GDAPI godot_vector2_snapped(godot_vector2 *p_dest, const godot_vector2 *p_src, godot_vector2 *p_by); -void GDAPI godot_vector2_tangent(godot_vector2 *p_dest, const godot_vector2 *p_src); -void GDAPI godot_vector2_to_string(godot_string *p_dest, const godot_vector2 *p_src); +godot_vector2 GDAPI godot_vector2_abs(const godot_vector2 *p_v); +godot_real GDAPI godot_vector2_angle(const godot_vector2 *p_v); +godot_real GDAPI godot_vector2_angle_to(const godot_vector2 *p_v, const godot_vector2 p_to); +godot_real GDAPI godot_vector2_angle_to_point(const godot_vector2 *p_v, const godot_vector2 p_to); +godot_vector2 GDAPI godot_vector2_clamped(const godot_vector2 *p_v, godot_real length); +godot_vector2 GDAPI godot_vector2_cubic_interpolate(const godot_vector2 *p_v, + const godot_vector2 p_b, const godot_vector2 p_pre_a, + const godot_vector2 p_post_b, godot_real t); +godot_real GDAPI godot_vector2_dot(const godot_vector2 *p_v, const godot_vector2 p_with); +godot_vector2 GDAPI godot_vector2_floor(const godot_vector2 *p_v); +godot_real GDAPI godot_vector2_aspect(const godot_vector2 *p_v); +godot_vector2 GDAPI godot_vector2_linear_interpolate(const godot_vector2 *p_v, + const godot_vector2 p_b, godot_real t); +godot_vector2 GDAPI godot_vector2_reflect(const godot_vector2 *p_v, const godot_vector2 p_vec); +godot_vector2 GDAPI godot_vector2_rotated(const godot_vector2 *p_v, godot_real phi); +godot_vector2 GDAPI godot_vector2_slide(const godot_vector2 *p_v, godot_vector2 p_vec); +godot_vector2 GDAPI godot_vector2_snapped(const godot_vector2 *p_v, godot_vector2 p_by); +godot_vector2 GDAPI godot_vector2_tangent(const godot_vector2 *p_v); +godot_string GDAPI godot_vector2_to_string(const godot_vector2 *p_v); -void GDAPI godot_vector2_operator_add(godot_vector2 *p_dest, const godot_vector2 *p_a, const godot_vector2 *p_b); -void GDAPI godot_vector2_operator_subtract(godot_vector2 *p_dest, const godot_vector2 *p_a, const godot_vector2 *p_b); -void GDAPI godot_vector2_operator_multiply_vector(godot_vector2 *p_dest, const godot_vector2 *p_a, const godot_vector2 *p_b); -void GDAPI godot_vector2_operator_multiply_scalar(godot_vector2 *p_dest, const godot_vector2 *p_a, const godot_real p_b); -void GDAPI godot_vector2_operator_divide_vector(godot_vector2 *p_dest, const godot_vector2 *p_a, const godot_vector2 *p_b); -void GDAPI godot_vector2_operator_divide_scalar(godot_vector2 *p_dest, const godot_vector2 *p_a, const godot_real p_b); +godot_vector2 GDAPI godot_vector2_operator_add(const godot_vector2 *p_v, const godot_vector2 p_b); +godot_vector2 GDAPI godot_vector2_operator_subtract(const godot_vector2 *p_v, const godot_vector2 p_b); +godot_vector2 GDAPI godot_vector2_operator_multiply_vector(const godot_vector2 *p_v, const godot_vector2 p_b); +godot_vector2 GDAPI godot_vector2_operator_multiply_scalar(const godot_vector2 *p_v, const godot_real p_b); +godot_vector2 GDAPI godot_vector2_operator_divide_vector(const godot_vector2 *p_v, const godot_vector2 p_b); +godot_vector2 GDAPI godot_vector2_operator_divide_scalar(const godot_vector2 *p_v, const godot_real p_b); -godot_bool GDAPI godot_vector2_operator_equal(const godot_vector2 *p_a, const godot_vector2 *p_b); -godot_bool GDAPI godot_vector2_operator_less(const godot_vector2 *p_a, const godot_vector2 *p_b); +godot_bool GDAPI godot_vector2_operator_equal(const godot_vector2 *p_v, const godot_vector2 p_b); +godot_bool GDAPI godot_vector2_operator_less(const godot_vector2 *p_v, const godot_vector2 p_b); #ifdef __cplusplus } diff --git a/modules/gdnative/godot/godot_vector3.cpp b/modules/gdnative/godot/godot_vector3.cpp index 41d1c1abf..5f71b9f7e 100644 --- a/modules/gdnative/godot/godot_vector3.cpp +++ b/modules/gdnative/godot/godot_vector3.cpp @@ -38,9 +38,11 @@ extern "C" { void _vector3_api_anchor() { } -void GDAPI godot_vector3_new(godot_vector3 *p_v, const godot_real p_x, const godot_real p_y, const godot_real p_z) { - Vector3 *v = (Vector3 *)p_v; +godot_vector3 GDAPI godot_vector3_new(const godot_real p_x, const godot_real p_y, const godot_real p_z) { + godot_vector3 value; + Vector3 *v = (Vector3 *)&value; *v = Vector3(p_x, p_y, p_z); + return value; } void GDAPI godot_vector3_set_axis(godot_vector3 *p_v, const godot_int p_axis, const godot_real p_val) { @@ -78,217 +80,261 @@ void GDAPI godot_vector3_normalize(godot_vector3 *p_v) { v->normalize(); } -void GDAPI godot_vector3_normalized(godot_vector3 *p_dest, const godot_vector3 *p_src) { - Vector3 *src = (Vector3 *)p_src; - Vector3 *dest = (Vector3 *)p_dest; - *dest = src->normalized(); +godot_vector3 GDAPI godot_vector3_normalized(const godot_vector3 *p_v) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + Vector3 *v = (Vector3 *)p_v; + *d = v->normalized(); + return dest; } -void godot_vector3_inverse(godot_vector3 *p_dest, const godot_vector3 *p_src) { - Vector3 *dest = (Vector3 *)p_dest; - const Vector3 *src = (Vector3 *)p_src; - *dest = src->inverse(); +godot_vector3 godot_vector3_inverse(const godot_vector3 *p_v) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Vector3 *v = (Vector3 *)p_v; + *d = v->inverse(); + return dest; } -void godot_vector3_zero(godot_vector3 *p_src) { - Vector3 *src = (Vector3 *)p_src; - src->zero(); +void godot_vector3_zero(godot_vector3 *p_v) { + Vector3 *v = (Vector3 *)p_v; + v->zero(); } -void godot_vector3_snap(godot_vector3 *p_src, godot_real val) { - Vector3 *src = (Vector3 *)p_src; - src->snap(val); +void godot_vector3_snap(godot_vector3 *p_v, const godot_real val) { + Vector3 *v = (Vector3 *)p_v; + v->snap(val); } -void godot_vector3_snapped(godot_vector3 *p_dest, const godot_vector3 *p_src, godot_real val) { - Vector3 *dest = (Vector3 *)p_dest; - const Vector3 *src = (Vector3 *)p_src; - *dest = src->snapped(val); +godot_vector3 godot_vector3_snapped(const godot_vector3 *p_v, const godot_real val) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Vector3 *v = (Vector3 *)p_v; + *d = v->snapped(val); + return dest; } -void godot_vector3_rotate(godot_vector3 *p_src, const godot_vector3 *p_axis, godot_real phi) { - Vector3 *src = (Vector3 *)p_src; - const Vector3 *axis = (Vector3 *)p_axis; - src->rotate(*axis, phi); +void godot_vector3_rotate(godot_vector3 *p_v, const godot_vector3 p_axis, const godot_real phi) { + Vector3 *v = (Vector3 *)p_v; + const Vector3 *axis = (Vector3 *)&p_axis; + v->rotate(*axis, phi); } -void godot_vector3_rotated(godot_vector3 *p_dest, const godot_vector3 *p_src, - const godot_vector3 *p_axis, godot_real phi) { - Vector3 *dest = (Vector3 *)p_dest; - const Vector3 *src = (Vector3 *)p_src; - const Vector3 *axis = (Vector3 *)p_axis; - *dest = src->rotated(*axis, phi); +godot_vector3 godot_vector3_rotated(const godot_vector3 *p_v, const godot_vector3 p_axis, const godot_real phi) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Vector3 *v = (Vector3 *)p_v; + const Vector3 *axis = (Vector3 *)&p_axis; + *d = v->rotated(*axis, phi); + return dest; } -void godot_vector3_linear_interpolate(godot_vector3 *p_dest, const godot_vector3 *p_src, - const godot_vector3 *p_b, godot_real t) { - Vector3 *dest = (Vector3 *)p_dest; - const Vector3 *src = (Vector3 *)p_src; - const Vector3 *b = (Vector3 *)p_b; - *dest = src->linear_interpolate(*b, t); +godot_vector3 godot_vector3_linear_interpolate(const godot_vector3 *p_v, const godot_vector3 p_b, const godot_real t) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Vector3 *v = (Vector3 *)p_v; + const Vector3 *b = (Vector3 *)&p_b; + *d = v->linear_interpolate(*b, t); + return dest; } -void godot_vector3_cubic_interpolate(godot_vector3 *p_dest, const godot_vector3 *p_src, - const godot_vector3 *p_b, const godot_vector3 *p_pre_a, - const godot_vector3 *p_post_b, godot_real t) { - Vector3 *dest = (Vector3 *)p_dest; - const Vector3 *src = (Vector3 *)p_src; - const Vector3 *b = (Vector3 *)p_b; - const Vector3 *pre_a = (Vector3 *)p_pre_a; - const Vector3 *post_b = (Vector3 *)p_post_b; - *dest = src->cubic_interpolate(*b, *pre_a, *post_b, t); +godot_vector3 godot_vector3_cubic_interpolate(const godot_vector3 *p_v, + const godot_vector3 p_b, const godot_vector3 p_pre_a, + const godot_vector3 p_post_b, const godot_real t) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Vector3 *v = (Vector3 *)p_v; + const Vector3 *b = (Vector3 *)&p_b; + const Vector3 *pre_a = (Vector3 *)&p_pre_a; + const Vector3 *post_b = (Vector3 *)&p_post_b; + *d = v->cubic_interpolate(*b, *pre_a, *post_b, t); + return dest; } -void godot_vector3_cubic_interpolaten(godot_vector3 *p_dest, const godot_vector3 *p_src, - const godot_vector3 *p_b, const godot_vector3 *p_pre_a, - const godot_vector3 *p_post_b, godot_real t) { - Vector3 *dest = (Vector3 *)p_dest; - const Vector3 *src = (Vector3 *)p_src; - const Vector3 *b = (Vector3 *)p_b; - const Vector3 *pre_a = (Vector3 *)p_pre_a; - const Vector3 *post_b = (Vector3 *)p_post_b; - *dest = src->cubic_interpolaten(*b, *pre_a, *post_b, t); +godot_vector3 godot_vector3_cubic_interpolaten(const godot_vector3 *p_v, + const godot_vector3 p_b, const godot_vector3 p_pre_a, + const godot_vector3 p_post_b, const godot_real t) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Vector3 *v = (Vector3 *)p_v; + const Vector3 *b = (Vector3 *)&p_b; + const Vector3 *pre_a = (Vector3 *)&p_pre_a; + const Vector3 *post_b = (Vector3 *)&p_post_b; + *d = v->cubic_interpolaten(*b, *pre_a, *post_b, t); + return dest; } -void godot_vector3_cross(godot_vector3 *p_dest, const godot_vector3 *p_src, const godot_vector3 *p_b) { - Vector3 *dest = (Vector3 *)p_dest; - const Vector3 *src = (Vector3 *)p_src; - const Vector3 *b = (Vector3 *)p_b; - *dest = src->cross(*b); +godot_vector3 godot_vector3_cross(const godot_vector3 *p_v, const godot_vector3 p_b) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Vector3 *v = (Vector3 *)p_v; + const Vector3 *b = (Vector3 *)&p_b; + *d = v->cross(*b); + return dest; } -godot_real godot_vector3_dot(const godot_vector3 *p_src, const godot_vector3 *p_b) { - const Vector3 *src = (Vector3 *)p_src; - const Vector3 *b = (Vector3 *)p_b; - return src->dot(*b); +godot_real godot_vector3_dot(const godot_vector3 *p_v, const godot_vector3 p_b) { + const Vector3 *v = (Vector3 *)p_v; + const Vector3 *b = (Vector3 *)&p_b; + return v->dot(*b); } -void godot_vector3_outer(godot_basis *p_dest, const godot_vector3 *p_src, const godot_vector3 *p_b) { - Basis *dest = (Basis *)p_dest; - const Vector3 *src = (Vector3 *)p_src; - const Vector3 *b = (Vector3 *)p_b; - *dest = src->outer(*b); +godot_basis godot_vector3_outer(const godot_vector3 *p_v, const godot_vector3 p_b) { + godot_basis dest; + Basis *d = (Basis *)&dest; + const Vector3 *v = (Vector3 *)p_v; + const Vector3 *b = (Vector3 *)&p_b; + *d = v->outer(*b); + return dest; } -void godot_vector3_to_diagonal_matrix(godot_basis *p_dest, const godot_vector3 *p_src) { - Basis *dest = (Basis *)p_dest; - const Vector3 *src = (Vector3 *)p_src; - *dest = src->to_diagonal_matrix(); +godot_basis godot_vector3_to_diagonal_matrix(const godot_vector3 *p_v) { + godot_basis dest; + Basis *d = (Basis *)&dest; + const Vector3 *v = (Vector3 *)p_v; + *d = v->to_diagonal_matrix(); + return dest; } -void godot_vector3_abs(godot_vector3 *p_dest, const godot_vector3 *p_src) { - Vector3 *dest = (Vector3 *)p_dest; - const Vector3 *src = (Vector3 *)p_src; - *dest = src->abs(); +godot_vector3 godot_vector3_abs(const godot_vector3 *p_v) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Vector3 *v = (Vector3 *)p_v; + *d = v->abs(); + return dest; } -void godot_vector3_floor(godot_vector3 *p_dest, const godot_vector3 *p_src) { - Vector3 *dest = (Vector3 *)p_dest; - const Vector3 *src = (Vector3 *)p_src; - *dest = src->floor(); +godot_vector3 godot_vector3_floor(const godot_vector3 *p_v) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Vector3 *v = (Vector3 *)p_v; + *d = v->floor(); + return dest; } -void godot_vector3_ceil(godot_vector3 *p_dest, const godot_vector3 *p_src) { - const Vector3 *src = (Vector3 *)p_src; - Vector3 *dest = (Vector3 *)p_dest; - *dest = src->ceil(); +godot_vector3 godot_vector3_ceil(const godot_vector3 *p_v) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Vector3 *v = (Vector3 *)p_v; + *d = v->ceil(); + return dest; } -godot_real GDAPI godot_vector3_distance_to(const godot_vector3 *p_a, const godot_vector3 *p_b) { - Vector3 *a = (Vector3 *)p_a; - Vector3 *b = (Vector3 *)p_b; - return a->distance_to(*b); +godot_real GDAPI godot_vector3_distance_to(const godot_vector3 *p_v, const godot_vector3 p_b) { + Vector3 *v = (Vector3 *)p_v; + Vector3 *b = (Vector3 *)&p_b; + return v->distance_to(*b); } -godot_real GDAPI godot_vector3_distance_squared_to(const godot_vector3 *p_a, const godot_vector3 *p_b) { - Vector3 *a = (Vector3 *)p_a; - Vector3 *b = (Vector3 *)p_b; - return a->distance_squared_to(*b); +godot_real GDAPI godot_vector3_distance_squared_to(const godot_vector3 *p_v, const godot_vector3 p_b) { + Vector3 *v = (Vector3 *)p_v; + Vector3 *b = (Vector3 *)&p_b; + return v->distance_squared_to(*b); } -godot_real GDAPI godot_vector3_angle_to(const godot_vector3 *p_a, const godot_vector3 *p_b) { - Vector3 *a = (Vector3 *)p_a; - Vector3 *b = (Vector3 *)p_b; - return a->angle_to(*b); +godot_real GDAPI godot_vector3_angle_to(const godot_vector3 *p_v, const godot_vector3 p_b) { + Vector3 *v = (Vector3 *)p_v; + Vector3 *b = (Vector3 *)&p_b; + return v->angle_to(*b); } -void godot_vector3_slide(godot_vector3 *p_dest, const godot_vector3 *p_src, const godot_vector3 *p_vec) { - const Vector3 *src = (Vector3 *)p_src; - const Vector3 *vec = (Vector3 *)p_vec; - Vector3 *dest = (Vector3 *)p_dest; - *dest = src->slide(*vec); +godot_vector3 godot_vector3_slide(const godot_vector3 *p_v, const godot_vector3 p_vec) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Vector3 *v = (Vector3 *)p_v; + const Vector3 *vec = (Vector3 *)&p_vec; + *d = v->slide(*vec); + return dest; } -void godot_vector3_bounce(godot_vector3 *p_dest, const godot_vector3 *p_src, const godot_vector3 *p_vec) { - const Vector3 *src = (Vector3 *)p_src; - const Vector3 *vec = (Vector3 *)p_vec; - Vector3 *dest = (Vector3 *)p_dest; - *dest = src->bounce(*vec); +godot_vector3 godot_vector3_bounce(const godot_vector3 *p_v, const godot_vector3 p_vec) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Vector3 *v = (Vector3 *)p_v; + const Vector3 *vec = (Vector3 *)&p_vec; + *d = v->bounce(*vec); + return dest; } -void godot_vector3_reflect(godot_vector3 *p_dest, const godot_vector3 *p_src, const godot_vector3 *p_vec) { - const Vector3 *src = (Vector3 *)p_src; - const Vector3 *vec = (Vector3 *)p_vec; - Vector3 *dest = (Vector3 *)p_dest; - *dest = src->reflect(*vec); +godot_vector3 godot_vector3_reflect(const godot_vector3 *p_v, const godot_vector3 p_vec) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + const Vector3 *v = (Vector3 *)p_v; + const Vector3 *vec = (Vector3 *)&p_vec; + *d = v->reflect(*vec); + return dest; } -void GDAPI godot_vector3_operator_add(godot_vector3 *p_dest, const godot_vector3 *p_a, const godot_vector3 *p_b) { - Vector3 *dest = (Vector3 *)p_dest; - Vector3 *a = (Vector3 *)p_a; - Vector3 *b = (Vector3 *)p_b; - *dest = *a + *b; +godot_vector3 GDAPI godot_vector3_operator_add(const godot_vector3 *p_v, const godot_vector3 p_b) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + Vector3 *v = (Vector3 *)p_v; + Vector3 *b = (Vector3 *)&p_b; + *d = *v + *b; + return dest; } -void GDAPI godot_vector3_operator_subtract(godot_vector3 *p_dest, const godot_vector3 *p_a, const godot_vector3 *p_b) { - Vector3 *dest = (Vector3 *)p_dest; - Vector3 *a = (Vector3 *)p_a; - Vector3 *b = (Vector3 *)p_b; - *dest = *a - *b; +godot_vector3 GDAPI godot_vector3_operator_subtract(const godot_vector3 *p_v, const godot_vector3 p_b) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + Vector3 *v = (Vector3 *)p_v; + Vector3 *b = (Vector3 *)&p_b; + *d = *v - *b; + return dest; } -void GDAPI godot_vector3_operator_multiply_vector(godot_vector3 *p_dest, const godot_vector3 *p_a, const godot_vector3 *p_b) { - Vector3 *dest = (Vector3 *)p_dest; - Vector3 *a = (Vector3 *)p_a; - Vector3 *b = (Vector3 *)p_b; - *dest = *a * *b; +godot_vector3 GDAPI godot_vector3_operator_multiply_vector(const godot_vector3 *p_v, const godot_vector3 p_b) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + Vector3 *v = (Vector3 *)p_v; + Vector3 *b = (Vector3 *)&p_b; + *d = *v * *b; + return dest; } -void GDAPI godot_vector3_operator_multiply_scalar(godot_vector3 *p_dest, const godot_vector3 *p_a, const godot_real p_b) { - Vector3 *dest = (Vector3 *)p_dest; - Vector3 *a = (Vector3 *)p_a; - *dest = *a * p_b; +godot_vector3 GDAPI godot_vector3_operator_multiply_scalar(const godot_vector3 *p_v, const godot_real p_b) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + Vector3 *v = (Vector3 *)p_v; + *d = *v * p_b; + return dest; } -void GDAPI godot_vector3_operator_divide_vector(godot_vector3 *p_dest, const godot_vector3 *p_a, const godot_vector3 *p_b) { - Vector3 *dest = (Vector3 *)p_dest; - Vector3 *a = (Vector3 *)p_a; - Vector3 *b = (Vector3 *)p_b; - *dest = *a / *b; +godot_vector3 GDAPI godot_vector3_operator_divide_vector(const godot_vector3 *p_v, const godot_vector3 p_b) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + Vector3 *v = (Vector3 *)p_v; + Vector3 *b = (Vector3 *)&p_b; + *d = *v / *b; + return dest; } -void GDAPI godot_vector3_operator_divide_scalar(godot_vector3 *p_dest, const godot_vector3 *p_a, const godot_real p_b) { - Vector3 *dest = (Vector3 *)p_dest; - Vector3 *a = (Vector3 *)p_a; - *dest = *a / p_b; +godot_vector3 GDAPI godot_vector3_operator_divide_scalar(const godot_vector3 *p_v, const godot_real p_b) { + godot_vector3 dest; + Vector3 *d = (Vector3 *)&dest; + Vector3 *v = (Vector3 *)p_v; + *d = *v / p_b; + return dest; } -godot_bool GDAPI godot_vector3_operator_equal(const godot_vector3 *p_a, const godot_vector3 *p_b) { - Vector3 *a = (Vector3 *)p_a; - Vector3 *b = (Vector3 *)p_b; - return *a == *b; +godot_bool GDAPI godot_vector3_operator_equal(const godot_vector3 *p_v, const godot_vector3 p_b) { + Vector3 *v = (Vector3 *)p_v; + Vector3 *b = (Vector3 *)&p_b; + return *v == *b; } -godot_bool GDAPI godot_vector3_operator_less(const godot_vector3 *p_a, const godot_vector3 *p_b) { - Vector3 *a = (Vector3 *)p_a; - Vector3 *b = (Vector3 *)p_b; - return *a < *b; +godot_bool GDAPI godot_vector3_operator_less(const godot_vector3 *p_v, const godot_vector3 p_b) { + Vector3 *v = (Vector3 *)p_v; + Vector3 *b = (Vector3 *)&p_b; + return *v < *b; } -void GDAPI godot_vector3_to_string(godot_string *p_dest, const godot_vector3 *p_src) { - const Vector3 *src = (Vector3 *)p_src; - String *dest = (String *)p_dest; - *dest = "(" + *src + ")"; +godot_string GDAPI godot_vector3_to_string(const godot_vector3 *p_v) { + godot_string dest; + String *d = (String *)&dest; + const Vector3 *v = (Vector3 *)p_v; + *d = "(" + *v + ")"; + return dest; } #ifdef __cplusplus diff --git a/modules/gdnative/godot/godot_vector3.h b/modules/gdnative/godot/godot_vector3.h index bc141bcfe..654ddd779 100644 --- a/modules/gdnative/godot/godot_vector3.h +++ b/modules/gdnative/godot/godot_vector3.h @@ -49,7 +49,7 @@ typedef struct godot_vector3 { #include "../godot.h" #include "godot_basis.h" -void GDAPI godot_vector3_new(godot_vector3 *p_v, const godot_real p_x, const godot_real p_y, const godot_real p_z); +godot_vector3 GDAPI godot_vector3_new(const godot_real p_x, const godot_real p_y, const godot_real p_z); void GDAPI godot_vector3_set_axis(godot_vector3 *p_v, const godot_int p_axis, const godot_real p_val); godot_real GDAPI godot_vector3_get_axis(const godot_vector3 *p_v, const godot_int p_axis); @@ -61,50 +61,50 @@ godot_real GDAPI godot_vector3_length(const godot_vector3 *p_v); godot_real GDAPI godot_vector3_length_squared(const godot_vector3 *p_v); void GDAPI godot_vector3_normalize(godot_vector3 *p_v); -void GDAPI godot_vector3_normalized(godot_vector3 *p_dest, const godot_vector3 *p_src); +godot_vector3 GDAPI godot_vector3_normalized(const godot_vector3 *p_v); -void GDAPI godot_vector3_inverse(godot_vector3 *p_dest, const godot_vector3 *p_src); -void GDAPI godot_vector3_zero(godot_vector3 *p_src); -void GDAPI godot_vector3_snap(godot_vector3 *p_src, godot_real val); -void GDAPI godot_vector3_snapped(godot_vector3 *p_dest, const godot_vector3 *p_src, godot_real val); -void GDAPI godot_vector3_rotate(godot_vector3 *p_src, const godot_vector3 *p_axis, godot_real phi); -void GDAPI godot_vector3_rotated(godot_vector3 *p_dest, const godot_vector3 *p_src, - const godot_vector3 *p_axis, godot_real phi); -void GDAPI godot_vector3_linear_interpolate(godot_vector3 *p_dest, const godot_vector3 *p_src, - const godot_vector3 *p_b, godot_real t); -void GDAPI godot_vector3_cubic_interpolate(godot_vector3 *p_dest, const godot_vector3 *p_src, - const godot_vector3 *p_b, const godot_vector3 *p_pre_a, - const godot_vector3 *p_post_b, godot_real t); -void GDAPI godot_vector3_cubic_interpolaten(godot_vector3 *p_dest, const godot_vector3 *p_src, - const godot_vector3 *p_b, const godot_vector3 *p_pre_a, - const godot_vector3 *p_post_b, godot_real t); -void GDAPI godot_vector3_cross(godot_vector3 *p_dest, const godot_vector3 *p_src, const godot_vector3 *p_b); -godot_real GDAPI godot_vector3_dot(const godot_vector3 *p_src, const godot_vector3 *p_b); -void GDAPI godot_vector3_outer(godot_basis *dest, const godot_vector3 *p_src, const godot_vector3 *p_b); -void GDAPI godot_vector3_to_diagonal_matrix(godot_basis *dest, const godot_vector3 *p_src); -void GDAPI godot_vector3_abs(godot_vector3 *p_dest, const godot_vector3 *p_src); -void GDAPI godot_vector3_floor(godot_vector3 *p_dest, const godot_vector3 *p_src); -void GDAPI godot_vector3_ceil(godot_vector3 *p_dest, const godot_vector3 *p_src); +godot_vector3 GDAPI godot_vector3_inverse(const godot_vector3 *p_v); +void GDAPI godot_vector3_zero(godot_vector3 *p_v); +void GDAPI godot_vector3_snap(godot_vector3 *p_v, const godot_real val); +godot_vector3 GDAPI godot_vector3_snapped(const godot_vector3 *p_v, const godot_real val); +void GDAPI godot_vector3_rotate(godot_vector3 *p_v, const godot_vector3 p_axis, const godot_real phi); +godot_vector3 GDAPI godot_vector3_rotated(const godot_vector3 *p_v, + const godot_vector3 p_axis, const godot_real phi); +godot_vector3 GDAPI godot_vector3_linear_interpolate(const godot_vector3 *p_v, + const godot_vector3 p_b, const godot_real t); +godot_vector3 GDAPI godot_vector3_cubic_interpolate(const godot_vector3 *p_v, + const godot_vector3 p_b, const godot_vector3 p_pre_a, + const godot_vector3 p_post_b, const godot_real t); +godot_vector3 GDAPI godot_vector3_cubic_interpolaten(const godot_vector3 *p_v, + const godot_vector3 p_b, const godot_vector3 p_pre_a, + const godot_vector3 p_post_b, const godot_real t); +godot_vector3 GDAPI godot_vector3_cross(const godot_vector3 *p_v, const godot_vector3 p_b); +godot_real GDAPI godot_vector3_dot(const godot_vector3 *p_v, const godot_vector3 p_b); +godot_basis GDAPI godot_vector3_outer(const godot_vector3 *p_v, const godot_vector3 p_b); +godot_basis GDAPI godot_vector3_to_diagonal_matrix(const godot_vector3 *p_v); +godot_vector3 GDAPI godot_vector3_abs(const godot_vector3 *p_v); +godot_vector3 GDAPI godot_vector3_floor(const godot_vector3 *p_v); +godot_vector3 GDAPI godot_vector3_ceil(const godot_vector3 *p_v); -godot_real GDAPI godot_vector3_distance_to(const godot_vector3 *p_a, const godot_vector3 *p_b); -godot_real GDAPI godot_vector3_distance_squared_to(const godot_vector3 *p_a, const godot_vector3 *p_b); -godot_real GDAPI godot_vector3_angle_to(const godot_vector3 *p_a, const godot_vector3 *p_b); +godot_real GDAPI godot_vector3_distance_to(const godot_vector3 *p_v, const godot_vector3 p_b); +godot_real GDAPI godot_vector3_distance_squared_to(const godot_vector3 *p_v, const godot_vector3 p_b); +godot_real GDAPI godot_vector3_angle_to(const godot_vector3 *p_v, const godot_vector3 p_b); -void GDAPI godot_vector3_slide(godot_vector3 *p_dest, const godot_vector3 *p_src, const godot_vector3 *p_vec); -void GDAPI godot_vector3_bounce(godot_vector3 *p_dest, const godot_vector3 *p_src, const godot_vector3 *p_vec); -void GDAPI godot_vector3_reflect(godot_vector3 *p_dest, const godot_vector3 *p_src, const godot_vector3 *p_vec); +godot_vector3 GDAPI godot_vector3_slide(const godot_vector3 *p_v, const godot_vector3 p_vec); +godot_vector3 GDAPI godot_vector3_bounce(const godot_vector3 *p_v, const godot_vector3 p_vec); +godot_vector3 GDAPI godot_vector3_reflect(const godot_vector3 *p_v, const godot_vector3 p_vec); -void GDAPI godot_vector3_operator_add(godot_vector3 *p_dest, const godot_vector3 *p_a, const godot_vector3 *p_b); -void GDAPI godot_vector3_operator_subtract(godot_vector3 *p_dest, const godot_vector3 *p_a, const godot_vector3 *p_b); -void GDAPI godot_vector3_operator_multiply_vector(godot_vector3 *p_dest, const godot_vector3 *p_a, const godot_vector3 *p_b); -void GDAPI godot_vector3_operator_multiply_scalar(godot_vector3 *p_dest, const godot_vector3 *p_a, const godot_real p_b); -void GDAPI godot_vector3_operator_divide_vector(godot_vector3 *p_dest, const godot_vector3 *p_a, const godot_vector3 *p_b); -void GDAPI godot_vector3_operator_divide_scalar(godot_vector3 *p_dest, const godot_vector3 *p_a, const godot_real p_b); +godot_vector3 GDAPI godot_vector3_operator_add(const godot_vector3 *p_v, const godot_vector3 p_b); +godot_vector3 GDAPI godot_vector3_operator_subtract(const godot_vector3 *p_v, const godot_vector3 p_b); +godot_vector3 GDAPI godot_vector3_operator_multiply_vector(const godot_vector3 *p_v, const godot_vector3 p_b); +godot_vector3 GDAPI godot_vector3_operator_multiply_scalar(const godot_vector3 *p_v, const godot_real p_b); +godot_vector3 GDAPI godot_vector3_operator_divide_vector(const godot_vector3 *p_v, const godot_vector3 p_b); +godot_vector3 GDAPI godot_vector3_operator_divide_scalar(const godot_vector3 *p_v, const godot_real p_b); -godot_bool GDAPI godot_vector3_operator_equal(const godot_vector3 *p_a, const godot_vector3 *p_b); -godot_bool GDAPI godot_vector3_operator_less(const godot_vector3 *p_a, const godot_vector3 *p_b); +godot_bool GDAPI godot_vector3_operator_equal(const godot_vector3 *p_v, const godot_vector3 p_b); +godot_bool GDAPI godot_vector3_operator_less(const godot_vector3 *p_v, const godot_vector3 p_b); -void GDAPI godot_vector3_to_string(godot_string *p_dest, const godot_vector3 *p_src); +godot_string GDAPI godot_vector3_to_string(const godot_vector3 *p_v); #ifdef __cplusplus } diff --git a/modules/gdscript/gd_editor.cpp b/modules/gdscript/gd_editor.cpp index ae5bb5694..7d5ba08d6 100644 --- a/modules/gdscript/gd_editor.cpp +++ b/modules/gdscript/gd_editor.cpp @@ -27,10 +27,15 @@ /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ +#include "editor/editor_settings.h" #include "gd_compiler.h" #include "gd_script.h" #include "global_config.h" #include "os/file_access.h" +#ifdef TOOLS_ENABLED +#include "editor/editor_file_system.h" +#include "editor/editor_settings.h" +#endif void GDScriptLanguage::get_comment_delimiters(List<String> *p_delimiters) const { @@ -50,11 +55,12 @@ Ref<Script> GDScriptLanguage::get_template(const String &p_class_name, const Str "# var a = 2\n" + "# var b = \"textvar\"\n\n" + "func _ready():\n" + - "\t# Called every time the node is added to the scene.\n" + - "\t# Initialization here\n" + - "\tpass\n"; + "%TS%# Called every time the node is added to the scene.\n" + + "%TS%# Initialization here\n" + + "%TS%pass\n"; _template = _template.replace("%BASE%", p_base_class_name); + _template = _template.replace("%TS%", _get_indentation()); Ref<GDScript> script; script.instance(); @@ -1315,7 +1321,7 @@ static void _find_identifiers(GDCompletionContext &context, int p_line, bool p_o static const char *_type_names[Variant::VARIANT_MAX] = { "null", "bool", "int", "float", "String", "Vector2", "Rect2", "Vector3", "Transform2D", "Plane", "Quat", "AABB", "Basis", "Transform", - "Color", "Image", "NodePath", "RID", "Object", "InputEvent", "Dictionary", "Array", "RawArray", "IntArray", "FloatArray", "StringArray", + "Color", "NodePath", "RID", "Object", "InputEvent", "Dictionary", "Array", "RawArray", "IntArray", "FloatArray", "StringArray", "Vector2Array", "Vector3Array", "ColorArray" }; @@ -1405,6 +1411,17 @@ static void _make_function_hint(const GDParser::FunctionNode *p_func, int p_argi arghint += ")"; } +void get_directory_contents(EditorFileSystemDirectory *p_dir, Set<String> &r_list) { + + for (int i = 0; i < p_dir->get_subdir_count(); i++) { + get_directory_contents(p_dir->get_subdir(i), r_list); + } + + for (int i = 0; i < p_dir->get_file_count(); i++) { + r_list.insert("\"" + p_dir->get_file_path(i) + "\""); + } +} + static void _find_type_arguments(GDCompletionContext &context, const GDParser::Node *p_node, int p_line, const StringName &p_method, const GDCompletionIdentifier &id, int p_argidx, Set<String> &result, String &arghint) { //print_line("find type arguments?"); @@ -1753,6 +1770,10 @@ static void _find_call_arguments(GDCompletionContext &context, const GDParser::N const GDParser::BuiltInFunctionNode *fn = static_cast<const GDParser::BuiltInFunctionNode *>(op->arguments[0]); MethodInfo mi = GDFunctions::get_info(fn->function); + if (mi.name == "load" && bool(EditorSettings::get_singleton()->get("text_editor/completion/complete_file_paths"))) { + get_directory_contents(EditorFileSystem::get_singleton()->get_filesystem(), result); + } + arghint = _get_visual_datatype(mi.return_val, false) + " " + GDFunctions::get_func_name(fn->function) + String("("); for (int i = 0; i < mi.arguments.size(); i++) { if (i > 0) @@ -2374,6 +2395,11 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_base } } break; + case GDParser::COMPLETION_RESOURCE_PATH: { + + if (EditorSettings::get_singleton()->get("text_editor/completion/complete_file_paths")) + get_directory_contents(EditorFileSystem::get_singleton()->get_filesystem(), options); + } break; } for (Set<String>::Element *E = options.front(); E; E = E->next()) { @@ -2391,8 +2417,29 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_base #endif +String GDScriptLanguage::_get_indentation() const { +#ifdef TOOLS_ENABLED + if (SceneTree::get_singleton()->is_editor_hint()) { + bool use_space_indentation = EDITOR_DEF("text_editor/indent/type", 0); + + if (use_space_indentation) { + int indent_size = EDITOR_DEF("text_editor/indent/size", 4); + + String space_indent = ""; + for (int i = 0; i < indent_size; i++) { + space_indent += " "; + } + return space_indent; + } + } +#endif + return "\t"; +} + void GDScriptLanguage::auto_indent_code(String &p_code, int p_from_line, int p_to_line) const { + String indent = _get_indentation(); + Vector<String> lines = p_code.split("\n"); List<int> indent_stack; @@ -2432,8 +2479,9 @@ void GDScriptLanguage::auto_indent_code(String &p_code, int p_from_line, int p_t if (i >= p_from_line) { l = ""; - for (int j = 0; j < indent_stack.size(); j++) - l += "\t"; + for (int j = 0; j < indent_stack.size(); j++) { + l += indent; + } l += st; } else if (i > p_to_line) { diff --git a/modules/gdscript/gd_function.cpp b/modules/gdscript/gd_function.cpp index 608256c88..fb32d23ad 100644 --- a/modules/gdscript/gd_function.cpp +++ b/modules/gdscript/gd_function.cpp @@ -1433,9 +1433,21 @@ Variant GDFunctionState::_signal_callback(const Variant **p_args, int p_argcount return ret; } -bool GDFunctionState::is_valid() const { +bool GDFunctionState::is_valid(bool p_extended_check) const { - return function != NULL; + if (function == NULL) + return false; + + if (p_extended_check) { + //class instance gone? + if (state.instance_id && !ObjectDB::get_instance(state.instance_id)) + return false; + //script gone? + if (state.script_id && !ObjectDB::get_instance(state.script_id)) + return false; + } + + return true; } Variant GDFunctionState::resume(const Variant &p_arg) { @@ -1464,7 +1476,7 @@ Variant GDFunctionState::resume(const Variant &p_arg) { void GDFunctionState::_bind_methods() { ClassDB::bind_method(D_METHOD("resume:Variant", "arg"), &GDFunctionState::resume, DEFVAL(Variant())); - ClassDB::bind_method(D_METHOD("is_valid"), &GDFunctionState::is_valid); + ClassDB::bind_method(D_METHOD("is_valid", "extended_check"), &GDFunctionState::is_valid, DEFVAL(false)); ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "_signal_callback", &GDFunctionState::_signal_callback, MethodInfo("_signal_callback")); } diff --git a/modules/gdscript/gd_function.h b/modules/gdscript/gd_function.h index f0bf33147..6d20b1977 100644 --- a/modules/gdscript/gd_function.h +++ b/modules/gdscript/gd_function.h @@ -237,7 +237,7 @@ protected: static void _bind_methods(); public: - bool is_valid() const; + bool is_valid(bool p_extended_check = false) const; Variant resume(const Variant &p_arg = Variant()); GDFunctionState(); ~GDFunctionState(); diff --git a/modules/gdscript/gd_parser.cpp b/modules/gdscript/gd_parser.cpp index cd16fef6b..4ae62eb1d 100644 --- a/modules/gdscript/gd_parser.cpp +++ b/modules/gdscript/gd_parser.cpp @@ -389,6 +389,19 @@ GDParser::Node *GDParser::_parse_expression(Node *p_parent, bool p_static, bool } tokenizer->advance(); + if (tokenizer->get_token() == GDTokenizer::TK_CURSOR) { + completion_cursor = StringName(); + completion_node = p_parent; + completion_type = COMPLETION_RESOURCE_PATH; + completion_class = current_class; + completion_function = current_function; + completion_line = tokenizer->get_token_line(); + completion_block = current_block; + completion_argument = 0; + completion_found = true; + tokenizer->advance(); + } + String path; bool found_constant = false; bool valid = false; @@ -460,10 +473,10 @@ GDParser::Node *GDParser::_parse_expression(Node *p_parent, bool p_static, bool _set_error("Expected ')' after 'preload' path"); return NULL; } + tokenizer->advance(); ConstantNode *constant = alloc_node<ConstantNode>(); constant->value = res; - tokenizer->advance(); expr = constant; } else if (tokenizer->get_token() == GDTokenizer::TK_PR_YIELD) { diff --git a/modules/gdscript/gd_parser.h b/modules/gdscript/gd_parser.h index 445ad7361..7e7e19de1 100644 --- a/modules/gdscript/gd_parser.h +++ b/modules/gdscript/gd_parser.h @@ -437,6 +437,7 @@ public: COMPLETION_PARENT_FUNCTION, COMPLETION_METHOD, COMPLETION_CALL_ARGUMENTS, + COMPLETION_RESOURCE_PATH, COMPLETION_INDEX, COMPLETION_VIRTUAL_FUNC, COMPLETION_YIELD, diff --git a/modules/gdscript/gd_script.cpp b/modules/gdscript/gd_script.cpp index 2367f6074..173014b13 100644 --- a/modules/gdscript/gd_script.cpp +++ b/modules/gdscript/gd_script.cpp @@ -1697,8 +1697,8 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so #ifdef TOOLS_ENABLED while (E->get()->placeholders.size()) { - Object *obj = E->get()->placeholders.front()->get()->get_owner(); + //save instance info List<Pair<StringName, Variant> > state; if (obj->get_script_instance()) { @@ -1706,6 +1706,9 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so obj->get_script_instance()->get_property_state(state); map[obj->get_instance_ID()] = state; obj->set_script(RefPtr()); + } else { + // no instance found. Let's remove it so we don't loop forever + E->get()->placeholders.erase(E->get()->placeholders.front()->get()); } } #endif diff --git a/modules/gdscript/gd_script.h b/modules/gdscript/gd_script.h index 93f8ee872..00ae13679 100644 --- a/modules/gdscript/gd_script.h +++ b/modules/gdscript/gd_script.h @@ -384,12 +384,14 @@ public: virtual bool validate(const String &p_script, int &r_line_error, int &r_col_error, String &r_test_error, const String &p_path = "", List<String> *r_functions = NULL) const; virtual Script *create_script() const; virtual bool has_named_classes() const; + virtual bool can_inherit_from_file() { return true; } virtual int find_function(const String &p_function, const String &p_code) const; virtual String make_function(const String &p_class, const String &p_name, const PoolStringArray &p_args) const; virtual Error complete_code(const String &p_code, const String &p_base_path, Object *p_owner, List<String> *r_options, String &r_call_hint); #ifdef TOOLS_ENABLED virtual Error lookup_code(const String &p_code, const String &p_symbol, const String &p_base_path, Object *p_owner, LookupResult &r_result); #endif + virtual String _get_indentation() const; virtual void auto_indent_code(String &p_code, int p_from_line, int p_to_line) const; virtual void add_global_constant(const StringName &p_variable, const Variant &p_value); diff --git a/modules/gdscript/gd_tokenizer.cpp b/modules/gdscript/gd_tokenizer.cpp index 13674f1f9..c26ba03a6 100644 --- a/modules/gdscript/gd_tokenizer.cpp +++ b/modules/gdscript/gd_tokenizer.cpp @@ -800,7 +800,6 @@ void GDTokenizerText::_advance() { { Variant::BASIS, "Basis" }, { Variant::TRANSFORM, "Transform" }, { Variant::COLOR, "Color" }, - { Variant::IMAGE, "Image" }, { Variant::_RID, "RID" }, { Variant::OBJECT, "Object" }, { Variant::INPUT_EVENT, "InputEvent" }, diff --git a/modules/gridmap/grid_map_editor_plugin.cpp b/modules/gridmap/grid_map_editor_plugin.cpp index 39fe0a167..d8993710a 100644 --- a/modules/gridmap/grid_map_editor_plugin.cpp +++ b/modules/gridmap/grid_map_editor_plugin.cpp @@ -519,12 +519,12 @@ bool GridMapEditor::forward_spatial_input_event(Camera *p_camera, const InputEve if (p_event.mouse_button.button_index == BUTTON_WHEEL_UP && (p_event.mouse_button.mod.command || p_event.mouse_button.mod.shift)) { if (p_event.mouse_button.pressed) - floor->set_value(floor->get_value() + 1); + floor->set_value(floor->get_value() + p_event.mouse_button.factor); return true; //eaten } else if (p_event.mouse_button.button_index == BUTTON_WHEEL_DOWN && (p_event.mouse_button.mod.command || p_event.mouse_button.mod.shift)) { if (p_event.mouse_button.pressed) - floor->set_value(floor->get_value() - 1); + floor->set_value(floor->get_value() - p_event.mouse_button.factor); return true; } diff --git a/modules/jpg/image_loader_jpegd.cpp b/modules/jpg/image_loader_jpegd.cpp index 83685d644..0741dd198 100644 --- a/modules/jpg/image_loader_jpegd.cpp +++ b/modules/jpg/image_loader_jpegd.cpp @@ -89,7 +89,7 @@ Error jpeg_load_image_from_buffer(Image *p_image, const uint8_t *p_buffer, int p return OK; } -Error ImageLoaderJPG::load_image(Image *p_image, FileAccess *f) { +Error ImageLoaderJPG::load_image(Ref<Image> p_image, FileAccess *f) { PoolVector<uint8_t> src_image; int src_image_len = f->get_len(); @@ -102,7 +102,7 @@ Error ImageLoaderJPG::load_image(Image *p_image, FileAccess *f) { f->close(); - Error err = jpeg_load_image_from_buffer(p_image, w.ptr(), src_image_len); + Error err = jpeg_load_image_from_buffer(p_image.ptr(), w.ptr(), src_image_len); w = PoolVector<uint8_t>::Write(); @@ -115,10 +115,11 @@ void ImageLoaderJPG::get_recognized_extensions(List<String> *p_extensions) const p_extensions->push_back("jpeg"); } -static Image _jpegd_mem_loader_func(const uint8_t *p_png, int p_size) { +static Ref<Image> _jpegd_mem_loader_func(const uint8_t *p_png, int p_size) { - Image img; - Error err = jpeg_load_image_from_buffer(&img, p_png, p_size); + Ref<Image> img; + img.instance(); + Error err = jpeg_load_image_from_buffer(img.ptr(), p_png, p_size); if (err) ERR_PRINT("Couldn't initialize ImageLoaderJPG with the given resource."); diff --git a/modules/jpg/image_loader_jpegd.h b/modules/jpg/image_loader_jpegd.h index d23e8a7d4..57d7a2bb1 100644 --- a/modules/jpg/image_loader_jpegd.h +++ b/modules/jpg/image_loader_jpegd.h @@ -38,7 +38,7 @@ class ImageLoaderJPG : public ImageFormatLoader { public: - virtual Error load_image(Image *p_image, FileAccess *f); + virtual Error load_image(Ref<Image> p_image, FileAccess *f); virtual void get_recognized_extensions(List<String> *p_extensions) const; ImageLoaderJPG(); }; diff --git a/modules/openssl/SCsub b/modules/openssl/SCsub index 0e811ce8c..add7d4dcf 100644 --- a/modules/openssl/SCsub +++ b/modules/openssl/SCsub @@ -677,7 +677,16 @@ if (env['builtin_openssl'] != 'no'): # Module sources env_openssl.add_source_files(env.modules_sources, "*.cpp") -env_openssl.add_source_files(env.modules_sources, "*.c") + + +# Other thirdparty dependencies +thirdparty_misc_dir = "#thirdparty/misc/" +thirdparty_misc_sources = [ + "curl_hostcheck.c", +] +thirdparty_misc_sources = [thirdparty_misc_dir + file for file in thirdparty_misc_sources] +env_openssl.add_source_files(env.modules_sources, thirdparty_misc_sources) + # platform/uwp need to know openssl is available, pass to main env if "platform" in env and env["platform"] == "uwp": diff --git a/modules/openssl/curl_hostcheck.c b/modules/openssl/curl_hostcheck.c deleted file mode 100644 index feef23261..000000000 --- a/modules/openssl/curl_hostcheck.c +++ /dev/null @@ -1,217 +0,0 @@ -/*************************************************************************** - * _ _ ____ _ - * Project ___| | | | _ \| | - * / __| | | | |_) | | - * | (__| |_| | _ <| |___ - * \___|\___/|_| \_\_____| - * - * Copyright (C) 1998 - 2012, Daniel Stenberg, <daniel@haxx.se>, et al. - * - * This software is licensed as described in the file COPYING, which - * you should have received as part of this distribution. The terms - * are also available at http://curl.haxx.se/docs/copyright.html. - * - * You may opt to use, copy, modify, merge, publish, distribute and/or sell - * copies of the Software, and permit persons to whom the Software is - * furnished to do so, under the terms of the COPYING file. - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY - * KIND, either express or implied. - * - ***************************************************************************/ - -/* This file is an amalgamation of hostcheck.c and most of rawstr.c - from cURL. The contents of the COPYING file mentioned above are: - -COPYRIGHT AND PERMISSION NOTICE - -Copyright (c) 1996 - 2013, Daniel Stenberg, <daniel@haxx.se>. - -All rights reserved. - -Permission to use, copy, modify, and distribute this software for any purpose -with or without fee is hereby granted, provided that the above copyright -notice and this permission notice appear in all copies. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN -NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, -DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR -OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE -OR OTHER DEALINGS IN THE SOFTWARE. - -Except as contained in this notice, the name of a copyright holder shall not -be used in advertising or otherwise to promote the sale, use or other dealings -in this Software without prior written authorization of the copyright holder. -*/ - -#include "curl_hostcheck.h" -#include <string.h> - -/* Portable, consistent toupper (remember EBCDIC). Do not use toupper() because - its behavior is altered by the current locale. */ -static char Curl_raw_toupper(char in) -{ - switch (in) { - case 'a': - return 'A'; - case 'b': - return 'B'; - case 'c': - return 'C'; - case 'd': - return 'D'; - case 'e': - return 'E'; - case 'f': - return 'F'; - case 'g': - return 'G'; - case 'h': - return 'H'; - case 'i': - return 'I'; - case 'j': - return 'J'; - case 'k': - return 'K'; - case 'l': - return 'L'; - case 'm': - return 'M'; - case 'n': - return 'N'; - case 'o': - return 'O'; - case 'p': - return 'P'; - case 'q': - return 'Q'; - case 'r': - return 'R'; - case 's': - return 'S'; - case 't': - return 'T'; - case 'u': - return 'U'; - case 'v': - return 'V'; - case 'w': - return 'W'; - case 'x': - return 'X'; - case 'y': - return 'Y'; - case 'z': - return 'Z'; - } - return in; -} - -/* - * Curl_raw_equal() is for doing "raw" case insensitive strings. This is meant - * to be locale independent and only compare strings we know are safe for - * this. See http://daniel.haxx.se/blog/2008/10/15/strcasecmp-in-turkish/ for - * some further explanation to why this function is necessary. - * - * The function is capable of comparing a-z case insensitively even for - * non-ascii. - */ - -static int Curl_raw_equal(const char *first, const char *second) -{ - while(*first && *second) { - if(Curl_raw_toupper(*first) != Curl_raw_toupper(*second)) - /* get out of the loop as soon as they don't match */ - break; - first++; - second++; - } - /* we do the comparison here (possibly again), just to make sure that if the - loop above is skipped because one of the strings reached zero, we must not - return this as a successful match */ - return (Curl_raw_toupper(*first) == Curl_raw_toupper(*second)); -} - -static int Curl_raw_nequal(const char *first, const char *second, size_t max) -{ - while(*first && *second && max) { - if(Curl_raw_toupper(*first) != Curl_raw_toupper(*second)) { - break; - } - max--; - first++; - second++; - } - if(0 == max) - return 1; /* they are equal this far */ - - return Curl_raw_toupper(*first) == Curl_raw_toupper(*second); -} - -/* - * Match a hostname against a wildcard pattern. - * E.g. - * "foo.host.com" matches "*.host.com". - * - * We use the matching rule described in RFC6125, section 6.4.3. - * http://tools.ietf.org/html/rfc6125#section-6.4.3 - */ - -static int hostmatch(const char *hostname, const char *pattern) -{ - const char *pattern_label_end, *pattern_wildcard, *hostname_label_end; - int wildcard_enabled; - size_t prefixlen, suffixlen; - pattern_wildcard = strchr(pattern, '*'); - if(pattern_wildcard == NULL) - return Curl_raw_equal(pattern, hostname) ? - CURL_HOST_MATCH : CURL_HOST_NOMATCH; - - /* We require at least 2 dots in pattern to avoid too wide wildcard - match. */ - wildcard_enabled = 1; - pattern_label_end = strchr(pattern, '.'); - if(pattern_label_end == NULL || strchr(pattern_label_end+1, '.') == NULL || - pattern_wildcard > pattern_label_end || - Curl_raw_nequal(pattern, "xn--", 4)) { - wildcard_enabled = 0; - } - if(!wildcard_enabled) - return Curl_raw_equal(pattern, hostname) ? - CURL_HOST_MATCH : CURL_HOST_NOMATCH; - - hostname_label_end = strchr(hostname, '.'); - if(hostname_label_end == NULL || - !Curl_raw_equal(pattern_label_end, hostname_label_end)) - return CURL_HOST_NOMATCH; - - /* The wildcard must match at least one character, so the left-most - label of the hostname is at least as large as the left-most label - of the pattern. */ - if(hostname_label_end - hostname < pattern_label_end - pattern) - return CURL_HOST_NOMATCH; - - prefixlen = pattern_wildcard - pattern; - suffixlen = pattern_label_end - (pattern_wildcard+1); - return Curl_raw_nequal(pattern, hostname, prefixlen) && - Curl_raw_nequal(pattern_wildcard+1, hostname_label_end - suffixlen, - suffixlen) ? - CURL_HOST_MATCH : CURL_HOST_NOMATCH; -} - -int Tool_Curl_cert_hostcheck(const char *match_pattern, const char *hostname) -{ - if(!match_pattern || !*match_pattern || - !hostname || !*hostname) /* sanity check */ - return 0; - - if(Curl_raw_equal(hostname, match_pattern)) /* trivial case */ - return 1; - - if(hostmatch(hostname,match_pattern) == CURL_HOST_MATCH) - return 1; - return 0; -} diff --git a/modules/openssl/curl_hostcheck.h b/modules/openssl/curl_hostcheck.h deleted file mode 100644 index 1b7fbe81e..000000000 --- a/modules/openssl/curl_hostcheck.h +++ /dev/null @@ -1,39 +0,0 @@ -#ifndef HEADER_TOOL_CURL_HOSTCHECK_H -#define HEADER_TOOL_CURL_HOSTCHECK_H - -#ifdef __cplusplus -extern "C" { -#endif - -/*************************************************************************** - * _ _ ____ _ - * Project ___| | | | _ \| | - * / __| | | | |_) | | - * | (__| |_| | _ <| |___ - * \___|\___/|_| \_\_____| - * - * Copyright (C) 1998 - 2012, Daniel Stenberg, <daniel@haxx.se>, et al. - * - * This software is licensed as described in the file COPYING, which - * you should have received as part of this distribution. The terms - * are also available at http://curl.haxx.se/docs/copyright.html. - * - * You may opt to use, copy, modify, merge, publish, distribute and/or sell - * copies of the Software, and permit persons to whom the Software is - * furnished to do so, under the terms of the COPYING file. - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY - * KIND, either express or implied. - * - ***************************************************************************/ - -#define CURL_HOST_NOMATCH 0 -#define CURL_HOST_MATCH 1 -int Tool_Curl_cert_hostcheck(const char *match_pattern, const char *hostname); - -#ifdef __cplusplus -} -#endif - -#endif /* HEADER_CURL_HOSTCHECK_H */ - diff --git a/modules/openssl/stream_peer_openssl.h b/modules/openssl/stream_peer_openssl.h index 12262da94..5c830ebf3 100644 --- a/modules/openssl/stream_peer_openssl.h +++ b/modules/openssl/stream_peer_openssl.h @@ -30,17 +30,19 @@ #ifndef STREAM_PEER_OPEN_SSL_H #define STREAM_PEER_OPEN_SSL_H -#include "curl_hostcheck.h" #include "global_config.h" #include "io/stream_peer_ssl.h" #include "os/file_access.h" -#include <stdio.h> // If you don't know what this is for stop reading now. + +#include "thirdparty/misc/curl_hostcheck.h" #include <openssl/bio.h> // BIO objects for I/O #include <openssl/err.h> // Error reporting #include <openssl/ssl.h> // SSL and SSL_CTX for SSL connections #include <openssl/x509v3.h> +#include <stdio.h> + class StreamPeerOpenSSL : public StreamPeerSSL { private: static int _bio_create(BIO *b); diff --git a/modules/pvr/texture_loader_pvr.cpp b/modules/pvr/texture_loader_pvr.cpp index 62cbd9cd8..bdd4779e2 100644 --- a/modules/pvr/texture_loader_pvr.cpp +++ b/modules/pvr/texture_loader_pvr.cpp @@ -164,8 +164,8 @@ RES ResourceFormatPVR::load(const String &p_path, const String &p_original_path, print_line("flip: " + itos(flags & PVR_VFLIP)); - Image image(width, height, mipmaps, format, data); - ERR_FAIL_COND_V(image.empty(), RES()); + Ref<Image> image = memnew(Image(width, height, mipmaps, format, data)); + ERR_FAIL_COND_V(image->empty(), RES()); Ref<ImageTexture> texture = memnew(ImageTexture); texture->create_from_image(image, tex_flags); @@ -193,30 +193,32 @@ String ResourceFormatPVR::get_resource_type(const String &p_path) const { static void _compress_pvrtc4(Image *p_img) { - Image img = *p_img; + Ref<Image> img = p_img->duplicate(); bool make_mipmaps = false; - if (img.get_width() % 8 || img.get_height() % 8) { - make_mipmaps = img.has_mipmaps(); - img.resize(img.get_width() + (8 - (img.get_width() % 8)), img.get_height() + (8 - (img.get_height() % 8))); + if (img->get_width() % 8 || img->get_height() % 8) { + make_mipmaps = img->has_mipmaps(); + img->resize(img->get_width() + (8 - (img->get_width() % 8)), img->get_height() + (8 - (img->get_height() % 8))); } - img.convert(Image::FORMAT_RGBA8); - if (!img.has_mipmaps() && make_mipmaps) - img.generate_mipmaps(); + img->convert(Image::FORMAT_RGBA8); + if (!img->has_mipmaps() && make_mipmaps) + img->generate_mipmaps(); - bool use_alpha = img.detect_alpha(); + bool use_alpha = img->detect_alpha(); - Image new_img; - new_img.create(img.get_width(), img.get_height(), true, use_alpha ? Image::FORMAT_PVRTC4A : Image::FORMAT_PVRTC4); - PoolVector<uint8_t> data = new_img.get_data(); + Ref<Image> new_img; + new_img.instance(); + new_img->create(img->get_width(), img->get_height(), true, use_alpha ? Image::FORMAT_PVRTC4A : Image::FORMAT_PVRTC4); + + PoolVector<uint8_t> data = new_img->get_data(); { PoolVector<uint8_t>::Write wr = data.write(); - PoolVector<uint8_t>::Read r = img.get_data().read(); + PoolVector<uint8_t>::Read r = img->get_data().read(); - for (int i = 0; i <= new_img.get_mipmap_count(); i++) { + for (int i = 0; i <= new_img->get_mipmap_count(); i++) { int ofs, size, w, h; - img.get_mipmap_offset_size_and_dimensions(i, ofs, size, w, h); + img->get_mipmap_offset_size_and_dimensions(i, ofs, size, w, h); Javelin::RgbaBitmap bm(w, h); copymem(bm.GetData(), &r[ofs], size); { @@ -226,12 +228,12 @@ static void _compress_pvrtc4(Image *p_img) { } } - new_img.get_mipmap_offset_size_and_dimensions(i, ofs, size, w, h); + new_img->get_mipmap_offset_size_and_dimensions(i, ofs, size, w, h); Javelin::PvrTcEncoder::EncodeRgba4Bpp(&wr[ofs], bm); } } - *p_img = Image(new_img.get_width(), new_img.get_height(), new_img.has_mipmaps(), new_img.get_format(), data); + p_img->create(new_img->get_width(), new_img->get_height(), new_img->has_mipmaps(), new_img->get_format(), data); } ResourceFormatPVR::ResourceFormatPVR() { @@ -676,8 +678,7 @@ static void _pvrtc_decompress(Image *p_img) { r = PoolVector<uint8_t>::Read(); bool make_mipmaps = p_img->has_mipmaps(); - Image newimg(p_img->get_width(), p_img->get_height(), false, Image::FORMAT_RGBA8, newdata); + p_img->create(p_img->get_width(), p_img->get_height(), false, Image::FORMAT_RGBA8, newdata); if (make_mipmaps) - newimg.generate_mipmaps(); - *p_img = newimg; + p_img->generate_mipmaps(); } diff --git a/modules/squish/image_compress_squish.cpp b/modules/squish/image_compress_squish.cpp index c6835d4b6..3f7ad8b2c 100644 --- a/modules/squish/image_compress_squish.cpp +++ b/modules/squish/image_compress_squish.cpp @@ -31,6 +31,12 @@ #include "print_string.h" +#if defined(__SSE2__) +#define SQUISH_USE_SSE 2 +#elif defined(__SSE__) +#define SQUISH_USE_SSE 1 +#endif + #include <squish.h> void image_compress_squish(Image *p_image) { diff --git a/modules/stb_vorbis/audio_stream_ogg_vorbis.cpp b/modules/stb_vorbis/audio_stream_ogg_vorbis.cpp index 227e5e61b..c645a5570 100644 --- a/modules/stb_vorbis/audio_stream_ogg_vorbis.cpp +++ b/modules/stb_vorbis/audio_stream_ogg_vorbis.cpp @@ -30,7 +30,8 @@ #include "audio_stream_ogg_vorbis.h" #include "os/file_access.h" -#include "thirdparty/stb_vorbis/stb_vorbis.c" + +#include "thirdparty/misc/stb_vorbis.c" void AudioStreamPlaybackOGGVorbis::_mix_internal(AudioFrame *p_buffer, int p_frames) { @@ -42,6 +43,7 @@ void AudioStreamPlaybackOGGVorbis::_mix_internal(AudioFrame *p_buffer, int p_fra int mixed = stb_vorbis_get_samples_float_interleaved(ogg_stream, 2, (float *)p_buffer, todo * 2); todo -= mixed; + frames_mixed += mixed; if (todo) { //end of file! @@ -66,8 +68,8 @@ float AudioStreamPlaybackOGGVorbis::get_stream_sampling_rate() { void AudioStreamPlaybackOGGVorbis::start(float p_from_pos) { - seek_pos(p_from_pos); active = true; + seek_pos(p_from_pos); loops = 0; _begin_resample(); } @@ -95,7 +97,12 @@ void AudioStreamPlaybackOGGVorbis::seek_pos(float p_time) { if (!active) return; - stb_vorbis_seek(ogg_stream, uint32_t(p_time * vorbis_stream->sample_rate)); + if (p_time >= get_length()) { + p_time = 0; + } + frames_mixed = uint32_t(vorbis_stream->sample_rate * p_time); + + stb_vorbis_seek(ogg_stream, frames_mixed); } float AudioStreamPlaybackOGGVorbis::get_length() const { diff --git a/modules/stb_vorbis/audio_stream_ogg_vorbis.h b/modules/stb_vorbis/audio_stream_ogg_vorbis.h index bb895c4df..287aa4ca4 100644 --- a/modules/stb_vorbis/audio_stream_ogg_vorbis.h +++ b/modules/stb_vorbis/audio_stream_ogg_vorbis.h @@ -34,7 +34,7 @@ #include "servers/audio/audio_stream.h" #define STB_VORBIS_HEADER_ONLY -#include "thirdparty/stb_vorbis/stb_vorbis.c" +#include "thirdparty/misc/stb_vorbis.c" #undef STB_VORBIS_HEADER_ONLY class AudioStreamOGGVorbis; diff --git a/modules/theora/video_stream_theora.cpp b/modules/theora/video_stream_theora.cpp index 28463e2cb..d895f6028 100644 --- a/modules/theora/video_stream_theora.cpp +++ b/modules/theora/video_stream_theora.cpp @@ -31,7 +31,8 @@ #include "global_config.h" #include "os/os.h" -#include "yuv2rgb.h" + +#include "thirdparty/misc/yuv2rgb.h" int VideoStreamPlaybackTheora::buffer_data() { @@ -137,7 +138,7 @@ void VideoStreamPlaybackTheora::video_write(void) { format = Image::FORMAT_RGBA8; } - Image img(size.x, size.y, 0, Image::FORMAT_RGBA8, frame_data); //zero copy image creation + Ref<Image> img = memnew(Image(size.x, size.y, 0, Image::FORMAT_RGBA8, frame_data)); //zero copy image creation texture->set_data(img); //zero copy send to visual server diff --git a/modules/theora/yuv2rgb.h b/modules/theora/yuv2rgb.h deleted file mode 100644 index a9bef76da..000000000 --- a/modules/theora/yuv2rgb.h +++ /dev/null @@ -1,1123 +0,0 @@ -/* Thirdparty code presumably from http://wss.co.uk/pinknoise/yuv2rgb/ */ -/* FIXME: Move to thirdparty dir */ - -#ifndef YUV2RGB_H -#define YUV2RGB_H - -#include "typedefs.h" - -static const uint32_t tables[256*3] = { - /* y_table */ - 0x7FFFFFEDU, - 0x7FFFFFEFU, - 0x7FFFFFF0U, - 0x7FFFFFF1U, - 0x7FFFFFF2U, - 0x7FFFFFF3U, - 0x7FFFFFF4U, - 0x7FFFFFF6U, - 0x7FFFFFF7U, - 0x7FFFFFF8U, - 0x7FFFFFF9U, - 0x7FFFFFFAU, - 0x7FFFFFFBU, - 0x7FFFFFFDU, - 0x7FFFFFFEU, - 0x7FFFFFFFU, - 0x80000000U, - 0x80400801U, - 0x80A01002U, - 0x80E01803U, - 0x81202805U, - 0x81803006U, - 0x81C03807U, - 0x82004008U, - 0x82604809U, - 0x82A0500AU, - 0x82E0600CU, - 0x8340680DU, - 0x8380700EU, - 0x83C0780FU, - 0x84208010U, - 0x84608811U, - 0x84A09813U, - 0x8500A014U, - 0x8540A815U, - 0x8580B016U, - 0x85E0B817U, - 0x8620C018U, - 0x8660D01AU, - 0x86C0D81BU, - 0x8700E01CU, - 0x8740E81DU, - 0x87A0F01EU, - 0x87E0F81FU, - 0x88210821U, - 0x88811022U, - 0x88C11823U, - 0x89012024U, - 0x89412825U, - 0x89A13026U, - 0x89E14028U, - 0x8A214829U, - 0x8A81502AU, - 0x8AC1582BU, - 0x8B01602CU, - 0x8B61682DU, - 0x8BA1782FU, - 0x8BE18030U, - 0x8C418831U, - 0x8C819032U, - 0x8CC19833U, - 0x8D21A034U, - 0x8D61B036U, - 0x8DA1B837U, - 0x8E01C038U, - 0x8E41C839U, - 0x8E81D03AU, - 0x8EE1D83BU, - 0x8F21E83DU, - 0x8F61F03EU, - 0x8FC1F83FU, - 0x90020040U, - 0x90420841U, - 0x90A21042U, - 0x90E22044U, - 0x91222845U, - 0x91823046U, - 0x91C23847U, - 0x92024048U, - 0x92624849U, - 0x92A2504AU, - 0x92E2604CU, - 0x9342684DU, - 0x9382704EU, - 0x93C2784FU, - 0x94228050U, - 0x94628851U, - 0x94A29853U, - 0x9502A054U, - 0x9542A855U, - 0x9582B056U, - 0x95E2B857U, - 0x9622C058U, - 0x9662D05AU, - 0x96C2D85BU, - 0x9702E05CU, - 0x9742E85DU, - 0x97A2F05EU, - 0x97E2F85FU, - 0x98230861U, - 0x98831062U, - 0x98C31863U, - 0x99032064U, - 0x99632865U, - 0x99A33066U, - 0x99E34068U, - 0x9A434869U, - 0x9A83506AU, - 0x9AC3586BU, - 0x9B23606CU, - 0x9B63686DU, - 0x9BA3786FU, - 0x9BE38070U, - 0x9C438871U, - 0x9C839072U, - 0x9CC39873U, - 0x9D23A074U, - 0x9D63B076U, - 0x9DA3B877U, - 0x9E03C078U, - 0x9E43C879U, - 0x9E83D07AU, - 0x9EE3D87BU, - 0x9F23E87DU, - 0x9F63F07EU, - 0x9FC3F87FU, - 0xA0040080U, - 0xA0440881U, - 0xA0A41082U, - 0xA0E42084U, - 0xA1242885U, - 0xA1843086U, - 0xA1C43887U, - 0xA2044088U, - 0xA2644889U, - 0xA2A4588BU, - 0xA2E4608CU, - 0xA344688DU, - 0xA384708EU, - 0xA3C4788FU, - 0xA4248090U, - 0xA4649092U, - 0xA4A49893U, - 0xA504A094U, - 0xA544A895U, - 0xA584B096U, - 0xA5E4B897U, - 0xA624C098U, - 0xA664D09AU, - 0xA6C4D89BU, - 0xA704E09CU, - 0xA744E89DU, - 0xA7A4F09EU, - 0xA7E4F89FU, - 0xA82508A1U, - 0xA88510A2U, - 0xA8C518A3U, - 0xA90520A4U, - 0xA96528A5U, - 0xA9A530A6U, - 0xA9E540A8U, - 0xAA4548A9U, - 0xAA8550AAU, - 0xAAC558ABU, - 0xAB2560ACU, - 0xAB6568ADU, - 0xABA578AFU, - 0xAC0580B0U, - 0xAC4588B1U, - 0xAC8590B2U, - 0xACE598B3U, - 0xAD25A0B4U, - 0xAD65B0B6U, - 0xADA5B8B7U, - 0xAE05C0B8U, - 0xAE45C8B9U, - 0xAE85D0BAU, - 0xAEE5D8BBU, - 0xAF25E8BDU, - 0xAF65F0BEU, - 0xAFC5F8BFU, - 0xB00600C0U, - 0xB04608C1U, - 0xB0A610C2U, - 0xB0E620C4U, - 0xB12628C5U, - 0xB18630C6U, - 0xB1C638C7U, - 0xB20640C8U, - 0xB26648C9U, - 0xB2A658CBU, - 0xB2E660CCU, - 0xB34668CDU, - 0xB38670CEU, - 0xB3C678CFU, - 0xB42680D0U, - 0xB46690D2U, - 0xB4A698D3U, - 0xB506A0D4U, - 0xB546A8D5U, - 0xB586B0D6U, - 0xB5E6B8D7U, - 0xB626C8D9U, - 0xB666D0DAU, - 0xB6C6D8DBU, - 0xB706E0DCU, - 0xB746E8DDU, - 0xB7A6F0DEU, - 0xB7E6F8DFU, - 0xB82708E1U, - 0xB88710E2U, - 0xB8C718E3U, - 0xB90720E4U, - 0xB96728E5U, - 0xB9A730E6U, - 0xB9E740E8U, - 0xBA4748E9U, - 0xBA8750EAU, - 0xBAC758EBU, - 0xBB2760ECU, - 0xBB6768EDU, - 0xBBA778EFU, - 0xBC0780F0U, - 0xBC4788F1U, - 0xBC8790F2U, - 0xBCE798F3U, - 0xBD27A0F4U, - 0xBD67B0F6U, - 0xBDC7B8F7U, - 0xBE07C0F8U, - 0xBE47C8F9U, - 0xBEA7D0FAU, - 0xBEE7D8FBU, - 0xBF27E8FDU, - 0xBF87F0FEU, - 0xBFC7F8FFU, - 0xC0080100U, - 0xC0480901U, - 0xC0A81102U, - 0xC0E82104U, - 0xC0E82104U, - 0xC0E82104U, - 0xC0E82104U, - 0xC0E82104U, - 0xC0E82104U, - 0xC0E82104U, - 0xC0E82104U, - 0xC0E82104U, - 0xC0E82104U, - 0xC0E82104U, - 0xC0E82104U, - 0xC0E82104U, - 0xC0E82104U, - 0xC0E82104U, - 0xC0E82104U, - 0xC0E82104U, - /* u_table */ - 0x0C400103U, - 0x0C200105U, - 0x0C200107U, - 0x0C000109U, - 0x0BE0010BU, - 0x0BC0010DU, - 0x0BA0010FU, - 0x0BA00111U, - 0x0B800113U, - 0x0B600115U, - 0x0B400117U, - 0x0B400119U, - 0x0B20011BU, - 0x0B00011DU, - 0x0AE0011FU, - 0x0AE00121U, - 0x0AC00123U, - 0x0AA00125U, - 0x0A800127U, - 0x0A600129U, - 0x0A60012BU, - 0x0A40012DU, - 0x0A20012FU, - 0x0A000131U, - 0x0A000132U, - 0x09E00134U, - 0x09C00136U, - 0x09A00138U, - 0x09A0013AU, - 0x0980013CU, - 0x0960013EU, - 0x09400140U, - 0x09400142U, - 0x09200144U, - 0x09000146U, - 0x08E00148U, - 0x08C0014AU, - 0x08C0014CU, - 0x08A0014EU, - 0x08800150U, - 0x08600152U, - 0x08600154U, - 0x08400156U, - 0x08200158U, - 0x0800015AU, - 0x0800015CU, - 0x07E0015EU, - 0x07C00160U, - 0x07A00162U, - 0x07A00164U, - 0x07800166U, - 0x07600168U, - 0x0740016AU, - 0x0720016CU, - 0x0720016EU, - 0x07000170U, - 0x06E00172U, - 0x06C00174U, - 0x06C00176U, - 0x06A00178U, - 0x0680017AU, - 0x0660017CU, - 0x0660017EU, - 0x06400180U, - 0x06200182U, - 0x06000184U, - 0x05E00185U, - 0x05E00187U, - 0x05C00189U, - 0x05A0018BU, - 0x0580018DU, - 0x0580018FU, - 0x05600191U, - 0x05400193U, - 0x05200195U, - 0x05200197U, - 0x05000199U, - 0x04E0019BU, - 0x04C0019DU, - 0x04C0019FU, - 0x04A001A1U, - 0x048001A3U, - 0x046001A5U, - 0x044001A7U, - 0x044001A9U, - 0x042001ABU, - 0x040001ADU, - 0x03E001AFU, - 0x03E001B1U, - 0x03C001B3U, - 0x03A001B5U, - 0x038001B7U, - 0x038001B9U, - 0x036001BBU, - 0x034001BDU, - 0x032001BFU, - 0x032001C1U, - 0x030001C3U, - 0x02E001C5U, - 0x02C001C7U, - 0x02A001C9U, - 0x02A001CBU, - 0x028001CDU, - 0x026001CFU, - 0x024001D1U, - 0x024001D3U, - 0x022001D5U, - 0x020001D7U, - 0x01E001D8U, - 0x01E001DAU, - 0x01C001DCU, - 0x01A001DEU, - 0x018001E0U, - 0x016001E2U, - 0x016001E4U, - 0x014001E6U, - 0x012001E8U, - 0x010001EAU, - 0x010001ECU, - 0x00E001EEU, - 0x00C001F0U, - 0x00A001F2U, - 0x00A001F4U, - 0x008001F6U, - 0x006001F8U, - 0x004001FAU, - 0x004001FCU, - 0x002001FEU, - 0x00000200U, - 0xFFE00202U, - 0xFFC00204U, - 0xFFC00206U, - 0xFFA00208U, - 0xFF80020AU, - 0xFF60020CU, - 0xFF60020EU, - 0xFF400210U, - 0xFF200212U, - 0xFF000214U, - 0xFF000216U, - 0xFEE00218U, - 0xFEC0021AU, - 0xFEA0021CU, - 0xFEA0021EU, - 0xFE800220U, - 0xFE600222U, - 0xFE400224U, - 0xFE200226U, - 0xFE200228U, - 0xFE000229U, - 0xFDE0022BU, - 0xFDC0022DU, - 0xFDC0022FU, - 0xFDA00231U, - 0xFD800233U, - 0xFD600235U, - 0xFD600237U, - 0xFD400239U, - 0xFD20023BU, - 0xFD00023DU, - 0xFCE0023FU, - 0xFCE00241U, - 0xFCC00243U, - 0xFCA00245U, - 0xFC800247U, - 0xFC800249U, - 0xFC60024BU, - 0xFC40024DU, - 0xFC20024FU, - 0xFC200251U, - 0xFC000253U, - 0xFBE00255U, - 0xFBC00257U, - 0xFBC00259U, - 0xFBA0025BU, - 0xFB80025DU, - 0xFB60025FU, - 0xFB400261U, - 0xFB400263U, - 0xFB200265U, - 0xFB000267U, - 0xFAE00269U, - 0xFAE0026BU, - 0xFAC0026DU, - 0xFAA0026FU, - 0xFA800271U, - 0xFA800273U, - 0xFA600275U, - 0xFA400277U, - 0xFA200279U, - 0xFA20027BU, - 0xFA00027CU, - 0xF9E0027EU, - 0xF9C00280U, - 0xF9A00282U, - 0xF9A00284U, - 0xF9800286U, - 0xF9600288U, - 0xF940028AU, - 0xF940028CU, - 0xF920028EU, - 0xF9000290U, - 0xF8E00292U, - 0xF8E00294U, - 0xF8C00296U, - 0xF8A00298U, - 0xF880029AU, - 0xF860029CU, - 0xF860029EU, - 0xF84002A0U, - 0xF82002A2U, - 0xF80002A4U, - 0xF80002A6U, - 0xF7E002A8U, - 0xF7C002AAU, - 0xF7A002ACU, - 0xF7A002AEU, - 0xF78002B0U, - 0xF76002B2U, - 0xF74002B4U, - 0xF74002B6U, - 0xF72002B8U, - 0xF70002BAU, - 0xF6E002BCU, - 0xF6C002BEU, - 0xF6C002C0U, - 0xF6A002C2U, - 0xF68002C4U, - 0xF66002C6U, - 0xF66002C8U, - 0xF64002CAU, - 0xF62002CCU, - 0xF60002CEU, - 0xF60002CFU, - 0xF5E002D1U, - 0xF5C002D3U, - 0xF5A002D5U, - 0xF5A002D7U, - 0xF58002D9U, - 0xF56002DBU, - 0xF54002DDU, - 0xF52002DFU, - 0xF52002E1U, - 0xF50002E3U, - 0xF4E002E5U, - 0xF4C002E7U, - 0xF4C002E9U, - 0xF4A002EBU, - 0xF48002EDU, - 0xF46002EFU, - 0xF46002F1U, - 0xF44002F3U, - 0xF42002F5U, - 0xF40002F7U, - 0xF3E002F9U, - 0xF3E002FBU, - /* v_table */ - 0x1A09A000U, - 0x19E9A800U, - 0x19A9B800U, - 0x1969C800U, - 0x1949D000U, - 0x1909E000U, - 0x18C9E800U, - 0x18A9F800U, - 0x186A0000U, - 0x182A1000U, - 0x180A2000U, - 0x17CA2800U, - 0x17AA3800U, - 0x176A4000U, - 0x172A5000U, - 0x170A6000U, - 0x16CA6800U, - 0x168A7800U, - 0x166A8000U, - 0x162A9000U, - 0x160AA000U, - 0x15CAA800U, - 0x158AB800U, - 0x156AC000U, - 0x152AD000U, - 0x14EAE000U, - 0x14CAE800U, - 0x148AF800U, - 0x146B0000U, - 0x142B1000U, - 0x13EB2000U, - 0x13CB2800U, - 0x138B3800U, - 0x134B4000U, - 0x132B5000U, - 0x12EB6000U, - 0x12CB6800U, - 0x128B7800U, - 0x124B8000U, - 0x122B9000U, - 0x11EBA000U, - 0x11ABA800U, - 0x118BB800U, - 0x114BC000U, - 0x112BD000U, - 0x10EBE000U, - 0x10ABE800U, - 0x108BF800U, - 0x104C0000U, - 0x100C1000U, - 0x0FEC2000U, - 0x0FAC2800U, - 0x0F8C3800U, - 0x0F4C4000U, - 0x0F0C5000U, - 0x0EEC5800U, - 0x0EAC6800U, - 0x0E6C7800U, - 0x0E4C8000U, - 0x0E0C9000U, - 0x0DEC9800U, - 0x0DACA800U, - 0x0D6CB800U, - 0x0D4CC000U, - 0x0D0CD000U, - 0x0CCCD800U, - 0x0CACE800U, - 0x0C6CF800U, - 0x0C4D0000U, - 0x0C0D1000U, - 0x0BCD1800U, - 0x0BAD2800U, - 0x0B6D3800U, - 0x0B2D4000U, - 0x0B0D5000U, - 0x0ACD5800U, - 0x0AAD6800U, - 0x0A6D7800U, - 0x0A2D8000U, - 0x0A0D9000U, - 0x09CD9800U, - 0x098DA800U, - 0x096DB800U, - 0x092DC000U, - 0x090DD000U, - 0x08CDD800U, - 0x088DE800U, - 0x086DF800U, - 0x082E0000U, - 0x07EE1000U, - 0x07CE1800U, - 0x078E2800U, - 0x076E3800U, - 0x072E4000U, - 0x06EE5000U, - 0x06CE5800U, - 0x068E6800U, - 0x064E7800U, - 0x062E8000U, - 0x05EE9000U, - 0x05CE9800U, - 0x058EA800U, - 0x054EB800U, - 0x052EC000U, - 0x04EED000U, - 0x04AED800U, - 0x048EE800U, - 0x044EF000U, - 0x042F0000U, - 0x03EF1000U, - 0x03AF1800U, - 0x038F2800U, - 0x034F3000U, - 0x030F4000U, - 0x02EF5000U, - 0x02AF5800U, - 0x028F6800U, - 0x024F7000U, - 0x020F8000U, - 0x01EF9000U, - 0x01AF9800U, - 0x016FA800U, - 0x014FB000U, - 0x010FC000U, - 0x00EFD000U, - 0x00AFD800U, - 0x006FE800U, - 0x004FF000U, - 0x00100000U, - 0xFFD01000U, - 0xFFB01800U, - 0xFF702800U, - 0xFF303000U, - 0xFF104000U, - 0xFED05000U, - 0xFEB05800U, - 0xFE706800U, - 0xFE307000U, - 0xFE108000U, - 0xFDD09000U, - 0xFD909800U, - 0xFD70A800U, - 0xFD30B000U, - 0xFD10C000U, - 0xFCD0D000U, - 0xFC90D800U, - 0xFC70E800U, - 0xFC30F000U, - 0xFBF10000U, - 0xFBD11000U, - 0xFB911800U, - 0xFB712800U, - 0xFB313000U, - 0xFAF14000U, - 0xFAD14800U, - 0xFA915800U, - 0xFA516800U, - 0xFA317000U, - 0xF9F18000U, - 0xF9D18800U, - 0xF9919800U, - 0xF951A800U, - 0xF931B000U, - 0xF8F1C000U, - 0xF8B1C800U, - 0xF891D800U, - 0xF851E800U, - 0xF831F000U, - 0xF7F20000U, - 0xF7B20800U, - 0xF7921800U, - 0xF7522800U, - 0xF7123000U, - 0xF6F24000U, - 0xF6B24800U, - 0xF6925800U, - 0xF6526800U, - 0xF6127000U, - 0xF5F28000U, - 0xF5B28800U, - 0xF5729800U, - 0xF552A800U, - 0xF512B000U, - 0xF4F2C000U, - 0xF4B2C800U, - 0xF472D800U, - 0xF452E800U, - 0xF412F000U, - 0xF3D30000U, - 0xF3B30800U, - 0xF3731800U, - 0xF3532800U, - 0xF3133000U, - 0xF2D34000U, - 0xF2B34800U, - 0xF2735800U, - 0xF2336800U, - 0xF2137000U, - 0xF1D38000U, - 0xF1B38800U, - 0xF1739800U, - 0xF133A800U, - 0xF113B000U, - 0xF0D3C000U, - 0xF093C800U, - 0xF073D800U, - 0xF033E000U, - 0xF013F000U, - 0xEFD40000U, - 0xEF940800U, - 0xEF741800U, - 0xEF342000U, - 0xEEF43000U, - 0xEED44000U, - 0xEE944800U, - 0xEE745800U, - 0xEE346000U, - 0xEDF47000U, - 0xEDD48000U, - 0xED948800U, - 0xED549800U, - 0xED34A000U, - 0xECF4B000U, - 0xECD4C000U, - 0xEC94C800U, - 0xEC54D800U, - 0xEC34E000U, - 0xEBF4F000U, - 0xEBB50000U, - 0xEB950800U, - 0xEB551800U, - 0xEB352000U, - 0xEAF53000U, - 0xEAB54000U, - 0xEA954800U, - 0xEA555800U, - 0xEA156000U, - 0xE9F57000U, - 0xE9B58000U, - 0xE9958800U, - 0xE9559800U, - 0xE915A000U, - 0xE8F5B000U, - 0xE8B5C000U, - 0xE875C800U, - 0xE855D800U, - 0xE815E000U, - 0xE7F5F000U, - 0xE7B60000U, - 0xE7760800U, - 0xE7561800U, - 0xE7162000U, - 0xE6D63000U, - 0xE6B64000U, - 0xE6764800U, - 0xE6365800U -}; - -#define FLAGS 0x40080100 -#define READUV(U,V) (tables[256 + (U)] + tables[512 + (V)]) -#define READY(Y) tables[Y] -#define FIXUP(Y) \ -do { \ - int tmp = (Y) & FLAGS; \ - if (tmp != 0) \ - { \ - tmp -= tmp>>8; \ - (Y) |= tmp; \ - tmp = FLAGS & ~(Y>>1); \ - (Y) += tmp>>8; \ - } \ -} while (0 == 1) - -#define STORE(Y,DSTPTR) \ -do { \ - *(DSTPTR)++ = (Y); \ - *(DSTPTR)++ = (Y)>>22; \ - *(DSTPTR)++ = (Y)>>11; \ - *(DSTPTR)++ = 255; \ -} while (0 == 1) - -static void yuv422_2_rgb8888(uint8_t *dst_ptr, - const uint8_t *y_ptr, - const uint8_t *u_ptr, - const uint8_t *v_ptr, - int32_t width, - int32_t height, - int32_t y_span, - int32_t uv_span, - int32_t dst_span, - int32_t dither) -{ - height -= 1; - while (height > 0) - { - height -= width<<16; - height += 1<<16; - while (height < 0) - { - /* Do top row pair */ - uint32_t uv, y0, y1; - - uv = READUV(*u_ptr++,*v_ptr++); - y0 = uv + READY(*y_ptr++); - y1 = uv + READY(*y_ptr++); - FIXUP(y0); - FIXUP(y1); - STORE(y0, dst_ptr); - STORE(y1, dst_ptr); - height += (2<<16); - } - if ((height>>16) == 0) - { - /* Trailing top row pix */ - uint32_t uv, y0; - - uv = READUV(*u_ptr,*v_ptr); - y0 = uv + READY(*y_ptr++); - FIXUP(y0); - STORE(y0, dst_ptr); - } - dst_ptr += dst_span-width*4; - y_ptr += y_span-width; - u_ptr += uv_span-(width>>1); - v_ptr += uv_span-(width>>1); - height = (height<<16)>>16; - height -= 1; - if (height == 0) - break; - height -= width<<16; - height += 1<<16; - while (height < 0) - { - /* Do second row pair */ - uint32_t uv, y0, y1; - - uv = READUV(*u_ptr++,*v_ptr++); - y0 = uv + READY(*y_ptr++); - y1 = uv + READY(*y_ptr++); - FIXUP(y0); - FIXUP(y1); - STORE(y0, dst_ptr); - STORE(y1, dst_ptr); - height += (2<<16); - } - if ((height>>16) == 0) - { - /* Trailing bottom row pix */ - uint32_t uv, y0; - - uv = READUV(*u_ptr,*v_ptr); - y0 = uv + READY(*y_ptr++); - FIXUP(y0); - STORE(y0, dst_ptr); - } - dst_ptr += dst_span-width*4; - y_ptr += y_span-width; - u_ptr += uv_span-(width>>1); - v_ptr += uv_span-(width>>1); - height = (height<<16)>>16; - height -= 1; - } -} - - -#undef FLAGS -#undef READUV -#undef READY -#undef FIXUP -#undef STORE - - -#define FLAGS 0x40080100 -#define READUV(U,V) (tables[256 + (U)] + tables[512 + (V)]) -#define READY(Y) tables[Y] -#define FIXUP(Y) \ -do { \ - int tmp = (Y) & FLAGS; \ - if (tmp != 0) \ - { \ - tmp -= tmp>>8; \ - (Y) |= tmp; \ - tmp = FLAGS & ~(Y>>1); \ - (Y) += tmp>>8; \ - } \ -} while (0 == 1) - -#define STORE(Y,DSTPTR) \ -do { \ - (DSTPTR) = 0xFF000000 | (Y & 0xFF) | (0xFF00 & (Y>>14)) | (0xFF0000 & (Y<<5));\ -} while (0 == 1) - -static void yuv420_2_rgb8888(uint8_t *dst_ptr_, - const uint8_t *y_ptr, - const uint8_t *u_ptr, - const uint8_t *v_ptr, - int32_t width, - int32_t height, - int32_t y_span, - int32_t uv_span, - int32_t dst_span, - int32_t dither) -{ - uint32_t *dst_ptr = (uint32_t *)(void *)dst_ptr_; - dst_span >>= 2; - - height -= 1; - while (height > 0) - { - height -= width<<16; - height += 1<<16; - while (height < 0) - { - /* Do 2 column pairs */ - uint32_t uv, y0, y1; - - uv = READUV(*u_ptr++,*v_ptr++); - y1 = uv + READY(y_ptr[y_span]); - y0 = uv + READY(*y_ptr++); - FIXUP(y1); - FIXUP(y0); - STORE(y1, dst_ptr[dst_span]); - STORE(y0, *dst_ptr++); - y1 = uv + READY(y_ptr[y_span]); - y0 = uv + READY(*y_ptr++); - FIXUP(y1); - FIXUP(y0); - STORE(y1, dst_ptr[dst_span]); - STORE(y0, *dst_ptr++); - height += (2<<16); - } - if ((height>>16) == 0) - { - /* Trailing column pair */ - uint32_t uv, y0, y1; - - uv = READUV(*u_ptr,*v_ptr); - y1 = uv + READY(y_ptr[y_span]); - y0 = uv + READY(*y_ptr++); - FIXUP(y1); - FIXUP(y0); - STORE(y0, dst_ptr[dst_span]); - STORE(y1, *dst_ptr++); - } - dst_ptr += dst_span*2-width; - y_ptr += y_span*2-width; - u_ptr += uv_span-(width>>1); - v_ptr += uv_span-(width>>1); - height = (height<<16)>>16; - height -= 2; - } - if (height == 0) - { - /* Trail row */ - height -= width<<16; - height += 1<<16; - while (height < 0) - { - /* Do a row pair */ - uint32_t uv, y0, y1; - - uv = READUV(*u_ptr++,*v_ptr++); - y1 = uv + READY(*y_ptr++); - y0 = uv + READY(*y_ptr++); - FIXUP(y1); - FIXUP(y0); - STORE(y1, *dst_ptr++); - STORE(y0, *dst_ptr++); - height += (2<<16); - } - if ((height>>16) == 0) - { - /* Trailing pix */ - uint32_t uv, y0; - - uv = READUV(*u_ptr++,*v_ptr++); - y0 = uv + READY(*y_ptr++); - FIXUP(y0); - STORE(y0, *dst_ptr++); - } - } -} - - - -#undef FLAGS -#undef READUV -#undef READY -#undef FIXUP -#undef STORE - -#define FLAGS 0x40080100 -#define READUV(U,V) (tables[256 + (U)] + tables[512 + (V)]) -#define READY(Y) tables[Y] -#define FIXUP(Y) \ -do { \ - int tmp = (Y) & FLAGS; \ - if (tmp != 0) \ - { \ - tmp -= tmp>>8; \ - (Y) |= tmp; \ - tmp = FLAGS & ~(Y>>1); \ - (Y) += tmp>>8; \ - } \ -} while (0 == 1) - -#define STORE(Y,DSTPTR) \ -do { \ - *(DSTPTR)++ = (Y); \ - *(DSTPTR)++ = (Y)>>22; \ - *(DSTPTR)++ = (Y)>>11; \ - *(DSTPTR)++ = 255; \ -} while (0 == 1) - -static void yuv444_2_rgb8888(uint8_t *dst_ptr, - const uint8_t *y_ptr, - const uint8_t *u_ptr, - const uint8_t *v_ptr, - int32_t width, - int32_t height, - int32_t y_span, - int32_t uv_span, - int32_t dst_span, - int32_t dither) -{ - height -= 1; - while (height > 0) - { - height -= width<<16; - height += 1<<16; - while (height < 0) - { - /* Do top row pair */ - uint32_t uv, y0, y1; - - uv = READUV(*u_ptr++,*v_ptr++); - y0 = uv + READY(*y_ptr++); - FIXUP(y0); - STORE(y0, dst_ptr); - uv = READUV(*u_ptr++,*v_ptr++); - y1 = uv + READY(*y_ptr++); - FIXUP(y1); - STORE(y1, dst_ptr); - height += (2<<16); - } - if ((height>>16) == 0) - { - /* Trailing top row pix */ - uint32_t uv, y0; - - uv = READUV(*u_ptr++,*v_ptr++); - y0 = uv + READY(*y_ptr++); - FIXUP(y0); - STORE(y0, dst_ptr); - } - dst_ptr += dst_span-width*4; - y_ptr += y_span-width; - u_ptr += uv_span-width; - v_ptr += uv_span-width; - height = (height<<16)>>16; - height -= 1; - if (height == 0) - break; - height -= width<<16; - height += 1<<16; - while (height < 0) - { - /* Do second row pair */ - uint32_t uv, y0, y1; - - uv = READUV(*u_ptr++,*v_ptr++); - y0 = uv + READY(*y_ptr++); - FIXUP(y0); - STORE(y0, dst_ptr); - uv = READUV(*u_ptr++,*v_ptr++); - y1 = uv + READY(*y_ptr++); - FIXUP(y1); - STORE(y1, dst_ptr); - height += (2<<16); - } - if ((height>>16) == 0) - { - /* Trailing bottom row pix */ - uint32_t uv, y0; - - uv = READUV(*u_ptr++,*v_ptr++); - y0 = uv + READY(*y_ptr++); - FIXUP(y0); - STORE(y0, dst_ptr); - } - dst_ptr += dst_span-width*4; - y_ptr += y_span-width; - u_ptr += uv_span-width; - v_ptr += uv_span-width; - height = (height<<16)>>16; - height -= 1; - } -} -#endif // YUV2RGB_H diff --git a/modules/visual_script/visual_script.cpp b/modules/visual_script/visual_script.cpp index 53521c55a..aec60391d 100644 --- a/modules/visual_script/visual_script.cpp +++ b/modules/visual_script/visual_script.cpp @@ -1073,6 +1073,18 @@ void VisualScript::get_script_property_list(List<PropertyInfo> *p_list) const { } } +int VisualScript::get_member_line(const StringName &p_member) const { +#ifdef TOOLS_ENABLED + if (has_function(p_member)) { + for (Map<int, Function::NodeData>::Element *E = functions[p_member].nodes.front(); E; E = E->next()) { + if (E->get().node->cast_to<VisualScriptFunction>()) + return E->key(); + } + } +#endif + return -1; +} + #ifdef TOOLS_ENABLED bool VisualScript::are_subnodes_edited() const { diff --git a/modules/visual_script/visual_script.h b/modules/visual_script/visual_script.h index ee8ed2c96..273a81961 100644 --- a/modules/visual_script/visual_script.h +++ b/modules/visual_script/visual_script.h @@ -356,6 +356,8 @@ public: virtual void get_script_property_list(List<PropertyInfo> *p_list) const; + virtual int get_member_line(const StringName &p_member) const; + #ifdef TOOLS_ENABLED virtual bool are_subnodes_edited() const; #endif diff --git a/modules/visual_script/visual_script_editor.cpp b/modules/visual_script/visual_script_editor.cpp index 724763692..340e2fe63 100644 --- a/modules/visual_script/visual_script_editor.cpp +++ b/modules/visual_script/visual_script_editor.cpp @@ -346,7 +346,6 @@ static Color _color_from_type(Variant::Type p_type) { case Variant::TRANSFORM: color = Color::html("f6a86e"); break; case Variant::COLOR: color = Color::html("9dff70"); break; - case Variant::IMAGE: color = Color::html("93f1b9"); break; case Variant::NODE_PATH: color = Color::html("6993ec"); break; case Variant::_RID: color = Color::html("69ec9a"); break; case Variant::OBJECT: color = Color::html("79f3e8"); break; @@ -451,7 +450,6 @@ void VisualScriptEditor::_update_graph(int p_only_id) { Control::get_icon("MiniBasis", "EditorIcons"), Control::get_icon("MiniTransform", "EditorIcons"), Control::get_icon("MiniColor", "EditorIcons"), - Control::get_icon("MiniImage", "EditorIcons"), Control::get_icon("MiniPath", "EditorIcons"), Control::get_icon("MiniRid", "EditorIcons"), Control::get_icon("MiniObject", "EditorIcons"), @@ -490,7 +488,7 @@ void VisualScriptEditor::_update_graph(int p_only_id) { } if (EditorSettings::get_singleton()->has("editors/visual_script/color_" + node->get_category())) { - gnode->set_modulate(EditorSettings::get_singleton()->get("editors/visual_script/color_" + node->get_category())); + gnode->set_self_modulate(EditorSettings::get_singleton()->get("editors/visual_script/color_" + node->get_category())); } gnode->set_meta("__vnode", node); @@ -735,7 +733,6 @@ void VisualScriptEditor::_update_members() { Control::get_icon("MiniMatrix3", "EditorIcons"), Control::get_icon("MiniTransform", "EditorIcons"), Control::get_icon("MiniColor", "EditorIcons"), - Control::get_icon("MiniImage", "EditorIcons"), Control::get_icon("MiniPath", "EditorIcons"), Control::get_icon("MiniRid", "EditorIcons"), Control::get_icon("MiniObject", "EditorIcons"), @@ -2153,7 +2150,7 @@ void VisualScriptEditor::goto_line(int p_line, bool p_with_error) { _update_graph(); _update_members(); - call_deferred("_center_on_node", p_line); //editor might be just created and size might not exist yet + call_deferred("call_deferred", "_center_on_node", p_line); //editor might be just created and size might not exist yet return; } @@ -2163,6 +2160,12 @@ void VisualScriptEditor::goto_line(int p_line, bool p_with_error) { void VisualScriptEditor::trim_trailing_whitespace() { } +void VisualScriptEditor::convert_indent_to_spaces() { +} + +void VisualScriptEditor::convert_indent_to_tabs() { +} + void VisualScriptEditor::ensure_focus() { graph->grab_focus(); @@ -2192,18 +2195,6 @@ void VisualScriptEditor::get_breakpoints(List<int> *p_breakpoints) { } } -bool VisualScriptEditor::goto_method(const String &p_method) { - - if (!script->has_function(p_method)) - return false; - - edited_func = p_method; - selected = edited_func; - _update_members(); - _update_graph(); - return true; -} - void VisualScriptEditor::add_callback(const String &p_function, PoolStringArray p_args) { if (script->has_function(p_function)) { @@ -2839,7 +2830,7 @@ void VisualScriptEditor::_node_filter_changed(const String &p_text) { void VisualScriptEditor::_notification(int p_what) { if (p_what == NOTIFICATION_READY) { - node_filter_icon->set_texture(Control::get_icon("Zoom", "EditorIcons")); + node_filter_icon->set_texture(Control::get_icon("Search", "EditorIcons")); } } diff --git a/modules/visual_script/visual_script_editor.h b/modules/visual_script/visual_script_editor.h index 7322da5cf..1fd97cc1b 100644 --- a/modules/visual_script/visual_script_editor.h +++ b/modules/visual_script/visual_script_editor.h @@ -240,11 +240,12 @@ public: virtual void set_edit_state(const Variant &p_state); virtual void goto_line(int p_line, bool p_with_error = false); virtual void trim_trailing_whitespace(); + virtual void convert_indent_to_spaces(); + virtual void convert_indent_to_tabs(); virtual void ensure_focus(); virtual void tag_saved_version(); virtual void reload(bool p_soft); virtual void get_breakpoints(List<int> *p_breakpoints); - virtual bool goto_method(const String &p_method); virtual void add_callback(const String &p_function, PoolStringArray p_args); virtual void update_settings(); virtual void set_debugger_active(bool p_active); diff --git a/modules/webm/libvpx/SCsub b/modules/webm/libvpx/SCsub index 241d6e30c..0ee2ed45b 100644 --- a/modules/webm/libvpx/SCsub +++ b/modules/webm/libvpx/SCsub @@ -273,7 +273,7 @@ else: webm_cpu_x86 = True else: webm_cpu_x86 = not is_x11_or_server_arm and (cpu_bits == '32' or cpu_bits == '64') and (env["platform"] == 'windows' or env["platform"] == 'x11' or env["platform"] == 'osx' or env["platform"] == 'haiku' or is_android_x86 or is_ios_x86) - webm_cpu_arm = is_x11_or_server_arm or (not is_ios_x86 and env["platform"] == 'iphone') or env["platform"] == 'bb10' or (not is_android_x86 and env["platform"] == 'android') + webm_cpu_arm = is_x11_or_server_arm or (not is_ios_x86 and env["platform"] == 'iphone') or (not is_android_x86 and env["platform"] == 'android') if webm_cpu_x86: import subprocess diff --git a/modules/webm/video_stream_webm.cpp b/modules/webm/video_stream_webm.cpp index 9d8062d28..eaf421530 100644 --- a/modules/webm/video_stream_webm.cpp +++ b/modules/webm/video_stream_webm.cpp @@ -32,12 +32,13 @@ #include "OpusVorbisDecoder.hpp" #include "VPXDecoder.hpp" -#include "../theora/yuv2rgb.h" #include "mkvparser/mkvparser.h" #include "global_config.h" #include "os/file_access.h" +#include "thirdparty/misc/yuv2rgb.h" + #include <string.h> class MkvReader : public mkvparser::IMkvReader { diff --git a/modules/webp/image_loader_webp.cpp b/modules/webp/image_loader_webp.cpp index 39c8f812a..7313cb6c7 100644 --- a/modules/webp/image_loader_webp.cpp +++ b/modules/webp/image_loader_webp.cpp @@ -37,23 +37,23 @@ #include <webp/decode.h> #include <webp/encode.h> -static PoolVector<uint8_t> _webp_lossy_pack(const Image &p_image, float p_quality) { +static PoolVector<uint8_t> _webp_lossy_pack(const Ref<Image> &p_image, float p_quality) { - ERR_FAIL_COND_V(p_image.empty(), PoolVector<uint8_t>()); + ERR_FAIL_COND_V(p_image.is_null() || p_image->empty(), PoolVector<uint8_t>()); - Image img = p_image; - if (img.detect_alpha()) - img.convert(Image::FORMAT_RGBA8); + Ref<Image> img = p_image->duplicate(); + if (img->detect_alpha()) + img->convert(Image::FORMAT_RGBA8); else - img.convert(Image::FORMAT_RGB8); + img->convert(Image::FORMAT_RGB8); - Size2 s(img.get_width(), img.get_height()); - PoolVector<uint8_t> data = img.get_data(); + Size2 s(img->get_width(), img->get_height()); + PoolVector<uint8_t> data = img->get_data(); PoolVector<uint8_t>::Read r = data.read(); uint8_t *dst_buff = NULL; size_t dst_size = 0; - if (img.get_format() == Image::FORMAT_RGB8) { + if (img->get_format() == Image::FORMAT_RGB8) { dst_size = WebPEncodeRGB(r.ptr(), s.width, s.height, 3 * s.width, CLAMP(p_quality * 100.0, 0, 100.0), &dst_buff); } else { @@ -74,22 +74,24 @@ static PoolVector<uint8_t> _webp_lossy_pack(const Image &p_image, float p_qualit return dst; } -static Image _webp_lossy_unpack(const PoolVector<uint8_t> &p_buffer) { +static Ref<Image> _webp_lossy_unpack(const PoolVector<uint8_t> &p_buffer) { int size = p_buffer.size() - 4; - ERR_FAIL_COND_V(size <= 0, Image()); + ERR_FAIL_COND_V(size <= 0, Ref<Image>()); PoolVector<uint8_t>::Read r = p_buffer.read(); - ERR_FAIL_COND_V(r[0] != 'W' || r[1] != 'E' || r[2] != 'B' || r[3] != 'P', Image()); + ERR_FAIL_COND_V(r[0] != 'W' || r[1] != 'E' || r[2] != 'B' || r[3] != 'P', Ref<Image>()); WebPBitstreamFeatures features; if (WebPGetFeatures(&r[4], size, &features) != VP8_STATUS_OK) { ERR_EXPLAIN("Error unpacking WEBP image:"); - ERR_FAIL_V(Image()); + ERR_FAIL_V(Ref<Image>()); } - //print_line("width: "+itos(features.width)); - //print_line("height: "+itos(features.height)); - //print_line("alpha: "+itos(features.has_alpha)); + /* + print_line("width: "+itos(features.width)); + print_line("height: "+itos(features.height)); + print_line("alpha: "+itos(features.has_alpha)); + */ PoolVector<uint8_t> dst_image; int datasize = features.width * features.height * (features.has_alpha ? 4 : 3); @@ -105,14 +107,15 @@ static Image _webp_lossy_unpack(const PoolVector<uint8_t> &p_buffer) { } //ERR_EXPLAIN("Error decoding webp! - "+p_file); - ERR_FAIL_COND_V(errdec, Image()); + ERR_FAIL_COND_V(errdec, Ref<Image>()); dst_w = PoolVector<uint8_t>::Write(); - return Image(features.width, features.height, 0, features.has_alpha ? Image::FORMAT_RGBA8 : Image::FORMAT_RGB8, dst_image); + Ref<Image> img = memnew(Image(features.width, features.height, 0, features.has_alpha ? Image::FORMAT_RGBA8 : Image::FORMAT_RGB8, dst_image)); + return img; } -Error ImageLoaderWEBP::load_image(Image *p_image, FileAccess *f) { +Error ImageLoaderWEBP::load_image(Ref<Image> p_image, FileAccess *f) { uint32_t size = f->get_len(); PoolVector<uint8_t> src_image; @@ -130,9 +133,11 @@ Error ImageLoaderWEBP::load_image(Image *p_image, FileAccess *f) { ERR_FAIL_V(ERR_FILE_CORRUPT); } + /* print_line("width: " + itos(features.width)); print_line("height: " + itos(features.height)); print_line("alpha: " + itos(features.has_alpha)); + */ src_w = PoolVector<uint8_t>::Write(); @@ -156,7 +161,7 @@ Error ImageLoaderWEBP::load_image(Image *p_image, FileAccess *f) { src_r = PoolVector<uint8_t>::Read(); dst_w = PoolVector<uint8_t>::Write(); - *p_image = Image(features.width, features.height, 0, features.has_alpha ? Image::FORMAT_RGBA8 : Image::FORMAT_RGB8, dst_image); + p_image->create(features.width, features.height, 0, features.has_alpha ? Image::FORMAT_RGBA8 : Image::FORMAT_RGB8, dst_image); return OK; } diff --git a/modules/webp/image_loader_webp.h b/modules/webp/image_loader_webp.h index 2d0ac796d..ba817e0ec 100644 --- a/modules/webp/image_loader_webp.h +++ b/modules/webp/image_loader_webp.h @@ -38,7 +38,7 @@ class ImageLoaderWEBP : public ImageFormatLoader { public: - virtual Error load_image(Image *p_image, FileAccess *f); + virtual Error load_image(Ref<Image> p_image, FileAccess *f); virtual void get_recognized_extensions(List<String> *p_extensions) const; ImageLoaderWEBP(); }; |