diff options
Diffstat (limited to 'core')
35 files changed, 1471 insertions, 2239 deletions
diff --git a/core/bind/core_bind.cpp b/core/bind/core_bind.cpp index 7a03ceb64c..2752391901 100644 --- a/core/bind/core_bind.cpp +++ b/core/bind/core_bind.cpp @@ -505,7 +505,7 @@ int _OS::get_dynamic_memory_usage() const { return OS::get_singleton()->get_dynamic_memory_usage(); } -void _OS::set_icon(const Image &p_icon) { +void _OS::set_icon(const Ref<Image> &p_icon) { OS::get_singleton()->set_icon(p_icon); } diff --git a/core/bind/core_bind.h b/core/bind/core_bind.h index 222339bce1..e48b5c85ad 100644 --- a/core/bind/core_bind.h +++ b/core/bind/core_bind.h @@ -30,6 +30,7 @@ #ifndef CORE_BIND_H #define CORE_BIND_H +#include "image.h" #include "io/resource_loader.h" #include "io/resource_saver.h" #include "os/dir_access.h" @@ -226,7 +227,7 @@ public: void set_use_file_access_save_and_swap(bool p_enable); - void set_icon(const Image &p_icon); + void set_icon(const Ref<Image> &p_icon); int get_exit_code() const; void set_exit_code(int p_code); diff --git a/core/global_config.cpp b/core/global_config.cpp index 81b923f01e..896384d9c8 100644 --- a/core/global_config.cpp +++ b/core/global_config.cpp @@ -846,10 +846,8 @@ GlobalConfig::GlobalConfig() { registering_order = true; Array va; - InputEvent key; - key.type = InputEvent::KEY; - InputEvent joyb; - joyb.type = InputEvent::JOYPAD_BUTTON; + Ref<InputEventKey> key; + Ref<InputEventJoypadButton> joyb; GLOBAL_DEF("application/name", ""); GLOBAL_DEF("application/main_scene", ""); @@ -858,87 +856,106 @@ GlobalConfig::GlobalConfig() { GLOBAL_DEF("application/disable_stderr", false); GLOBAL_DEF("application/use_shared_user_dir", true); - key.key.scancode = KEY_RETURN; + key.instance(); + key->set_scancode(KEY_RETURN); va.push_back(key); - key.key.scancode = KEY_ENTER; + key.instance(); + key->set_scancode(KEY_ENTER); va.push_back(key); - key.key.scancode = KEY_SPACE; + key.instance(); + key->set_scancode(KEY_SPACE); va.push_back(key); - joyb.joy_button.button_index = JOY_BUTTON_0; + joyb.instance(); + joyb->set_button_index(JOY_BUTTON_0); va.push_back(joyb); GLOBAL_DEF("input/ui_accept", va); input_presets.push_back("input/ui_accept"); va = Array(); - key.key.scancode = KEY_SPACE; + key.instance(); + key->set_scancode(KEY_SPACE); va.push_back(key); - joyb.joy_button.button_index = JOY_BUTTON_3; + joyb.instance(); + joyb->set_button_index(JOY_BUTTON_3); va.push_back(joyb); GLOBAL_DEF("input/ui_select", va); input_presets.push_back("input/ui_select"); va = Array(); - key.key.scancode = KEY_ESCAPE; + key.instance(); + key->set_scancode(KEY_ESCAPE); va.push_back(key); - joyb.joy_button.button_index = JOY_BUTTON_1; + joyb.instance(); + joyb->set_button_index(JOY_BUTTON_1); va.push_back(joyb); GLOBAL_DEF("input/ui_cancel", va); input_presets.push_back("input/ui_cancel"); va = Array(); - key.key.scancode = KEY_TAB; + key.instance(); + key->set_scancode(KEY_TAB); va.push_back(key); GLOBAL_DEF("input/ui_focus_next", va); input_presets.push_back("input/ui_focus_next"); va = Array(); - key.key.scancode = KEY_TAB; - key.key.mod.shift = true; + key.instance(); + key->set_scancode(KEY_TAB); + key->set_shift(true); va.push_back(key); GLOBAL_DEF("input/ui_focus_prev", va); input_presets.push_back("input/ui_focus_prev"); - key.key.mod.shift = false; va = Array(); - key.key.scancode = KEY_LEFT; + key.instance(); + key->set_scancode(KEY_LEFT); va.push_back(key); - joyb.joy_button.button_index = JOY_DPAD_LEFT; + joyb.instance(); + joyb->set_button_index(JOY_DPAD_LEFT); va.push_back(joyb); GLOBAL_DEF("input/ui_left", va); input_presets.push_back("input/ui_left"); va = Array(); - key.key.scancode = KEY_RIGHT; + key.instance(); + key->set_scancode(KEY_RIGHT); va.push_back(key); - joyb.joy_button.button_index = JOY_DPAD_RIGHT; + joyb.instance(); + joyb->set_button_index(JOY_DPAD_RIGHT); va.push_back(joyb); GLOBAL_DEF("input/ui_right", va); input_presets.push_back("input/ui_right"); va = Array(); - key.key.scancode = KEY_UP; + key.instance(); + key->set_scancode(KEY_UP); va.push_back(key); - joyb.joy_button.button_index = JOY_DPAD_UP; + joyb.instance(); + joyb->set_button_index(JOY_DPAD_UP); va.push_back(joyb); GLOBAL_DEF("input/ui_up", va); input_presets.push_back("input/ui_up"); va = Array(); - key.key.scancode = KEY_DOWN; + key.instance(); + key->set_scancode(KEY_DOWN); va.push_back(key); - joyb.joy_button.button_index = JOY_DPAD_DOWN; + joyb.instance(); + joyb->set_button_index(JOY_DPAD_DOWN); va.push_back(joyb); GLOBAL_DEF("input/ui_down", va); input_presets.push_back("input/ui_down"); va = Array(); - key.key.scancode = KEY_PAGEUP; + key.instance(); + key->set_scancode(KEY_PAGEUP); va.push_back(key); GLOBAL_DEF("input/ui_page_up", va); input_presets.push_back("input/ui_page_up"); va = Array(); - key.key.scancode = KEY_PAGEDOWN; + key.instance(); + key->set_scancode(KEY_PAGEDOWN); va.push_back(key); GLOBAL_DEF("input/ui_page_down", va); input_presets.push_back("input/ui_page_down"); diff --git a/core/global_constants.cpp b/core/global_constants.cpp index 9bc98c5ad7..4f535fb05e 100644 --- a/core/global_constants.cpp +++ b/core/global_constants.cpp @@ -30,6 +30,7 @@ #include "global_constants.h" #include "object.h" +#include "os/input_event.h" #include "os/keyboard.h" #include "variant.h" @@ -506,22 +507,20 @@ static _GlobalConstant _global_constants[] = { { "TYPE_TRANSFORM2D", Variant::TRANSFORM2D }, { "TYPE_PLANE", Variant::PLANE }, { "TYPE_QUAT", Variant::QUAT }, // 10 - { "TYPE_RECT3", Variant::RECT3 }, //sorry naming convention fail :( not like it's used often + { "TYPE_RECT3", Variant::RECT3 }, { "TYPE_BASIS", Variant::BASIS }, { "TYPE_TRANSFORM", Variant::TRANSFORM }, { "TYPE_COLOR", Variant::COLOR }, - { "TYPE_IMAGE", Variant::IMAGE }, // 15 - { "TYPE_NODE_PATH", Variant::NODE_PATH }, + { "TYPE_NODE_PATH", Variant::NODE_PATH }, // 15 { "TYPE_RID", Variant::_RID }, { "TYPE_OBJECT", Variant::OBJECT }, - { "TYPE_INPUT_EVENT", Variant::INPUT_EVENT }, { "TYPE_DICTIONARY", Variant::DICTIONARY }, // 20 { "TYPE_ARRAY", Variant::ARRAY }, { "TYPE_RAW_ARRAY", Variant::POOL_BYTE_ARRAY }, { "TYPE_INT_ARRAY", Variant::POOL_INT_ARRAY }, { "TYPE_REAL_ARRAY", Variant::POOL_REAL_ARRAY }, - { "TYPE_STRING_ARRAY", Variant::POOL_STRING_ARRAY }, // 25 - { "TYPE_VECTOR2_ARRAY", Variant::POOL_VECTOR2_ARRAY }, + { "TYPE_STRING_ARRAY", Variant::POOL_STRING_ARRAY }, + { "TYPE_VECTOR2_ARRAY", Variant::POOL_VECTOR2_ARRAY }, // 25 { "TYPE_VECTOR3_ARRAY", Variant::POOL_VECTOR3_ARRAY }, { "TYPE_COLOR_ARRAY", Variant::POOL_COLOR_ARRAY }, { "TYPE_MAX", Variant::VARIANT_MAX }, diff --git a/core/image.cpp b/core/image.cpp index b81d92fa33..85ca63be5e 100644 --- a/core/image.cpp +++ b/core/image.cpp @@ -415,7 +415,7 @@ void Image::convert(Format p_new_format) { //mipmaps=false; - *this = new_img; + _copy_internals_from(new_img); if (gen_mipmaps) generate_mipmaps(); @@ -611,14 +611,6 @@ void Image::resize_to_po2(bool p_square) { resize(w, h); } -Image Image::resized(int p_width, int p_height, int p_interpolation) { - - Image ret = *this; - ret.resize(p_width, p_height, (Interpolation)p_interpolation); - - return ret; -}; - void Image::resize(int p_width, int p_height, Interpolation p_interpolation) { if (!_can_modify(format)) { @@ -681,7 +673,7 @@ void Image::resize(int p_width, int p_height, Interpolation p_interpolation) { if (mipmaps > 0) dst.generate_mipmaps(); - *this = dst; + _copy_internals_from(dst); } void Image::crop(int p_width, int p_height) { @@ -728,7 +720,7 @@ void Image::crop(int p_width, int p_height) { if (mipmaps > 0) dst.generate_mipmaps(); - *this = dst; + _copy_internals_from(dst); } void Image::flip_y() { @@ -1383,17 +1375,7 @@ Error Image::save_png(const String &p_path) { if (save_png_func == NULL) return ERR_UNAVAILABLE; - return save_png_func(p_path, *this); -} - -bool Image::operator==(const Image &p_image) const { - - if (data.size() == 0 && p_image.data.size() == 0) - return true; - PoolVector<uint8_t>::Read r = data.read(); - PoolVector<uint8_t>::Read pr = p_image.data.read(); - - return r.ptr() == pr.ptr(); + return save_png_func(p_path, Ref<Image>(this)); } int Image::get_image_data_size(int p_width, int p_height, Format p_format, int p_mipmaps) { @@ -1736,13 +1718,6 @@ bool Image::is_compressed() const { return format >= FORMAT_RGB565; } -Image Image::decompressed() const { - - Image img = *this; - img.decompress(); - return img; -} - Error Image::decompress() { if (format >= FORMAT_DXT1 && format <= FORMAT_ATI2) @@ -1797,14 +1772,6 @@ Error Image::compress(CompressMode p_mode) { return OK; } -Image Image::compressed(int p_mode) { - - Image ret = *this; - ret.compress((Image::CompressMode)p_mode); - - return ret; -} - Image::Image(const char **p_xpm) { width = 0; @@ -1875,21 +1842,21 @@ Rect2 Image::get_used_rect() const { return Rect2(minx, miny, maxx - minx + 1, maxy - miny + 1); } -Image Image::get_rect(const Rect2 &p_area) const { - - Image img(p_area.size.x, p_area.size.y, mipmaps, format); - img.blit_rect(*this, p_area, Point2(0, 0)); +Ref<Image> Image::get_rect(const Rect2 &p_area) const { + Ref<Image> img = memnew(Image(p_area.size.x, p_area.size.y, mipmaps, format)); + img->blit_rect(Ref<Image>(this), p_area, Point2(0, 0)); return img; } -void Image::blit_rect(const Image &p_src, const Rect2 &p_src_rect, const Point2 &p_dest) { +void Image::blit_rect(const Ref<Image> &p_src, const Rect2 &p_src_rect, const Point2 &p_dest) { + ERR_FAIL_COND(p_src.is_null()); int dsize = data.size(); - int srcdsize = p_src.data.size(); + int srcdsize = p_src->data.size(); ERR_FAIL_COND(dsize == 0); ERR_FAIL_COND(srcdsize == 0); - ERR_FAIL_COND(format != p_src.format); + ERR_FAIL_COND(format != p_src->format); Rect2i local_src_rect = Rect2i(0, 0, width, height).clip(Rect2i(p_dest + p_src_rect.pos, p_src_rect.size)); @@ -1900,7 +1867,7 @@ void Image::blit_rect(const Image &p_src, const Rect2 &p_src_rect, const Point2 PoolVector<uint8_t>::Write wp = data.write(); uint8_t *dst_data_ptr = wp.ptr(); - PoolVector<uint8_t>::Read rp = p_src.data.read(); + PoolVector<uint8_t>::Read rp = p_src->data.read(); const uint8_t *src_data_ptr = rp.ptr(); int pixel_size = get_format_pixel_size(format); @@ -1915,7 +1882,7 @@ void Image::blit_rect(const Image &p_src, const Rect2 &p_src_rect, const Point2 int dst_x = local_src_rect.pos.x + j; int dst_y = local_src_rect.pos.y + i; - const uint8_t *src = &src_data_ptr[(src_y * p_src.width + src_x) * pixel_size]; + const uint8_t *src = &src_data_ptr[(src_y * p_src->width + src_x) * pixel_size]; uint8_t *dst = &dst_data_ptr[(dst_y * width + dst_x) * pixel_size]; for (int k = 0; k < pixel_size; k++) { @@ -1925,8 +1892,8 @@ void Image::blit_rect(const Image &p_src, const Rect2 &p_src_rect, const Point2 } } -Image (*Image::_png_mem_loader_func)(const uint8_t *, int) = NULL; -Image (*Image::_jpg_mem_loader_func)(const uint8_t *, int) = NULL; +Ref<Image> (*Image::_png_mem_loader_func)(const uint8_t *, int) = NULL; +Ref<Image> (*Image::_jpg_mem_loader_func)(const uint8_t *, int) = NULL; void (*Image::_image_compress_bc_func)(Image *) = NULL; void (*Image::_image_compress_pvrtc2_func)(Image *) = NULL; @@ -1938,10 +1905,157 @@ void (*Image::_image_decompress_bc)(Image *) = NULL; void (*Image::_image_decompress_etc)(Image *) = NULL; void (*Image::_image_decompress_etc2)(Image *) = NULL; -PoolVector<uint8_t> (*Image::lossy_packer)(const Image &, float) = NULL; -Image (*Image::lossy_unpacker)(const PoolVector<uint8_t> &) = NULL; -PoolVector<uint8_t> (*Image::lossless_packer)(const Image &) = NULL; -Image (*Image::lossless_unpacker)(const PoolVector<uint8_t> &) = NULL; +PoolVector<uint8_t> (*Image::lossy_packer)(const Ref<Image> &, float) = NULL; +Ref<Image> (*Image::lossy_unpacker)(const PoolVector<uint8_t> &) = NULL; +PoolVector<uint8_t> (*Image::lossless_packer)(const Ref<Image> &) = NULL; +Ref<Image> (*Image::lossless_unpacker)(const PoolVector<uint8_t> &) = NULL; + +void Image::_set_data(const Dictionary &p_data) { + + ERR_FAIL_COND(!p_data.has("width")); + ERR_FAIL_COND(!p_data.has("height")); + ERR_FAIL_COND(!p_data.has("format")); + ERR_FAIL_COND(!p_data.has("mipmaps")); + ERR_FAIL_COND(!p_data.has("data")); + + int dwidth = p_data["width"]; + int dheight = p_data["height"]; + String dformat = p_data["format"]; + bool dmipmaps = p_data["mipmaps"]; + PoolVector<uint8_t> ddata = p_data["data"]; + Format ddformat = FORMAT_MAX; + for (int i = 0; i < FORMAT_MAX; i++) { + if (dformat == get_format_name(Format(i))) { + ddformat = Format(i); + break; + } + } + + ERR_FAIL_COND(ddformat == FORMAT_MAX); + + create(dwidth, dheight, dmipmaps, ddformat, ddata); +} + +Dictionary Image::_get_data() const { + + Dictionary d; + d["width"] = width; + d["height"] = height; + d["format"] = get_format_name(format); + d["mipmaps"] = mipmaps; + d["data"] = data; + return d; +} + +void Image::_bind_methods() { + + ClassDB::bind_method(D_METHOD("get_width"), &Image::get_width); + ClassDB::bind_method(D_METHOD("get_height"), &Image::get_height); + ClassDB::bind_method(D_METHOD("has_mipmaps"), &Image::has_mipmaps); + ClassDB::bind_method(D_METHOD("get_format"), &Image::get_format); + ClassDB::bind_method(D_METHOD("get_data"), &Image::get_data); + + ClassDB::bind_method(D_METHOD("convert", "format"), &Image::convert); + + ClassDB::bind_method(D_METHOD("get_mipmap_offset", "mipmap"), &Image::get_mipmap_offset); + + ClassDB::bind_method(D_METHOD("resize_to_po2", "square"), &Image::resize_to_po2, DEFVAL("false")); + ClassDB::bind_method(D_METHOD("resize", "width", "height", "interpolation"), &Image::resize, DEFVAL(INTERPOLATE_BILINEAR)); + ClassDB::bind_method(D_METHOD("shrink_x2"), &Image::shrink_x2); + ClassDB::bind_method(D_METHOD("expand_x2_hq2x"), &Image::expand_x2_hq2x); + + ClassDB::bind_method(D_METHOD("crop", "width", "height"), &Image::crop); + ClassDB::bind_method(D_METHOD("flip_x"), &Image::flip_x); + ClassDB::bind_method(D_METHOD("flip_y"), &Image::flip_y); + ClassDB::bind_method(D_METHOD("generate_mipmaps"), &Image::generate_mipmaps); + ClassDB::bind_method(D_METHOD("clear_mipmaps"), &Image::clear_mipmaps); + + ClassDB::bind_method(D_METHOD("create", "width", "height", "use_mipmaps", "format"), &Image::_create_empty); + ClassDB::bind_method(D_METHOD("create_from_data", "width", "height", "use_mipmaps", "format", "data"), &Image::_create_from_data); + + ClassDB::bind_method(D_METHOD("is_empty"), &Image::empty); + + ClassDB::bind_method(D_METHOD("load", "path"), &Image::load); + ClassDB::bind_method(D_METHOD("save_png", "path"), &Image::save_png); + + ClassDB::bind_method(D_METHOD("detect_alpha"), &Image::detect_alpha); + ClassDB::bind_method(D_METHOD("is_invisible"), &Image::is_invisible); + + ClassDB::bind_method(D_METHOD("compress", "mode"), &Image::compress); + ClassDB::bind_method(D_METHOD("decompress"), &Image::decompress); + ClassDB::bind_method(D_METHOD("is_compressed"), &Image::is_compressed); + + ClassDB::bind_method(D_METHOD("fix_alpha_edges"), &Image::fix_alpha_edges); + ClassDB::bind_method(D_METHOD("premultiply_alpha"), &Image::premultiply_alpha); + ClassDB::bind_method(D_METHOD("srgb_to_linear"), &Image::srgb_to_linear); + ClassDB::bind_method(D_METHOD("normalmap_to_xy"), &Image::normalmap_to_xy); + + ClassDB::bind_method(D_METHOD("blit_rect", "src:Image", "src_rect", "dst"), &Image::blit_rect); + + ClassDB::bind_method(D_METHOD("get_used_rect"), &Image::get_used_rect); + ClassDB::bind_method(D_METHOD("get_rect:Image", "rect"), &Image::get_rect); + + ClassDB::bind_method(D_METHOD("copy_from", "src:Image"), &Image::copy_internals_from); + + ClassDB::bind_method(D_METHOD("_set_data", "data"), &Image::_set_data); + ClassDB::bind_method(D_METHOD("_get_data"), &Image::_get_data); + + ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY, "data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE), "_set_data", "_get_data"); + + BIND_CONSTANT(FORMAT_L8); //luminance + BIND_CONSTANT(FORMAT_LA8); //luminance-alpha + BIND_CONSTANT(FORMAT_R8); + BIND_CONSTANT(FORMAT_RG8); + BIND_CONSTANT(FORMAT_RGB8); + BIND_CONSTANT(FORMAT_RGBA8); + BIND_CONSTANT(FORMAT_RGB565); //16 bit + BIND_CONSTANT(FORMAT_RGBA4444); + BIND_CONSTANT(FORMAT_RGBA5551); + BIND_CONSTANT(FORMAT_RF); //float + BIND_CONSTANT(FORMAT_RGF); + BIND_CONSTANT(FORMAT_RGBF); + BIND_CONSTANT(FORMAT_RGBAF); + BIND_CONSTANT(FORMAT_RH); //half float + BIND_CONSTANT(FORMAT_RGH); + BIND_CONSTANT(FORMAT_RGBH); + BIND_CONSTANT(FORMAT_RGBAH); + BIND_CONSTANT(FORMAT_DXT1); //s3tc bc1 + BIND_CONSTANT(FORMAT_DXT3); //bc2 + BIND_CONSTANT(FORMAT_DXT5); //bc3 + BIND_CONSTANT(FORMAT_ATI1); //bc4 + BIND_CONSTANT(FORMAT_ATI2); //bc5 + BIND_CONSTANT(FORMAT_BPTC_RGBA); //btpc bc6h + BIND_CONSTANT(FORMAT_BPTC_RGBF); //float / + BIND_CONSTANT(FORMAT_BPTC_RGBFU); //unsigned float + BIND_CONSTANT(FORMAT_PVRTC2); //pvrtc + BIND_CONSTANT(FORMAT_PVRTC2A); + BIND_CONSTANT(FORMAT_PVRTC4); + BIND_CONSTANT(FORMAT_PVRTC4A); + BIND_CONSTANT(FORMAT_ETC); //etc1 + BIND_CONSTANT(FORMAT_ETC2_R11); //etc2 + BIND_CONSTANT(FORMAT_ETC2_R11S); //signed ); NOT srgb. + BIND_CONSTANT(FORMAT_ETC2_RG11); + BIND_CONSTANT(FORMAT_ETC2_RG11S); + BIND_CONSTANT(FORMAT_ETC2_RGB8); + BIND_CONSTANT(FORMAT_ETC2_RGBA8); + BIND_CONSTANT(FORMAT_ETC2_RGB8A1); + BIND_CONSTANT(FORMAT_MAX); + + BIND_CONSTANT(INTERPOLATE_NEAREST); + BIND_CONSTANT(INTERPOLATE_BILINEAR); + BIND_CONSTANT(INTERPOLATE_CUBIC); + + BIND_CONSTANT(ALPHA_NONE); + BIND_CONSTANT(ALPHA_BIT); + BIND_CONSTANT(ALPHA_BLEND); + + BIND_CONSTANT(COMPRESS_16BIT); + BIND_CONSTANT(COMPRESS_S3TC); + BIND_CONSTANT(COMPRESS_PVRTC2); + BIND_CONSTANT(COMPRESS_PVRTC4); + BIND_CONSTANT(COMPRESS_ETC); + BIND_CONSTANT(COMPRESS_ETC2); +} void Image::set_compress_bc_func(void (*p_compress_func)(Image *)) { @@ -2108,14 +2222,22 @@ Image::Image(const uint8_t *p_mem_png_jpg, int p_len) { format = FORMAT_L8; if (_png_mem_loader_func) { - *this = _png_mem_loader_func(p_mem_png_jpg, p_len); + copy_internals_from(_png_mem_loader_func(p_mem_png_jpg, p_len)); } if (empty() && _jpg_mem_loader_func) { - *this = _jpg_mem_loader_func(p_mem_png_jpg, p_len); + copy_internals_from(_jpg_mem_loader_func(p_mem_png_jpg, p_len)); } } +Ref<Resource> Image::duplicate(bool p_subresources) const { + + Ref<Image> copy; + copy.instance(); + copy->_copy_internals_from(*this); + return copy; +} + Image::Image() { width = 0; diff --git a/core/image.h b/core/image.h index fc87ee8847..4decaa3436 100644 --- a/core/image.h +++ b/core/image.h @@ -33,6 +33,8 @@ #include "color.h" #include "dvector.h" #include "math_2d.h" +#include "resource.h" + /** * @author Juan Linietsky <reduzio@gmail.com> * @@ -43,9 +45,10 @@ class Image; -typedef Error (*SavePNGFunc)(const String &p_path, Image &p_img); +typedef Error (*SavePNGFunc)(const String &p_path, const Ref<Image> &p_img); -class Image { +class Image : public Resource { + GDCLASS(Image, Resource); enum { MAX_WIDTH = 16384, // force a limit somehow @@ -108,8 +111,8 @@ public: //some functions provided by something else - static Image (*_png_mem_loader_func)(const uint8_t *p_png, int p_size); - static Image (*_jpg_mem_loader_func)(const uint8_t *p_png, int p_size); + static Ref<Image> (*_png_mem_loader_func)(const uint8_t *p_png, int p_size); + static Ref<Image> (*_jpg_mem_loader_func)(const uint8_t *p_png, int p_size); static void (*_image_compress_bc_func)(Image *); static void (*_image_compress_pvrtc2_func)(Image *); @@ -124,17 +127,36 @@ public: Error _decompress_bc(); - static PoolVector<uint8_t> (*lossy_packer)(const Image &p_image, float p_quality); - static Image (*lossy_unpacker)(const PoolVector<uint8_t> &p_buffer); - static PoolVector<uint8_t> (*lossless_packer)(const Image &p_image); - static Image (*lossless_unpacker)(const PoolVector<uint8_t> &p_buffer); + static PoolVector<uint8_t> (*lossy_packer)(const Ref<Image> &p_image, float p_quality); + static Ref<Image> (*lossy_unpacker)(const PoolVector<uint8_t> &p_buffer); + static PoolVector<uint8_t> (*lossless_packer)(const Ref<Image> &p_image); + static Ref<Image> (*lossless_unpacker)(const PoolVector<uint8_t> &p_buffer); + +protected: + static void _bind_methods(); private: + void _create_empty(int p_width, int p_height, bool p_use_mipmaps, Format p_format) { + create(p_width, p_height, p_use_mipmaps, p_format); + } + + void _create_from_data(int p_width, int p_height, bool p_use_mipmaps, Format p_format, const PoolVector<uint8_t> &p_data) { + create(p_width, p_height, p_use_mipmaps, p_format, p_data); + } + Format format; PoolVector<uint8_t> data; int width, height; bool mipmaps; + void _copy_internals_from(const Image &p_image) { + format = p_image.format; + width = p_image.width; + height = p_image.height; + mipmaps = p_image.mipmaps; + data = p_image.data; + } + _FORCE_INLINE_ void _get_mipmap_offset_and_size(int p_mipmap, int &r_offset, int &r_width, int &r_height) const; //get where the mipmap begins in data static int _get_dst_image_size(int p_width, int p_height, Format p_format, int &r_mipmaps, int p_mipmaps = -1); @@ -143,6 +165,9 @@ private: _FORCE_INLINE_ void _put_pixelb(int p_x, int p_y, uint32_t p_pixelsize, uint8_t *p_dst, const uint8_t *p_src); _FORCE_INLINE_ void _get_pixelb(int p_x, int p_y, uint32_t p_pixelsize, const uint8_t *p_src, uint8_t *p_dst); + void _set_data(const Dictionary &p_data); + Dictionary _get_data() const; + public: int get_width() const; ///< Get image width int get_height() const; ///< Get image height @@ -154,14 +179,6 @@ public: */ void convert(Format p_new_format); - Image converted(int p_new_format) { - ERR_FAIL_INDEX_V(p_new_format, FORMAT_MAX, Image()); - - Image ret = *this; - ret.convert((Format)p_new_format); - return ret; - }; - /** * Get the current image format. */ @@ -178,7 +195,6 @@ public: void resize_to_po2(bool p_square = false); void resize(int p_width, int p_height, Interpolation p_interpolation = INTERPOLATE_BILINEAR); - Image resized(int p_width, int p_height, int p_interpolation = INTERPOLATE_BILINEAR); void shrink_x2(); void expand_x2_hq2x(); /** @@ -242,8 +258,6 @@ public: static int get_image_data_size(int p_width, int p_height, Format p_format, int p_mipmaps = 0); static int get_image_required_mipmaps(int p_width, int p_height, Format p_format); - bool operator==(const Image &p_image) const; - enum CompressMode { COMPRESS_16BIT, COMPRESS_S3TC, @@ -254,9 +268,7 @@ public: }; Error compress(CompressMode p_mode = COMPRESS_S3TC); - Image compressed(int p_mode); /* from the Image::CompressMode enum */ Error decompress(); - Image decompressed() const; bool is_compressed() const; void fix_alpha_edges(); @@ -264,17 +276,34 @@ public: void srgb_to_linear(); void normalmap_to_xy(); - void blit_rect(const Image &p_src, const Rect2 &p_src_rect, const Point2 &p_dest); + void blit_rect(const Ref<Image> &p_src, const Rect2 &p_src_rect, const Point2 &p_dest); Rect2 get_used_rect() const; - Image get_rect(const Rect2 &p_area) const; + Ref<Image> get_rect(const Rect2 &p_area) const; static void set_compress_bc_func(void (*p_compress_func)(Image *)); static String get_format_name(Format p_format); Image(const uint8_t *p_mem_png_jpg, int p_len = -1); Image(const char **p_xpm); + + virtual Ref<Resource> duplicate(bool p_subresources = false) const; + + void copy_internals_from(const Ref<Image> &p_image) { + ERR_FAIL_COND(p_image.is_null()); + format = p_image->format; + width = p_image->width; + height = p_image->height; + mipmaps = p_image->mipmaps; + data = p_image->data; + } + ~Image(); }; +VARIANT_ENUM_CAST(Image::Format) +VARIANT_ENUM_CAST(Image::Interpolation) +VARIANT_ENUM_CAST(Image::CompressMode) +VARIANT_ENUM_CAST(Image::AlphaMode) + #endif diff --git a/core/input_map.cpp b/core/input_map.cpp index 9f9eba01c7..1307c467e6 100644 --- a/core/input_map.cpp +++ b/core/input_map.cpp @@ -37,8 +37,6 @@ InputMap *InputMap::singleton = NULL; void InputMap::_bind_methods() { ClassDB::bind_method(D_METHOD("has_action", "action"), &InputMap::has_action); - ClassDB::bind_method(D_METHOD("get_action_id", "action"), &InputMap::get_action_id); - ClassDB::bind_method(D_METHOD("get_action_from_id", "id"), &InputMap::get_action_from_id); ClassDB::bind_method(D_METHOD("get_actions"), &InputMap::_get_actions); ClassDB::bind_method(D_METHOD("add_action", "action"), &InputMap::add_action); ClassDB::bind_method(D_METHOD("erase_action", "action"), &InputMap::erase_action); @@ -57,23 +55,15 @@ void InputMap::add_action(const StringName &p_action) { input_map[p_action] = Action(); static int last_id = 1; input_map[p_action].id = last_id; - input_id_map[last_id] = p_action; last_id++; } void InputMap::erase_action(const StringName &p_action) { ERR_FAIL_COND(!input_map.has(p_action)); - input_id_map.erase(input_map[p_action].id); input_map.erase(p_action); } -StringName InputMap::get_action_from_id(int p_id) const { - - ERR_FAIL_COND_V(!input_id_map.has(p_id), StringName()); - return input_id_map[p_id]; -} - Array InputMap::_get_actions() { Array ret; @@ -103,49 +93,18 @@ List<StringName> InputMap::get_actions() const { return actions; } -List<InputEvent>::Element *InputMap::_find_event(List<InputEvent> &p_list, const InputEvent &p_event, bool p_action_test) const { - - for (List<InputEvent>::Element *E = p_list.front(); E; E = E->next()) { - - const InputEvent &e = E->get(); - if (e.type != p_event.type) - continue; - if (e.type != InputEvent::KEY && e.device != p_event.device) - continue; - - bool same = false; - - switch (p_event.type) { - - case InputEvent::KEY: { - - if (p_action_test) { - uint32_t code = e.key.get_scancode_with_modifiers(); - uint32_t event_code = p_event.key.get_scancode_with_modifiers(); - same = (e.key.scancode == p_event.key.scancode && (!p_event.key.pressed || ((code & event_code) == code))); - } else { - same = (e.key.scancode == p_event.key.scancode && e.key.mod == p_event.key.mod); - } - - } break; - case InputEvent::JOYPAD_BUTTON: { +List<Ref<InputEvent> >::Element *InputMap::_find_event(List<Ref<InputEvent> > &p_list, const Ref<InputEvent> &p_event, bool p_action_test) const { - same = (e.joy_button.button_index == p_event.joy_button.button_index); + for (List<Ref<InputEvent> >::Element *E = p_list.front(); E; E = E->next()) { - } break; - case InputEvent::MOUSE_BUTTON: { + const Ref<InputEvent> e = E->get(); - same = (e.mouse_button.button_index == p_event.mouse_button.button_index); + //if (e.type != Ref<InputEvent>::KEY && e.device != p_event.device) -- unsure about the KEY comparison, why is this here? + // continue; - } break; - case InputEvent::JOYPAD_MOTION: { - - same = (e.joy_motion.axis == p_event.joy_motion.axis && (e.joy_motion.axis_value < 0) == (p_event.joy_motion.axis_value < 0)); - - } break; - } - - if (same) + if (e->get_device() != p_event->get_device()) + continue; + if (e->action_match(p_event)) return E; } @@ -157,9 +116,9 @@ bool InputMap::has_action(const StringName &p_action) const { return input_map.has(p_action); } -void InputMap::action_add_event(const StringName &p_action, const InputEvent &p_event) { +void InputMap::action_add_event(const StringName &p_action, const Ref<InputEvent> &p_event) { - ERR_FAIL_COND(p_event.type == InputEvent::ACTION); + ERR_FAIL_COND(p_event.is_null()); ERR_FAIL_COND(!input_map.has(p_action)); if (_find_event(input_map[p_action].inputs, p_event)) return; //already gots @@ -167,23 +126,17 @@ void InputMap::action_add_event(const StringName &p_action, const InputEvent &p_ input_map[p_action].inputs.push_back(p_event); } -int InputMap::get_action_id(const StringName &p_action) const { - - ERR_FAIL_COND_V(!input_map.has(p_action), -1); - return input_map[p_action].id; -} - -bool InputMap::action_has_event(const StringName &p_action, const InputEvent &p_event) { +bool InputMap::action_has_event(const StringName &p_action, const Ref<InputEvent> &p_event) { ERR_FAIL_COND_V(!input_map.has(p_action), false); return (_find_event(input_map[p_action].inputs, p_event) != NULL); } -void InputMap::action_erase_event(const StringName &p_action, const InputEvent &p_event) { +void InputMap::action_erase_event(const StringName &p_action, const Ref<InputEvent> &p_event) { ERR_FAIL_COND(!input_map.has(p_action)); - List<InputEvent>::Element *E = _find_event(input_map[p_action].inputs, p_event); + List<Ref<InputEvent> >::Element *E = _find_event(input_map[p_action].inputs, p_event); if (E) input_map[p_action].inputs.erase(E); } @@ -191,9 +144,9 @@ void InputMap::action_erase_event(const StringName &p_action, const InputEvent & Array InputMap::_get_action_list(const StringName &p_action) { Array ret; - const List<InputEvent> *al = get_action_list(p_action); + const List<Ref<InputEvent> > *al = get_action_list(p_action); if (al) { - for (const List<InputEvent>::Element *E = al->front(); E; E = E->next()) { + for (const List<Ref<InputEvent> >::Element *E = al->front(); E; E = E->next()) { ret.push_back(E->get()); } @@ -202,7 +155,7 @@ Array InputMap::_get_action_list(const StringName &p_action) { return ret; } -const List<InputEvent> *InputMap::get_action_list(const StringName &p_action) { +const List<Ref<InputEvent> > *InputMap::get_action_list(const StringName &p_action) { const Map<StringName, Action>::Element *E = input_map.find(p_action); if (!E) @@ -211,7 +164,7 @@ const List<InputEvent> *InputMap::get_action_list(const StringName &p_action) { return &E->get().inputs; } -bool InputMap::event_is_action(const InputEvent &p_event, const StringName &p_action) const { +bool InputMap::event_is_action(const Ref<InputEvent> &p_event, const StringName &p_action) const { Map<StringName, Action>::Element *E = input_map.find(p_action); if (!E) { @@ -219,9 +172,9 @@ bool InputMap::event_is_action(const InputEvent &p_event, const StringName &p_ac ERR_FAIL_COND_V(!E, false); } - if (p_event.type == InputEvent::ACTION) { - - return p_event.action.action == E->get().id; + Ref<InputEventAction> iea = p_event; + if (iea.is_valid()) { + return iea->get_action() == p_action; } return _find_event(E->get().inputs, p_event, true) != NULL; @@ -252,8 +205,8 @@ void InputMap::load_from_globals() { for (int i = 0; i < va.size(); i++) { - InputEvent ie = va[i]; - if (ie.type == InputEvent::NONE) + Ref<InputEvent> ie = va[i]; + if (ie.is_null()) continue; action_add_event(name, ie); } @@ -262,57 +215,70 @@ void InputMap::load_from_globals() { void InputMap::load_default() { - InputEvent key; - key.type = InputEvent::KEY; + Ref<InputEventKey> key; add_action("ui_accept"); - key.key.scancode = KEY_RETURN; + key.instance(); + key->set_scancode(KEY_RETURN); action_add_event("ui_accept", key); - key.key.scancode = KEY_ENTER; + + key.instance(); + key->set_scancode(KEY_ENTER); action_add_event("ui_accept", key); - key.key.scancode = KEY_SPACE; + + key.instance(); + key->set_scancode(KEY_SPACE); action_add_event("ui_accept", key); add_action("ui_select"); - key.key.scancode = KEY_SPACE; + key.instance(); + key->set_scancode(KEY_SPACE); action_add_event("ui_select", key); add_action("ui_cancel"); - key.key.scancode = KEY_ESCAPE; + key.instance(); + key->set_scancode(KEY_ESCAPE); action_add_event("ui_cancel", key); add_action("ui_focus_next"); - key.key.scancode = KEY_TAB; + key.instance(); + key->set_scancode(KEY_TAB); action_add_event("ui_focus_next", key); add_action("ui_focus_prev"); - key.key.scancode = KEY_TAB; - key.key.mod.shift = true; + key.instance(); + key->set_scancode(KEY_TAB); + key->set_shift(true); action_add_event("ui_focus_prev", key); - key.key.mod.shift = false; add_action("ui_left"); - key.key.scancode = KEY_LEFT; + key.instance(); + key->set_scancode(KEY_LEFT); action_add_event("ui_left", key); add_action("ui_right"); - key.key.scancode = KEY_RIGHT; + key.instance(); + key->set_scancode(KEY_RIGHT); action_add_event("ui_right", key); add_action("ui_up"); - key.key.scancode = KEY_UP; + key.instance(); + key->set_scancode(KEY_UP); action_add_event("ui_up", key); add_action("ui_down"); - key.key.scancode = KEY_DOWN; + key.instance(); + key->set_scancode(KEY_DOWN); action_add_event("ui_down", key); add_action("ui_page_up"); - key.key.scancode = KEY_PAGEUP; + key.instance(); + key->set_scancode(KEY_PAGEUP); action_add_event("ui_page_up", key); add_action("ui_page_down"); - key.key.scancode = KEY_PAGEDOWN; + key.instance(); + key->set_scancode(KEY_PAGEDOWN); action_add_event("ui_page_down", key); //set("display/handheld/orientation", "landscape"); diff --git a/core/input_map.h b/core/input_map.h index a25255da2d..ba93e61f5f 100644 --- a/core/input_map.h +++ b/core/input_map.h @@ -31,6 +31,7 @@ #define INPUT_MAP_H #include "object.h" +#include "os/input_event.h" class InputMap : public Object { @@ -39,16 +40,15 @@ class InputMap : public Object { public: struct Action { int id; - List<InputEvent> inputs; + List<Ref<InputEvent> > inputs; }; private: static InputMap *singleton; mutable Map<StringName, Action> input_map; - mutable Map<int, StringName> input_id_map; - List<InputEvent>::Element *_find_event(List<InputEvent> &p_list, const InputEvent &p_event, bool p_action_test = false) const; + List<Ref<InputEvent> >::Element *_find_event(List<Ref<InputEvent> > &p_list, const Ref<InputEvent> &p_event, bool p_action_test = false) const; Array _get_action_list(const StringName &p_action); Array _get_actions(); @@ -60,18 +60,16 @@ public: static _FORCE_INLINE_ InputMap *get_singleton() { return singleton; } bool has_action(const StringName &p_action) const; - int get_action_id(const StringName &p_action) const; - StringName get_action_from_id(int p_id) const; List<StringName> get_actions() const; void add_action(const StringName &p_action); void erase_action(const StringName &p_action); - void action_add_event(const StringName &p_action, const InputEvent &p_event); - bool action_has_event(const StringName &p_action, const InputEvent &p_event); - void action_erase_event(const StringName &p_action, const InputEvent &p_event); + void action_add_event(const StringName &p_action, const Ref<InputEvent> &p_event); + bool action_has_event(const StringName &p_action, const Ref<InputEvent> &p_event); + void action_erase_event(const StringName &p_action, const Ref<InputEvent> &p_event); - const List<InputEvent> *get_action_list(const StringName &p_action); - bool event_is_action(const InputEvent &p_event, const StringName &p_action) const; + const List<Ref<InputEvent> > *get_action_list(const StringName &p_action); + bool event_is_action(const Ref<InputEvent> &p_event, const StringName &p_action) const; const Map<StringName, Action> &get_action_map() const; void load_from_globals(); diff --git a/core/io/image_loader.cpp b/core/io/image_loader.cpp index 4864c18831..6ed20ac015 100644 --- a/core/io/image_loader.cpp +++ b/core/io/image_loader.cpp @@ -43,7 +43,8 @@ bool ImageFormatLoader::recognize(const String &p_extension) const { return false; } -Error ImageLoader::load_image(String p_file, Image *p_image, FileAccess *p_custom) { +Error ImageLoader::load_image(String p_file, Ref<Image> p_image, FileAccess *p_custom) { + ERR_FAIL_COND_V(p_image.is_null(), ERR_INVALID_PARAMETER); FileAccess *f = p_custom; if (!f) { diff --git a/core/io/image_loader.h b/core/io/image_loader.h index 37149dbe9d..7114cbf8ad 100644 --- a/core/io/image_loader.h +++ b/core/io/image_loader.h @@ -56,7 +56,7 @@ class ImageFormatLoader { friend class ImageLoader; protected: - virtual Error load_image(Image *p_image, FileAccess *p_fileaccess) = 0; + virtual Error load_image(Ref<Image> p_image, FileAccess *p_fileaccess) = 0; virtual void get_recognized_extensions(List<String> *p_extensions) const = 0; bool recognize(const String &p_extension) const; @@ -75,7 +75,7 @@ class ImageLoader { protected: public: - static Error load_image(String p_file, Image *p_image, FileAccess *p_custom = NULL); + static Error load_image(String p_file, Ref<Image> p_image, FileAccess *p_custom = NULL); static void get_recognized_extensions(List<String> *p_extensions); static bool recognize(const String &p_extension); diff --git a/core/io/marshalls.cpp b/core/io/marshalls.cpp index 5e66b7f7f5..dccf70ad7a 100644 --- a/core/io/marshalls.cpp +++ b/core/io/marshalls.cpp @@ -276,38 +276,6 @@ Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int (*r_len) += 4 * 4; } break; - case Variant::IMAGE: { - - ERR_FAIL_COND_V(len < (int)5 * 4, ERR_INVALID_DATA); - Image::Format fmt = (Image::Format)decode_uint32(&buf[0]); - ERR_FAIL_INDEX_V(fmt, Image::FORMAT_MAX, ERR_INVALID_DATA); - uint32_t mipmaps = decode_uint32(&buf[4]); - uint32_t w = decode_uint32(&buf[8]); - uint32_t h = decode_uint32(&buf[12]); - uint32_t datalen = decode_uint32(&buf[16]); - - Image img; - if (datalen > 0) { - len -= 5 * 4; - ERR_FAIL_COND_V(len < datalen, ERR_INVALID_DATA); - PoolVector<uint8_t> data; - data.resize(datalen); - PoolVector<uint8_t>::Write wr = data.write(); - copymem(&wr[0], &buf[20], datalen); - wr = PoolVector<uint8_t>::Write(); - - img = Image(w, h, mipmaps, fmt, data); - } - - r_variant = img; - if (r_len) { - if (datalen % 4) - (*r_len) += 4 - datalen % 4; - - (*r_len) += 4 * 5 + datalen; - } - - } break; case Variant::NODE_PATH: { ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA); @@ -397,66 +365,6 @@ Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int r_variant = (Object *)NULL; } break; - case Variant::INPUT_EVENT: { - - InputEvent ie; - - ie.type = decode_uint32(&buf[0]); - ie.device = decode_uint32(&buf[4]); - - if (r_len) - (*r_len) += 12; - - switch (ie.type) { - - case InputEvent::KEY: { - - uint32_t mods = decode_uint32(&buf[12]); - if (mods & KEY_MASK_SHIFT) - ie.key.mod.shift = true; - if (mods & KEY_MASK_CTRL) - ie.key.mod.control = true; - if (mods & KEY_MASK_ALT) - ie.key.mod.alt = true; - if (mods & KEY_MASK_META) - ie.key.mod.meta = true; - ie.key.scancode = decode_uint32(&buf[16]); - - if (r_len) - (*r_len) += 8; - - } break; - case InputEvent::MOUSE_BUTTON: { - - ie.mouse_button.button_index = decode_uint32(&buf[12]); - if (r_len) - (*r_len) += 4; - - } break; - case InputEvent::JOYPAD_BUTTON: { - - ie.joy_button.button_index = decode_uint32(&buf[12]); - if (r_len) - (*r_len) += 4; - } break; - case InputEvent::SCREEN_TOUCH: { - - ie.screen_touch.index = decode_uint32(&buf[12]); - if (r_len) - (*r_len) += 4; - } break; - case InputEvent::JOYPAD_MOTION: { - - ie.joy_motion.axis = decode_uint32(&buf[12]); - ie.joy_motion.axis_value = decode_float(&buf[16]); - if (r_len) - (*r_len) += 8; - } break; - } - - r_variant = ie; - - } break; case Variant::DICTIONARY: { ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA); @@ -1078,30 +986,6 @@ Error encode_variant(const Variant &p_variant, uint8_t *r_buffer, int &r_len) { r_len += 4 * 4; } break; - case Variant::IMAGE: { - - Image image = p_variant; - PoolVector<uint8_t> data = image.get_data(); - - if (buf) { - - encode_uint32(image.get_format(), &buf[0]); - encode_uint32(image.has_mipmaps(), &buf[4]); - encode_uint32(image.get_width(), &buf[8]); - encode_uint32(image.get_height(), &buf[12]); - int ds = data.size(); - encode_uint32(ds, &buf[16]); - PoolVector<uint8_t>::Read r = data.read(); - copymem(&buf[20], &r[0], ds); - } - - int pad = 0; - if (data.size() % 4) - pad = 4 - data.size() % 4; - - r_len += data.size() + 5 * 4 + pad; - - } break; /*case Variant::RESOURCE: { ERR_EXPLAIN("Can't marshallize resources"); @@ -1111,83 +995,6 @@ Error encode_variant(const Variant &p_variant, uint8_t *r_buffer, int &r_len) { case Variant::OBJECT: { } break; - case Variant::INPUT_EVENT: { - - InputEvent ie = p_variant; - - if (buf) { - - encode_uint32(ie.type, &buf[0]); - encode_uint32(ie.device, &buf[4]); - encode_uint32(0, &buf[8]); - } - - int llen = 12; - - switch (ie.type) { - - case InputEvent::KEY: { - - if (buf) { - - uint32_t mods = 0; - if (ie.key.mod.shift) - mods |= KEY_MASK_SHIFT; - if (ie.key.mod.control) - mods |= KEY_MASK_CTRL; - if (ie.key.mod.alt) - mods |= KEY_MASK_ALT; - if (ie.key.mod.meta) - mods |= KEY_MASK_META; - - encode_uint32(mods, &buf[llen]); - encode_uint32(ie.key.scancode, &buf[llen + 4]); - } - llen += 8; - - } break; - case InputEvent::MOUSE_BUTTON: { - - if (buf) { - - encode_uint32(ie.mouse_button.button_index, &buf[llen]); - } - llen += 4; - } break; - case InputEvent::JOYPAD_BUTTON: { - - if (buf) { - - encode_uint32(ie.joy_button.button_index, &buf[llen]); - } - llen += 4; - } break; - case InputEvent::SCREEN_TOUCH: { - - if (buf) { - - encode_uint32(ie.screen_touch.index, &buf[llen]); - } - llen += 4; - } break; - case InputEvent::JOYPAD_MOTION: { - - if (buf) { - - int axis = ie.joy_motion.axis; - encode_uint32(axis, &buf[llen]); - encode_float(ie.joy_motion.axis_value, &buf[llen + 4]); - } - llen += 8; - } break; - } - - if (buf) - encode_uint32(llen, &buf[8]); - r_len += llen; - - // not supported - } break; case Variant::DICTIONARY: { Dictionary d = p_variant; diff --git a/core/io/resource_format_binary.cpp b/core/io/resource_format_binary.cpp index fc18a44ed3..26b53c2a31 100644 --- a/core/io/resource_format_binary.cpp +++ b/core/io/resource_format_binary.cpp @@ -49,12 +49,12 @@ enum { VARIANT_VECTOR3 = 12, VARIANT_PLANE = 13, VARIANT_QUAT = 14, - VARIANT_AABB = 15, + VARIANT_RECT3 = 15, VARIANT_MATRIX3 = 16, VARIANT_TRANSFORM = 17, VARIANT_MATRIX32 = 18, VARIANT_COLOR = 20, - VARIANT_IMAGE = 21, + //VARIANT_IMAGE = 21, - no longer variant type VARIANT_NODE_PATH = 22, VARIANT_RID = 23, VARIANT_OBJECT = 24, @@ -71,11 +71,6 @@ enum { VARIANT_INT64 = 40, VARIANT_DOUBLE = 41, - IMAGE_ENCODING_EMPTY = 0, - IMAGE_ENCODING_RAW = 1, - IMAGE_ENCODING_LOSSLESS = 2, - IMAGE_ENCODING_LOSSY = 3, - OBJECT_EMPTY = 0, OBJECT_EXTERNAL_RESOURCE = 1, OBJECT_INTERNAL_RESOURCE = 2, @@ -193,7 +188,7 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant &r_v) { r_v = v; } break; - case VARIANT_AABB: { + case VARIANT_RECT3: { Rect3 v; v.pos.x = f->get_real(); @@ -259,74 +254,7 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant &r_v) { r_v = v; } break; - case VARIANT_IMAGE: { - - uint32_t encoding = f->get_32(); - if (encoding == IMAGE_ENCODING_EMPTY) { - r_v = Variant(); - break; - } else if (encoding == IMAGE_ENCODING_RAW) { - uint32_t width = f->get_32(); - uint32_t height = f->get_32(); - uint32_t mipmaps = f->get_32(); - uint32_t format = f->get_32(); - const uint32_t format_version_shift = 24; - const uint32_t format_version_mask = format_version_shift - 1; - - uint32_t format_version = format >> format_version_shift; - - const uint32_t current_version = 0; - if (format_version > current_version) { - - ERR_PRINT("Format version for encoded binary image is too new"); - return ERR_PARSE_ERROR; - } - - Image::Format fmt = Image::Format(format & format_version_mask); //if format changes, we can add a compatibility bit on top - - uint32_t datalen = f->get_32(); - print_line("image format: " + String(Image::get_format_name(fmt)) + " datalen " + itos(datalen)); - - PoolVector<uint8_t> imgdata; - imgdata.resize(datalen); - PoolVector<uint8_t>::Write w = imgdata.write(); - f->get_buffer(w.ptr(), datalen); - _advance_padding(datalen); - w = PoolVector<uint8_t>::Write(); - -#ifdef TOOLS_ENABLED - //compatibility - int correct_size = Image::get_image_data_size(width, height, fmt, mipmaps ? -1 : 0); - if (correct_size < datalen) { - WARN_PRINT("Image data was too large, shrinking for compatibility") - imgdata.resize(correct_size); - } -#endif - r_v = Image(width, height, mipmaps, fmt, imgdata); - - } else { - //compressed - PoolVector<uint8_t> data; - data.resize(f->get_32()); - PoolVector<uint8_t>::Write w = data.write(); - f->get_buffer(w.ptr(), data.size()); - w = PoolVector<uint8_t>::Write(); - - Image img; - if (encoding == IMAGE_ENCODING_LOSSY && Image::lossy_unpacker) { - - img = Image::lossy_unpacker(data); - } else if (encoding == IMAGE_ENCODING_LOSSLESS && Image::lossless_unpacker) { - - img = Image::lossless_unpacker(data); - } - _advance_padding(data.size()); - - r_v = img; - } - - } break; case VARIANT_NODE_PATH: { Vector<StringName> names; @@ -431,13 +359,6 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant &r_v) { } } break; - case VARIANT_INPUT_EVENT: { - - InputEvent ev; - ev.type = f->get_32(); //will only work for null though. - r_v = ev; - - } break; case VARIANT_DICTIONARY: { uint32_t len = f->get_32(); @@ -1404,7 +1325,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant &p_property, } break; case Variant::RECT3: { - f->store_32(VARIANT_AABB); + f->store_32(VARIANT_RECT3); Rect3 val = p_property; f->store_real(val.pos.x); f->store_real(val.pos.y); @@ -1469,67 +1390,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant &p_property, f->store_real(val.a); } break; - case Variant::IMAGE: { - - f->store_32(VARIANT_IMAGE); - Image val = p_property; - if (val.empty()) { - f->store_32(IMAGE_ENCODING_EMPTY); - break; - } - - int encoding = IMAGE_ENCODING_RAW; - float quality = 0.7; - - if (!val.is_compressed()) { - //can only compress uncompressed stuff - - if (p_hint.hint == PROPERTY_HINT_IMAGE_COMPRESS_LOSSY && Image::lossy_packer) { - encoding = IMAGE_ENCODING_LOSSY; - float qs = p_hint.hint_string.to_double(); - if (qs != 0.0) - quality = qs; - - } else if (p_hint.hint == PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS && Image::lossless_packer) { - encoding = IMAGE_ENCODING_LOSSLESS; - } - } - - f->store_32(encoding); //raw encoding - - if (encoding == IMAGE_ENCODING_RAW) { - - f->store_32(val.get_width()); - f->store_32(val.get_height()); - f->store_32(val.has_mipmaps()); - f->store_32(val.get_format()); //if format changes we can add a compatibility version bit - - int dlen = val.get_data().size(); - f->store_32(dlen); - PoolVector<uint8_t>::Read r = val.get_data().read(); - f->store_buffer(r.ptr(), dlen); - _pad_buffer(dlen); - } else { - PoolVector<uint8_t> data; - if (encoding == IMAGE_ENCODING_LOSSY) { - data = Image::lossy_packer(val, quality); - - } else if (encoding == IMAGE_ENCODING_LOSSLESS) { - data = Image::lossless_packer(val); - } - - int ds = data.size(); - f->store_32(ds); - if (ds > 0) { - PoolVector<uint8_t>::Read r = data.read(); - f->store_buffer(r.ptr(), ds); - - _pad_buffer(ds); - } - } - - } break; case Variant::NODE_PATH: { f->store_32(VARIANT_NODE_PATH); NodePath np = p_property; @@ -1578,13 +1439,6 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant &p_property, } } break; - case Variant::INPUT_EVENT: { - - f->store_32(VARIANT_INPUT_EVENT); - InputEvent event = p_property; - f->store_32(0); //event type none, nothing else suported for now. - - } break; case Variant::DICTIONARY: { f->store_32(VARIANT_DICTIONARY); diff --git a/core/math/a_star.cpp b/core/math/a_star.cpp index 2a3fd79cad..320990cc50 100644 --- a/core/math/a_star.cpp +++ b/core/math/a_star.cpp @@ -43,6 +43,7 @@ int AStar::get_available_point_id() const { void AStar::add_point(int p_id, const Vector3 &p_pos, real_t p_weight_scale) { ERR_FAIL_COND(p_id < 0); + ERR_FAIL_COND(p_weight_scale < 1); if (!points.has(p_id)) { Point *pt = memnew(Point); pt->id = p_id; @@ -86,7 +87,7 @@ void AStar::remove_point(int p_id) { points.erase(p_id); } -void AStar::connect_points(int p_id, int p_with_id) { +void AStar::connect_points(int p_id, int p_with_id, bool bidirectional) { ERR_FAIL_COND(!points.has(p_id)); ERR_FAIL_COND(!points.has(p_with_id)); @@ -95,7 +96,9 @@ void AStar::connect_points(int p_id, int p_with_id) { Point *a = points[p_id]; Point *b = points[p_with_id]; a->neighbours.push_back(b); - b->neighbours.push_back(a); + + if (bidirectional) + b->neighbours.push_back(a); Segment s(p_id, p_with_id); if (s.from == p_id) { @@ -398,7 +401,7 @@ void AStar::_bind_methods() { ClassDB::bind_method(D_METHOD("get_point_weight_scale", "id"), &AStar::get_point_weight_scale); ClassDB::bind_method(D_METHOD("remove_point", "id"), &AStar::remove_point); - ClassDB::bind_method(D_METHOD("connect_points", "id", "to_id"), &AStar::connect_points); + ClassDB::bind_method(D_METHOD("connect_points", "id", "to_id"), &AStar::connect_points, DEFVAL(true)); ClassDB::bind_method(D_METHOD("disconnect_points", "id", "to_id"), &AStar::disconnect_points); ClassDB::bind_method(D_METHOD("are_points_connected", "id", "to_id"), &AStar::are_points_connected); diff --git a/core/math/a_star.h b/core/math/a_star.h index b9c8833386..34a5358344 100644 --- a/core/math/a_star.h +++ b/core/math/a_star.h @@ -105,7 +105,7 @@ public: real_t get_point_weight_scale(int p_id) const; void remove_point(int p_id); - void connect_points(int p_id, int p_with_id); + void connect_points(int p_id, int p_with_id, bool bidirectional = true); void disconnect_points(int p_id, int p_with_id); bool are_points_connected(int p_id, int p_with_id) const; diff --git a/core/message_queue.cpp b/core/message_queue.cpp index fa1c8112cc..d7d31b6c1e 100644 --- a/core/message_queue.cpp +++ b/core/message_queue.cpp @@ -318,12 +318,19 @@ void MessageQueue::flush() { while (read_pos < buffer_end) { - _THREAD_SAFE_UNLOCK_ - //lock on each interation, so a call can re-add itself to the message queue Message *message = (Message *)&buffer[read_pos]; + uint32_t advance = sizeof(Message); + if ((message->type & FLAG_MASK) != TYPE_NOTIFICATION) + advance += sizeof(Variant) * message->args; + + //pre-advance so this function is reentrant + read_pos += advance; + + _THREAD_SAFE_UNLOCK_ + Object *target = ObjectDB::get_instance(message->instance_ID); if (target != NULL) { @@ -359,13 +366,9 @@ void MessageQueue::flush() { } } - uint32_t advance = sizeof(Message); - if ((message->type & FLAG_MASK) != TYPE_NOTIFICATION) - advance += sizeof(Variant) * message->args; message->~Message(); _THREAD_SAFE_LOCK_ - read_pos += advance; } buffer_end = 0; // reset buffer diff --git a/core/method_bind.h b/core/method_bind.h index 749d8b4fda..8d72c8573a 100644 --- a/core/method_bind.h +++ b/core/method_bind.h @@ -146,7 +146,7 @@ struct VariantCaster<const T &> { // some helpers VARIANT_ENUM_CAST(Vector3::Axis); -VARIANT_ENUM_CAST(Image::Format); + VARIANT_ENUM_CAST(Error); VARIANT_ENUM_CAST(wchar_t); VARIANT_ENUM_CAST(Margin); @@ -154,7 +154,6 @@ VARIANT_ENUM_CAST(Orientation); VARIANT_ENUM_CAST(HAlign); VARIANT_ENUM_CAST(Variant::Type); VARIANT_ENUM_CAST(Variant::Operator); -VARIANT_ENUM_CAST(InputEvent::Type); class MethodBind { diff --git a/core/method_ptrcall.h b/core/method_ptrcall.h index 8cb2903842..bcbf2e4531 100644 --- a/core/method_ptrcall.h +++ b/core/method_ptrcall.h @@ -103,10 +103,8 @@ MAKE_PTRARG(Rect3); MAKE_PTRARG(Basis); MAKE_PTRARG(Transform); MAKE_PTRARG(Color); -MAKE_PTRARG(Image); MAKE_PTRARG(NodePath); MAKE_PTRARG(RID); -MAKE_PTRARG(InputEvent); MAKE_PTRARG(Dictionary); MAKE_PTRARG(Array); MAKE_PTRARG(PoolByteArray); diff --git a/core/os/input.h b/core/os/input.h index 4f26f097c2..6759c624e3 100644 --- a/core/os/input.h +++ b/core/os/input.h @@ -82,7 +82,7 @@ public: virtual int get_mouse_button_mask() const = 0; virtual void warp_mouse_pos(const Vector2 &p_to) = 0; - virtual Point2i warp_mouse_motion(const InputEventMouseMotion &p_motion, const Rect2 &p_rect) = 0; + virtual Point2i warp_mouse_motion(const Ref<InputEventMouseMotion> &p_motion, const Rect2 &p_rect) = 0; virtual Vector3 get_gravity() const = 0; virtual Vector3 get_accelerometer() const = 0; @@ -104,7 +104,7 @@ public: virtual int get_joy_button_index_from_string(String p_button) = 0; virtual int get_joy_axis_index_from_string(String p_axis) = 0; - virtual void parse_input_event(const InputEvent &p_event) = 0; + virtual void parse_input_event(const Ref<InputEvent> &p_event) = 0; Input(); }; diff --git a/core/os/input_event.cpp b/core/os/input_event.cpp index 474bc33b41..2538e8dad2 100644 --- a/core/os/input_event.cpp +++ b/core/os/input_event.cpp @@ -34,275 +34,794 @@ * */ -bool InputEvent::operator==(const InputEvent &p_event) const { - if (type != p_event.type) { - return false; - } +void InputEvent::set_id(uint32_t p_id) { + id = p_id; +} - switch (type) { - /** Current clang-format style doesn't play well with the aligned return values of that switch. */ - /* clang-format off */ - case NONE: - return true; - case KEY: - return key.unicode == p_event.key.unicode - && key.scancode == p_event.key.scancode - && key.echo == p_event.key.echo - && key.pressed == p_event.key.pressed - && key.mod == p_event.key.mod; - case MOUSE_MOTION: - return mouse_motion.x == p_event.mouse_motion.x - && mouse_motion.y == p_event.mouse_motion.y - && mouse_motion.relative_x == p_event.mouse_motion.relative_x - && mouse_motion.relative_y == p_event.mouse_motion.relative_y - && mouse_motion.button_mask == p_event.mouse_motion.button_mask - && key.mod == p_event.key.mod; - case MOUSE_BUTTON: - return mouse_button.pressed == p_event.mouse_button.pressed - && mouse_button.x == p_event.mouse_button.x - && mouse_button.y == p_event.mouse_button.y - && mouse_button.button_index == p_event.mouse_button.button_index - && mouse_button.button_mask == p_event.mouse_button.button_mask - && key.mod == p_event.key.mod; - case JOYPAD_MOTION: - return joy_motion.axis == p_event.joy_motion.axis - && joy_motion.axis_value == p_event.joy_motion.axis_value; - case JOYPAD_BUTTON: - return joy_button.pressed == p_event.joy_button.pressed - && joy_button.button_index == p_event.joy_button.button_index - && joy_button.pressure == p_event.joy_button.pressure; - case SCREEN_TOUCH: - return screen_touch.pressed == p_event.screen_touch.pressed - && screen_touch.index == p_event.screen_touch.index - && screen_touch.x == p_event.screen_touch.x - && screen_touch.y == p_event.screen_touch.y; - case SCREEN_DRAG: - return screen_drag.index == p_event.screen_drag.index - && screen_drag.x == p_event.screen_drag.x - && screen_drag.y == p_event.screen_drag.y; - case ACTION: - return action.action == p_event.action.action - && action.pressed == p_event.action.pressed; - /* clang-format on */ - default: - ERR_PRINT("No logic to compare InputEvents of this type, this shouldn't happen."); - } +uint32_t InputEvent::get_id() const { + return id; +} - return false; +void InputEvent::set_device(int p_device) { + device = p_device; } -InputEvent::operator String() const { - - String str = "Device " + itos(device) + " ID " + itos(ID) + " "; - - switch (type) { - - case NONE: { - - return "Event: None"; - } break; - case KEY: { - - str += "Event: Key "; - str = str + "Unicode: " + String::chr(key.unicode) + " Scan: " + itos(key.scancode) + " Echo: " + String(key.echo ? "True" : "False") + " Pressed" + String(key.pressed ? "True" : "False") + " Mod: "; - if (key.mod.shift) - str += "S"; - if (key.mod.control) - str += "C"; - if (key.mod.alt) - str += "A"; - if (key.mod.meta) - str += "M"; - - return str; - } break; - case MOUSE_MOTION: { - - str += "Event: Motion "; - str = str + " Pos: " + itos(mouse_motion.x) + "," + itos(mouse_motion.y) + " Rel: " + itos(mouse_motion.relative_x) + "," + itos(mouse_motion.relative_y) + " Mask: "; - for (int i = 0; i < 8; i++) { - - if ((1 << i) & mouse_motion.button_mask) - str += itos(i + 1); - } - str += " Mod: "; - if (key.mod.shift) - str += "S"; - if (key.mod.control) - str += "C"; - if (key.mod.alt) - str += "A"; - if (key.mod.meta) - str += "M"; - - return str; - } break; - case MOUSE_BUTTON: { - str += "Event: Button "; - str = str + "Pressed: " + itos(mouse_button.pressed) + " Pos: " + itos(mouse_button.x) + "," + itos(mouse_button.y) + " Button: " + itos(mouse_button.button_index) + " Mask: "; - for (int i = 0; i < 8; i++) { - - if ((1 << i) & mouse_button.button_mask) - str += itos(i + 1); - } - str += " Mod: "; - if (key.mod.shift) - str += "S"; - if (key.mod.control) - str += "C"; - if (key.mod.alt) - str += "A"; - if (key.mod.meta) - str += "M"; - - str += String(" DoubleClick: ") + (mouse_button.doubleclick ? "Yes" : "No"); - - return str; - - } break; - case JOYPAD_MOTION: { - str += "Event: JoypadMotion "; - str = str + "Axis: " + itos(joy_motion.axis) + " Value: " + rtos(joy_motion.axis_value); - return str; - - } break; - case JOYPAD_BUTTON: { - str += "Event: JoypadButton "; - str = str + "Pressed: " + itos(joy_button.pressed) + " Index: " + itos(joy_button.button_index) + " pressure " + rtos(joy_button.pressure); - return str; - - } break; - case SCREEN_TOUCH: { - str += "Event: ScreenTouch "; - str = str + "Pressed: " + itos(screen_touch.pressed) + " Index: " + itos(screen_touch.index) + " pos " + rtos(screen_touch.x) + "," + rtos(screen_touch.y); - return str; - - } break; - case SCREEN_DRAG: { - str += "Event: ScreenDrag "; - str = str + " Index: " + itos(screen_drag.index) + " pos " + rtos(screen_drag.x) + "," + rtos(screen_drag.y); - return str; - - } break; - case ACTION: { - str += "Event: Action: " + InputMap::get_singleton()->get_action_from_id(action.action) + " Pressed: " + itos(action.pressed); - return str; - - } break; - } - return ""; +int InputEvent::get_device() const { + return device; } -void InputEvent::set_as_action(const String &p_action, bool p_pressed) { +bool InputEvent::is_pressed() const { - type = ACTION; - action.action = InputMap::get_singleton()->get_action_id(p_action); - action.pressed = p_pressed; + return false; } -bool InputEvent::is_pressed() const { +bool InputEvent::is_action(const StringName &p_action) const { - switch (type) { + return InputMap::get_singleton()->event_is_action(Ref<InputEvent>(this), p_action); +} - case KEY: return key.pressed; - case MOUSE_BUTTON: return mouse_button.pressed; - case JOYPAD_BUTTON: return joy_button.pressed; - case SCREEN_TOUCH: return screen_touch.pressed; - case JOYPAD_MOTION: return ABS(joy_motion.axis_value) > 0.5; - case ACTION: return action.pressed; - default: {} - } +bool InputEvent::is_action_pressed(const StringName &p_action) const { + + return false; // InputMap::get_singleton()->event_is_action(Ref<InputEvent>(this),p_action); +} +bool InputEvent::is_action_released(const StringName &p_action) const { return false; } bool InputEvent::is_echo() const { - return (type == KEY && key.echo); + return false; +} + +Ref<InputEvent> InputEvent::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const { + + return Ref<InputEvent>((InputEvent *)this); +} + +String InputEvent::as_text() const { + + return String(); +} + +bool InputEvent::action_match(const Ref<InputEvent> &p_event) const { + + return false; +} + +bool InputEvent::is_action_type() const { + + return false; +} + +#if 0 +if (String(p_method) == "is_action" && p_argidx == 0) { + + List<PropertyInfo> pinfo; + GlobalConfig::get_singleton()->get_property_list(&pinfo); + + for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) { + const PropertyInfo &pi = E->get(); + + if (!pi.name.begins_with("input/")) + continue; + + String name = pi.name.substr(pi.name.find("/") + 1, pi.name.length()); + result.insert("\"" + name + "\""); + } + +} else +#endif + +void InputEvent::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_id", "id"), &InputEvent::set_id); + ClassDB::bind_method(D_METHOD("get_id"), &InputEvent::get_id); + + ClassDB::bind_method(D_METHOD("set_device", "device"), &InputEvent::set_device); + ClassDB::bind_method(D_METHOD("get_device"), &InputEvent::get_device); + + ClassDB::bind_method(D_METHOD("is_pressed"), &InputEvent::is_pressed); + ClassDB::bind_method(D_METHOD("is_action", "action"), &InputEvent::is_action); + ClassDB::bind_method(D_METHOD("is_action_pressed", "action"), &InputEvent::is_action_pressed); + ClassDB::bind_method(D_METHOD("is_action_released", "action"), &InputEvent::is_action_released); + ClassDB::bind_method(D_METHOD("is_echo"), &InputEvent::is_echo); + + ClassDB::bind_method(D_METHOD("as_text"), &InputEvent::as_text); + + ClassDB::bind_method(D_METHOD("action_match", "event:InputEvent"), &InputEvent::action_match); + + ClassDB::bind_method(D_METHOD("is_action_type"), &InputEvent::is_action_type); + + ClassDB::bind_method(D_METHOD("xformed_by:InputEvent", "xform", "local_ofs"), &InputEvent::xformed_by, DEFVAL(Vector2())); +} + +InputEvent::InputEvent() { + + id = 0; + device = 0; +} + +////////////////// + +void InputEventWithModifiers::set_shift(bool p_enabled) { + + shift = p_enabled; +} + +bool InputEventWithModifiers::get_shift() const { + + return shift; +} + +void InputEventWithModifiers::set_alt(bool p_enabled) { + + alt = p_enabled; +} +bool InputEventWithModifiers::get_alt() const { + + return alt; +} + +void InputEventWithModifiers::set_control(bool p_enabled) { + + control = p_enabled; +} +bool InputEventWithModifiers::get_control() const { + + return control; +} + +void InputEventWithModifiers::set_metakey(bool p_enabled) { + + meta = p_enabled; +} +bool InputEventWithModifiers::get_metakey() const { + + return meta; +} + +void InputEventWithModifiers::set_command(bool p_enabled) { + + command = p_enabled; +} +bool InputEventWithModifiers::get_command() const { + + return command; +} + +void InputEventWithModifiers::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_alt", "enable"), &InputEventWithModifiers::set_alt); + ClassDB::bind_method(D_METHOD("get_alt"), &InputEventWithModifiers::get_alt); + + ClassDB::bind_method(D_METHOD("set_shift", "enable"), &InputEventWithModifiers::set_shift); + ClassDB::bind_method(D_METHOD("get_shift"), &InputEventWithModifiers::get_shift); + + ClassDB::bind_method(D_METHOD("set_control", "enable"), &InputEventWithModifiers::set_control); + ClassDB::bind_method(D_METHOD("get_control"), &InputEventWithModifiers::get_control); + + ClassDB::bind_method(D_METHOD("set_metakey", "enable"), &InputEventWithModifiers::set_metakey); + ClassDB::bind_method(D_METHOD("get_metakey"), &InputEventWithModifiers::get_metakey); + + ClassDB::bind_method(D_METHOD("set_command", "enable"), &InputEventWithModifiers::set_command); + ClassDB::bind_method(D_METHOD("get_command"), &InputEventWithModifiers::get_command); + + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "alt"), "set_alt", "get_alt"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "shift"), "set_shift", "get_shift"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "control"), "set_control", "get_control"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "meta"), "set_metakey", "get_metakey"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "command"), "set_command", "get_command"); +} + +InputEventWithModifiers::InputEventWithModifiers() { + + alt = false; + shift = false; + control = false; + meta = false; +} + +////////////////////////////////// + +void InputEventKey::set_pressed(bool p_pressed) { + + pressed = p_pressed; +} + +bool InputEventKey::is_pressed() { + + return pressed; } -bool InputEvent::is_action(const String &p_action) const { +void InputEventKey::set_scancode(uint32_t p_scancode) { + + scancode = p_scancode; +} +uint32_t InputEventKey::get_scancode() const { - return InputMap::get_singleton()->event_is_action(*this, p_action); + return scancode; } -bool InputEvent::is_action_pressed(const String &p_action) const { +void InputEventKey::set_unicode(uint32_t p_unicode) { - return is_action(p_action) && is_pressed() && !is_echo(); + unicode = p_unicode; } +uint32_t InputEventKey::get_unicode() const { -bool InputEvent::is_action_released(const String &p_action) const { + return unicode; +} + +void InputEventKey::set_echo(bool p_enable) { + + echo = p_enable; +} +bool InputEventKey::is_echo() const { - return is_action(p_action) && !is_pressed(); + return echo; } uint32_t InputEventKey::get_scancode_with_modifiers() const { uint32_t sc = scancode; - if (mod.control) + if (get_control()) sc |= KEY_MASK_CTRL; - if (mod.alt) + if (get_alt()) sc |= KEY_MASK_ALT; - if (mod.shift) + if (get_shift()) sc |= KEY_MASK_SHIFT; - if (mod.meta) + if (get_metakey()) sc |= KEY_MASK_META; return sc; } -InputEvent InputEvent::xform_by(const Transform2D &p_xform) const { - - InputEvent ev = *this; - - switch (ev.type) { - - case InputEvent::MOUSE_BUTTON: { - - Vector2 g = p_xform.xform(Vector2(ev.mouse_button.global_x, ev.mouse_button.global_y)); - Vector2 l = p_xform.xform(Vector2(ev.mouse_button.x, ev.mouse_button.y)); - ev.mouse_button.x = l.x; - ev.mouse_button.y = l.y; - ev.mouse_button.global_x = g.x; - ev.mouse_button.global_y = g.y; - - } break; - case InputEvent::MOUSE_MOTION: { - - Vector2 g = p_xform.xform(Vector2(ev.mouse_motion.global_x, ev.mouse_motion.global_y)); - Vector2 l = p_xform.xform(Vector2(ev.mouse_motion.x, ev.mouse_motion.y)); - Vector2 r = p_xform.basis_xform(Vector2(ev.mouse_motion.relative_x, ev.mouse_motion.relative_y)); - Vector2 s = p_xform.basis_xform(Vector2(ev.mouse_motion.speed_x, ev.mouse_motion.speed_y)); - ev.mouse_motion.x = l.x; - ev.mouse_motion.y = l.y; - ev.mouse_motion.global_x = g.x; - ev.mouse_motion.global_y = g.y; - ev.mouse_motion.relative_x = r.x; - ev.mouse_motion.relative_y = r.y; - ev.mouse_motion.speed_x = s.x; - ev.mouse_motion.speed_y = s.y; - - } break; - case InputEvent::SCREEN_TOUCH: { - - Vector2 t = p_xform.xform(Vector2(ev.screen_touch.x, ev.screen_touch.y)); - ev.screen_touch.x = t.x; - ev.screen_touch.y = t.y; - - } break; - case InputEvent::SCREEN_DRAG: { - - Vector2 t = p_xform.xform(Vector2(ev.screen_drag.x, ev.screen_drag.y)); - Vector2 r = p_xform.basis_xform(Vector2(ev.screen_drag.relative_x, ev.screen_drag.relative_y)); - Vector2 s = p_xform.basis_xform(Vector2(ev.screen_drag.speed_x, ev.screen_drag.speed_y)); - ev.screen_drag.x = t.x; - ev.screen_drag.y = t.y; - ev.screen_drag.relative_x = r.x; - ev.screen_drag.relative_y = r.y; - ev.screen_drag.speed_x = s.x; - ev.screen_drag.speed_y = s.y; - } break; - } +bool InputEventKey::action_match(const Ref<InputEvent> &p_event) const { + + Ref<InputEventKey> key = p_event; + if (key.is_null()) + return false; + + return get_scancode_with_modifiers() == key->get_scancode_with_modifiers(); +} + +void InputEventKey::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventKey::set_pressed); + + ClassDB::bind_method(D_METHOD("set_scancode", "scancode"), &InputEventKey::set_scancode); + ClassDB::bind_method(D_METHOD("get_scancode"), &InputEventKey::get_scancode); + + ClassDB::bind_method(D_METHOD("set_unicode", "unicode"), &InputEventKey::set_unicode); + ClassDB::bind_method(D_METHOD("get_unicode"), &InputEventKey::get_unicode); + + ClassDB::bind_method(D_METHOD("set_echo", "echo"), &InputEventKey::set_echo); + + ClassDB::bind_method(D_METHOD("get_scancode_with_modifiers"), &InputEventKey::get_scancode_with_modifiers); + + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "scancode"), "set_scancode", "get_scancode"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "unicode"), "set_unicode", "get_unicode"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "echo"), "set_echo", "is_echo"); +} + +InputEventKey::InputEventKey() { + + pressed = false; + scancode = 0; + unicode = 0; ///unicode + echo = false; +} + +//////////////////////////////////////// + +void InputEventMouse::set_button_mask(int p_mask) { + + button_mask = p_mask; +} +int InputEventMouse::get_button_mask() const { + + return button_mask; +} + +void InputEventMouse::set_pos(const Vector2 &p_pos) { + + pos = p_pos; +} +Vector2 InputEventMouse::get_pos() const { + + return pos; +} + +void InputEventMouse::set_global_pos(const Vector2 &p_global_pos) { + + global_pos = p_global_pos; +} +Vector2 InputEventMouse::get_global_pos() const { + + return global_pos; +} + +void InputEventMouse::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_button_mask", "button_mask"), &InputEventMouse::set_button_mask); + ClassDB::bind_method(D_METHOD("get_button_mask"), &InputEventMouse::get_button_mask); + + ClassDB::bind_method(D_METHOD("set_pos", "pos"), &InputEventMouse::set_pos); + ClassDB::bind_method(D_METHOD("get_pos"), &InputEventMouse::get_pos); + + ClassDB::bind_method(D_METHOD("set_global_pos", "global_pos"), &InputEventMouse::set_global_pos); + ClassDB::bind_method(D_METHOD("get_global_pos"), &InputEventMouse::get_global_pos); + + ADD_PROPERTY(PropertyInfo(Variant::INT, "button_mask"), "set_button_mask", "get_button_mask"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "pos"), "set_pos", "get_pos"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "global_pos"), "set_global_pos", "get_global_pos"); +} + +InputEventMouse::InputEventMouse() { + + button_mask = 0; +} + +/////////////////////////////////////// + +void InputEventMouseButton::set_factor(float p_factor) { + + factor = p_factor; +} + +float InputEventMouseButton::get_factor() { + + return factor; +} + +void InputEventMouseButton::set_button_index(int p_index) { + + button_index = p_index; +} +int InputEventMouseButton::get_button_index() const { + + return button_index; +} + +void InputEventMouseButton::set_pressed(bool p_pressed) { + + pressed = p_pressed; +} +bool InputEventMouseButton::is_pressed() const { + + return pressed; +} + +void InputEventMouseButton::set_doubleclick(bool p_doubleclick) { + + doubleclick = p_doubleclick; +} +bool InputEventMouseButton::is_doubleclick() const { + + return doubleclick; +} + +Ref<InputEvent> InputEventMouseButton::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const { + + Vector2 g = p_xform.xform(get_global_pos()); + Vector2 l = p_xform.xform(get_pos() + p_local_ofs); + + Ref<InputEventMouseButton> mb; + mb.instance(); + + mb->set_id(get_id()); + mb->set_device(get_device()); + + mb->set_alt(get_alt()); + mb->set_shift(get_shift()); + mb->set_control(get_control()); + mb->set_metakey(get_metakey()); + + mb->set_pos(l); + mb->set_global_pos(g); + + mb->set_button_mask(get_button_mask()); + mb->set_pressed(pressed); + mb->set_doubleclick(doubleclick); + mb->set_factor(factor); + mb->set_button_index(button_index); + + return mb; +} + +bool InputEventMouseButton::action_match(const Ref<InputEvent> &p_event) const { + + Ref<InputEventMouseButton> mb = p_event; + if (mb.is_null()) + return false; + + return mb->button_index == button_index; +} + +void InputEventMouseButton::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_factor", "factor"), &InputEventMouseButton::set_factor); + ClassDB::bind_method(D_METHOD("get_factor"), &InputEventMouseButton::get_factor); + + ClassDB::bind_method(D_METHOD("set_button_index", "button_index"), &InputEventMouseButton::set_button_index); + ClassDB::bind_method(D_METHOD("get_button_index"), &InputEventMouseButton::get_button_index); + + ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventMouseButton::set_pressed); + // ClassDB::bind_method(D_METHOD("is_pressed"), &InputEventMouseButton::is_pressed); + + ClassDB::bind_method(D_METHOD("set_doubleclick", "doubleclick"), &InputEventMouseButton::set_doubleclick); + ClassDB::bind_method(D_METHOD("is_doubleclick"), &InputEventMouseButton::is_doubleclick); + + ADD_PROPERTY(PropertyInfo(Variant::REAL, "factor"), "set_factor", "get_factor"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "button_index"), "set_button_index", "get_button_index"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "doubleclick"), "set_doubleclick", "is_doubleclick"); +} + +InputEventMouseButton::InputEventMouseButton() { + + factor = 0; + button_index = 0; + pressed = false; + doubleclick = false; +} + +//////////////////////////////////////////// + +void InputEventMouseMotion::set_relative(const Vector2 &p_relative) { + + relative = p_relative; +} +Vector2 InputEventMouseMotion::get_relative() const { + + return relative; +} + +void InputEventMouseMotion::set_speed(const Vector2 &p_speed) { + + speed = p_speed; +} +Vector2 InputEventMouseMotion::get_speed() const { + + return speed; +} + +Ref<InputEvent> InputEventMouseMotion::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const { + + Vector2 g = p_xform.xform(get_global_pos()); + Vector2 l = p_xform.xform(get_pos() + p_local_ofs); + Vector2 r = p_xform.basis_xform(get_relative()); + Vector2 s = p_xform.basis_xform(get_speed()); + + Ref<InputEventMouseMotion> mm; + mm.instance(); + + mm->set_id(get_id()); + mm->set_device(get_device()); + + mm->set_alt(get_alt()); + mm->set_shift(get_shift()); + mm->set_control(get_control()); + mm->set_metakey(get_metakey()); + + mm->set_pos(l); + mm->set_global_pos(g); + + mm->set_button_mask(get_button_mask()); + mm->set_relative(r); + mm->set_speed(s); + + return mm; +} + +void InputEventMouseMotion::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_relative", "relative"), &InputEventMouseMotion::set_relative); + ClassDB::bind_method(D_METHOD("get_relative"), &InputEventMouseMotion::get_relative); + + ClassDB::bind_method(D_METHOD("set_speed", "speed"), &InputEventMouseMotion::set_speed); + ClassDB::bind_method(D_METHOD("get_speed"), &InputEventMouseMotion::get_speed); + + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "relative"), "set_relative", "get_relative"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "speed"), "set_speed", "get_speed"); +} + +InputEventMouseMotion::InputEventMouseMotion() { +} + +//////////////////////////////////////// + +void InputEventJoypadMotion::set_axis(int p_axis) { + + axis = p_axis; +} + +int InputEventJoypadMotion::get_axis() const { + + return axis; +} + +void InputEventJoypadMotion::set_axis_value(float p_value) { + + axis_value = p_value; +} +float InputEventJoypadMotion::get_axis_value() const { + + return axis_value; +} + +bool InputEventJoypadMotion::action_match(const Ref<InputEvent> &p_event) const { + + Ref<InputEventJoypadMotion> jm = p_event; + if (jm.is_null()) + return false; + + return (axis == jm->axis && (axis_value < 0) == (jm->axis_value < 0)); +} + +void InputEventJoypadMotion::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_axis", "axis"), &InputEventJoypadMotion::set_axis); + ClassDB::bind_method(D_METHOD("get_axis"), &InputEventJoypadMotion::get_axis); + + ClassDB::bind_method(D_METHOD("set_axis_value", "axis_value"), &InputEventJoypadMotion::set_axis_value); + ClassDB::bind_method(D_METHOD("get_axis_value"), &InputEventJoypadMotion::get_axis_value); + + ADD_PROPERTY(PropertyInfo(Variant::INT, "axis"), "set_axis", "get_axis"); + ADD_PROPERTY(PropertyInfo(Variant::REAL, "axis_value"), "set_axis_value", "get_axis_value"); +} + +InputEventJoypadMotion::InputEventJoypadMotion() { + + axis = 0; + axis_value = 0; +} +///////////////////////////////// + +void InputEventJoypadButton::set_button_index(int p_index) { + + button_index = p_index; +} + +int InputEventJoypadButton::get_button_index() const { + + return button_index; +} + +void InputEventJoypadButton::set_pressed(bool p_pressed) { + + pressed = p_pressed; +} +bool InputEventJoypadButton::is_pressed() const { + + return pressed; +} + +void InputEventJoypadButton::set_pressure(float p_pressure) { + + pressure = p_pressure; +} +float InputEventJoypadButton::get_pressure() const { + + return pressure; +} + +bool InputEventJoypadButton::action_match(const Ref<InputEvent> &p_event) const { + + Ref<InputEventJoypadButton> jb = p_event; + if (jb.is_null()) + return false; + + return button_index == jb->button_index; +} + +void InputEventJoypadButton::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_button_index", "button_index"), &InputEventJoypadButton::set_button_index); + ClassDB::bind_method(D_METHOD("get_button_index"), &InputEventJoypadButton::get_button_index); + + ClassDB::bind_method(D_METHOD("set_pressure", "pressure"), &InputEventJoypadButton::set_pressure); + ClassDB::bind_method(D_METHOD("get_pressure"), &InputEventJoypadButton::get_pressure); + + ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventJoypadButton::set_pressed); + // ClassDB::bind_method(D_METHOD("is_pressed"), &InputEventJoypadButton::is_pressed); + + ADD_PROPERTY(PropertyInfo(Variant::INT, "button_index"), "set_button_index", "get_button_index"); + ADD_PROPERTY(PropertyInfo(Variant::REAL, "pressure"), "set_pressure", "get_pressure"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed"); +} + +InputEventJoypadButton::InputEventJoypadButton() { + + button_index = 0; + pressure = 0; + pressed = false; +} + +////////////////////////////////////////////// + +void InputEventScreenTouch::set_index(int p_index) { + + index = p_index; +} +int InputEventScreenTouch::get_index() const { + + return index; +} + +void InputEventScreenTouch::set_pos(const Vector2 &p_pos) { + + pos = p_pos; +} +Vector2 InputEventScreenTouch::get_pos() const { + + return pos; +} + +void InputEventScreenTouch::set_pressed(bool p_pressed) { + + pressed = p_pressed; +} +bool InputEventScreenTouch::is_pressed() const { + + return pressed; +} + +Ref<InputEvent> InputEventScreenTouch::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const { + + Ref<InputEventScreenTouch> st; + st.instance(); + st->set_id(get_id()); + st->set_device(get_device()); + st->set_index(index); + st->set_pos(p_xform.xform(pos + p_local_ofs)); + st->set_pressed(pressed); + + return st; +} + +void InputEventScreenTouch::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_index", "index"), &InputEventScreenTouch::set_index); + ClassDB::bind_method(D_METHOD("get_index"), &InputEventScreenTouch::get_index); + + ClassDB::bind_method(D_METHOD("set_pos", "pos"), &InputEventScreenTouch::set_pos); + ClassDB::bind_method(D_METHOD("get_pos"), &InputEventScreenTouch::get_pos); + + ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventScreenTouch::set_pressed); + //ClassDB::bind_method(D_METHOD("is_pressed"),&InputEventScreenTouch::is_pressed); + + ADD_PROPERTY(PropertyInfo(Variant::INT, "index"), "set_index", "get_index"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "pos"), "set_pos", "get_pos"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed"); +} + +InputEventScreenTouch::InputEventScreenTouch() { + + index = 0; + pressed = false; +} + +///////////////////////////// + +void InputEventScreenDrag::set_index(int p_index) { + + index = p_index; +} + +int InputEventScreenDrag::get_index() const { + + return index; +} + +void InputEventScreenDrag::set_pos(const Vector2 &p_pos) { + + pos = p_pos; +} +Vector2 InputEventScreenDrag::get_pos() const { + + return pos; +} + +void InputEventScreenDrag::set_relative(const Vector2 &p_relative) { + + relative = p_relative; +} +Vector2 InputEventScreenDrag::get_relative() const { + + return relative; +} + +void InputEventScreenDrag::set_speed(const Vector2 &p_speed) { + + speed = p_speed; +} +Vector2 InputEventScreenDrag::get_speed() const { + + return speed; +} + +Ref<InputEvent> InputEventScreenDrag::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const { + + Ref<InputEventScreenDrag> sd; + + sd.instance(); + + sd->set_id(get_id()); + sd->set_device(get_device()); + + sd->set_index(index); + sd->set_pos(p_xform.xform(pos + p_local_ofs)); + sd->set_relative(p_xform.basis_xform(relative)); + sd->set_speed(p_xform.basis_xform(speed)); + + return sd; +} + +void InputEventScreenDrag::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_index", "index"), &InputEventScreenDrag::set_index); + ClassDB::bind_method(D_METHOD("get_index"), &InputEventScreenDrag::get_index); + + ClassDB::bind_method(D_METHOD("set_pos", "pos"), &InputEventScreenDrag::set_pos); + ClassDB::bind_method(D_METHOD("get_pos"), &InputEventScreenDrag::get_pos); + + ClassDB::bind_method(D_METHOD("set_relative", "relative"), &InputEventScreenDrag::set_relative); + ClassDB::bind_method(D_METHOD("get_relative"), &InputEventScreenDrag::get_relative); + + ClassDB::bind_method(D_METHOD("set_speed", "speed"), &InputEventScreenDrag::set_speed); + ClassDB::bind_method(D_METHOD("get_speed"), &InputEventScreenDrag::get_speed); + + ADD_PROPERTY(PropertyInfo(Variant::INT, "index"), "set_index", "get_index"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "pos"), "set_pos", "get_pos"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "relative"), "set_relative", "get_relative"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "speed"), "set_speed", "get_speed"); +} + +InputEventScreenDrag::InputEventScreenDrag() { + + index = 0; +} +///////////////////////////// + +void InputEventAction::set_action(const StringName &p_action) { + + action = p_action; +} +StringName InputEventAction::get_action() const { + + return action; +} + +void InputEventAction::set_pressed(bool p_pressed) { + + pressed = p_pressed; +} +bool InputEventAction::is_pressed() const { + + return pressed; +} + +bool InputEventAction::is_action(const StringName &p_action) const { + + return action == p_action; +} + +void InputEventAction::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_action", "action"), &InputEventAction::set_action); + ClassDB::bind_method(D_METHOD("get_action"), &InputEventAction::get_action); + + ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventAction::set_pressed); + //ClassDB::bind_method(D_METHOD("is_pressed"), &InputEventAction::is_pressed); + + ClassDB::bind_method(D_METHOD("is_action", "name"), &InputEventAction::is_action); + + ADD_PROPERTY(PropertyInfo(Variant::STRING, "action"), "set_action", "get_action"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed"); +} - return ev; +InputEventAction::InputEventAction() { + pressed = false; } diff --git a/core/os/input_event.h b/core/os/input_event.h index 93cceac27c..b94f0ef46a 100644 --- a/core/os/input_event.h +++ b/core/os/input_event.h @@ -32,6 +32,7 @@ #include "math_2d.h" #include "os/copymem.h" +#include "resource.h" #include "typedefs.h" #include "ustring.h" /** @@ -137,7 +138,40 @@ enum { * Input Modifier Status * for keyboard/mouse events. */ -struct InputModifierState { + +class InputEvent : public Resource { + GDCLASS(InputEvent, Resource) + + uint32_t id; + int device; + +protected: + static void _bind_methods(); + +public: + void set_id(uint32_t p_id); + uint32_t get_id() const; + + void set_device(int p_device); + int get_device() const; + + virtual bool is_pressed() const; + virtual bool is_action(const StringName &p_action) const; + virtual bool is_action_pressed(const StringName &p_action) const; + virtual bool is_action_released(const StringName &p_action) const; + virtual bool is_echo() const; + virtual String as_text() const; + + virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const; + + virtual bool action_match(const Ref<InputEvent> &p_event) const; + virtual bool is_action_type() const; + + InputEvent(); +}; + +class InputEventWithModifiers : public InputEvent { + GDCLASS(InputEventWithModifiers, InputEvent) bool shift; bool alt; @@ -157,126 +191,267 @@ struct InputModifierState { #endif - bool operator==(const InputModifierState &rvalue) const { +protected: + static void _bind_methods(); + +public: + void set_shift(bool p_enabled); + bool get_shift() const; + + void set_alt(bool p_enabled); + bool get_alt() const; + + void set_control(bool p_enabled); + bool get_control() const; + + void set_metakey(bool p_enabled); + bool get_metakey() const; + + void set_command(bool p_enabled); + bool get_command() const; - return ((shift == rvalue.shift) && (alt == rvalue.alt) && (control == rvalue.control) && (meta == rvalue.meta)); - } + InputEventWithModifiers(); }; -struct InputEventKey { +class InputEventKey : public InputEventWithModifiers { - InputModifierState mod; + GDCLASS(InputEventKey, InputEventWithModifiers) bool pressed; /// otherwise release uint32_t scancode; ///< check keyboard.h , KeyCode enum, without modifier masks uint32_t unicode; ///unicode + bool echo; /// true if this is an echo key + +protected: + static void _bind_methods(); + +public: + void set_pressed(bool p_pressed); + bool is_pressed(); + + void set_scancode(uint32_t p_scancode); + uint32_t get_scancode() const; + + void set_unicode(uint32_t p_unicode); + uint32_t get_unicode() const; + + void set_echo(bool p_enable); + bool is_echo() const; + uint32_t get_scancode_with_modifiers() const; - bool echo; /// true if this is an echo key + virtual bool action_match(const Ref<InputEvent> &p_event) const; + + virtual bool is_action_type() const { return true; } + + InputEventKey(); }; -struct InputEventMouse { +class InputEventMouse : public InputEventWithModifiers { + + GDCLASS(InputEventMouse, InputEventWithModifiers) - InputModifierState mod; int button_mask; - float x, y; - float global_x, global_y; - int pointer_index; + + Vector2 pos; + Vector2 global_pos; + +protected: + static void _bind_methods(); + +public: + void set_button_mask(int p_mask); + int get_button_mask() const; + + void set_pos(const Vector2 &p_pos); + Vector2 get_pos() const; + + void set_global_pos(const Vector2 &p_global_pos); + Vector2 get_global_pos() const; + + InputEventMouse(); }; -struct InputEventMouseButton : public InputEventMouse { +class InputEventMouseButton : public InputEventMouse { + + GDCLASS(InputEventMouseButton, InputEventMouse) - double factor; + float factor; int button_index; bool pressed; //otherwise released bool doubleclick; //last even less than doubleclick time + +protected: + static void _bind_methods(); + +public: + void set_factor(float p_factor); + float get_factor(); + + void set_button_index(int p_index); + int get_button_index() const; + + void set_pressed(bool p_pressed); + virtual bool is_pressed() const; + + void set_doubleclick(bool p_doubleclick); + bool is_doubleclick() const; + + virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const; + virtual bool action_match(const Ref<InputEvent> &p_event) const; + + virtual bool is_action_type() const { return true; } + + InputEventMouseButton(); }; -struct InputEventMouseMotion : public InputEventMouse { +class InputEventMouseMotion : public InputEventMouse { + + GDCLASS(InputEventMouseMotion, InputEventMouse) + Vector2 relative; + Vector2 speed; + +protected: + static void _bind_methods(); + +public: + void set_relative(const Vector2 &p_relative); + Vector2 get_relative() const; + + void set_speed(const Vector2 &p_speed); + Vector2 get_speed() const; + + virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const; - float relative_x, relative_y; - float speed_x, speed_y; + InputEventMouseMotion(); }; -struct InputEventJoypadMotion { +class InputEventJoypadMotion : public InputEvent { + GDCLASS(InputEventJoypadMotion, InputEvent) int axis; ///< Joypad axis float axis_value; ///< -1 to 1 + +protected: + static void _bind_methods(); + +public: + void set_axis(int p_axis); + int get_axis() const; + + void set_axis_value(float p_value); + float get_axis_value() const; + + virtual bool action_match(const Ref<InputEvent> &p_event) const; + + virtual bool is_action_type() const { return true; } + + InputEventJoypadMotion(); }; -struct InputEventJoypadButton { +class InputEventJoypadButton : public InputEvent { + GDCLASS(InputEventJoypadButton, InputEvent) int button_index; bool pressed; float pressure; //0 to 1 -}; +protected: + static void _bind_methods(); + +public: + void set_button_index(int p_index); + int get_button_index() const; + + void set_pressed(bool p_pressed); + virtual bool is_pressed() const; + + void set_pressure(float p_pressure); + float get_pressure() const; -struct InputEventScreenTouch { + virtual bool action_match(const Ref<InputEvent> &p_event) const; + virtual bool is_action_type() const { return true; } + + InputEventJoypadButton(); +}; + +struct InputEventScreenTouch : public InputEvent { + GDCLASS(InputEventScreenTouch, InputEvent) int index; - float x, y; + Vector2 pos; bool pressed; + +protected: + static void _bind_methods(); + +public: + void set_index(int p_index); + int get_index() const; + + void set_pos(const Vector2 &p_pos); + Vector2 get_pos() const; + + void set_pressed(bool p_pressed); + virtual bool is_pressed() const; + + virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const; + + InputEventScreenTouch(); }; -struct InputEventScreenDrag { +class InputEventScreenDrag : public InputEvent { + + GDCLASS(InputEventScreenDrag, InputEvent) int index; - float x, y; - float relative_x, relative_y; - float speed_x, speed_y; + Vector2 pos; + Vector2 relative; + Vector2 speed; + +protected: + static void _bind_methods(); + +public: + void set_index(int p_index); + int get_index() const; + + void set_pos(const Vector2 &p_pos); + Vector2 get_pos() const; + + void set_relative(const Vector2 &p_relative); + Vector2 get_relative() const; + + void set_speed(const Vector2 &p_speed); + Vector2 get_speed() const; + + virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const; + + InputEventScreenDrag(); }; -struct InputEventAction { +class InputEventAction : public InputEvent { + + GDCLASS(InputEventAction, InputEvent) - int action; + StringName action; bool pressed; -}; -struct InputEvent { - - enum Type { - NONE, - KEY, - MOUSE_MOTION, - MOUSE_BUTTON, - JOYPAD_MOTION, - JOYPAD_BUTTON, - SCREEN_TOUCH, - SCREEN_DRAG, - ACTION, - TYPE_MAX - }; +protected: + static void _bind_methods(); - uint32_t ID; - int type; - int device; +public: + void set_action(const StringName &p_action); + StringName get_action() const; - union { - InputEventMouseMotion mouse_motion; - InputEventMouseButton mouse_button; - InputEventJoypadMotion joy_motion; - InputEventJoypadButton joy_button; - InputEventKey key; - InputEventScreenTouch screen_touch; - InputEventScreenDrag screen_drag; - InputEventAction action; - }; + void set_pressed(bool p_pressed); + virtual bool is_pressed() const; - bool is_pressed() const; - bool is_action(const String &p_action) const; - bool is_action_pressed(const String &p_action) const; - bool is_action_released(const String &p_action) const; - bool is_echo() const; - void set_as_action(const String &p_action, bool p_pressed); - - InputEvent xform_by(const Transform2D &p_xform) const; - bool operator==(const InputEvent &p_event) const; - operator String() const; - InputEvent() { - zeromem(this, sizeof(InputEvent)); - mouse_button.factor = 1; - } + virtual bool is_action(const StringName &p_action) const; + + virtual bool is_action_type() const { return true; } + + InputEventAction(); }; #endif diff --git a/core/os/main_loop.cpp b/core/os/main_loop.cpp index 9f8fcccd82..248f5537c6 100644 --- a/core/os/main_loop.cpp +++ b/core/os/main_loop.cpp @@ -39,7 +39,7 @@ void MainLoop::_bind_methods() { ClassDB::bind_method(D_METHOD("idle", "delta"), &MainLoop::idle); ClassDB::bind_method(D_METHOD("finish"), &MainLoop::finish); - BIND_VMETHOD(MethodInfo("_input_event", PropertyInfo(Variant::INPUT_EVENT, "ev"))); + BIND_VMETHOD(MethodInfo("_input_event", PropertyInfo(Variant::OBJECT, "ev", PROPERTY_HINT_RESOURCE_TYPE, "InputEvent"))); BIND_VMETHOD(MethodInfo("_input_text", PropertyInfo(Variant::STRING, "text"))); BIND_VMETHOD(MethodInfo("_initialize")); BIND_VMETHOD(MethodInfo("_iteration", PropertyInfo(Variant::REAL, "delta"))); @@ -73,7 +73,7 @@ void MainLoop::input_text(const String &p_text) { get_script_instance()->call("_input_text", p_text); } -void MainLoop::input_event(const InputEvent &p_event) { +void MainLoop::input_event(const Ref<InputEvent> &p_event) { if (get_script_instance()) get_script_instance()->call("_input_event", p_event); diff --git a/core/os/main_loop.h b/core/os/main_loop.h index a53137afa4..23b352468e 100644 --- a/core/os/main_loop.h +++ b/core/os/main_loop.h @@ -59,7 +59,7 @@ public: NOTIFICATION_TRANSLATION_CHANGED = 10, }; - virtual void input_event(const InputEvent &p_event); + virtual void input_event(const Ref<InputEvent> &p_event); virtual void input_text(const String &p_text); virtual void init(); diff --git a/core/os/os.cpp b/core/os/os.cpp index e323e03829..8bee725813 100644 --- a/core/os/os.cpp +++ b/core/os/os.cpp @@ -389,7 +389,7 @@ void OS::_ensure_data_dir() { memdelete(da); } -void OS::set_icon(const Image &p_icon) { +void OS::set_icon(const Ref<Image> &p_icon) { } String OS::get_model_name() const { diff --git a/core/os/os.h b/core/os/os.h index ff2a24f40d..037ce436c1 100644 --- a/core/os/os.h +++ b/core/os/os.h @@ -31,6 +31,7 @@ #define OS_H #include "engine.h" +#include "image.h" #include "list.h" #include "os/main_loop.h" #include "power.h" @@ -357,7 +358,7 @@ public: virtual void make_rendering_thread(); virtual void swap_buffers(); - virtual void set_icon(const Image &p_icon); + virtual void set_icon(const Ref<Image> &p_icon); virtual int get_exit_code() const; virtual void set_exit_code(int p_code); diff --git a/core/packed_data_container.cpp b/core/packed_data_container.cpp index addb0841f4..0565d0d3f5 100644 --- a/core/packed_data_container.cpp +++ b/core/packed_data_container.cpp @@ -237,8 +237,6 @@ uint32_t PackedDataContainer::_pack(const Variant &p_data, Vector<uint8_t> &tmpd case Variant::RECT3: case Variant::BASIS: case Variant::TRANSFORM: - case Variant::IMAGE: - case Variant::INPUT_EVENT: case Variant::POOL_BYTE_ARRAY: case Variant::POOL_INT_ARRAY: case Variant::POOL_REAL_ARRAY: diff --git a/core/register_core_types.cpp b/core/register_core_types.cpp index 4d12e42895..b089ba9129 100644 --- a/core/register_core_types.cpp +++ b/core/register_core_types.cpp @@ -108,6 +108,20 @@ void register_core_types() { ClassDB::register_class<Reference>(); ClassDB::register_class<WeakRef>(); ClassDB::register_class<Resource>(); + ClassDB::register_class<Image>(); + + ClassDB::register_virtual_class<InputEvent>(); + ClassDB::register_virtual_class<InputEventWithModifiers>(); + ClassDB::register_class<InputEventKey>(); + ClassDB::register_virtual_class<InputEventMouse>(); + ClassDB::register_class<InputEventMouseButton>(); + ClassDB::register_class<InputEventMouseMotion>(); + ClassDB::register_class<InputEventJoypadButton>(); + ClassDB::register_class<InputEventJoypadMotion>(); + ClassDB::register_class<InputEventScreenDrag>(); + ClassDB::register_class<InputEventScreenTouch>(); + ClassDB::register_class<InputEventAction>(); + ClassDB::register_class<FuncRef>(); ClassDB::register_virtual_class<StreamPeer>(); ClassDB::register_class<StreamPeerBuffer>(); diff --git a/core/resource.cpp b/core/resource.cpp index aa070558f5..559d4c1201 100644 --- a/core/resource.cpp +++ b/core/resource.cpp @@ -185,7 +185,7 @@ Ref<Resource> Resource::duplicate_for_local_scene(Node *p_for_scene, Map<Ref<Res return Ref<Resource>(r); } -Ref<Resource> Resource::duplicate(bool p_subresources) { +Ref<Resource> Resource::duplicate(bool p_subresources) const { List<PropertyInfo> plist; get_property_list(&plist); diff --git a/core/resource.h b/core/resource.h index ab3404df8f..903edeff52 100644 --- a/core/resource.h +++ b/core/resource.h @@ -103,7 +103,7 @@ public: void set_subindex(int p_sub_index); int get_subindex() const; - Ref<Resource> duplicate(bool p_subresources = false); + virtual Ref<Resource> duplicate(bool p_subresources = false) const; Ref<Resource> duplicate_for_local_scene(Node *p_scene, Map<Ref<Resource>, Ref<Resource> > &remap_cache); void set_local_to_scene(bool p_enable); diff --git a/core/ring_buffer.h b/core/ring_buffer.h index d5085e9560..8b32bb5e10 100644 --- a/core/ring_buffer.h +++ b/core/ring_buffer.h @@ -101,6 +101,32 @@ public: return p_size; }; + int find(const T &t, int p_offset, int p_max_size) { + + int left = data_left(); + if ((p_offset + p_max_size) > left) { + p_max_size -= left - p_offset; + if (p_max_size <= 0) + return 0; + } + p_max_size = MIN(left, p_max_size); + int pos = read_pos; + inc(pos, p_offset); + int to_read = p_max_size; + while (to_read) { + int end = pos + to_read; + end = MIN(end, size()); + int total = end - pos; + for (int i = 0; i < total; i++) { + if (data[pos + i] == t) + return i + (p_max_size - to_read); + }; + to_read -= total; + pos = 0; + } + return -1; + } + inline int advance_read(int p_n) { p_n = MIN(p_n, data_left()); inc(read_pos, p_n); diff --git a/core/script_debugger_remote.cpp b/core/script_debugger_remote.cpp index bd0352b7a4..f230a4bc95 100644 --- a/core/script_debugger_remote.cpp +++ b/core/script_debugger_remote.cpp @@ -586,9 +586,7 @@ void ScriptDebuggerRemote::_send_object_id(ObjectID p_id) { packet_peer_stream->put_var(E->get().hint); packet_peer_stream->put_var(E->get().hint_string); //only send information that can be sent.. - if (var.get_type() == Variant::IMAGE) { - var = Image(); - } + if (var.get_type() >= Variant::DICTIONARY) { var = Array(); //send none for now, may be to big } diff --git a/core/variant.cpp b/core/variant.cpp index 67ce8af483..ae5141b8bf 100644 --- a/core/variant.cpp +++ b/core/variant.cpp @@ -120,11 +120,6 @@ String Variant::get_type_name(Variant::Type p_type) { return "Color"; } break; - case IMAGE: { - - return "Image"; - - } break; case _RID: { return "RID"; @@ -138,11 +133,6 @@ String Variant::get_type_name(Variant::Type p_type) { return "NodePath"; } break; - case INPUT_EVENT: { - - return "InputEvent"; - - } break; case DICTIONARY: { return "Dictionary"; @@ -249,7 +239,6 @@ bool Variant::can_convert(Variant::Type p_type_from, Variant::Type p_type_to) { static const Type invalid[] = { OBJECT, - IMAGE, NIL }; @@ -791,11 +780,6 @@ bool Variant::is_zero() const { return *reinterpret_cast<const Color *>(_data._mem) == Color(); } break; - case IMAGE: { - - return _data._image->empty(); - - } break; case _RID: { return *reinterpret_cast<const RID *>(_data._mem) == RID(); @@ -809,11 +793,6 @@ bool Variant::is_zero() const { return reinterpret_cast<const NodePath *>(_data._mem)->is_empty(); } break; - case INPUT_EVENT: { - - return _data._input_event->type == InputEvent::NONE; - - } break; case DICTIONARY: { return reinterpret_cast<const Dictionary *>(_data._mem)->empty(); @@ -1016,11 +995,6 @@ void Variant::reference(const Variant &p_variant) { memnew_placement(_data._mem, Color(*reinterpret_cast<const Color *>(p_variant._data._mem))); } break; - case IMAGE: { - - _data._image = memnew(Image(*p_variant._data._image)); - - } break; case _RID: { memnew_placement(_data._mem, RID(*reinterpret_cast<const RID *>(p_variant._data._mem))); @@ -1034,11 +1008,6 @@ void Variant::reference(const Variant &p_variant) { memnew_placement(_data._mem, NodePath(*reinterpret_cast<const NodePath *>(p_variant._data._mem))); } break; - case INPUT_EVENT: { - - _data._input_event = memnew(InputEvent(*p_variant._data._input_event)); - - } break; case DICTIONARY: { memnew_placement(_data._mem, Dictionary(*reinterpret_cast<const Dictionary *>(p_variant._data._mem))); @@ -1141,11 +1110,6 @@ void Variant::clear() { } break; // misc types - case IMAGE: { - - memdelete(_data._image); - - } break; case NODE_PATH: { reinterpret_cast<NodePath *>(_data._mem)->~NodePath(); @@ -1170,12 +1134,6 @@ void Variant::clear() { reinterpret_cast<Array *>(_data._mem)->~Array(); } break; - case INPUT_EVENT: { - - memdelete(_data._input_event); - - } break; - // arrays case POOL_BYTE_ARRAY: { @@ -1524,7 +1482,6 @@ Variant::operator String() const { } break; case TRANSFORM: return operator Transform(); case NODE_PATH: return operator NodePath(); - case INPUT_EVENT: return operator InputEvent(); case COLOR: return String::num(operator Color().r) + "," + String::num(operator Color().g) + "," + String::num(operator Color().b) + "," + String::num(operator Color().a); case DICTIONARY: { @@ -1760,13 +1717,6 @@ Variant::operator Color() const { else return Color(); } -Variant::operator Image() const { - - if (type == IMAGE) - return *_data._image; - else - return Image(); -} Variant::operator NodePath() const { @@ -1826,14 +1776,6 @@ Variant::operator Control *() const { return NULL; } -Variant::operator InputEvent() const { - - if (type == INPUT_EVENT) - return *reinterpret_cast<const InputEvent *>(_data._input_event); - else - return InputEvent(); -} - Variant::operator Dictionary() const { if (type == DICTIONARY) @@ -2306,11 +2248,6 @@ Variant::Variant(const Color &p_color) { type = COLOR; memnew_placement(_data._mem, Color(p_color)); } -Variant::Variant(const Image &p_image) { - - type = IMAGE; - _data._image = memnew(Image(p_image)); -} Variant::Variant(const NodePath &p_node_path) { @@ -2318,12 +2255,6 @@ Variant::Variant(const NodePath &p_node_path) { memnew_placement(_data._mem, NodePath(p_node_path)); } -Variant::Variant(const InputEvent &p_input_event) { - - type = INPUT_EVENT; - _data._input_event = memnew(InputEvent(p_input_event)); -} - Variant::Variant(const RefPtr &p_resource) { type = OBJECT; @@ -2711,11 +2642,6 @@ uint32_t Variant::hash() const { return hash_djb2_one_float(reinterpret_cast<const Color *>(_data._mem)->a, hash); } break; - case IMAGE: { - - return 0; - - } break; case _RID: { return hash_djb2_one_64(reinterpret_cast<const RID *>(_data._mem)->get_id()); @@ -2728,11 +2654,6 @@ uint32_t Variant::hash() const { return reinterpret_cast<const NodePath *>(_data._mem)->hash(); } break; - case INPUT_EVENT: { - - return hash_djb2_buffer((uint8_t *)_data._input_event, sizeof(InputEvent)); - - } break; case DICTIONARY: { return reinterpret_cast<const Dictionary *>(_data._mem)->hash(); diff --git a/core/variant.h b/core/variant.h index e1a2b89a07..661d31cf16 100644 --- a/core/variant.h +++ b/core/variant.h @@ -39,11 +39,9 @@ #include "dictionary.h" #include "dvector.h" #include "face3.h" -#include "image.h" #include "io/ip_address.h" #include "math_2d.h" #include "matrix3.h" -#include "os/input_event.h" #include "os/power.h" #include "path_db.h" #include "plane.h" @@ -92,26 +90,24 @@ public: TRANSFORM2D, PLANE, QUAT, // 10 - RECT3, //sorry naming convention fail :( not like it's used often + RECT3, BASIS, TRANSFORM, // misc types COLOR, - IMAGE, // 15 - NODE_PATH, + NODE_PATH, // 15 _RID, OBJECT, - INPUT_EVENT, - DICTIONARY, // 20 - ARRAY, + DICTIONARY, + ARRAY, // 20 // arrays POOL_BYTE_ARRAY, POOL_INT_ARRAY, POOL_REAL_ARRAY, - POOL_STRING_ARRAY, // 25 - POOL_VECTOR2_ARRAY, + POOL_STRING_ARRAY, + POOL_VECTOR2_ARRAY, // 25 POOL_VECTOR3_ARRAY, POOL_COLOR_ARRAY, @@ -145,8 +141,6 @@ private: Basis *_basis; Transform *_transform; RefPtr *_resource; - InputEvent *_input_event; - Image *_image; void *_ptr; //generic pointer uint8_t _mem[sizeof(ObjData) > (sizeof(real_t) * 4) ? sizeof(ObjData) : (sizeof(real_t) * 4)]; } _data; @@ -207,11 +201,10 @@ public: operator Transform2D() const; operator Color() const; - operator Image() const; operator NodePath() const; operator RefPtr() const; operator RID() const; - operator InputEvent() const; + operator Object *() const; operator Node *() const; operator Control *() const; @@ -276,12 +269,10 @@ public: Variant(const Transform2D &p_transform); Variant(const Transform &p_transform); Variant(const Color &p_color); - Variant(const Image &p_image); Variant(const NodePath &p_path); Variant(const RefPtr &p_resource); Variant(const RID &p_rid); Variant(const Object *p_object); - Variant(const InputEvent &p_input_event); Variant(const Dictionary &p_dictionary); Variant(const Array &p_array); diff --git a/core/variant_call.cpp b/core/variant_call.cpp index beaee188eb..6568dc877e 100644 --- a/core/variant_call.cpp +++ b/core/variant_call.cpp @@ -37,9 +37,6 @@ typedef void (*VariantFunc)(Variant &r_ret, Variant &p_self, const Variant **p_args); typedef void (*VariantConstructFunc)(Variant &r_ret, const Variant **p_args); -VARIANT_ENUM_CAST(Image::CompressMode); -//VARIANT_ENUM_CAST(Image::Format); - struct _VariantCall { static void Vector3_dot(Variant &r_ret, Variant &p_self, const Variant **p_args) { @@ -614,22 +611,6 @@ struct _VariantCall { #define VCALL_PTR5R(m_type, m_method) \ static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { r_ret = reinterpret_cast<m_type *>(p_self._data._ptr)->m_method(*p_args[0], *p_args[1], *p_args[2], *p_args[3], *p_args[4]); } - VCALL_PTR0R(Image, get_format); - VCALL_PTR0R(Image, get_width); - VCALL_PTR0R(Image, get_height); - VCALL_PTR0R(Image, empty); - VCALL_PTR0R(Image, get_used_rect); - VCALL_PTR1R(Image, load); - VCALL_PTR1R(Image, save_png); - VCALL_PTR1R(Image, get_rect); - VCALL_PTR1R(Image, compressed); - VCALL_PTR0R(Image, decompressed); - VCALL_PTR3R(Image, resized); - VCALL_PTR0R(Image, get_data); - VCALL_PTR3(Image, blit_rect); - VCALL_PTR1R(Image, converted); - VCALL_PTR0(Image, fix_alpha_edges); - VCALL_PTR0R(Rect3, get_area); VCALL_PTR0R(Rect3, has_no_area); VCALL_PTR0R(Rect3, has_no_surface); @@ -756,13 +737,6 @@ struct _VariantCall { VCALL_PTR1( Transform, translate ); VCALL_PTR0( Transform, orthonormalize ); */ - VCALL_PTR0R(InputEvent, is_pressed); - VCALL_PTR1R(InputEvent, is_action); - VCALL_PTR1R(InputEvent, is_action_pressed); - VCALL_PTR1R(InputEvent, is_action_released); - VCALL_PTR0R(InputEvent, is_echo); - VCALL_PTR2(InputEvent, set_as_action); - struct ConstructData { int arg_count; @@ -901,11 +875,6 @@ struct _VariantCall { r_ret = Transform(p_args[0]->operator Basis(), p_args[1]->operator Vector3()); } - static void Image_init1(Variant &r_ret, const Variant **p_args) { - - r_ret = Image(*p_args[0], *p_args[1], *p_args[2], Image::Format(p_args[3]->operator int())); - } - static void add_constructor(VariantConstructFunc p_func, const Variant::Type p_type, const String &p_name1 = "", const Variant::Type p_type1 = Variant::NIL, const String &p_name2 = "", const Variant::Type p_type2 = Variant::NIL, @@ -1056,12 +1025,10 @@ Variant Variant::construct(const Variant::Type p_type, const Variant **p_args, i // misc types case COLOR: return Color(); - case IMAGE: return Image(); case NODE_PATH: return NodePath(); // 15 case _RID: return RID(); case OBJECT: return (Object *)NULL; - case INPUT_EVENT: return InputEvent(); case DICTIONARY: return Dictionary(); case ARRAY: return Array(); // 20 @@ -1138,12 +1105,10 @@ Variant Variant::construct(const Variant::Type p_type, const Variant **p_args, i // misc types case COLOR: return p_args[0]->type == Variant::STRING ? Color::html(*p_args[0]) : Color::hex(*p_args[0]); - case IMAGE: return (Image(*p_args[0])); case NODE_PATH: return (NodePath(p_args[0]->operator NodePath())); // 15 case _RID: return (RID(*p_args[0])); case OBJECT: return ((Object *)(p_args[0]->operator Object *())); - case INPUT_EVENT: return (InputEvent(*p_args[0])); case DICTIONARY: return p_args[0]->operator Dictionary(); case ARRAY: return p_args[0]->operator Array(); // 20 @@ -1486,7 +1451,6 @@ void register_variant_methods() { ADDFUNC1(VECTOR3, BASIS, Vector3, outer, VECTOR3, "b", varray()); ADDFUNC0(VECTOR3, BASIS, Vector3, to_diagonal_matrix, varray()); ADDFUNC0(VECTOR3, VECTOR3, Vector3, abs, varray()); - ADDFUNC0(VECTOR3, VECTOR3, Vector3, abs, varray()); ADDFUNC0(VECTOR3, VECTOR3, Vector3, floor, varray()); ADDFUNC0(VECTOR3, VECTOR3, Vector3, ceil, varray()); ADDFUNC1(VECTOR3, REAL, Vector3, distance_to, VECTOR3, "b", varray()); @@ -1527,22 +1491,6 @@ void register_variant_methods() { ADDFUNC1(COLOR, COLOR, Color, blend, COLOR, "over", varray()); ADDFUNC1(COLOR, STRING, Color, to_html, BOOL, "with_alpha", varray(true)); - ADDFUNC0(IMAGE, INT, Image, get_format, varray()); - ADDFUNC0(IMAGE, INT, Image, get_width, varray()); - ADDFUNC0(IMAGE, INT, Image, get_height, varray()); - ADDFUNC0(IMAGE, BOOL, Image, empty, varray()); - ADDFUNC1(IMAGE, INT, Image, load, STRING, "path", varray(0)); - ADDFUNC1(IMAGE, INT, Image, save_png, STRING, "path", varray(0)); - ADDFUNC0(IMAGE, RECT2, Image, get_used_rect, varray(0)); - ADDFUNC1(IMAGE, IMAGE, Image, get_rect, RECT2, "area", varray(0)); - ADDFUNC1(IMAGE, IMAGE, Image, compressed, INT, "format", varray(0)); - ADDFUNC0(IMAGE, IMAGE, Image, decompressed, varray(0)); - ADDFUNC3(IMAGE, IMAGE, Image, resized, INT, "x", INT, "y", INT, "interpolation", varray(((int)Image::INTERPOLATE_BILINEAR))); - ADDFUNC0(IMAGE, POOL_BYTE_ARRAY, Image, get_data, varray()); - ADDFUNC3(IMAGE, NIL, Image, blit_rect, IMAGE, "src", RECT2, "src_rect", VECTOR2, "dest", varray(0)); - ADDFUNC1(IMAGE, IMAGE, Image, converted, INT, "format", varray(0)); - ADDFUNC0(IMAGE, NIL, Image, fix_alpha_edges, varray()); - ADDFUNC0(_RID, INT, RID, get_id, varray()); ADDFUNC0(NODE_PATH, BOOL, NodePath, is_absolute, varray()); @@ -1733,13 +1681,6 @@ void register_variant_methods() { _VariantCall::type_funcs[Variant::TRANSFORM].functions["xform_inv"].returns = true; #endif - ADDFUNC0(INPUT_EVENT, BOOL, InputEvent, is_pressed, varray()); - ADDFUNC1(INPUT_EVENT, BOOL, InputEvent, is_action, STRING, "action", varray()); - ADDFUNC1(INPUT_EVENT, BOOL, InputEvent, is_action_pressed, STRING, "action", varray()); - ADDFUNC1(INPUT_EVENT, BOOL, InputEvent, is_action_released, STRING, "action", varray()); - ADDFUNC0(INPUT_EVENT, BOOL, InputEvent, is_echo, varray()); - ADDFUNC2(INPUT_EVENT, NIL, InputEvent, set_as_action, STRING, "action", BOOL, "pressed", varray()); - /* REGISTER CONSTRUCTORS */ _VariantCall::add_constructor(_VariantCall::Vector2_init1, Variant::VECTOR2, "x", Variant::REAL, "y", Variant::REAL); @@ -1771,73 +1712,11 @@ void register_variant_methods() { _VariantCall::add_constructor(_VariantCall::Transform_init1, Variant::TRANSFORM, "x_axis", Variant::VECTOR3, "y_axis", Variant::VECTOR3, "z_axis", Variant::VECTOR3, "origin", Variant::VECTOR3); _VariantCall::add_constructor(_VariantCall::Transform_init2, Variant::TRANSFORM, "basis", Variant::BASIS, "origin", Variant::VECTOR3); - _VariantCall::add_constructor(_VariantCall::Image_init1, Variant::IMAGE, "width", Variant::INT, "height", Variant::INT, "mipmaps", Variant::BOOL, "format", Variant::INT); - /* REGISTER CONSTANTS */ _VariantCall::add_constant(Variant::VECTOR3, "AXIS_X", Vector3::AXIS_X); _VariantCall::add_constant(Variant::VECTOR3, "AXIS_Y", Vector3::AXIS_Y); _VariantCall::add_constant(Variant::VECTOR3, "AXIS_Z", Vector3::AXIS_Z); - - _VariantCall::add_constant(Variant::INPUT_EVENT, "NONE", InputEvent::NONE); - _VariantCall::add_constant(Variant::INPUT_EVENT, "KEY", InputEvent::KEY); - _VariantCall::add_constant(Variant::INPUT_EVENT, "MOUSE_MOTION", InputEvent::MOUSE_MOTION); - _VariantCall::add_constant(Variant::INPUT_EVENT, "MOUSE_BUTTON", InputEvent::MOUSE_BUTTON); - _VariantCall::add_constant(Variant::INPUT_EVENT, "JOYPAD_MOTION", InputEvent::JOYPAD_MOTION); - _VariantCall::add_constant(Variant::INPUT_EVENT, "JOYPAD_BUTTON", InputEvent::JOYPAD_BUTTON); - _VariantCall::add_constant(Variant::INPUT_EVENT, "SCREEN_TOUCH", InputEvent::SCREEN_TOUCH); - _VariantCall::add_constant(Variant::INPUT_EVENT, "SCREEN_DRAG", InputEvent::SCREEN_DRAG); - _VariantCall::add_constant(Variant::INPUT_EVENT, "ACTION", InputEvent::ACTION); - - _VariantCall::add_constant(Variant::IMAGE, "COMPRESS_16BIT", Image::COMPRESS_16BIT); - _VariantCall::add_constant(Variant::IMAGE, "COMPRESS_S3TC", Image::COMPRESS_S3TC); - _VariantCall::add_constant(Variant::IMAGE, "COMPRESS_PVRTC2", Image::COMPRESS_PVRTC2); - _VariantCall::add_constant(Variant::IMAGE, "COMPRESS_PVRTC4", Image::COMPRESS_PVRTC4); - _VariantCall::add_constant(Variant::IMAGE, "COMPRESS_ETC", Image::COMPRESS_ETC); - _VariantCall::add_constant(Variant::IMAGE, "COMPRESS_ETC2", Image::COMPRESS_ETC2); - - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_L8", Image::FORMAT_L8); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_LA8", Image::FORMAT_LA8); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_R8", Image::FORMAT_R8); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RG8", Image::FORMAT_RG8); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGB8", Image::FORMAT_RGB8); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGBA8", Image::FORMAT_RGBA8); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGB565", Image::FORMAT_RGB565); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGBA4444", Image::FORMAT_RGBA4444); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGBA5551", Image::FORMAT_DXT1); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RF", Image::FORMAT_RF); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGF", Image::FORMAT_RGF); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGBF", Image::FORMAT_RGBF); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGBAF", Image::FORMAT_RGBAF); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RH", Image::FORMAT_RH); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGH", Image::FORMAT_RGH); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGBH", Image::FORMAT_RGBH); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGBAH", Image::FORMAT_RGBAH); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_DXT1", Image::FORMAT_DXT1); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_DXT3", Image::FORMAT_DXT3); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_DXT5", Image::FORMAT_DXT5); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ATI1", Image::FORMAT_ATI1); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ATI2", Image::FORMAT_ATI2); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_BPTC_RGBA", Image::FORMAT_BPTC_RGBA); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_BPTC_RGBF", Image::FORMAT_BPTC_RGBF); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_BPTC_RGBFU", Image::FORMAT_BPTC_RGBFU); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_PVRTC2", Image::FORMAT_PVRTC2); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_PVRTC2A", Image::FORMAT_PVRTC2A); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_PVRTC4", Image::FORMAT_PVRTC4); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_PVRTC4A", Image::FORMAT_PVRTC4A); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ETC", Image::FORMAT_ETC); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ETC2_R11", Image::FORMAT_ETC2_R11); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ETC2_R11S", Image::FORMAT_ETC2_R11S); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ETC2_RG11", Image::FORMAT_ETC2_RG11); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ETC2_RG11S", Image::FORMAT_ETC2_RG11S); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ETC2_RGB8", Image::FORMAT_ETC2_RGB8); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ETC2_RGBA8", Image::FORMAT_ETC2_RGBA8); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ETC2_RGB8A1", Image::FORMAT_ETC2_RGB8A1); - _VariantCall::add_constant(Variant::IMAGE, "FORMAT_MAX", Image::FORMAT_MAX); - - _VariantCall::add_constant(Variant::IMAGE, "INTERPOLATE_NEAREST", Image::INTERPOLATE_NEAREST); - _VariantCall::add_constant(Variant::IMAGE, "INTERPOLATE_BILINEAR", Image::INTERPOLATE_BILINEAR); - _VariantCall::add_constant(Variant::IMAGE, "INTERPOLATE_CUBIC", Image::INTERPOLATE_CUBIC); } void unregister_variant_methods() { diff --git a/core/variant_op.cpp b/core/variant_op.cpp index e8274d10af..7b9b7abd9e 100644 --- a/core/variant_op.cpp +++ b/core/variant_op.cpp @@ -58,11 +58,9 @@ bool Variant::booleanize(bool &r_valid) const { case BASIS: case TRANSFORM: case COLOR: - case IMAGE: r_valid = false; return false; case _RID: return (*reinterpret_cast<const RID *>(_data._mem)).is_valid(); case OBJECT: return _get_obj().obj; case NODE_PATH: return (*reinterpret_cast<const NodePath *>(_data._mem)) != NodePath(); - case INPUT_EVENT: case DICTIONARY: case ARRAY: case POOL_BYTE_ARRAY: @@ -283,7 +281,6 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & DEFAULT_OP_PTRREF(==, TRANSFORM, _transform); DEFAULT_OP_LOCALMEM(==, COLOR, Color); - DEFAULT_OP_PTRREF(==, IMAGE, _image); DEFAULT_OP_STR(==, NODE_PATH, NodePath); DEFAULT_OP_LOCALMEM(==, _RID, RID); case OBJECT: { @@ -293,7 +290,6 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & if (p_b.type == NIL) _RETURN(!p_a._get_obj().obj); } break; - DEFAULT_OP_PTRREF(==, INPUT_EVENT, _input_event); case DICTIONARY: { @@ -372,7 +368,7 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_FAIL(COLOR); - DEFAULT_OP_FAIL(IMAGE); + DEFAULT_OP_FAIL(NODE_PATH); DEFAULT_OP_LOCALMEM(<, _RID, RID); case OBJECT: { @@ -380,7 +376,6 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & if (p_b.type == OBJECT) _RETURN((p_a._get_obj().obj < p_b._get_obj().obj)); } break; - DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); case ARRAY: { @@ -437,7 +432,7 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_FAIL(COLOR); - DEFAULT_OP_FAIL(IMAGE); + DEFAULT_OP_FAIL(NODE_PATH); DEFAULT_OP_LOCALMEM(<=, _RID, RID); case OBJECT: { @@ -445,7 +440,6 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & if (p_b.type == OBJECT) _RETURN((p_a._get_obj().obj <= p_b._get_obj().obj)); } break; - DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); @@ -500,11 +494,10 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_FAIL(COLOR); - DEFAULT_OP_FAIL(IMAGE); + DEFAULT_OP_FAIL(NODE_PATH); DEFAULT_OP_FAIL(_RID); DEFAULT_OP_FAIL(OBJECT); - DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); case ARRAY: { @@ -557,11 +550,10 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_FAIL(COLOR); - DEFAULT_OP_FAIL(IMAGE); + DEFAULT_OP_FAIL(NODE_PATH); DEFAULT_OP_FAIL(_RID); DEFAULT_OP_FAIL(OBJECT); - DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); @@ -654,11 +646,10 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & return; } break; DEFAULT_OP_FAIL(COLOR); - DEFAULT_OP_FAIL(IMAGE); + DEFAULT_OP_FAIL(NODE_PATH); DEFAULT_OP_FAIL(_RID); DEFAULT_OP_FAIL(OBJECT); - DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); @@ -727,11 +718,10 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_FAIL(COLOR); - DEFAULT_OP_FAIL(IMAGE); + DEFAULT_OP_FAIL(NODE_PATH); DEFAULT_OP_FAIL(_RID); DEFAULT_OP_FAIL(OBJECT); - DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); @@ -769,11 +759,10 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & DEFAULT_OP_LOCALMEM_POS(VECTOR2, Vector2); DEFAULT_OP_FAIL(COLOR); - DEFAULT_OP_FAIL(IMAGE); + DEFAULT_OP_FAIL(NODE_PATH); DEFAULT_OP_FAIL(_RID); DEFAULT_OP_FAIL(OBJECT); - DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); @@ -809,11 +798,10 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & DEFAULT_OP_FAIL(TRANSFORM); DEFAULT_OP_FAIL(COLOR); - DEFAULT_OP_FAIL(IMAGE); + DEFAULT_OP_FAIL(NODE_PATH); DEFAULT_OP_FAIL(_RID); DEFAULT_OP_FAIL(OBJECT); - DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); @@ -1305,7 +1293,7 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) } } - } break; + } break; // 10 case RECT3: { if (p_value.type != Variant::VECTOR3) @@ -1330,7 +1318,7 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) return; } } - } break; //sorry naming convention fail :( not like it's used often // 10 + } break; case BASIS: { if (p_value.type != Variant::VECTOR3) @@ -1480,8 +1468,6 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) } } break; - case IMAGE: { - } break; case NODE_PATH: { } break; // 15 case _RID: { @@ -1511,402 +1497,19 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) return obj->set(p_index, p_value, r_valid); } } break; - case INPUT_EVENT: { - - InputEvent &ie = *_data._input_event; - - if (p_index.get_type() != Variant::STRING) - return; - - const String &str = *reinterpret_cast<const String *>(p_index._data._mem); - - if (str == "type") { - - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - - int type = p_value; - if (type < 0 || type >= InputEvent::TYPE_MAX) - return; //fail - valid = true; - ie.type = InputEvent::Type(type); - return; - } else if (str == "device") { - - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - - valid = true; - ie.device = p_value; - return; - } else if (str == "ID") { - - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - - valid = true; - ie.ID = p_value; - return; - } - - if (ie.type == InputEvent::KEY || ie.type == InputEvent::MOUSE_BUTTON || ie.type == InputEvent::MOUSE_MOTION) { - - if (str == "shift") { - - if (p_value.type != Variant::INT && p_value.type != Variant::REAL && p_value.type != Variant::BOOL) - return; - - valid = true; - ie.key.mod.shift = p_value; - return; - } - if (str == "alt") { - - if (p_value.type != Variant::INT && p_value.type != Variant::REAL && p_value.type != Variant::BOOL) - return; - - valid = true; - ie.key.mod.alt = p_value; - return; - } - if (str == "control") { - - if (p_value.type != Variant::INT && p_value.type != Variant::REAL && p_value.type != Variant::BOOL) - return; - - valid = true; - ie.key.mod.control = p_value; - return; - } - if (str == "meta") { - - if (p_value.type != Variant::INT && p_value.type != Variant::REAL && p_value.type != Variant::BOOL) - return; - - valid = true; - ie.key.mod.meta = p_value; - return; - } - } - - if (ie.type == InputEvent::KEY) { - - if (str == "pressed") { - - if (p_value.type != Variant::INT && p_value.type != Variant::REAL && p_value.type != Variant::BOOL) - return; - - valid = true; - ie.key.pressed = p_value; - return; - } else if (str == "scancode") { - - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - - valid = true; - ie.key.scancode = p_value; - return; - } else if (str == "unicode") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.key.unicode = p_value; - return; - } else if (str == "echo") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL && p_value.type != Variant::BOOL) - return; - - valid = true; - ie.key.echo = p_value; - return; - } - } - - if (ie.type == InputEvent::MOUSE_MOTION || ie.type == InputEvent::MOUSE_BUTTON) { - - if (str == "button_mask") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_button.button_mask = p_value; - return; - } else if (str == "x") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_button.x = p_value; - return; - } else if (str == "y") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_button.y = p_value; - return; - } else if (str == "pos") { - if (p_value.type != Variant::VECTOR2) - return; - valid = true; - Point2 value = p_value; - ie.mouse_button.x = value.x; - ie.mouse_button.y = value.y; - return; - } else if (str == "global_x") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_button.global_x = p_value; - return; - } else if (str == "global_y") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_button.global_y = p_value; - return; - } else if (str == "global_pos") { - if (p_value.type != Variant::VECTOR2) - return; - valid = true; - Point2 value = p_value; - ie.mouse_button.global_x = value.x; - ie.mouse_button.global_y = value.y; - return; - } /*else if (str=="pointer_index") { - valid=true; - return ie.mouse_button.pointer_index; - }*/ - - if (ie.type == InputEvent::MOUSE_MOTION) { - - if (str == "relative_x") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_motion.relative_x = p_value; - return; - } else if (str == "relative_y") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_motion.relative_y = p_value; - return; - } else if (str == "relative_pos") { - if (p_value.type != Variant::VECTOR2) - return; - valid = true; - Point2 value = p_value; - ie.mouse_motion.relative_x = value.x; - ie.mouse_motion.relative_y = value.y; - return; - } - - if (str == "speed_x") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_motion.speed_x = p_value; - return; - } else if (str == "speed_y") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_motion.speed_y = p_value; - return; - } else if (str == "speed") { - if (p_value.type != Variant::VECTOR2) - return; - valid = true; - Point2 value = p_value; - ie.mouse_motion.speed_x = value.x; - ie.mouse_motion.speed_y = value.y; - return; - } - - } else if (ie.type == InputEvent::MOUSE_BUTTON) { - - if (str == "button_index") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_button.button_index = p_value; - return; - } else if (str == "pressed") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL && p_value.type != Variant::BOOL) - return; - valid = true; - ie.mouse_button.pressed = p_value; - return; - } else if (str == "doubleclick") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL && p_value.type != Variant::BOOL) - return; - valid = true; - ie.mouse_button.doubleclick = p_value; - return; - } - } - } - - if (ie.type == InputEvent::JOYPAD_BUTTON) { - - if (str == "button_index") { - if (p_value.type != Variant::REAL && p_value.type != Variant::INT) - return; - valid = true; - ie.joy_button.button_index = p_value; - return; - } - if (str == "pressed") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL && p_value.type != Variant::BOOL) - return; - - valid = true; - ie.joy_button.pressed = p_value; - return; - } - if (str == "pressure") { - if (p_value.type != Variant::REAL && p_value.type != Variant::INT) - return; - valid = true; - ie.joy_button.pressure = p_value; - return; - } - } - - if (ie.type == InputEvent::JOYPAD_MOTION) { - - if (str == "axis") { - if (p_value.type != Variant::REAL && p_value.type != Variant::INT) - return; - valid = true; - ie.joy_motion.axis = p_value; - return; - } - if (str == "value") { - if (p_value.type != Variant::REAL && p_value.type != Variant::INT) - return; - valid = true; - ie.joy_motion.axis_value = p_value; - return; - } - } - - if (ie.type == InputEvent::SCREEN_TOUCH) { - - if (str == "index") { - valid = true; - ie.screen_touch.index = p_value; - return; - } - if (str == "x") { - valid = true; - ie.screen_touch.x = p_value; - return; - } - if (str == "y") { - valid = true; - ie.screen_touch.y = p_value; - return; - } - if (str == "pos") { - valid = true; - Vector2 v = p_value; - ie.screen_touch.x = v.x; - ie.screen_touch.y = v.y; - return; - } - if (str == "pressed") { - valid = true; - ie.screen_touch.pressed = p_value; - return; - } - } - - if (ie.type == InputEvent::SCREEN_DRAG) { - - if (str == "index") { - valid = true; - ie.screen_drag.index = p_value; - return; - } - if (str == "x") { - valid = true; - ie.screen_drag.x = p_value; - return; - } - if (str == "y") { - valid = true; - ie.screen_drag.y = p_value; - return; - } - if (str == "pos") { - valid = true; - Vector2 v = p_value; - ie.screen_drag.x = v.x; - ie.screen_drag.y = v.y; - return; - } - if (str == "relative_x") { - valid = true; - ie.screen_drag.relative_x = p_value; - return; - } - if (str == "relative_y") { - valid = true; - ie.screen_drag.relative_y = p_value; - return; - } - if (str == "relative_pos") { - valid = true; - Vector2 v = p_value; - ie.screen_drag.relative_x = v.x; - ie.screen_drag.relative_y = v.y; - return; - } - if (str == "speed_x") { - valid = true; - ie.screen_drag.speed_x = p_value; - return; - } - if (str == "speed_y") { - valid = true; - ie.screen_drag.speed_y = p_value; - return; - } - if (str == "speed") { - valid = true; - Vector2 v = p_value; - ie.screen_drag.speed_x = v.x; - ie.screen_drag.speed_y = v.y; - return; - } - } - if (ie.type == InputEvent::ACTION) { - - if (str == "action") { - valid = true; - ie.action.action = p_value; - return; - } else if (str == "pressed") { - valid = true; - ie.action.pressed = p_value; - return; - } - } - - } break; case DICTIONARY: { Dictionary *dic = reinterpret_cast<Dictionary *>(_data._mem); dic->operator[](p_index) = p_value; valid = true; //always valid, i guess? should this really be ok? return; - } break; // 20 - DEFAULT_OP_ARRAY_CMD(ARRAY, Array, ;, (*arr)[index] = p_value; return ) + } break; + DEFAULT_OP_ARRAY_CMD(ARRAY, Array, ;, (*arr)[index] = p_value; return ) // 20 DEFAULT_OP_DVECTOR_SET(POOL_BYTE_ARRAY, uint8_t, p_value.type != Variant::REAL && p_value.type != Variant::INT) DEFAULT_OP_DVECTOR_SET(POOL_INT_ARRAY, int, p_value.type != Variant::REAL && p_value.type != Variant::INT) DEFAULT_OP_DVECTOR_SET(POOL_REAL_ARRAY, real_t, p_value.type != Variant::REAL && p_value.type != Variant::INT) - DEFAULT_OP_DVECTOR_SET(POOL_STRING_ARRAY, String, p_value.type != Variant::STRING) // 25 - DEFAULT_OP_DVECTOR_SET(POOL_VECTOR2_ARRAY, Vector2, p_value.type != Variant::VECTOR2) + DEFAULT_OP_DVECTOR_SET(POOL_STRING_ARRAY, String, p_value.type != Variant::STRING) + DEFAULT_OP_DVECTOR_SET(POOL_VECTOR2_ARRAY, Vector2, p_value.type != Variant::VECTOR2) // 25 DEFAULT_OP_DVECTOR_SET(POOL_VECTOR3_ARRAY, Vector3, p_value.type != Variant::VECTOR3) DEFAULT_OP_DVECTOR_SET(POOL_COLOR_ARRAY, Color, p_value.type != Variant::COLOR) default: return; @@ -2107,7 +1710,7 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } } - } break; + } break; // 10 case RECT3: { if (p_index.get_type() == Variant::STRING) { @@ -2126,7 +1729,7 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { return v->size + v->pos; } } - } break; //sorry naming convention fail :( not like it's used often // 10 + } break; case BASIS: { if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) { @@ -2239,8 +1842,6 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } } break; - case IMAGE: { - } break; case NODE_PATH: { } break; // 15 case _RID: { @@ -2267,235 +1868,6 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } } break; - case INPUT_EVENT: { - - InputEvent ie = operator InputEvent(); - - if (p_index.get_type() != Variant::STRING) - break; - - const String &str = *reinterpret_cast<const String *>(p_index._data._mem); - - if (str == "type") { - valid = true; - return ie.type; - } else if (str == "device") { - valid = true; - return ie.device; - } else if (str == "ID") { - valid = true; - return ie.ID; - } - - if (ie.type == InputEvent::KEY || ie.type == InputEvent::MOUSE_BUTTON || ie.type == InputEvent::MOUSE_MOTION) { - - if (str == "shift") { - valid = true; - return ie.key.mod.shift; - } - if (str == "alt") { - valid = true; - return ie.key.mod.alt; - } - if (str == "control") { - valid = true; - return ie.key.mod.control; - } - if (str == "meta") { - valid = true; - return ie.key.mod.meta; - } - } - - if (ie.type == InputEvent::KEY) { - - if (str == "pressed") { - valid = true; - return ie.key.pressed; - } else if (str == "scancode") { - valid = true; - return ie.key.scancode; - } else if (str == "unicode") { - valid = true; - return ie.key.unicode; - } else if (str == "echo") { - valid = true; - return ie.key.echo; - } - } - - if (ie.type == InputEvent::MOUSE_MOTION || ie.type == InputEvent::MOUSE_BUTTON) { - - if (str == "button_mask") { - valid = true; - return ie.mouse_button.button_mask; - } else if (str == "x") { - valid = true; - return ie.mouse_button.x; - } else if (str == "y") { - valid = true; - return ie.mouse_button.y; - } else if (str == "pos") { - valid = true; - return Point2(ie.mouse_button.x, ie.mouse_button.y); - } else if (str == "global_x") { - valid = true; - return ie.mouse_button.global_x; - } else if (str == "global_y") { - valid = true; - return ie.mouse_button.global_y; - } else if (str == "global_pos") { - valid = true; - return Point2(ie.mouse_button.global_x, ie.mouse_button.global_y); - } /*else if (str=="pointer_index") { - valid=true; - return ie.mouse_button.pointer_index; - }*/ - - if (ie.type == InputEvent::MOUSE_MOTION) { - - if (str == "relative_x") { - valid = true; - return ie.mouse_motion.relative_x; - } else if (str == "relative_y") { - valid = true; - return ie.mouse_motion.relative_y; - } else if (str == "relative_pos") { - valid = true; - return Point2(ie.mouse_motion.relative_x, ie.mouse_motion.relative_y); - } else if (str == "speed_x") { - valid = true; - return ie.mouse_motion.speed_x; - } else if (str == "speed_y") { - valid = true; - return ie.mouse_motion.speed_y; - } else if (str == "speed") { - valid = true; - return Point2(ie.mouse_motion.speed_x, ie.mouse_motion.speed_y); - } - - } else if (ie.type == InputEvent::MOUSE_BUTTON) { - - if (str == "button_index") { - valid = true; - return ie.mouse_button.button_index; - } else if (str == "pressed") { - valid = true; - return ie.mouse_button.pressed; - } else if (str == "doubleclick") { - valid = true; - return ie.mouse_button.doubleclick; - } - } - } - - if (ie.type == InputEvent::JOYPAD_BUTTON) { - - if (str == "button_index") { - valid = true; - return ie.joy_button.button_index; - } - if (str == "pressed") { - valid = true; - return ie.joy_button.pressed; - } - if (str == "pressure") { - valid = true; - return ie.joy_button.pressure; - } - } - - if (ie.type == InputEvent::JOYPAD_MOTION) { - - if (str == "axis") { - valid = true; - return ie.joy_motion.axis; - } - if (str == "value") { - valid = true; - return ie.joy_motion.axis_value; - } - } - - if (ie.type == InputEvent::SCREEN_TOUCH) { - - if (str == "index") { - valid = true; - return ie.screen_touch.index; - } - if (str == "x") { - valid = true; - return ie.screen_touch.x; - } - if (str == "y") { - valid = true; - return ie.screen_touch.y; - } - if (str == "pos") { - valid = true; - return Vector2(ie.screen_touch.x, ie.screen_touch.y); - } - if (str == "pressed") { - valid = true; - return ie.screen_touch.pressed; - } - } - - if (ie.type == InputEvent::SCREEN_DRAG) { - - if (str == "index") { - valid = true; - return ie.screen_drag.index; - } - if (str == "x") { - valid = true; - return ie.screen_drag.x; - } - if (str == "y") { - valid = true; - return ie.screen_drag.y; - } - if (str == "pos") { - valid = true; - return Vector2(ie.screen_drag.x, ie.screen_drag.y); - } - if (str == "relative_x") { - valid = true; - return ie.screen_drag.relative_x; - } - if (str == "relative_y") { - valid = true; - return ie.screen_drag.relative_y; - } - if (str == "relative_pos") { - valid = true; - return Vector2(ie.screen_drag.relative_x, ie.screen_drag.relative_y); - } - if (str == "speed_x") { - valid = true; - return ie.screen_drag.speed_x; - } - if (str == "speed_y") { - valid = true; - return ie.screen_drag.speed_y; - } - if (str == "speed") { - valid = true; - return Vector2(ie.screen_drag.speed_x, ie.screen_drag.speed_y); - } - } - if (ie.type == InputEvent::ACTION) { - - if (str == "action") { - valid = true; - return ie.action.action; - } else if (str == "pressed") { - valid = true; - return ie.action.pressed; - } - } - - } break; case DICTIONARY: { const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem); @@ -2504,13 +1876,13 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { valid = true; return *res; } - } break; // 20 - DEFAULT_OP_ARRAY_CMD(ARRAY, const Array, ;, return (*arr)[index]) + } break; + DEFAULT_OP_ARRAY_CMD(ARRAY, const Array, ;, return (*arr)[index]) // 20 DEFAULT_OP_DVECTOR_GET(POOL_BYTE_ARRAY, uint8_t) DEFAULT_OP_DVECTOR_GET(POOL_INT_ARRAY, int) DEFAULT_OP_DVECTOR_GET(POOL_REAL_ARRAY, real_t) DEFAULT_OP_DVECTOR_GET(POOL_STRING_ARRAY, String) - DEFAULT_OP_DVECTOR_GET(POOL_VECTOR2_ARRAY, Vector2) + DEFAULT_OP_DVECTOR_GET(POOL_VECTOR2_ARRAY, Vector2) // 25 DEFAULT_OP_DVECTOR_GET(POOL_VECTOR3_ARRAY, Vector3) DEFAULT_OP_DVECTOR_GET(POOL_COLOR_ARRAY, Color) default: return Variant(); @@ -2774,12 +2146,12 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { p_list->push_back(PropertyInfo(Variant::REAL, "z")); p_list->push_back(PropertyInfo(Variant::REAL, "w")); - } break; + } break; // 10 case RECT3: { p_list->push_back(PropertyInfo(Variant::VECTOR3, "pos")); p_list->push_back(PropertyInfo(Variant::VECTOR3, "size")); p_list->push_back(PropertyInfo(Variant::VECTOR3, "end")); - } break; //sorry naming convention fail :( not like it's used often // 10 + } break; case BASIS: { p_list->push_back(PropertyInfo(Variant::VECTOR3, "x")); @@ -2807,8 +2179,6 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { p_list->push_back(PropertyInfo(Variant::INT, "a8")); } break; - case IMAGE: { - } break; case NODE_PATH: { } break; // 15 case _RID: { @@ -2831,94 +2201,6 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { } } break; - case INPUT_EVENT: { - - InputEvent ie = operator InputEvent(); - - p_list->push_back(PropertyInfo(Variant::INT, "type")); - p_list->push_back(PropertyInfo(Variant::INT, "device")); - p_list->push_back(PropertyInfo(Variant::INT, "ID")); - - if (ie.type == InputEvent::KEY || ie.type == InputEvent::MOUSE_BUTTON || ie.type == InputEvent::MOUSE_MOTION) { - - p_list->push_back(PropertyInfo(Variant::BOOL, "shift")); - p_list->push_back(PropertyInfo(Variant::BOOL, "alt")); - p_list->push_back(PropertyInfo(Variant::BOOL, "control")); - p_list->push_back(PropertyInfo(Variant::BOOL, "meta")); - } - - if (ie.type == InputEvent::KEY) { - - p_list->push_back(PropertyInfo(Variant::BOOL, "pressed")); - p_list->push_back(PropertyInfo(Variant::BOOL, "echo")); - p_list->push_back(PropertyInfo(Variant::INT, "scancode")); - p_list->push_back(PropertyInfo(Variant::INT, "unicode")); - } - - if (ie.type == InputEvent::MOUSE_MOTION || ie.type == InputEvent::MOUSE_BUTTON) { - - p_list->push_back(PropertyInfo(Variant::INT, "button_mask")); - p_list->push_back(PropertyInfo(Variant::REAL, "x")); - p_list->push_back(PropertyInfo(Variant::REAL, "y")); - p_list->push_back(PropertyInfo(Variant::VECTOR2, "pos")); - p_list->push_back(PropertyInfo(Variant::REAL, "global_x")); - p_list->push_back(PropertyInfo(Variant::REAL, "global_y")); - p_list->push_back(PropertyInfo(Variant::VECTOR2, "global_pos")); - - if (ie.type == InputEvent::MOUSE_MOTION) { - - p_list->push_back(PropertyInfo(Variant::REAL, "relative_x")); - p_list->push_back(PropertyInfo(Variant::REAL, "relative_y")); - p_list->push_back(PropertyInfo(Variant::VECTOR2, "relative_pos")); - p_list->push_back(PropertyInfo(Variant::REAL, "speed_x")); - p_list->push_back(PropertyInfo(Variant::REAL, "speed_y")); - p_list->push_back(PropertyInfo(Variant::VECTOR2, "speed")); - - } else if (ie.type == InputEvent::MOUSE_BUTTON) { - - p_list->push_back(PropertyInfo(Variant::INT, "button_index")); - p_list->push_back(PropertyInfo(Variant::BOOL, "pressed")); - p_list->push_back(PropertyInfo(Variant::BOOL, "doubleclick")); - } - } - - if (ie.type == InputEvent::JOYPAD_BUTTON) { - - p_list->push_back(PropertyInfo(Variant::INT, "button_index")); - p_list->push_back(PropertyInfo(Variant::BOOL, "pressed")); - p_list->push_back(PropertyInfo(Variant::REAL, "pressure")); - } - - if (ie.type == InputEvent::JOYPAD_MOTION) { - - p_list->push_back(PropertyInfo(Variant::INT, "axis")); - p_list->push_back(PropertyInfo(Variant::REAL, "value")); - } - - if (ie.type == InputEvent::SCREEN_TOUCH) { - - p_list->push_back(PropertyInfo(Variant::INT, "index")); - p_list->push_back(PropertyInfo(Variant::REAL, "x")); - p_list->push_back(PropertyInfo(Variant::REAL, "y")); - p_list->push_back(PropertyInfo(Variant::VECTOR2, "pos")); - p_list->push_back(PropertyInfo(Variant::BOOL, "pressed")); - } - - if (ie.type == InputEvent::SCREEN_DRAG) { - - p_list->push_back(PropertyInfo(Variant::INT, "index")); - p_list->push_back(PropertyInfo(Variant::REAL, "x")); - p_list->push_back(PropertyInfo(Variant::REAL, "y")); - p_list->push_back(PropertyInfo(Variant::VECTOR2, "pos")); - p_list->push_back(PropertyInfo(Variant::REAL, "relative_x")); - p_list->push_back(PropertyInfo(Variant::REAL, "relative_y")); - p_list->push_back(PropertyInfo(Variant::VECTOR2, "relative_pos")); - p_list->push_back(PropertyInfo(Variant::REAL, "speed_x")); - p_list->push_back(PropertyInfo(Variant::REAL, "speed_y")); - p_list->push_back(PropertyInfo(Variant::VECTOR2, "speed")); - } - - } break; case DICTIONARY: { const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem); @@ -2929,12 +2211,13 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { p_list->push_back(PropertyInfo(Variant::STRING, E->get())); } } - } break; // 20 - case ARRAY: + } break; + case ARRAY: // 20 case POOL_BYTE_ARRAY: case POOL_INT_ARRAY: case POOL_REAL_ARRAY: case POOL_STRING_ARRAY: + case POOL_VECTOR2_ARRAY: // 25 case POOL_VECTOR3_ARRAY: case POOL_COLOR_ARRAY: { @@ -3631,10 +2914,6 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & r_dst = reinterpret_cast<const Color *>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Color *>(b._data._mem), c); } return; - case IMAGE: { - r_dst = a; - } - return; case NODE_PATH: { r_dst = a; } @@ -3647,10 +2926,6 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & r_dst = a; } return; - case INPUT_EVENT: { - r_dst = a; - } - return; case DICTIONARY: { } return; diff --git a/core/variant_parser.cpp b/core/variant_parser.cpp index 234156d39f..0d4d0429e7 100644 --- a/core/variant_parser.cpp +++ b/core/variant_parser.cpp @@ -30,6 +30,7 @@ #include "variant_parser.h" #include "io/resource_loader.h" +#include "os/input_event.h" #include "os/keyboard.h" CharType VariantParser::StreamFile::get_char() { @@ -504,39 +505,7 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, return OK; } else if (token.type == TK_IDENTIFIER) { - /* - VECTOR2, // 5 - RECT2, - VECTOR3, - MATRIX32, - PLANE, - QUAT, // 10 - _AABB, //sorry naming convention fail :( not like it's used often - MATRIX3, - TRANSFORM, - // misc types - COLOR, - IMAGE, // 15 - NODE_PATH, - _RID, - OBJECT, - INPUT_EVENT, - DICTIONARY, // 20 - ARRAY, - - // arrays - RAW_ARRAY, - INT_ARRAY, - REAL_ARRAY, - STRING_ARRAY, // 25 - VECTOR2_ARRAY, - VECTOR3_ARRAY, - COLOR_ARRAY, - - VARIANT_MAX - -*/ String id = token.value; if (id == "true") value = true; @@ -681,126 +650,6 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, value = Color(args[0], args[1], args[2], args[3]); return OK; - } else if (id == "Image") { - - //:| - - get_token(p_stream, token, line, r_err_str); - if (token.type != TK_PARENTHESIS_OPEN) { - r_err_str = "Expected '('"; - return ERR_PARSE_ERROR; - } - - get_token(p_stream, token, line, r_err_str); - if (token.type == TK_PARENTHESIS_CLOSE) { - value = Image(); // just an Image() - return OK; - } else if (token.type != TK_NUMBER) { - r_err_str = "Expected number (width)"; - return ERR_PARSE_ERROR; - } - - get_token(p_stream, token, line, r_err_str); - - int width = token.value; - if (token.type != TK_COMMA) { - r_err_str = "Expected ','"; - return ERR_PARSE_ERROR; - } - - get_token(p_stream, token, line, r_err_str); - if (token.type != TK_NUMBER) { - r_err_str = "Expected number (height)"; - return ERR_PARSE_ERROR; - } - - int height = token.value; - - get_token(p_stream, token, line, r_err_str); - if (token.type != TK_COMMA) { - r_err_str = "Expected ','"; - return ERR_PARSE_ERROR; - } - - get_token(p_stream, token, line, r_err_str); - - bool has_mipmaps = false; - - if (token.type == TK_NUMBER) { - has_mipmaps = bool(token.value); - } else if (token.type == TK_IDENTIFIER && String(token.value) == "true") { - has_mipmaps = true; - } else if (token.type == TK_IDENTIFIER && String(token.value) == "false") { - has_mipmaps = false; - } else { - r_err_str = "Expected number/true/false (mipmaps)"; - return ERR_PARSE_ERROR; - } - - int mipmaps = token.value; - - get_token(p_stream, token, line, r_err_str); - if (token.type != TK_COMMA) { - r_err_str = "Expected ','"; - return ERR_PARSE_ERROR; - } - - get_token(p_stream, token, line, r_err_str); - if (token.type != TK_IDENTIFIER) { - r_err_str = "Expected identifier (format)"; - return ERR_PARSE_ERROR; - } - - String sformat = token.value; - - Image::Format format = Image::FORMAT_MAX; - - for (int i = 0; i < Image::FORMAT_MAX; i++) { - if (Image::get_format_name(Image::Format(i)) == sformat) { - format = Image::Format(i); - } - } - - if (format == Image::FORMAT_MAX) { - r_err_str = "Unknown image format: " + String(sformat); - return ERR_PARSE_ERROR; - } - - int len = Image::get_image_data_size(width, height, format, mipmaps); - - PoolVector<uint8_t> buffer; - buffer.resize(len); - - if (buffer.size() != len) { - r_err_str = "Couldn't allocate image buffer of size: " + itos(len); - } - - { - PoolVector<uint8_t>::Write w = buffer.write(); - - for (int i = 0; i < len; i++) { - get_token(p_stream, token, line, r_err_str); - if (token.type != TK_COMMA) { - r_err_str = "Expected ','"; - return ERR_PARSE_ERROR; - } - - get_token(p_stream, token, line, r_err_str); - if (token.type != TK_NUMBER) { - r_err_str = "Expected number"; - return ERR_PARSE_ERROR; - } - - w[i] = int(token.value); - } - } - - Image img(width, height, mipmaps, format, buffer); - - value = img; - - return OK; - } else if (id == "NodePath") { get_token(p_stream, token, line, r_err_str); @@ -912,7 +761,7 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, } return OK; - +#ifndef DISABLE_DEPRECATED } else if (id == "InputEvent") { get_token(p_stream, token, line, r_err_str); @@ -930,12 +779,10 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, String id = token.value; - InputEvent ie; + Ref<InputEvent> ie; if (id == "NONE") { - ie.type = InputEvent::NONE; - get_token(p_stream, token, line, r_err_str); if (token.type != TK_PARENTHESIS_CLOSE) { @@ -945,21 +792,23 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, } else if (id == "KEY") { + Ref<InputEventKey> key; + key.instance(); + ie = key; + get_token(p_stream, token, line, r_err_str); if (token.type != TK_COMMA) { r_err_str = "Expected ','"; return ERR_PARSE_ERROR; } - ie.type = InputEvent::KEY; - get_token(p_stream, token, line, r_err_str); if (token.type == TK_IDENTIFIER) { String name = token.value; - ie.key.scancode = find_keycode(name); + key->set_scancode(find_keycode(name)); } else if (token.type == TK_NUMBER) { - ie.key.scancode = token.value; + key->set_scancode(token.value); } else { r_err_str = "Expected string or integer for keycode"; @@ -980,13 +829,13 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, String mods = token.value; if (mods.findn("C") != -1) - ie.key.mod.control = true; + key->set_control(true); if (mods.findn("A") != -1) - ie.key.mod.alt = true; + key->set_alt(true); if (mods.findn("S") != -1) - ie.key.mod.shift = true; + key->set_shift(true); if (mods.findn("M") != -1) - ie.key.mod.meta = true; + key->set_metakey(true); get_token(p_stream, token, line, r_err_str); if (token.type != TK_PARENTHESIS_CLOSE) { @@ -1002,21 +851,23 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, } else if (id == "MBUTTON") { + Ref<InputEventMouseButton> mb; + mb.instance(); + ie = mb; + get_token(p_stream, token, line, r_err_str); if (token.type != TK_COMMA) { r_err_str = "Expected ','"; return ERR_PARSE_ERROR; } - ie.type = InputEvent::MOUSE_BUTTON; - get_token(p_stream, token, line, r_err_str); if (token.type != TK_NUMBER) { r_err_str = "Expected button index"; return ERR_PARSE_ERROR; } - ie.mouse_button.button_index = token.value; + mb->set_button_index(token.value); get_token(p_stream, token, line, r_err_str); if (token.type != TK_PARENTHESIS_CLOSE) { @@ -1026,21 +877,23 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, } else if (id == "JBUTTON") { + Ref<InputEventJoypadButton> jb; + jb.instance(); + ie = jb; + get_token(p_stream, token, line, r_err_str); if (token.type != TK_COMMA) { r_err_str = "Expected ','"; return ERR_PARSE_ERROR; } - ie.type = InputEvent::JOYPAD_BUTTON; - get_token(p_stream, token, line, r_err_str); if (token.type != TK_NUMBER) { r_err_str = "Expected button index"; return ERR_PARSE_ERROR; } - ie.joy_button.button_index = token.value; + jb->set_button_index(token.value); get_token(p_stream, token, line, r_err_str); if (token.type != TK_PARENTHESIS_CLOSE) { @@ -1050,21 +903,23 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, } else if (id == "JAXIS") { + Ref<InputEventJoypadMotion> jm; + jm.instance(); + ie = jm; + get_token(p_stream, token, line, r_err_str); if (token.type != TK_COMMA) { r_err_str = "Expected ','"; return ERR_PARSE_ERROR; } - ie.type = InputEvent::JOYPAD_MOTION; - get_token(p_stream, token, line, r_err_str); if (token.type != TK_NUMBER) { r_err_str = "Expected axis index"; return ERR_PARSE_ERROR; } - ie.joy_motion.axis = token.value; + jm->set_axis(token.value); get_token(p_stream, token, line, r_err_str); @@ -1079,7 +934,7 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, return ERR_PARSE_ERROR; } - ie.joy_motion.axis_value = token.value; + jm->set_axis_value(token.value); get_token(p_stream, token, line, r_err_str); @@ -1097,7 +952,7 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, value = ie; return OK; - +#endif } else if (id == "PoolByteArray" || id == "ByteArray") { Vector<uint8_t> args; @@ -1273,152 +1128,11 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, value = arr; return OK; - } else if (id == "key") { // compatibility with project.godot - - Vector<String> params; - Error err = _parse_enginecfg(p_stream, params, line, r_err_str); - if (err) - return err; - ERR_FAIL_COND_V(params.size() != 1 && params.size() != 2, ERR_PARSE_ERROR); - - int scode = 0; - - if (params[0].is_numeric()) { - scode = params[0].to_int(); - if (scode < 10) { - scode = KEY_0 + scode; - } - } else - scode = find_keycode(params[0]); - - InputEvent ie; - ie.type = InputEvent::KEY; - ie.key.scancode = scode; - - if (params.size() == 2) { - String mods = params[1]; - if (mods.findn("C") != -1) - ie.key.mod.control = true; - if (mods.findn("A") != -1) - ie.key.mod.alt = true; - if (mods.findn("S") != -1) - ie.key.mod.shift = true; - if (mods.findn("M") != -1) - ie.key.mod.meta = true; - } - value = ie; - return OK; - - } else if (id == "mbutton") { // compatibility with project.godot - - Vector<String> params; - Error err = _parse_enginecfg(p_stream, params, line, r_err_str); - if (err) - return err; - ERR_FAIL_COND_V(params.size() != 2, ERR_PARSE_ERROR); - - InputEvent ie; - ie.type = InputEvent::MOUSE_BUTTON; - ie.device = params[0].to_int(); - ie.mouse_button.button_index = params[1].to_int(); - - value = ie; - return OK; - } else if (id == "jbutton") { // compatibility with project.godot - - Vector<String> params; - Error err = _parse_enginecfg(p_stream, params, line, r_err_str); - if (err) - return err; - ERR_FAIL_COND_V(params.size() != 2, ERR_PARSE_ERROR); - InputEvent ie; - ie.type = InputEvent::JOYPAD_BUTTON; - ie.device = params[0].to_int(); - ie.joy_button.button_index = params[1].to_int(); - - value = ie; - - return OK; - } else if (id == "jaxis") { // compatibility with project.godot - - Vector<String> params; - Error err = _parse_enginecfg(p_stream, params, line, r_err_str); - if (err) - return err; - ERR_FAIL_COND_V(params.size() != 2, ERR_PARSE_ERROR); - - InputEvent ie; - ie.type = InputEvent::JOYPAD_MOTION; - ie.device = params[0].to_int(); - int axis = params[1].to_int(); - ie.joy_motion.axis = axis >> 1; - ie.joy_motion.axis_value = axis & 1 ? 1 : -1; - - value = ie; - - return OK; - } else if (id == "img") { // compatibility with project.godot - - Token token; // FIXME: no need for this declaration? the first argument in line 509 is a Token& token. - get_token(p_stream, token, line, r_err_str); - if (token.type != TK_PARENTHESIS_OPEN) { - r_err_str = "Expected '(' in old-style project.godot construct"; - return ERR_PARSE_ERROR; - } - - while (true) { - CharType c = p_stream->get_char(); - if (p_stream->is_eof()) { - r_err_str = "Unexpected EOF in old style project.godot img()"; - return ERR_PARSE_ERROR; - } - if (c == ')') - break; - } - - value = Image(); - - return OK; - } else { r_err_str = "Unexpected identifier: '" + id + "'."; return ERR_PARSE_ERROR; } - /* - VECTOR2, // 5 - RECT2, - VECTOR3, - MATRIX32, - PLANE, - QUAT, // 10 - _AABB, //sorry naming convention fail :( not like it's used often - MATRIX3, - TRANSFORM, - - // misc types - COLOR, - IMAGE, // 15 - NODE_PATH, - _RID, - OBJECT, - INPUT_EVENT, - DICTIONARY, // 20 - ARRAY, - - // arrays - RAW_ARRAY, - INT_ARRAY, - REAL_ARRAY, - STRING_ARRAY, // 25 - VECTOR2_ARRAY, - VECTOR3_ARRAY, - COLOR_ARRAY, - - VARIANT_MAX - - */ - return OK; } else if (token.type == TK_NUMBER) { @@ -1886,39 +1600,6 @@ Error VariantWriter::write(const Variant &p_variant, StoreStringFunc p_store_str p_store_string_func(p_store_string_ud, "Color( " + rtosfix(c.r) + ", " + rtosfix(c.g) + ", " + rtosfix(c.b) + ", " + rtosfix(c.a) + " )"); } break; - case Variant::IMAGE: { - - Image img = p_variant; - - if (img.empty()) { - p_store_string_func(p_store_string_ud, "Image()"); - break; - } - - String imgstr = "Image( "; - imgstr += itos(img.get_width()); - imgstr += ", " + itos(img.get_height()); - imgstr += ", " + String(img.has_mipmaps() ? "true" : "false"); - imgstr += ", " + Image::get_format_name(img.get_format()); - - String s; - - PoolVector<uint8_t> data = img.get_data(); - int len = data.size(); - PoolVector<uint8_t>::Read r = data.read(); - const uint8_t *ptr = r.ptr(); - for (int i = 0; i < len; i++) { - - if (i > 0) - s += ", "; - s += itos(ptr[i]); - } - - imgstr += ", "; - p_store_string_func(p_store_string_ud, imgstr); - p_store_string_func(p_store_string_ud, s); - p_store_string_func(p_store_string_ud, " )"); - } break; case Variant::NODE_PATH: { String str = p_variant; @@ -1956,50 +1637,7 @@ Error VariantWriter::write(const Variant &p_variant, StoreStringFunc p_store_str p_store_string_func(p_store_string_ud, res_text); } break; - case Variant::INPUT_EVENT: { - - String str = "InputEvent("; - - InputEvent ev = p_variant; - switch (ev.type) { - case InputEvent::KEY: { - - str += "KEY," + itos(ev.key.scancode); - String mod; - if (ev.key.mod.alt) - mod += "A"; - if (ev.key.mod.shift) - mod += "S"; - if (ev.key.mod.control) - mod += "C"; - if (ev.key.mod.meta) - mod += "M"; - - if (mod != String()) - str += "," + mod; - } break; - case InputEvent::MOUSE_BUTTON: { - - str += "MBUTTON," + itos(ev.mouse_button.button_index); - } break; - case InputEvent::JOYPAD_BUTTON: { - str += "JBUTTON," + itos(ev.joy_button.button_index); - - } break; - case InputEvent::JOYPAD_MOTION: { - str += "JAXIS," + itos(ev.joy_motion.axis) + "," + itos(ev.joy_motion.axis_value); - } break; - case InputEvent::NONE: { - str += "NONE"; - } break; - default: {} - } - - str += ")"; - p_store_string_func(p_store_string_ud, str); //will be added later - - } break; case Variant::DICTIONARY: { Dictionary dict = p_variant; |