From 5dbf1809c6e3e905b94b8764e99491e608122261 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Verschelde?= Date: Sun, 5 Mar 2017 16:44:50 +0100 Subject: A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code --- modules/cscript/godot_c.cpp | 1 - modules/cscript/godot_c.h | 309 +-- modules/cscript/register_types.cpp | 3 - modules/dds/register_types.cpp | 2 +- modules/dds/texture_loader_dds.cpp | 345 ++- modules/dds/texture_loader_dds.h | 9 +- modules/enet/networked_multiplayer_enet.cpp | 446 ++-- modules/enet/networked_multiplayer_enet.h | 31 +- modules/enet/register_types.cpp | 7 +- modules/etc1/image_etc.cpp | 153 +- modules/etc1/image_etc.h | 1 - modules/etc1/register_types.cpp | 2 +- modules/etc1/texture_loader_pkm.cpp | 46 +- modules/etc1/texture_loader_pkm.h | 9 +- modules/gdscript/gd_compiler.cpp | 1303 +++++----- modules/gdscript/gd_compiler.h | 144 +- modules/gdscript/gd_editor.cpp | 2016 +++++++-------- modules/gdscript/gd_function.cpp | 991 ++++---- modules/gdscript/gd_function.h | 84 +- modules/gdscript/gd_functions.cpp | 1044 ++++---- modules/gdscript/gd_functions.h | 4 +- modules/gdscript/gd_parser.cpp | 2682 ++++++++++---------- modules/gdscript/gd_parser.h | 164 +- modules/gdscript/gd_script.cpp | 1069 ++++---- modules/gdscript/gd_script.h | 270 +- modules/gdscript/gd_tokenizer.cpp | 1163 ++++----- modules/gdscript/gd_tokenizer.h | 122 +- modules/gdscript/register_types.cpp | 28 +- modules/gridmap/grid_map.cpp | 974 ++++--- modules/gridmap/grid_map.h | 88 +- modules/gridmap/grid_map_editor_plugin.cpp | 958 ++++--- modules/gridmap/grid_map_editor_plugin.h | 36 +- modules/gridmap/register_types.cpp | 4 - modules/jpg/image_loader_jpegd.cpp | 54 +- modules/jpg/image_loader_jpegd.h | 8 +- modules/jpg/register_types.cpp | 4 +- modules/openssl/stream_peer_openssl.cpp | 360 ++- modules/openssl/stream_peer_openssl.h | 50 +- modules/opus/audio_stream_opus.cpp | 222 +- modules/opus/audio_stream_opus.h | 36 +- modules/opus/register_types.cpp | 4 +- modules/pbm/bitmap_loader_pbm.cpp | 154 +- modules/pbm/bitmap_loader_pbm.h | 8 +- modules/pbm/register_types.cpp | 6 +- modules/pvr/register_types.cpp | 2 +- modules/pvr/texture_loader_pvr.cpp | 447 ++-- modules/pvr/texture_loader_pvr.h | 12 +- modules/regex/regex.cpp | 461 ++-- modules/regex/regex.h | 29 +- modules/regex/register_types.cpp | 2 - modules/squish/image_compress_squish.cpp | 53 +- modules/stb_vorbis/audio_stream_ogg_vorbis.cpp | 134 +- modules/stb_vorbis/audio_stream_ogg_vorbis.h | 31 +- modules/stb_vorbis/register_types.cpp | 1 - .../stb_vorbis/resource_importer_ogg_vorbis.cpp | 31 +- modules/stb_vorbis/resource_importer_ogg_vorbis.h | 11 +- modules/theora/register_types.cpp | 6 +- modules/theora/video_stream_theora.cpp | 458 ++-- modules/theora/video_stream_theora.h | 56 +- modules/visual_script/register_types.cpp | 26 +- modules/visual_script/visual_script.cpp | 1841 ++++++-------- modules/visual_script/visual_script.h | 435 ++-- .../visual_script/visual_script_builtin_funcs.cpp | 713 +++--- .../visual_script/visual_script_builtin_funcs.h | 20 +- modules/visual_script/visual_script_editor.cpp | 2441 ++++++++---------- modules/visual_script/visual_script_editor.h | 91 +- modules/visual_script/visual_script_expression.cpp | 1158 ++++----- modules/visual_script/visual_script_expression.h | 107 +- .../visual_script/visual_script_flow_control.cpp | 1235 ++++----- modules/visual_script/visual_script_flow_control.h | 138 +- modules/visual_script/visual_script_func_nodes.cpp | 1611 ++++++------ modules/visual_script/visual_script_func_nodes.h | 113 +- modules/visual_script/visual_script_nodes.cpp | 2142 +++++++--------- modules/visual_script/visual_script_nodes.h | 387 +-- .../visual_script/visual_script_yield_nodes.cpp | 355 ++- modules/visual_script/visual_script_yield_nodes.h | 39 +- modules/vorbis/audio_stream_ogg_vorbis.cpp | 269 +- modules/vorbis/audio_stream_ogg_vorbis.h | 35 +- modules/vorbis/register_types.cpp | 4 +- modules/webm/video_stream_webm.cpp | 55 +- modules/webm/video_stream_webm.h | 2 +- modules/webp/image_loader_webp.cpp | 103 +- modules/webp/image_loader_webp.h | 8 +- modules/webp/register_types.cpp | 4 +- 84 files changed, 13900 insertions(+), 16580 deletions(-) (limited to 'modules') diff --git a/modules/cscript/godot_c.cpp b/modules/cscript/godot_c.cpp index 85ee28d6d2..f754f2bb21 100644 --- a/modules/cscript/godot_c.cpp +++ b/modules/cscript/godot_c.cpp @@ -27,4 +27,3 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "godot_c.h" - diff --git a/modules/cscript/godot_c.h b/modules/cscript/godot_c.h index 97a63a439f..e38de1e489 100644 --- a/modules/cscript/godot_c.h +++ b/modules/cscript/godot_c.h @@ -33,7 +33,6 @@ extern "C" { #endif - #if defined(GDAPI_BUILT_IN) || !defined(WINDOWS_ENABLED) #define GDAPI #elif defined(GDAPI_EXPORTS) @@ -42,10 +41,8 @@ extern "C" { #define GDAPI __declspec(dllimport) #endif - #define GODOT_API_VERSION 1 - typedef int godot_bool; #define GODOT_FALSE 0 @@ -53,7 +50,6 @@ typedef int godot_bool; ////// Image - #define GODOT_IMAGE_FORMAT_GRAYSCALE 0 #define GODOT_IMAGE_FORMAT_INTENSITY 1 #define GODOT_IMAGE_FORMAT_GRAYSCALE_ALPHA 2 @@ -77,11 +73,11 @@ typedef int godot_bool; #define GODOT_IMAGE_FORMAT_ATC_ALPHA_EXPLICIT 20 #define GODOT_IMAGE_FORMAT_ATC_ALPHA_INTERPOLATED 21 -typedef void* godot_image; +typedef void *godot_image; godot_image GDAPI godot_image_create_empty(); -godot_image GDAPI godot_image_create(int p_width,int p_height,int p_format,int p_use_mipmaps); -godot_image GDAPI godot_image_create_with_data(int p_width,int p_height,int p_format,int p_use_mipmaps,unsigned char* p_buffer); +godot_image GDAPI godot_image_create(int p_width, int p_height, int p_format, int p_use_mipmaps); +godot_image GDAPI godot_image_create_with_data(int p_width, int p_height, int p_format, int p_use_mipmaps, unsigned char *p_buffer); int GDAPI godot_image_get_width(godot_image p_image); int GDAPI godot_image_get_height(godot_image p_image); int GDAPI godot_image_get_format(godot_image p_image); @@ -89,10 +85,9 @@ int GDAPI godot_image_get_mipmap_count(godot_image p_image); godot_image GDAPI godot_image_copy(godot_image p_image); void GDAPI godot_image_free(godot_image p_image); - ////// RID -typedef void* godot_rid; +typedef void *godot_rid; godot_rid GDAPI godot_rid_create(); godot_rid GDAPI godot_rid_copy(godot_rid p_rid); @@ -100,37 +95,36 @@ void GDAPI godot_rid_free(godot_rid p_rid); ////// Variant (forward declared) -typedef void* godot_variant; - +typedef void *godot_variant; ////// Dictionary -typedef void* godot_dictionary; +typedef void *godot_dictionary; godot_dictionary GDAPI godot_dictionary_create(); -void GDAPI godot_dictionary_has(godot_dictionary p_dictionary,godot_variant p_key); -godot_variant GDAPI godot_dictionary_get(godot_dictionary p_dictionary,godot_variant p_key); -void GDAPI godot_dictionary_insert(godot_dictionary p_dictionary,godot_variant p_key,godot_variant p_value); -void GDAPI godot_dictionary_remove(godot_dictionary p_dictionary,godot_variant p_key); +void GDAPI godot_dictionary_has(godot_dictionary p_dictionary, godot_variant p_key); +godot_variant GDAPI godot_dictionary_get(godot_dictionary p_dictionary, godot_variant p_key); +void GDAPI godot_dictionary_insert(godot_dictionary p_dictionary, godot_variant p_key, godot_variant p_value); +void GDAPI godot_dictionary_remove(godot_dictionary p_dictionary, godot_variant p_key); void GDAPI godot_dictionary_clear(godot_dictionary p_dictionary); int GDAPI godot_dictionary_get_size(godot_dictionary p_dictionary); -void GDAPI godot_dictionary_get_keys(godot_dictionary p_dictionary,godot_variant* p_keys); +void GDAPI godot_dictionary_get_keys(godot_dictionary p_dictionary, godot_variant *p_keys); godot_dictionary GDAPI godot_dictionary_copy(godot_dictionary p_dictionary); void GDAPI godot_dictionary_free(godot_dictionary p_dictionary); ////// Array -typedef void* godot_array; +typedef void *godot_array; godot_array GDAPI godot_array_create(); -godot_variant GDAPI godot_array_get(godot_array p_array,int p_index); -void GDAPI godot_array_set(godot_array p_array,int p_index,godot_variant p_value); -void GDAPI godot_array_resize(godot_array p_array,int p_size); -void GDAPI godot_array_insert(godot_array p_array,int p_position,godot_variant p_value); -void GDAPI godot_array_remove(godot_array p_array,int p_position); +godot_variant GDAPI godot_array_get(godot_array p_array, int p_index); +void GDAPI godot_array_set(godot_array p_array, int p_index, godot_variant p_value); +void GDAPI godot_array_resize(godot_array p_array, int p_size); +void GDAPI godot_array_insert(godot_array p_array, int p_position, godot_variant p_value); +void GDAPI godot_array_remove(godot_array p_array, int p_position); void GDAPI godot_array_clear(godot_array p_array); int GDAPI godot_array_get_size(godot_array p_array); -int GDAPI godot_array_find(godot_array p_array,godot_variant p_value,int p_from_pos=-1); +int GDAPI godot_array_find(godot_array p_array, godot_variant p_value, int p_from_pos = -1); godot_array GDAPI godot_array_copy(godot_array p_array); void GDAPI godot_array_free(godot_array p_array); @@ -143,9 +137,9 @@ void GDAPI godot_array_free(godot_array p_array); #define INPUT_EVENT_BUTTON_WHEEL_DOWN 5 #define INPUT_EVENT_BUTTON_WHEEL_LEFT 6 #define INPUT_EVENT_BUTTON_WHEEL_RIGHT 7 -#define INPUT_EVENT_BUTTON_MASK_LEFT (1<<(INPUT_EVENT_BUTTON_LEFT-1)) -#define INPUT_EVENT_BUTTON_MASK_RIGHT (1<<(INPUT_EVENT_BUTTON_RIGHT-1)) -#define INPUT_EVENT_BUTTON_MASK_MIDDLE (1<<(INPUT_EVENT_BUTTON_MIDDLE-1)) +#define INPUT_EVENT_BUTTON_MASK_LEFT (1 << (INPUT_EVENT_BUTTON_LEFT - 1)) +#define INPUT_EVENT_BUTTON_MASK_RIGHT (1 << (INPUT_EVENT_BUTTON_RIGHT - 1)) +#define INPUT_EVENT_BUTTON_MASK_MIDDLE (1 << (INPUT_EVENT_BUTTON_MIDDLE - 1)) #define INPUT_EVENT_TYPE_NONE 0 #define INPUT_EVENT_TYPE_KEY 1 @@ -157,8 +151,7 @@ void GDAPI godot_array_free(godot_array p_array); #define INPUT_EVENT_TYPE_SCREEN_DRAG 7 #define INPUT_EVENT_TYPE_ACTION 8 -typedef void* godot_input_event; - +typedef void *godot_input_event; godot_input_event GDAPI godot_input_event_create(); godot_input_event GDAPI godot_input_event_copy(godot_input_event p_input_event); @@ -201,7 +194,6 @@ int GDAPI godot_input_event_joypad_button_get_button_index(godot_input_event p_e godot_bool GDAPI godot_input_event_joypad_button_is_pressed(godot_input_event p_event); float GDAPI godot_input_event_joypad_button_get_pressure(godot_input_event p_event); - int GDAPI godot_input_event_screen_touch_get_index(godot_input_event p_event); int GDAPI godot_input_event_screen_touch_get_x(godot_input_event p_event); int GDAPI godot_input_event_screen_touch_get_y(godot_input_event p_event); @@ -215,49 +207,47 @@ int GDAPI godot_input_event_screen_drag_get_relative_y(godot_input_event p_event int GDAPI godot_input_event_screen_drag_get_speed_x(godot_input_event p_event); int GDAPI godot_input_event_screen_drag_get_speed_y(godot_input_event p_event); -int GDAPI godot_input_event_is_action(godot_input_event p_event,char *p_action); -int GDAPI godot_input_event_is_action_pressed(godot_input_event p_event,char *p_action); +int GDAPI godot_input_event_is_action(godot_input_event p_event, char *p_action); +int GDAPI godot_input_event_is_action_pressed(godot_input_event p_event, char *p_action); ////// ByteArray -typedef void* godot_byte_array; +typedef void *godot_byte_array; godot_byte_array GDAPI godot_byte_array_create(); godot_byte_array GDAPI godot_byte_array_copy(godot_byte_array p_byte_array); void GDAPI godot_byte_array_free(godot_byte_array p_byte_array); int GDAPI godot_byte_array_get_size(godot_byte_array p_byte_array); -unsigned char GDAPI godot_byte_array_get(godot_byte_array p_byte_array,int p_index); -void GDAPI godot_byte_array_set(godot_byte_array p_byte_array,int p_index,unsigned char p_value); -void GDAPI godot_byte_array_remove(godot_byte_array p_byte_array,int p_index); +unsigned char GDAPI godot_byte_array_get(godot_byte_array p_byte_array, int p_index); +void GDAPI godot_byte_array_set(godot_byte_array p_byte_array, int p_index, unsigned char p_value); +void GDAPI godot_byte_array_remove(godot_byte_array p_byte_array, int p_index); void GDAPI godot_byte_array_clear(godot_byte_array p_byte_array); -typedef void* godot_byte_array_lock; +typedef void *godot_byte_array_lock; godot_byte_array_lock GDAPI godot_byte_array_get_lock(godot_byte_array p_byte_array); unsigned char GDAPI *godot_byte_array_lock_get_pointer(godot_byte_array_lock p_byte_array_lock); void GDAPI godot_byte_array_lock_free(godot_byte_array_lock p_byte_array_lock); - -godot_image GDAPI godot_image_create_with_array(int p_width,int p_height,int p_format,int p_use_mipmaps,godot_array p_array); +godot_image GDAPI godot_image_create_with_array(int p_width, int p_height, int p_format, int p_use_mipmaps, godot_array p_array); godot_byte_array GDAPI godot_image_get_data(godot_image p_image); - ////// IntArray -typedef void* godot_int_array; +typedef void *godot_int_array; godot_int_array GDAPI godot_int_array_create(); godot_int_array GDAPI godot_int_array_copy(godot_int_array p_int_array); void GDAPI godot_int_array_free(godot_int_array p_int_array); int GDAPI godot_int_array_get_size(godot_int_array p_int_array); -int GDAPI godot_int_array_get(godot_int_array p_int_array,int p_index); -void GDAPI godot_int_array_set(godot_int_array p_int_array,int p_index,int p_value); -void GDAPI godot_int_array_remove(godot_int_array p_int_array,int p_index); +int GDAPI godot_int_array_get(godot_int_array p_int_array, int p_index); +void GDAPI godot_int_array_set(godot_int_array p_int_array, int p_index, int p_value); +void GDAPI godot_int_array_remove(godot_int_array p_int_array, int p_index); void GDAPI godot_int_array_clear(godot_int_array p_int_array); -typedef void* godot_int_array_lock; +typedef void *godot_int_array_lock; godot_int_array_lock GDAPI godot_int_array_get_lock(godot_int_array p_int_array); int GDAPI *godot_int_array_lock_get_pointer(godot_int_array_lock p_int_array_lock); @@ -265,44 +255,41 @@ void GDAPI godot_int_array_lock_free(godot_int_array_lock p_int_array_lock); ////// RealArray -typedef void* godot_real_array; - +typedef void *godot_real_array; godot_real_array GDAPI godot_real_array_create(); godot_real_array GDAPI godot_real_array_copy(godot_real_array p_real_array); void GDAPI godot_real_array_free(godot_real_array p_real_array); int GDAPI godot_real_array_get_size(godot_real_array p_real_array); -float GDAPI godot_real_array_get(godot_real_array p_real_array,int p_index); -void GDAPI godot_real_array_set(godot_real_array p_real_array,int p_index,float p_value); -void GDAPI godot_real_array_remove(godot_real_array p_real_array,int p_index); +float GDAPI godot_real_array_get(godot_real_array p_real_array, int p_index); +void GDAPI godot_real_array_set(godot_real_array p_real_array, int p_index, float p_value); +void GDAPI godot_real_array_remove(godot_real_array p_real_array, int p_index); void GDAPI godot_real_array_clear(godot_real_array p_real_array); -typedef void* godot_real_array_lock; +typedef void *godot_real_array_lock; godot_real_array_lock GDAPI godot_real_array_get_lock(godot_real_array p_real_array); float GDAPI *godot_real_array_lock_get_pointer(godot_real_array_lock p_real_array_lock); void GDAPI godot_real_array_lock_free(godot_real_array_lock p_real_array_lock); - ////// StringArray -typedef void* godot_string_array; - +typedef void *godot_string_array; godot_string_array GDAPI godot_string_array_create(); godot_string_array GDAPI godot_string_array_copy(godot_string_array p_string_array); void GDAPI godot_string_array_free(godot_string_array p_string_array); int GDAPI godot_string_array_get_size(godot_string_array p_string_array); -int GDAPI godot_string_array_get(godot_string_array p_string_array,int p_index,unsigned char* p_string,int p_max_len); -void GDAPI godot_string_array_set(godot_string_array p_string_array,int p_index,unsigned char *p_string); -void GDAPI godot_string_array_remove(godot_string_array p_string_array,int p_index); +int GDAPI godot_string_array_get(godot_string_array p_string_array, int p_index, unsigned char *p_string, int p_max_len); +void GDAPI godot_string_array_set(godot_string_array p_string_array, int p_index, unsigned char *p_string); +void GDAPI godot_string_array_remove(godot_string_array p_string_array, int p_index); void GDAPI godot_string_array_clear(godot_string_array p_string_array); ////// Vector2Array -typedef void* godot_vector2_array; +typedef void *godot_vector2_array; godot_vector2_array GDAPI godot_vector2_array_create(); godot_vector2_array GDAPI godot_vector2_array_copy(godot_vector2_array p_vector2_array); @@ -310,13 +297,12 @@ void GDAPI godot_vector2_array_free(godot_vector2_array p_vector2_array); int GDAPI godot_vector2_array_get_size(godot_vector2_array p_vector2_array); int GDAPI godot_vector2_array_get_stride(godot_vector2_array p_vector2_array); -void GDAPI godot_vector2_array_get(godot_vector2_array p_vector2_array,int p_index,float* p_vector2); -void GDAPI godot_vector2_array_set(godot_vector2_array p_vector2_array,int p_index,float *p_vector2); -void GDAPI godot_vector2_array_remove(godot_vector2_array p_vector2_array,int p_index); +void GDAPI godot_vector2_array_get(godot_vector2_array p_vector2_array, int p_index, float *p_vector2); +void GDAPI godot_vector2_array_set(godot_vector2_array p_vector2_array, int p_index, float *p_vector2); +void GDAPI godot_vector2_array_remove(godot_vector2_array p_vector2_array, int p_index); void GDAPI godot_vector2_array_clear(godot_vector2_array p_vector2_array); - -typedef void* godot_vector2_array_lock; +typedef void *godot_vector2_array_lock; godot_vector2_array_lock GDAPI godot_vector2_array_get_lock(godot_vector2_array p_vector2_array); float GDAPI *godot_vector2_array_lock_get_pointer(godot_vector2_array_lock p_vector2_array_lock); @@ -324,7 +310,7 @@ void GDAPI godot_vector2_array_lock_free(godot_vector2_array_lock p_vector2_arra ////// Vector3Array -typedef void* godot_vector3_array; +typedef void *godot_vector3_array; godot_vector3_array GDAPI godot_vector3_array_create(); godot_vector3_array GDAPI godot_vector3_array_copy(godot_vector3_array p_vector3_array); @@ -332,13 +318,12 @@ void GDAPI godot_vector3_array_free(godot_vector3_array p_vector3_array); int GDAPI godot_vector3_array_get_size(godot_vector3_array p_vector3_array); int GDAPI godot_vector3_array_get_stride(godot_vector3_array p_vector3_array); -void GDAPI godot_vector3_array_get(godot_vector3_array p_vector3_array,int p_index,float* p_vector3); -void GDAPI godot_vector3_array_set(godot_vector3_array p_vector3_array,int p_index,float *p_vector3); -void GDAPI godot_vector3_array_remove(godot_vector3_array p_vector3_array,int p_index); +void GDAPI godot_vector3_array_get(godot_vector3_array p_vector3_array, int p_index, float *p_vector3); +void GDAPI godot_vector3_array_set(godot_vector3_array p_vector3_array, int p_index, float *p_vector3); +void GDAPI godot_vector3_array_remove(godot_vector3_array p_vector3_array, int p_index); void GDAPI godot_vector3_array_clear(godot_vector3_array p_vector3_array); - -typedef void* godot_vector3_array_lock; +typedef void *godot_vector3_array_lock; godot_vector3_array_lock GDAPI godot_vector3_array_get_lock(godot_vector3_array p_vector3_array); float GDAPI *godot_vector3_array_lock_get_pointer(godot_vector3_array_lock p_vector3_array_lock); @@ -346,7 +331,7 @@ void GDAPI godot_vector3_array_lock_free(godot_vector3_array_lock p_vector3_arra ////// ColorArray -typedef void* godot_color_array; +typedef void *godot_color_array; godot_color_array GDAPI godot_color_array_create(); godot_color_array GDAPI godot_color_array_copy(godot_color_array p_color_array); @@ -354,19 +339,17 @@ void GDAPI godot_color_array_free(godot_color_array p_color_array); int GDAPI godot_color_array_get_size(godot_color_array p_color_array); int GDAPI godot_color_array_get_stride(godot_color_array p_color_array); -void GDAPI godot_color_array_get(godot_color_array p_color_array,int p_index,float* p_color); -void GDAPI godot_color_array_set(godot_color_array p_color_array,int p_index,float *p_color); -void GDAPI godot_color_array_remove(godot_color_array p_color_array,int p_index); +void GDAPI godot_color_array_get(godot_color_array p_color_array, int p_index, float *p_color); +void GDAPI godot_color_array_set(godot_color_array p_color_array, int p_index, float *p_color); +void GDAPI godot_color_array_remove(godot_color_array p_color_array, int p_index); void GDAPI godot_color_array_clear(godot_color_array p_color_array); - -typedef void* godot_color_array_lock; +typedef void *godot_color_array_lock; godot_color_array_lock GDAPI godot_color_array_get_lock(godot_color_array p_color_array); float GDAPI *godot_color_array_lock_get_pointer(godot_color_array_lock p_color_array_lock); void GDAPI godot_color_array_lock_free(godot_color_array_lock p_color_array_lock); - ////// Instance (forward declared) typedef void *godot_instance; @@ -409,52 +392,52 @@ godot_variant *godot_variant_new(); int GDAPI godot_variant_get_type(godot_variant p_variant); void GDAPI godot_variant_set_null(godot_variant p_variant); -void GDAPI godot_variant_set_bool(godot_variant p_variant,godot_bool p_bool); -void GDAPI godot_variant_set_int(godot_variant p_variant,int p_int); -void GDAPI godot_variant_set_float(godot_variant p_variant,int p_float); -void GDAPI godot_variant_set_string(godot_variant p_variant,char *p_string); -void GDAPI godot_variant_set_vector2(godot_variant p_variant,float *p_elems); -void GDAPI godot_variant_set_rect2(godot_variant p_variant,float *p_elems); -void GDAPI godot_variant_set_vector3(godot_variant p_variant,float *p_elems); -void GDAPI godot_variant_set_matrix32(godot_variant p_variant,float *p_elems); -void GDAPI godot_variant_set_plane(godot_variant p_variant,float *p_elems); -void GDAPI godot_variant_set_aabb(godot_variant p_variant,float *p_elems); -void GDAPI godot_variant_set_matrix3(godot_variant p_variant,float *p_elems); -void GDAPI godot_variant_set_transform(godot_variant p_variant,float *p_elems); -void GDAPI godot_variant_set_color(godot_variant p_variant,float *p_elems); -void GDAPI godot_variant_set_image(godot_variant p_variant,godot_image *p_image); -void GDAPI godot_variant_set_node_path(godot_variant p_variant,char *p_path); -void GDAPI godot_variant_set_rid(godot_variant p_variant,char *p_path); -void GDAPI godot_variant_set_instance(godot_variant p_variant,godot_instance p_instance); -void GDAPI godot_variant_set_input_event(godot_variant p_variant,godot_input_event p_instance); -void GDAPI godot_variant_set_dictionary(godot_variant p_variant,godot_dictionary p_dictionary); -void GDAPI godot_variant_set_array(godot_variant p_variant,godot_array p_array); -void GDAPI godot_variant_set_byte_array(godot_variant p_variant,godot_byte_array p_array); -void GDAPI godot_variant_set_int_array(godot_variant p_variant,godot_byte_array p_array); -void GDAPI godot_variant_set_string_array(godot_variant p_variant,godot_string_array p_array); -void GDAPI godot_variant_set_vector2_array(godot_variant p_variant,godot_vector2_array p_array); -void GDAPI godot_variant_set_vector3_array(godot_variant p_variant,godot_vector3_array p_array); -void GDAPI godot_variant_set_color_array(godot_variant p_variant,godot_color_array p_array); +void GDAPI godot_variant_set_bool(godot_variant p_variant, godot_bool p_bool); +void GDAPI godot_variant_set_int(godot_variant p_variant, int p_int); +void GDAPI godot_variant_set_float(godot_variant p_variant, int p_float); +void GDAPI godot_variant_set_string(godot_variant p_variant, char *p_string); +void GDAPI godot_variant_set_vector2(godot_variant p_variant, float *p_elems); +void GDAPI godot_variant_set_rect2(godot_variant p_variant, float *p_elems); +void GDAPI godot_variant_set_vector3(godot_variant p_variant, float *p_elems); +void GDAPI godot_variant_set_matrix32(godot_variant p_variant, float *p_elems); +void GDAPI godot_variant_set_plane(godot_variant p_variant, float *p_elems); +void GDAPI godot_variant_set_aabb(godot_variant p_variant, float *p_elems); +void GDAPI godot_variant_set_matrix3(godot_variant p_variant, float *p_elems); +void GDAPI godot_variant_set_transform(godot_variant p_variant, float *p_elems); +void GDAPI godot_variant_set_color(godot_variant p_variant, float *p_elems); +void GDAPI godot_variant_set_image(godot_variant p_variant, godot_image *p_image); +void GDAPI godot_variant_set_node_path(godot_variant p_variant, char *p_path); +void GDAPI godot_variant_set_rid(godot_variant p_variant, char *p_path); +void GDAPI godot_variant_set_instance(godot_variant p_variant, godot_instance p_instance); +void GDAPI godot_variant_set_input_event(godot_variant p_variant, godot_input_event p_instance); +void GDAPI godot_variant_set_dictionary(godot_variant p_variant, godot_dictionary p_dictionary); +void GDAPI godot_variant_set_array(godot_variant p_variant, godot_array p_array); +void GDAPI godot_variant_set_byte_array(godot_variant p_variant, godot_byte_array p_array); +void GDAPI godot_variant_set_int_array(godot_variant p_variant, godot_byte_array p_array); +void GDAPI godot_variant_set_string_array(godot_variant p_variant, godot_string_array p_array); +void GDAPI godot_variant_set_vector2_array(godot_variant p_variant, godot_vector2_array p_array); +void GDAPI godot_variant_set_vector3_array(godot_variant p_variant, godot_vector3_array p_array); +void GDAPI godot_variant_set_color_array(godot_variant p_variant, godot_color_array p_array); godot_bool GDAPI godot_variant_get_bool(godot_variant p_variant); int GDAPI godot_variant_get_int(godot_variant p_variant); float GDAPI godot_variant_get_float(godot_variant p_variant); -int GDAPI godot_variant_get_string(godot_variant p_variant,char *p_string,int p_bufsize); -void GDAPI godot_variant_get_vector2(godot_variant p_variant,float *p_elems); -void GDAPI godot_variant_get_rect2(godot_variant p_variant,float *p_elems); -void GDAPI godot_variant_get_vector3(godot_variant p_variant,float *p_elems); -void GDAPI godot_variant_get_matrix32(godot_variant p_variant,float *p_elems); -void GDAPI godot_variant_get_plane(godot_variant p_variant,float *p_elems); -void GDAPI godot_variant_get_aabb(godot_variant p_variant,float *p_elems); -void GDAPI godot_variant_get_matrix3(godot_variant p_variant,float *p_elems); -void GDAPI godot_variant_get_transform(godot_variant p_variant,float *p_elems); -void GDAPI godot_variant_get_color(godot_variant p_variant,float *p_elems); +int GDAPI godot_variant_get_string(godot_variant p_variant, char *p_string, int p_bufsize); +void GDAPI godot_variant_get_vector2(godot_variant p_variant, float *p_elems); +void GDAPI godot_variant_get_rect2(godot_variant p_variant, float *p_elems); +void GDAPI godot_variant_get_vector3(godot_variant p_variant, float *p_elems); +void GDAPI godot_variant_get_matrix32(godot_variant p_variant, float *p_elems); +void GDAPI godot_variant_get_plane(godot_variant p_variant, float *p_elems); +void GDAPI godot_variant_get_aabb(godot_variant p_variant, float *p_elems); +void GDAPI godot_variant_get_matrix3(godot_variant p_variant, float *p_elems); +void GDAPI godot_variant_get_transform(godot_variant p_variant, float *p_elems); +void GDAPI godot_variant_get_color(godot_variant p_variant, float *p_elems); godot_image GDAPI *godot_variant_get_image(godot_variant p_variant); -int GDAPI godot_variant_get_node_path(godot_variant p_variant,char *p_path, int p_bufsize); +int GDAPI godot_variant_get_node_path(godot_variant p_variant, char *p_path, int p_bufsize); godot_rid GDAPI godot_variant_get_rid(godot_variant p_variant); godot_instance GDAPI godot_variant_get_instance(godot_variant p_variant); -void GDAPI godot_variant_get_input_event(godot_variant p_variant,godot_input_event); -void GDAPI godot_variant_get_dictionary(godot_variant p_variant,godot_dictionary); +void GDAPI godot_variant_get_input_event(godot_variant p_variant, godot_input_event); +void GDAPI godot_variant_get_dictionary(godot_variant p_variant, godot_dictionary); godot_array GDAPI godot_variant_get_array(godot_variant p_variant); godot_byte_array GDAPI godot_variant_get_byte_array(godot_variant p_variant); godot_byte_array GDAPI godot_variant_get_int_array(godot_variant p_variant); @@ -463,7 +446,6 @@ godot_vector2_array GDAPI godot_variant_get_vector2_array(godot_variant p_varian godot_vector3_array GDAPI godot_variant_get_vector3_array(godot_variant p_variant); godot_color_array GDAPI godot_variant_get_color_array(godot_variant p_variant); - void GDAPI godot_variant_delete(godot_variant p_variant); ////// Class @@ -471,17 +453,16 @@ void GDAPI godot_variant_delete(godot_variant p_variant); char GDAPI **godot_class_get_list(); //get list of classes in array to array of strings, must be freed, use godot_list_free() -int GDAPI godot_class_get_base(char* p_class,char *p_base,int p_max_len); -int GDAPI godot_class_get_name(char* p_class,char *p_base,int p_max_len); - -char GDAPI **godot_class_get_method_list(char* p_class); //free with godot_list_free() -int GDAPI godot_class_method_get_argument_count(char* p_class,char *p_method); -int GDAPI godot_class_method_get_argument_type(char* p_class,char *p_method,int p_argument); -godot_variant GDAPI godot_class_method_get_argument_default_value(char* p_class,char *p_method,int p_argument); +int GDAPI godot_class_get_base(char *p_class, char *p_base, int p_max_len); +int GDAPI godot_class_get_name(char *p_class, char *p_base, int p_max_len); -char GDAPI **godot_class_get_constant_list(char* p_class); //free with godot_list_free() -int GDAPI godot_class_constant_get_value(char* p_class,char *p_constant); +char GDAPI **godot_class_get_method_list(char *p_class); //free with godot_list_free() +int GDAPI godot_class_method_get_argument_count(char *p_class, char *p_method); +int GDAPI godot_class_method_get_argument_type(char *p_class, char *p_method, int p_argument); +godot_variant GDAPI godot_class_method_get_argument_default_value(char *p_class, char *p_method, int p_argument); +char GDAPI **godot_class_get_constant_list(char *p_class); //free with godot_list_free() +int GDAPI godot_class_constant_get_value(char *p_class, char *p_constant); ////// Instance @@ -491,8 +472,8 @@ typedef int godot_call_error; #define GODOT_CALL_ERROR_WRONG_ARGUMENTS #define GODOT_CALL_ERROR_INVALID_INSTANCE -godot_instance GDAPI godot_instance_new(char* p_class); -int GDAPI godot_instance_get_class(godot_instance p_instance,char* p_class,int p_max_len); +godot_instance GDAPI godot_instance_new(char *p_class); +int GDAPI godot_instance_get_class(godot_instance p_instance, char *p_class, int p_max_len); typedef struct { char *name; @@ -501,34 +482,32 @@ typedef struct { int usage; } godot_property_info; -godot_call_error GDAPI godot_instance_call(godot_instance p_instance, char* p_method, ...); -godot_call_error GDAPI godot_instance_call_ret(godot_instance p_instance, godot_variant r_return, char* p_method, ...); -godot_bool GDAPI godot_instance_set(godot_instance p_instance, char* p_prop,godot_variant p_value); -godot_variant GDAPI godot_instance_get(godot_instance p_instance, char* p_prop); - +godot_call_error GDAPI godot_instance_call(godot_instance p_instance, char *p_method, ...); +godot_call_error GDAPI godot_instance_call_ret(godot_instance p_instance, godot_variant r_return, char *p_method, ...); +godot_bool GDAPI godot_instance_set(godot_instance p_instance, char *p_prop, godot_variant p_value); +godot_variant GDAPI godot_instance_get(godot_instance p_instance, char *p_prop); #define GODOT_PROPERTY_HINT_NONE 0 ///< no hint provided. -#define GODOT_PROPERTY_HINT_RANGE 1///< hint_text = "min,max,step,slider; //slider is optional" -#define GODOT_PROPERTY_HINT_EXP_RANGE 2///< hint_text = "min,max,step", exponential edit -#define GODOT_PROPERTY_HINT_ENUM 3///< hint_text= "val1,val2,val3,etc" -#define GODOT_PROPERTY_HINT_EXP_EASING 4/// exponential easing funciton (Math::ease) -#define GODOT_PROPERTY_HINT_LENGTH 5///< hint_text= "length" (as integer) +#define GODOT_PROPERTY_HINT_RANGE 1 ///< hint_text = "min,max,step,slider; //slider is optional" +#define GODOT_PROPERTY_HINT_EXP_RANGE 2 ///< hint_text = "min,max,step", exponential edit +#define GODOT_PROPERTY_HINT_ENUM 3 ///< hint_text= "val1,val2,val3,etc" +#define GODOT_PROPERTY_HINT_EXP_EASING 4 /// exponential easing funciton (Math::ease) +#define GODOT_PROPERTY_HINT_LENGTH 5 ///< hint_text= "length" (as integer) #define GODOT_PROPERTY_HINT_SPRITE_FRAME 6 -#define GODOT_PROPERTY_HINT_KEY_ACCEL 7///< hint_text= "length" (as integer) -#define GODOT_PROPERTY_HINT_FLAGS 8///< hint_text= "flag1,flag2,etc" (as bit flags) +#define GODOT_PROPERTY_HINT_KEY_ACCEL 7 ///< hint_text= "length" (as integer) +#define GODOT_PROPERTY_HINT_FLAGS 8 ///< hint_text= "flag1,flag2,etc" (as bit flags) #define GODOT_PROPERTY_HINT_ALL_FLAGS 9 #define GODOT_PROPERTY_HINT_FILE 10 ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc," #define GODOT_PROPERTY_HINT_DIR 11 ///< a directort path must be passed -#define GODOT_PROPERTY_HINT_GLOBAL_FILE 12///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc," +#define GODOT_PROPERTY_HINT_GLOBAL_FILE 12 ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc," #define GODOT_PROPERTY_HINT_GLOBAL_DIR 13 ///< a directort path must be passed -#define GODOT_PROPERTY_HINT_RESOURCE_TYPE 14///< a resource object type -#define GODOT_PROPERTY_HINT_MULTILINE_TEXT 15///< used for string properties that can contain multiple lines -#define GODOT_PROPERTY_HINT_COLOR_NO_ALPHA 16///< used for ignoring alpha component when editing a color +#define GODOT_PROPERTY_HINT_RESOURCE_TYPE 14 ///< a resource object type +#define GODOT_PROPERTY_HINT_MULTILINE_TEXT 15 ///< used for string properties that can contain multiple lines +#define GODOT_PROPERTY_HINT_COLOR_NO_ALPHA 16 ///< used for ignoring alpha component when editing a color #define GODOT_PROPERTY_HINT_IMAGE_COMPRESS_LOSSY 17 #define GODOT_PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS 18 #define GODOT_PROPERTY_HINT_OBJECT_ID 19 - #define GODOT_PROPERTY_USAGE_STORAGE 1 #define GODOT_PROPERTY_USAGE_EDITOR 2 #define GODOT_PROPERTY_USAGE_NETWORK 4 @@ -546,51 +525,43 @@ godot_variant GDAPI godot_instance_get(godot_instance p_instance, char* p_prop); #define GODOT_PROPERTY_USAGE_STORE_IF_NULL 16384 #define GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER 32768 -#define GODOT_PROPERTY_USAGE_DEFAULT GODOT_PROPERTY_USAGE_STORAGE|GODOT_PROPERTY_USAGE_EDITOR|GODOT_PROPERTY_USAGE_NETWORK -#define GODOT_PROPERTY_USAGE_DEFAULT_INTL GODOT_PROPERTY_USAGE_STORAGE|GODOT_PROPERTY_USAGE_EDITOR|GODOT_PROPERTY_USAGE_NETWORK|GODOT_PROPERTY_USAGE_INTERNATIONALIZED -#define GODOT_PROPERTY_USAGE_NOEDITOR GODOT_PROPERTY_USAGE_STORAGE|GODOT_PROPERTY_USAGE_NETWORK - +#define GODOT_PROPERTY_USAGE_DEFAULT GODOT_PROPERTY_USAGE_STORAGE | GODOT_PROPERTY_USAGE_EDITOR | GODOT_PROPERTY_USAGE_NETWORK +#define GODOT_PROPERTY_USAGE_DEFAULT_INTL GODOT_PROPERTY_USAGE_STORAGE | GODOT_PROPERTY_USAGE_EDITOR | GODOT_PROPERTY_USAGE_NETWORK | GODOT_PROPERTY_USAGE_INTERNATIONALIZED +#define GODOT_PROPERTY_USAGE_NOEDITOR GODOT_PROPERTY_USAGE_STORAGE | GODOT_PROPERTY_USAGE_NETWORK godot_property_info GDAPI **godot_instance_get_property_list(godot_instance p_instance); -void GDAPI godot_instance_free_property_list(godot_instance p_instance,godot_property_info** p_list); - - +void GDAPI godot_instance_free_property_list(godot_instance p_instance, godot_property_info **p_list); void GDAPI godot_list_free(char **p_name); //helper to free all the class list - ////// Script API -typedef void* (godot_script_instance_func)(godot_instance); //passed an instance, return a pointer to your userdata -typedef void (godot_script_free_func)(godot_instance,void*); //passed an instance, please free your userdata - -void GDAPI godot_script_register(char* p_base,char* p_name,godot_script_instance_func p_instance_func,godot_script_free_func p_free_func); -void GDAPI godot_script_unregister(char* p_name); +typedef void *(godot_script_instance_func)(godot_instance); //passed an instance, return a pointer to your userdata +typedef void(godot_script_free_func)(godot_instance, void *); //passed an instance, please free your userdata -typedef GDAPI godot_variant (godot_script_func)(godot_instance,void*,godot_variant*,int); //instance,userdata,arguments,argument count. Return something or NULL. Arguments must not be freed. +void GDAPI godot_script_register(char *p_base, char *p_name, godot_script_instance_func p_instance_func, godot_script_free_func p_free_func); +void GDAPI godot_script_unregister(char *p_name); +typedef GDAPI godot_variant(godot_script_func)(godot_instance, void *, godot_variant *, int); //instance,userdata,arguments,argument count. Return something or NULL. Arguments must not be freed. -void GDAPI godot_script_add_function(char* p_name,char* p_function_name,godot_script_func p_func); -void GDAPI godot_script_add_validated_function(char* p_name,char* p_function_name,godot_script_func p_func,int* p_arg_types,int p_arg_count,godot_variant* p_default_args,int p_default_arg_count); +void GDAPI godot_script_add_function(char *p_name, char *p_function_name, godot_script_func p_func); +void GDAPI godot_script_add_validated_function(char *p_name, char *p_function_name, godot_script_func p_func, int *p_arg_types, int p_arg_count, godot_variant *p_default_args, int p_default_arg_count); -typedef void (godot_set_property_func)(godot_instance,void*,godot_variant); //instance,userdata,value. Value must not be freed. -typedef godot_variant (godot_get_property_func)(godot_instance,void*); //instance,userdata. Return a value or NULL. - -void GDAPI godot_script_add_property(char* p_name,char* p_path,godot_set_property_func p_set_func,godot_get_property_func p_get_func); -void GDAPI godot_script_add_listed_property(char* p_name,char* p_path,godot_set_property_func p_set_func,godot_get_property_func p_get_func,int p_type,int p_hint,char* p_hint_string,int p_usage); +typedef void(godot_set_property_func)(godot_instance, void *, godot_variant); //instance,userdata,value. Value must not be freed. +typedef godot_variant(godot_get_property_func)(godot_instance, void *); //instance,userdata. Return a value or NULL. +void GDAPI godot_script_add_property(char *p_name, char *p_path, godot_set_property_func p_set_func, godot_get_property_func p_get_func); +void GDAPI godot_script_add_listed_property(char *p_name, char *p_path, godot_set_property_func p_set_func, godot_get_property_func p_get_func, int p_type, int p_hint, char *p_hint_string, int p_usage); ////// System Functions //using these will help Godot track how much memory is in use in debug mode void GDAPI *godot_alloc(int p_bytes); -void GDAPI *godot_realloc(void* p_ptr,int p_bytes); -void GDAPI godot_free(void* p_ptr); - +void GDAPI *godot_realloc(void *p_ptr, int p_bytes); +void GDAPI godot_free(void *p_ptr); #ifdef __cplusplus } #endif - #endif // GODOT_C_H diff --git a/modules/cscript/register_types.cpp b/modules/cscript/register_types.cpp index d2101bbd49..2477bc51e2 100644 --- a/modules/cscript/register_types.cpp +++ b/modules/cscript/register_types.cpp @@ -28,10 +28,7 @@ /*************************************************************************/ #include "register_types.h" - void register_cscript_types() { - } void unregister_cscript_types() { - } diff --git a/modules/dds/register_types.cpp b/modules/dds/register_types.cpp index 917305f543..d0eaf3f995 100644 --- a/modules/dds/register_types.cpp +++ b/modules/dds/register_types.cpp @@ -34,7 +34,7 @@ static ResourceFormatDDS *resource_loader_dds = NULL; void register_dds_types() { - resource_loader_dds = memnew( ResourceFormatDDS ); + resource_loader_dds = memnew(ResourceFormatDDS); ResourceLoader::add_resource_format_loader(resource_loader_dds); } diff --git a/modules/dds/texture_loader_dds.cpp b/modules/dds/texture_loader_dds.cpp index 600cae991e..9c976179fa 100644 --- a/modules/dds/texture_loader_dds.cpp +++ b/modules/dds/texture_loader_dds.cpp @@ -29,18 +29,17 @@ #include "texture_loader_dds.h" #include "os/file_access.h" - enum { - DDS_MAGIC=0x20534444, - DDSD_CAPS=0x00000001, - DDSD_PIXELFORMAT=0x00001000, - DDSD_PITCH=0x00000008, - DDSD_LINEARSIZE=0x00080000, - DDSD_MIPMAPCOUNT=0x00020000, - DDPF_FOURCC=0x00000004, - DDPF_ALPHAPIXELS=0x00000001, - DDPF_INDEXED=0x00000020, - DDPF_RGB=0x00000040, + DDS_MAGIC = 0x20534444, + DDSD_CAPS = 0x00000001, + DDSD_PIXELFORMAT = 0x00001000, + DDSD_PITCH = 0x00000008, + DDSD_LINEARSIZE = 0x00080000, + DDSD_MIPMAPCOUNT = 0x00020000, + DDPF_FOURCC = 0x00000004, + DDPF_ALPHAPIXELS = 0x00000001, + DDPF_INDEXED = 0x00000020, + DDPF_RGB = 0x00000040, }; enum DDSFormat { @@ -72,41 +71,39 @@ struct DDSFormatInfo { Image::Format format; }; - -static const DDSFormatInfo dds_format_info[DDS_MAX]={ - {"DXT1",true,false,4,8,Image::FORMAT_DXT1}, - {"DXT3",true,false,4,16,Image::FORMAT_DXT3}, - {"DXT5",true,false,4,16,Image::FORMAT_DXT5}, - {"ATI1",true,false,4,8,Image::FORMAT_ATI1}, - {"ATI2",true,false,4,16,Image::FORMAT_ATI2}, - {"BGRA8",false,false,1,4,Image::FORMAT_RGBA8}, - {"BGR8",false,false,1,3,Image::FORMAT_RGB8}, - {"RGBA8",false,false,1,4,Image::FORMAT_RGBA8}, - {"RGB8",false,false,1,3,Image::FORMAT_RGB8}, - {"BGR5A1",false,false,1,2,Image::FORMAT_RGBA8}, - {"BGR565",false,false,1,2,Image::FORMAT_RGB8}, - {"BGR10A2",false,false,1,4,Image::FORMAT_RGBA8}, - {"GRAYSCALE",false,false,1,1,Image::FORMAT_L8}, - {"GRAYSCALE_ALPHA",false,false,1,2,Image::FORMAT_LA8} +static const DDSFormatInfo dds_format_info[DDS_MAX] = { + { "DXT1", true, false, 4, 8, Image::FORMAT_DXT1 }, + { "DXT3", true, false, 4, 16, Image::FORMAT_DXT3 }, + { "DXT5", true, false, 4, 16, Image::FORMAT_DXT5 }, + { "ATI1", true, false, 4, 8, Image::FORMAT_ATI1 }, + { "ATI2", true, false, 4, 16, Image::FORMAT_ATI2 }, + { "BGRA8", false, false, 1, 4, Image::FORMAT_RGBA8 }, + { "BGR8", false, false, 1, 3, Image::FORMAT_RGB8 }, + { "RGBA8", false, false, 1, 4, Image::FORMAT_RGBA8 }, + { "RGB8", false, false, 1, 3, Image::FORMAT_RGB8 }, + { "BGR5A1", false, false, 1, 2, Image::FORMAT_RGBA8 }, + { "BGR565", false, false, 1, 2, Image::FORMAT_RGB8 }, + { "BGR10A2", false, false, 1, 4, Image::FORMAT_RGBA8 }, + { "GRAYSCALE", false, false, 1, 1, Image::FORMAT_L8 }, + { "GRAYSCALE_ALPHA", false, false, 1, 2, Image::FORMAT_LA8 } }; - -RES ResourceFormatDDS::load(const String &p_path, const String& p_original_path, Error *r_error) { +RES ResourceFormatDDS::load(const String &p_path, const String &p_original_path, Error *r_error) { if (r_error) - *r_error=ERR_CANT_OPEN; + *r_error = ERR_CANT_OPEN; Error err; - FileAccess *f = FileAccess::open(p_path,FileAccess::READ,&err); + FileAccess *f = FileAccess::open(p_path, FileAccess::READ, &err); if (!f) return RES(); FileAccessRef fref(f); if (r_error) - *r_error=ERR_FILE_CORRUPT; + *r_error = ERR_FILE_CORRUPT; - ERR_EXPLAIN("Unable to open DDS texture file: "+p_path); - ERR_FAIL_COND_V(err!=OK,RES()); + ERR_EXPLAIN("Unable to open DDS texture file: " + p_path); + ERR_FAIL_COND_V(err != OK, RES()); uint32_t magic = f->get_32(); uint32_t hsize = f->get_32(); @@ -118,18 +115,17 @@ RES ResourceFormatDDS::load(const String &p_path, const String& p_original_path, uint32_t mipmaps = f->get_32(); //skip 11 - for(int i=0;i<11;i++) + for (int i = 0; i < 11; i++) f->get_32(); //validate - if (magic!=DDS_MAGIC || hsize!=124 || !(flags&DDSD_PIXELFORMAT) || !(flags&DDSD_CAPS)) { + if (magic != DDS_MAGIC || hsize != 124 || !(flags & DDSD_PIXELFORMAT) || !(flags & DDSD_CAPS)) { - ERR_EXPLAIN("Invalid or Unsupported DDS texture file: "+p_path); + ERR_EXPLAIN("Invalid or Unsupported DDS texture file: " + p_path); ERR_FAIL_V(RES()); } - /* uint32_t format_size = */ f->get_32(); uint32_t format_flags = f->get_32(); uint32_t format_fourcc = f->get_32(); @@ -155,258 +151,249 @@ RES ResourceFormatDDS::load(const String &p_path, const String& p_original_path, //printf("rmask: %x gmask: %x, bmask: %x, amask: %x\n",format_red_mask,format_green_mask,format_blue_mask,format_alpha_mask); //must avoid this later - while(f->get_pos()<128) + while (f->get_pos() < 128) f->get_8(); - DDSFormat dds_format; - if (format_flags&DDPF_FOURCC && format_fourcc==0x31545844) { //'1TXD' + if (format_flags & DDPF_FOURCC && format_fourcc == 0x31545844) { //'1TXD' - dds_format=DDS_DXT1; - } else if (format_flags&DDPF_FOURCC && format_fourcc==0x33545844) { //'3TXD' + dds_format = DDS_DXT1; + } else if (format_flags & DDPF_FOURCC && format_fourcc == 0x33545844) { //'3TXD' - dds_format=DDS_DXT3; + dds_format = DDS_DXT3; - } else if (format_flags&DDPF_FOURCC && format_fourcc==0x35545844) { //'5TXD' + } else if (format_flags & DDPF_FOURCC && format_fourcc == 0x35545844) { //'5TXD' - dds_format=DDS_DXT5; - } else if (format_flags&DDPF_FOURCC && format_fourcc==0x31495441) { //'1ITA' + dds_format = DDS_DXT5; + } else if (format_flags & DDPF_FOURCC && format_fourcc == 0x31495441) { //'1ITA' - dds_format=DDS_ATI1; - } else if (format_flags&DDPF_FOURCC && format_fourcc==0x32495441) { //'2ITA' + dds_format = DDS_ATI1; + } else if (format_flags & DDPF_FOURCC && format_fourcc == 0x32495441) { //'2ITA' - dds_format=DDS_ATI2; + dds_format = DDS_ATI2; - } else if (format_flags&DDPF_RGB && format_flags&DDPF_ALPHAPIXELS && format_rgb_bits==32 && format_red_mask==0xff0000 && format_green_mask==0xff00 && format_blue_mask==0xff && format_alpha_mask==0xff000000) { + } else if (format_flags & DDPF_RGB && format_flags & DDPF_ALPHAPIXELS && format_rgb_bits == 32 && format_red_mask == 0xff0000 && format_green_mask == 0xff00 && format_blue_mask == 0xff && format_alpha_mask == 0xff000000) { - dds_format=DDS_BGRA8; - } else if (format_flags&DDPF_RGB && !(format_flags&DDPF_ALPHAPIXELS ) && format_rgb_bits==24 && format_red_mask==0xff0000 && format_green_mask==0xff00 && format_blue_mask==0xff) { + dds_format = DDS_BGRA8; + } else if (format_flags & DDPF_RGB && !(format_flags & DDPF_ALPHAPIXELS) && format_rgb_bits == 24 && format_red_mask == 0xff0000 && format_green_mask == 0xff00 && format_blue_mask == 0xff) { - dds_format=DDS_BGR8; - } else if (format_flags&DDPF_RGB && format_flags&DDPF_ALPHAPIXELS && format_rgb_bits==32 && format_red_mask==0xff && format_green_mask==0xff00 && format_blue_mask==0xff0000 && format_alpha_mask==0xff000000) { + dds_format = DDS_BGR8; + } else if (format_flags & DDPF_RGB && format_flags & DDPF_ALPHAPIXELS && format_rgb_bits == 32 && format_red_mask == 0xff && format_green_mask == 0xff00 && format_blue_mask == 0xff0000 && format_alpha_mask == 0xff000000) { - dds_format=DDS_RGBA8; - } else if (format_flags&DDPF_RGB && !(format_flags&DDPF_ALPHAPIXELS ) && format_rgb_bits==24 && format_red_mask==0xff && format_green_mask==0xff00 && format_blue_mask==0xff0000) { + dds_format = DDS_RGBA8; + } else if (format_flags & DDPF_RGB && !(format_flags & DDPF_ALPHAPIXELS) && format_rgb_bits == 24 && format_red_mask == 0xff && format_green_mask == 0xff00 && format_blue_mask == 0xff0000) { - dds_format=DDS_RGB8; + dds_format = DDS_RGB8; - } else if (format_flags&DDPF_RGB && format_flags&DDPF_ALPHAPIXELS && format_rgb_bits==16 && format_red_mask==0x00007c00 && format_green_mask==0x000003e0 && format_blue_mask==0x0000001f && format_alpha_mask==0x00008000) { + } else if (format_flags & DDPF_RGB && format_flags & DDPF_ALPHAPIXELS && format_rgb_bits == 16 && format_red_mask == 0x00007c00 && format_green_mask == 0x000003e0 && format_blue_mask == 0x0000001f && format_alpha_mask == 0x00008000) { - dds_format=DDS_BGR5A1; - } else if (format_flags&DDPF_RGB && format_flags&DDPF_ALPHAPIXELS && format_rgb_bits==32 && format_red_mask==0x3ff00000 && format_green_mask==0xffc00 && format_blue_mask==0x3ff && format_alpha_mask==0xc0000000) { + dds_format = DDS_BGR5A1; + } else if (format_flags & DDPF_RGB && format_flags & DDPF_ALPHAPIXELS && format_rgb_bits == 32 && format_red_mask == 0x3ff00000 && format_green_mask == 0xffc00 && format_blue_mask == 0x3ff && format_alpha_mask == 0xc0000000) { - dds_format=DDS_BGR10A2; - } else if (format_flags&DDPF_RGB && !(format_flags&DDPF_ALPHAPIXELS) && format_rgb_bits==16 && format_red_mask==0x0000f800 && format_green_mask==0x000007e0 && format_blue_mask==0x0000001f) { + dds_format = DDS_BGR10A2; + } else if (format_flags & DDPF_RGB && !(format_flags & DDPF_ALPHAPIXELS) && format_rgb_bits == 16 && format_red_mask == 0x0000f800 && format_green_mask == 0x000007e0 && format_blue_mask == 0x0000001f) { - dds_format=DDS_BGR565; - } else if (!(format_flags&DDPF_ALPHAPIXELS) && format_rgb_bits==8 && format_red_mask==0xff && format_green_mask==0xff && format_blue_mask==0xff) { + dds_format = DDS_BGR565; + } else if (!(format_flags & DDPF_ALPHAPIXELS) && format_rgb_bits == 8 && format_red_mask == 0xff && format_green_mask == 0xff && format_blue_mask == 0xff) { - dds_format=DDS_LUMINANCE; - } else if ((format_flags&DDPF_ALPHAPIXELS) && format_rgb_bits==16 && format_red_mask==0xff && format_green_mask==0xff && format_blue_mask==0xff && format_alpha_mask==0xff00) { + dds_format = DDS_LUMINANCE; + } else if ((format_flags & DDPF_ALPHAPIXELS) && format_rgb_bits == 16 && format_red_mask == 0xff && format_green_mask == 0xff && format_blue_mask == 0xff && format_alpha_mask == 0xff00) { - dds_format=DDS_LUMINANCE_ALPHA; - } else if (format_flags&DDPF_INDEXED && format_rgb_bits==8) { + dds_format = DDS_LUMINANCE_ALPHA; + } else if (format_flags & DDPF_INDEXED && format_rgb_bits == 8) { - dds_format=DDS_BGR565; + dds_format = DDS_BGR565; } else { - printf("unrecognized fourcc %x format_flags: %x - rgbbits %i - red_mask %x green mask %x blue mask %x alpha mask %x\n",format_fourcc,format_flags,format_rgb_bits,format_red_mask,format_green_mask,format_blue_mask,format_alpha_mask); - ERR_EXPLAIN("Unrecognized or Unsupported color layout in DDS: "+p_path); + printf("unrecognized fourcc %x format_flags: %x - rgbbits %i - red_mask %x green mask %x blue mask %x alpha mask %x\n", format_fourcc, format_flags, format_rgb_bits, format_red_mask, format_green_mask, format_blue_mask, format_alpha_mask); + ERR_EXPLAIN("Unrecognized or Unsupported color layout in DDS: " + p_path); ERR_FAIL_V(RES()); - } - if (!(flags&DDSD_MIPMAPCOUNT)) - mipmaps=1; + if (!(flags & DDSD_MIPMAPCOUNT)) + mipmaps = 1; //print_line("found format: "+String(dds_format_info[dds_format].name)); PoolVector src_data; - const DDSFormatInfo &info=dds_format_info[dds_format]; + const DDSFormatInfo &info = dds_format_info[dds_format]; uint32_t w = width; uint32_t h = height; - if (info.compressed) { //compressed bc - uint32_t size = MAX( info.divisor, w )/info.divisor * MAX( info.divisor, h )/info.divisor * info.block_size; - ERR_FAIL_COND_V( size!=pitch, RES() ); - ERR_FAIL_COND_V( !(flags&DDSD_LINEARSIZE), RES() ); + uint32_t size = MAX(info.divisor, w) / info.divisor * MAX(info.divisor, h) / info.divisor * info.block_size; + ERR_FAIL_COND_V(size != pitch, RES()); + ERR_FAIL_COND_V(!(flags & DDSD_LINEARSIZE), RES()); - for(uint32_t i=1;i>1); - h=MAX(1,h>>1); - uint32_t bsize = MAX( info.divisor, w )/info.divisor * MAX( info.divisor, h )/info.divisor * info.block_size; + w = MAX(1, w >> 1); + h = MAX(1, h >> 1); + uint32_t bsize = MAX(info.divisor, w) / info.divisor * MAX(info.divisor, h) / info.divisor * info.block_size; //printf("%i x %i - block: %i\n",w,h,bsize); - size+= bsize; + size += bsize; } src_data.resize(size); PoolVector::Write wb = src_data.write(); - f->get_buffer(wb.ptr(),size); - wb=PoolVector::Write(); + f->get_buffer(wb.ptr(), size); + wb = PoolVector::Write(); } else if (info.palette) { //indexed - ERR_FAIL_COND_V( !(flags&DDSD_PITCH), RES()); - ERR_FAIL_COND_V( format_rgb_bits!=8, RES() ); + ERR_FAIL_COND_V(!(flags & DDSD_PITCH), RES()); + ERR_FAIL_COND_V(format_rgb_bits != 8, RES()); - uint32_t size = pitch*height; - ERR_FAIL_COND_V( size != width*height * info.block_size, RES()); + uint32_t size = pitch * height; + ERR_FAIL_COND_V(size != width * height * info.block_size, RES()); - uint8_t pallete[256*4]; - f->get_buffer(pallete,256*4); + uint8_t pallete[256 * 4]; + f->get_buffer(pallete, 256 * 4); - int colsize=3; - for(int i=0;i<256;i++) { + int colsize = 3; + for (int i = 0; i < 256; i++) { - if (pallete[i*4+3]<255) - colsize=4; + if (pallete[i * 4 + 3] < 255) + colsize = 4; } int w = width; int h = height; - for(uint32_t i=1;i>1; - h=(h+1)>>1; - size+= w*h*info.block_size; + w = (w + 1) >> 1; + h = (h + 1) >> 1; + size += w * h * info.block_size; } - src_data.resize(size + 256*colsize ); + src_data.resize(size + 256 * colsize); PoolVector::Write wb = src_data.write(); - f->get_buffer(wb.ptr(),size); + f->get_buffer(wb.ptr(), size); - for(int i=0;i<256;i++) { + for (int i = 0; i < 256; i++) { - int dst_ofs = size+i*colsize; - int src_ofs = i*4; - wb[dst_ofs+0]=pallete[src_ofs+2]; - wb[dst_ofs+1]=pallete[src_ofs+1]; - wb[dst_ofs+2]=pallete[src_ofs+0]; - if (colsize==4) - wb[dst_ofs+3]=pallete[src_ofs+3]; + int dst_ofs = size + i * colsize; + int src_ofs = i * 4; + wb[dst_ofs + 0] = pallete[src_ofs + 2]; + wb[dst_ofs + 1] = pallete[src_ofs + 1]; + wb[dst_ofs + 2] = pallete[src_ofs + 0]; + if (colsize == 4) + wb[dst_ofs + 3] = pallete[src_ofs + 3]; } - - wb=PoolVector::Write(); + wb = PoolVector::Write(); } else { //uncompressed generic... - uint32_t size = width*height*info.block_size; - + uint32_t size = width * height * info.block_size; - for(uint32_t i=1;i>1; - h=(h+1)>>1; - size+= w*h*info.block_size; + w = (w + 1) >> 1; + h = (h + 1) >> 1; + size += w * h * info.block_size; } - if (dds_format==DDS_BGR565) - size=size*3/2; - else if (dds_format==DDS_BGR5A1) - size=size*2; + if (dds_format == DDS_BGR565) + size = size * 3 / 2; + else if (dds_format == DDS_BGR5A1) + size = size * 2; src_data.resize(size); PoolVector::Write wb = src_data.write(); - f->get_buffer(wb.ptr(),size); - + f->get_buffer(wb.ptr(), size); - switch(dds_format) { + switch (dds_format) { case DDS_BGR5A1: { // TO RGBA - int colcount = size/4; + int colcount = size / 4; - for(int i=colcount-1;i>=0;i--) { + for (int i = colcount - 1; i >= 0; i--) { - int src_ofs = i*2; - int dst_ofs = i*4; + int src_ofs = i * 2; + int dst_ofs = i * 4; - uint8_t a=wb[src_ofs+1]&0x80; - uint8_t b= wb[src_ofs]&0x1F; - uint8_t g= (wb[src_ofs]>>5) | ((wb[src_ofs+1]&0x3)<<3); - uint8_t r= (wb[src_ofs+1]>>2)&0x1F; - wb[dst_ofs+0]=r<<3; - wb[dst_ofs+1]=g<<3; - wb[dst_ofs+2]=b<<3; - wb[dst_ofs+3]=a?255:0; + uint8_t a = wb[src_ofs + 1] & 0x80; + uint8_t b = wb[src_ofs] & 0x1F; + uint8_t g = (wb[src_ofs] >> 5) | ((wb[src_ofs + 1] & 0x3) << 3); + uint8_t r = (wb[src_ofs + 1] >> 2) & 0x1F; + wb[dst_ofs + 0] = r << 3; + wb[dst_ofs + 1] = g << 3; + wb[dst_ofs + 2] = b << 3; + wb[dst_ofs + 3] = a ? 255 : 0; } } break; case DDS_BGR565: { - int colcount = size/3; - - for(int i=colcount-1;i>=0;i--) { + int colcount = size / 3; - int src_ofs = i*2; - int dst_ofs = i*3; + for (int i = colcount - 1; i >= 0; i--) { - uint8_t b= wb[src_ofs]&0x1F; - uint8_t g= (wb[src_ofs]>>5) | ((wb[src_ofs+1]&0x7)<<3); - uint8_t r= wb[src_ofs+1]>>3; - wb[dst_ofs+0]=r<<3; - wb[dst_ofs+1]=g<<2; - wb[dst_ofs+2]=b<<3;//b<<3; + int src_ofs = i * 2; + int dst_ofs = i * 3; + uint8_t b = wb[src_ofs] & 0x1F; + uint8_t g = (wb[src_ofs] >> 5) | ((wb[src_ofs + 1] & 0x7) << 3); + uint8_t r = wb[src_ofs + 1] >> 3; + wb[dst_ofs + 0] = r << 3; + wb[dst_ofs + 1] = g << 2; + wb[dst_ofs + 2] = b << 3; //b<<3; } } break; case DDS_BGR10A2: { // TO RGBA - int colcount = size/4; - - for(int i=colcount-1;i>=0;i--) { - - int ofs = i*4; + int colcount = size / 4; - uint32_t w32 = uint32_t(wb[ofs+0]) | (uint32_t(wb[ofs+1])<<8) | (uint32_t(wb[ofs+2])<<16) | (uint32_t(wb[ofs+3])<<24); + for (int i = colcount - 1; i >= 0; i--) { - uint8_t a= (w32&0xc0000000) >> 24; - uint8_t r= (w32&0x3ff00000) >> 22; - uint8_t g= (w32&0xffc00) >> 12; - uint8_t b= (w32&0x3ff) >> 2; + int ofs = i * 4; + uint32_t w32 = uint32_t(wb[ofs + 0]) | (uint32_t(wb[ofs + 1]) << 8) | (uint32_t(wb[ofs + 2]) << 16) | (uint32_t(wb[ofs + 3]) << 24); - wb[ofs+0]=r; - wb[ofs+1]=g; - wb[ofs+2]=b; - wb[ofs+3]=a==0xc0 ? 255 : a; //0xc0 should be opaque + uint8_t a = (w32 & 0xc0000000) >> 24; + uint8_t r = (w32 & 0x3ff00000) >> 22; + uint8_t g = (w32 & 0xffc00) >> 12; + uint8_t b = (w32 & 0x3ff) >> 2; + wb[ofs + 0] = r; + wb[ofs + 1] = g; + wb[ofs + 2] = b; + wb[ofs + 3] = a == 0xc0 ? 255 : a; //0xc0 should be opaque } } break; case DDS_BGRA8: { - int colcount = size/4; + int colcount = size / 4; - for(int i=0;i::Write(); + wb = PoolVector::Write(); } + Image img(width, height, mipmaps - 1, info.format, src_data); - Image img(width,height,mipmaps-1,info.format,src_data); - - Ref texture = memnew( ImageTexture ); + Ref texture = memnew(ImageTexture); texture->create_from_image(img); if (r_error) - *r_error=OK; - + *r_error = OK; return texture; - } void ResourceFormatDDS::get_recognized_extensions(List *p_extensions) const { @@ -471,14 +454,14 @@ void ResourceFormatDDS::get_recognized_extensions(List *p_extensions) co p_extensions->push_back("dds"); } -bool ResourceFormatDDS::handles_type(const String& p_type) const { +bool ResourceFormatDDS::handles_type(const String &p_type) const { - return ClassDB::is_parent_class(p_type,"Texture"); + return ClassDB::is_parent_class(p_type, "Texture"); } String ResourceFormatDDS::get_resource_type(const String &p_path) const { - if (p_path.get_extension().to_lower()=="dds") + if (p_path.get_extension().to_lower() == "dds") return "ImageTexture"; return ""; } diff --git a/modules/dds/texture_loader_dds.h b/modules/dds/texture_loader_dds.h index d09af680c7..c347937cd5 100644 --- a/modules/dds/texture_loader_dds.h +++ b/modules/dds/texture_loader_dds.h @@ -29,15 +29,14 @@ #ifndef TEXTURE_LOADER_DDS_H #define TEXTURE_LOADER_DDS_H -#include "scene/resources/texture.h" #include "io/resource_loader.h" +#include "scene/resources/texture.h" -class ResourceFormatDDS : public ResourceFormatLoader{ +class ResourceFormatDDS : public ResourceFormatLoader { public: - - virtual RES load(const String &p_path,const String& p_original_path="",Error *r_error=NULL); + virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL); virtual void get_recognized_extensions(List *p_extensions) const; - virtual bool handles_type(const String& p_type) const; + virtual bool handles_type(const String &p_type) const; virtual String get_resource_type(const String &p_path) const; virtual ~ResourceFormatDDS() {} diff --git a/modules/enet/networked_multiplayer_enet.cpp b/modules/enet/networked_multiplayer_enet.cpp index af555b7eb6..2dfb0b4a6a 100644 --- a/modules/enet/networked_multiplayer_enet.cpp +++ b/modules/enet/networked_multiplayer_enet.cpp @@ -26,98 +26,96 @@ /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ -#include "os/os.h" -#include "io/marshalls.h" #include "networked_multiplayer_enet.h" +#include "io/marshalls.h" +#include "os/os.h" void NetworkedMultiplayerENet::set_transfer_mode(TransferMode p_mode) { - transfer_mode=p_mode; + transfer_mode = p_mode; } -void NetworkedMultiplayerENet::set_target_peer(int p_peer){ +void NetworkedMultiplayerENet::set_target_peer(int p_peer) { - target_peer=p_peer; + target_peer = p_peer; } -int NetworkedMultiplayerENet::get_packet_peer() const{ +int NetworkedMultiplayerENet::get_packet_peer() const { - ERR_FAIL_COND_V(!active,1); - ERR_FAIL_COND_V(incoming_packets.size()==0,1); + ERR_FAIL_COND_V(!active, 1); + ERR_FAIL_COND_V(incoming_packets.size() == 0, 1); return incoming_packets.front()->get().from; - } -Error NetworkedMultiplayerENet::create_server(int p_port, int p_max_clients, int p_in_bandwidth, int p_out_bandwidth){ +Error NetworkedMultiplayerENet::create_server(int p_port, int p_max_clients, int p_in_bandwidth, int p_out_bandwidth) { - ERR_FAIL_COND_V(active,ERR_ALREADY_IN_USE); + ERR_FAIL_COND_V(active, ERR_ALREADY_IN_USE); ENetAddress address; address.host = bind_ip; address.port = p_port; - host = enet_host_create (& address /* the address to bind the server host to */, - p_max_clients /* allow up to 32 clients and/or outgoing connections */, - SYSCH_MAX /* allow up to SYSCH_MAX channels to be used */, - p_in_bandwidth /* assume any amount of incoming bandwidth */, - p_out_bandwidth /* assume any amount of outgoing bandwidth */); + host = enet_host_create(&address /* the address to bind the server host to */, + p_max_clients /* allow up to 32 clients and/or outgoing connections */, + SYSCH_MAX /* allow up to SYSCH_MAX channels to be used */, + p_in_bandwidth /* assume any amount of incoming bandwidth */, + p_out_bandwidth /* assume any amount of outgoing bandwidth */); - ERR_FAIL_COND_V(!host,ERR_CANT_CREATE); + ERR_FAIL_COND_V(!host, ERR_CANT_CREATE); _setup_compressor(); - active=true; - server=true; - refuse_connections=false; - unique_id=1; - connection_status=CONNECTION_CONNECTED; + active = true; + server = true; + refuse_connections = false; + unique_id = 1; + connection_status = CONNECTION_CONNECTED; return OK; } -Error NetworkedMultiplayerENet::create_client(const IP_Address& p_ip, int p_port, int p_in_bandwidth, int p_out_bandwidth){ +Error NetworkedMultiplayerENet::create_client(const IP_Address &p_ip, int p_port, int p_in_bandwidth, int p_out_bandwidth) { - ERR_FAIL_COND_V(active,ERR_ALREADY_IN_USE); + ERR_FAIL_COND_V(active, ERR_ALREADY_IN_USE); ERR_FAIL_COND_V(!p_ip.is_ipv4(), ERR_INVALID_PARAMETER); - host = enet_host_create (NULL /* create a client host */, - 1 /* only allow 1 outgoing connection */, - SYSCH_MAX /* allow up to SYSCH_MAX channels to be used */, - p_in_bandwidth /* 56K modem with 56 Kbps downstream bandwidth */, - p_out_bandwidth /* 56K modem with 14 Kbps upstream bandwidth */); - - ERR_FAIL_COND_V(!host,ERR_CANT_CREATE); + host = enet_host_create(NULL /* create a client host */, + 1 /* only allow 1 outgoing connection */, + SYSCH_MAX /* allow up to SYSCH_MAX channels to be used */, + p_in_bandwidth /* 56K modem with 56 Kbps downstream bandwidth */, + p_out_bandwidth /* 56K modem with 14 Kbps upstream bandwidth */); + ERR_FAIL_COND_V(!host, ERR_CANT_CREATE); _setup_compressor(); ENetAddress address; - address.host=*((uint32_t *)p_ip.get_ipv4()); - address.port=p_port; + address.host = *((uint32_t *)p_ip.get_ipv4()); + address.port = p_port; //enet_address_set_host (& address, "localhost"); //address.port = p_port; - unique_id=_gen_unique_id(); + unique_id = _gen_unique_id(); /* Initiate the connection, allocating the enough channels */ - ENetPeer *peer = enet_host_connect (host, & address, SYSCH_MAX, unique_id); + ENetPeer *peer = enet_host_connect(host, &address, SYSCH_MAX, unique_id); if (peer == NULL) { enet_host_destroy(host); - ERR_FAIL_COND_V(!peer,ERR_CANT_CREATE); + ERR_FAIL_COND_V(!peer, ERR_CANT_CREATE); } //technically safe to ignore the peer or anything else. - connection_status=CONNECTION_CONNECTING; - active=true; - server=false; - refuse_connections=false; + connection_status = CONNECTION_CONNECTING; + active = true; + server = false; + refuse_connections = false; return OK; } -void NetworkedMultiplayerENet::poll(){ +void NetworkedMultiplayerENet::poll() { ERR_FAIL_COND(!active); @@ -130,17 +128,16 @@ void NetworkedMultiplayerENet::poll(){ if (!host || !active) //might have been disconnected while emitting a notification return; - int ret = enet_host_service (host, & event, 1); + int ret = enet_host_service(host, &event, 1); - if (ret<0) { + if (ret < 0) { //error, do something? break; - } else if (ret==0) { + } else if (ret == 0) { break; } - switch (event.type) - { + switch (event.type) { case ENET_EVENT_TYPE_CONNECT: { /* Store any relevant client information here. */ @@ -150,39 +147,39 @@ void NetworkedMultiplayerENet::poll(){ } IP_Address ip; - ip.set_ipv4((uint8_t *)&(event.peer -> address.host)); + ip.set_ipv4((uint8_t *)&(event.peer->address.host)); - int *new_id = memnew( int ); + int *new_id = memnew(int); *new_id = event.data; - if (*new_id==0) { //data zero is sent by server (enet won't let you configure this). Server is always 1 - *new_id=1; + if (*new_id == 0) { //data zero is sent by server (enet won't let you configure this). Server is always 1 + *new_id = 1; } - event.peer->data=new_id; + event.peer->data = new_id; - peer_map[*new_id]=event.peer; + peer_map[*new_id] = event.peer; - connection_status=CONNECTION_CONNECTED; //if connecting, this means it connected t something! + connection_status = CONNECTION_CONNECTED; //if connecting, this means it connected t something! - emit_signal("peer_connected",*new_id); + emit_signal("peer_connected", *new_id); if (server) { //someone connected, let it know of all the peers available - for (Map::Element *E=peer_map.front();E;E=E->next()) { + for (Map::Element *E = peer_map.front(); E; E = E->next()) { - if (E->key()==*new_id) + if (E->key() == *new_id) continue; //send existing peers to new peer - ENetPacket * packet = enet_packet_create (NULL,8,ENET_PACKET_FLAG_RELIABLE); - encode_uint32(SYSMSG_ADD_PEER,&packet->data[0]); - encode_uint32(E->key(),&packet->data[4]); - enet_peer_send(event.peer,SYSCH_CONFIG,packet); + ENetPacket *packet = enet_packet_create(NULL, 8, ENET_PACKET_FLAG_RELIABLE); + encode_uint32(SYSMSG_ADD_PEER, &packet->data[0]); + encode_uint32(E->key(), &packet->data[4]); + enet_peer_send(event.peer, SYSCH_CONFIG, packet); //send the new peer to existing peers - packet = enet_packet_create (NULL,8,ENET_PACKET_FLAG_RELIABLE); - encode_uint32(SYSMSG_ADD_PEER,&packet->data[0]); - encode_uint32(*new_id,&packet->data[4]); - enet_peer_send(E->get(),SYSCH_CONFIG,packet); + packet = enet_packet_create(NULL, 8, ENET_PACKET_FLAG_RELIABLE); + encode_uint32(SYSMSG_ADD_PEER, &packet->data[0]); + encode_uint32(*new_id, &packet->data[4]); + enet_peer_send(E->get(), SYSCH_CONFIG, packet); } } else { @@ -194,9 +191,7 @@ void NetworkedMultiplayerENet::poll(){ /* Reset the peer's client information. */ - int *id = (int*)event.peer -> data; - - + int *id = (int *)event.peer->data; if (!id) { if (!server) { @@ -206,15 +201,15 @@ void NetworkedMultiplayerENet::poll(){ if (server) { //someone disconnected, let it know to everyone else - for (Map::Element *E=peer_map.front();E;E=E->next()) { + for (Map::Element *E = peer_map.front(); E; E = E->next()) { - if (E->key()==*id) + if (E->key() == *id) continue; //send the new peer to existing peers - ENetPacket* packet = enet_packet_create (NULL,8,ENET_PACKET_FLAG_RELIABLE); - encode_uint32(SYSMSG_REMOVE_PEER,&packet->data[0]); - encode_uint32(*id,&packet->data[4]); - enet_peer_send(E->get(),SYSCH_CONFIG,packet); + ENetPacket *packet = enet_packet_create(NULL, 8, ENET_PACKET_FLAG_RELIABLE); + encode_uint32(SYSMSG_REMOVE_PEER, &packet->data[0]); + encode_uint32(*id, &packet->data[4]); + enet_peer_send(E->get(), SYSCH_CONFIG, packet); } } else if (!server) { emit_signal("server_disconnected"); @@ -222,91 +217,87 @@ void NetworkedMultiplayerENet::poll(){ return; } - emit_signal("peer_disconnected",*id); + emit_signal("peer_disconnected", *id); peer_map.erase(*id); - memdelete( id ); - + memdelete(id); } - } break; case ENET_EVENT_TYPE_RECEIVE: { - - if (event.channelID==SYSCH_CONFIG) { + if (event.channelID == SYSCH_CONFIG) { //some config message - ERR_CONTINUE( event.packet->dataLength < 8); + ERR_CONTINUE(event.packet->dataLength < 8); // Only server can send config messages - ERR_CONTINUE( server ); + ERR_CONTINUE(server); int msg = decode_uint32(&event.packet->data[0]); int id = decode_uint32(&event.packet->data[4]); - switch(msg) { + switch (msg) { case SYSMSG_ADD_PEER: { - peer_map[id]=NULL; - emit_signal("peer_connected",id); + peer_map[id] = NULL; + emit_signal("peer_connected", id); } break; case SYSMSG_REMOVE_PEER: { peer_map.erase(id); - emit_signal("peer_disconnected",id); + emit_signal("peer_disconnected", id); } break; } enet_packet_destroy(event.packet); - } else if (event.channelID < SYSCH_MAX){ + } else if (event.channelID < SYSCH_MAX) { Packet packet; packet.packet = event.packet; - uint32_t *id = (uint32_t*)event.peer->data; - - ERR_CONTINUE(event.packet->dataLength<12) + uint32_t *id = (uint32_t *)event.peer->data; + ERR_CONTINUE(event.packet->dataLength < 12) uint32_t source = decode_uint32(&event.packet->data[0]); int target = decode_uint32(&event.packet->data[4]); uint32_t flags = decode_uint32(&event.packet->data[8]); - packet.from=source; + packet.from = source; if (server) { // Someone is cheating and trying to fake the source! - ERR_CONTINUE(source!=*id); + ERR_CONTINUE(source != *id); - packet.from=*id; + packet.from = *id; - if (target==0) { + if (target == 0) { //re-send the everyone but sender :| incoming_packets.push_back(packet); //and make copies for sending - for (Map::Element *E=peer_map.front();E;E=E->next()) { + for (Map::Element *E = peer_map.front(); E; E = E->next()) { - if (uint32_t(E->key())==source) //do not resend to self + if (uint32_t(E->key()) == source) //do not resend to self continue; - ENetPacket* packet2 = enet_packet_create (packet.packet->data,packet.packet->dataLength,flags); + ENetPacket *packet2 = enet_packet_create(packet.packet->data, packet.packet->dataLength, flags); - enet_peer_send(E->get(),event.channelID,packet2); + enet_peer_send(E->get(), event.channelID, packet2); } - } else if (target<0) { + } else if (target < 0) { //to all but one //and make copies for sending - for (Map::Element *E=peer_map.front();E;E=E->next()) { + for (Map::Element *E = peer_map.front(); E; E = E->next()) { - if (uint32_t(E->key())==source || E->key()==-target) //do not resend to self, also do not send to excluded + if (uint32_t(E->key()) == source || E->key() == -target) //do not resend to self, also do not send to excluded continue; - ENetPacket* packet2 = enet_packet_create (packet.packet->data,packet.packet->dataLength,flags); + ENetPacket *packet2 = enet_packet_create(packet.packet->data, packet.packet->dataLength, flags); - enet_peer_send(E->get(),event.channelID,packet2); + enet_peer_send(E->get(), event.channelID, packet2); } if (-target != 1) { @@ -317,27 +308,25 @@ void NetworkedMultiplayerENet::poll(){ enet_packet_destroy(packet.packet); } - } else if (target==1) { + } else if (target == 1) { //to myself and only myself incoming_packets.push_back(packet); } else { //to someone else, specifically ERR_CONTINUE(!peer_map.has(target)); - enet_peer_send(peer_map[target],event.channelID,packet.packet); + enet_peer_send(peer_map[target], event.channelID, packet.packet); } } else { incoming_packets.push_back(packet); } - //destroy packet later.. } else { ERR_CONTINUE(true); } - - }break; + } break; case ENET_EVENT_TYPE_NONE: { //do nothing } break; @@ -346,7 +335,7 @@ void NetworkedMultiplayerENet::poll(){ } bool NetworkedMultiplayerENet::is_server() const { - ERR_FAIL_COND_V(!active,false); + ERR_FAIL_COND_V(!active, false); return server; } @@ -358,115 +347,112 @@ void NetworkedMultiplayerENet::close_connection() { _pop_current_packet(); - bool peers_disconnected=false; - for (Map::Element *E=peer_map.front();E;E=E->next()) { + bool peers_disconnected = false; + for (Map::Element *E = peer_map.front(); E; E = E->next()) { if (E->get()) { - enet_peer_disconnect_now(E->get(),unique_id); - peers_disconnected=true; + enet_peer_disconnect_now(E->get(), unique_id); + peers_disconnected = true; } } if (peers_disconnected) { enet_host_flush(host); OS::get_singleton()->delay_usec(100); //wait 100ms for disconnection packets to send - } enet_host_destroy(host); - active=false; + active = false; incoming_packets.clear(); - unique_id=1; //server is 1 - connection_status=CONNECTION_DISCONNECTED; + unique_id = 1; //server is 1 + connection_status = CONNECTION_DISCONNECTED; } int NetworkedMultiplayerENet::get_available_packet_count() const { return incoming_packets.size(); } -Error NetworkedMultiplayerENet::get_packet(const uint8_t **r_buffer,int &r_buffer_size) const{ +Error NetworkedMultiplayerENet::get_packet(const uint8_t **r_buffer, int &r_buffer_size) const { - ERR_FAIL_COND_V(incoming_packets.size()==0,ERR_UNAVAILABLE); + ERR_FAIL_COND_V(incoming_packets.size() == 0, ERR_UNAVAILABLE); _pop_current_packet(); current_packet = incoming_packets.front()->get(); incoming_packets.pop_front(); - *r_buffer=(const uint8_t*)(¤t_packet.packet->data[12]); - r_buffer_size=current_packet.packet->dataLength-12; + *r_buffer = (const uint8_t *)(¤t_packet.packet->data[12]); + r_buffer_size = current_packet.packet->dataLength - 12; return OK; } -Error NetworkedMultiplayerENet::put_packet(const uint8_t *p_buffer,int p_buffer_size){ +Error NetworkedMultiplayerENet::put_packet(const uint8_t *p_buffer, int p_buffer_size) { - ERR_FAIL_COND_V(!active,ERR_UNCONFIGURED); - ERR_FAIL_COND_V(connection_status!=CONNECTION_CONNECTED,ERR_UNCONFIGURED); + ERR_FAIL_COND_V(!active, ERR_UNCONFIGURED); + ERR_FAIL_COND_V(connection_status != CONNECTION_CONNECTED, ERR_UNCONFIGURED); - int packet_flags=0; - int channel=SYSCH_RELIABLE; + int packet_flags = 0; + int channel = SYSCH_RELIABLE; - switch(transfer_mode) { + switch (transfer_mode) { case TRANSFER_MODE_UNRELIABLE: { - packet_flags=ENET_PACKET_FLAG_UNSEQUENCED; - channel=SYSCH_UNRELIABLE; + packet_flags = ENET_PACKET_FLAG_UNSEQUENCED; + channel = SYSCH_UNRELIABLE; } break; case TRANSFER_MODE_UNRELIABLE_ORDERED: { - packet_flags=0; - channel=SYSCH_UNRELIABLE; + packet_flags = 0; + channel = SYSCH_UNRELIABLE; } break; case TRANSFER_MODE_RELIABLE: { - packet_flags=ENET_PACKET_FLAG_RELIABLE; - channel=SYSCH_RELIABLE; + packet_flags = ENET_PACKET_FLAG_RELIABLE; + channel = SYSCH_RELIABLE; } break; } - Map::Element *E=NULL; + Map::Element *E = NULL; - if (target_peer!=0) { + if (target_peer != 0) { E = peer_map.find(ABS(target_peer)); if (!E) { - ERR_EXPLAIN("Invalid Target Peer: "+itos(target_peer)); + ERR_EXPLAIN("Invalid Target Peer: " + itos(target_peer)); ERR_FAIL_V(ERR_INVALID_PARAMETER); } } - ENetPacket * packet = enet_packet_create (NULL,p_buffer_size+12,packet_flags); - encode_uint32(unique_id,&packet->data[0]); //source ID - encode_uint32(target_peer,&packet->data[4]); //dest ID - encode_uint32(packet_flags,&packet->data[8]); //dest ID - copymem(&packet->data[12],p_buffer,p_buffer_size); + ENetPacket *packet = enet_packet_create(NULL, p_buffer_size + 12, packet_flags); + encode_uint32(unique_id, &packet->data[0]); //source ID + encode_uint32(target_peer, &packet->data[4]); //dest ID + encode_uint32(packet_flags, &packet->data[8]); //dest ID + copymem(&packet->data[12], p_buffer, p_buffer_size); if (server) { - if (target_peer==0) { - enet_host_broadcast(host,channel,packet); - } else if (target_peer<0) { + if (target_peer == 0) { + enet_host_broadcast(host, channel, packet); + } else if (target_peer < 0) { //send to all but one //and make copies for sending - int exclude=-target_peer; + int exclude = -target_peer; - for (Map::Element *F=peer_map.front();F;F=F->next()) { + for (Map::Element *F = peer_map.front(); F; F = F->next()) { - if (F->key()==exclude) // exclude packet + if (F->key() == exclude) // exclude packet continue; - ENetPacket* packet2 = enet_packet_create (packet->data,packet->dataLength,packet_flags); + ENetPacket *packet2 = enet_packet_create(packet->data, packet->dataLength, packet_flags); - enet_peer_send(F->get(),channel,packet2); + enet_peer_send(F->get(), channel, packet2); } enet_packet_destroy(packet); //original packet no longer needed } else { - enet_peer_send (E->get(), channel, packet); - + enet_peer_send(E->get(), channel, packet); } } else { - ERR_FAIL_COND_V(!peer_map.has(1),ERR_BUG); - enet_peer_send (peer_map[1], channel, packet); //send to server for broadcast.. - + ERR_FAIL_COND_V(!peer_map.has(1), ERR_BUG); + enet_peer_send(peer_map[1], channel, packet); //send to server for broadcast.. } enet_host_flush(host); @@ -476,17 +462,16 @@ Error NetworkedMultiplayerENet::put_packet(const uint8_t *p_buffer,int p_buffer_ int NetworkedMultiplayerENet::get_max_packet_size() const { - return 1<<24; //anything is good + return 1 << 24; //anything is good } void NetworkedMultiplayerENet::_pop_current_packet() const { if (current_packet.packet) { enet_packet_destroy(current_packet.packet); - current_packet.packet=NULL; - current_packet.from=0; + current_packet.packet = NULL; + current_packet.from = 0; } - } NetworkedMultiplayerPeer::ConnectionStatus NetworkedMultiplayerENet::get_connection_status() const { @@ -498,24 +483,24 @@ uint32_t NetworkedMultiplayerENet::_gen_unique_id() const { uint32_t hash = 0; - while (hash==0 || hash==1) { + while (hash == 0 || hash == 1) { hash = hash_djb2_one_32( - (uint32_t)OS::get_singleton()->get_ticks_usec() ); + (uint32_t)OS::get_singleton()->get_ticks_usec()); hash = hash_djb2_one_32( - (uint32_t)OS::get_singleton()->get_unix_time(), hash ); + (uint32_t)OS::get_singleton()->get_unix_time(), hash); hash = hash_djb2_one_32( - (uint32_t)OS::get_singleton()->get_data_dir().hash64(), hash ); + (uint32_t)OS::get_singleton()->get_data_dir().hash64(), hash); /* hash = hash_djb2_one_32( (uint32_t)OS::get_singleton()->get_unique_ID().hash64(), hash ); */ hash = hash_djb2_one_32( - (uint32_t)((uint64_t)this), hash ); //rely on aslr heap + (uint32_t)((uint64_t)this), hash); //rely on aslr heap hash = hash_djb2_one_32( - (uint32_t)((uint64_t)&hash), hash ); //rely on aslr stack + (uint32_t)((uint64_t)&hash), hash); //rely on aslr stack - hash=hash&0x7FFFFFFF; // make it compatible with unsigned, since negatie id is used for exclusion + hash = hash & 0x7FFFFFFF; // make it compatible with unsigned, since negatie id is used for exclusion } return hash; @@ -523,13 +508,13 @@ uint32_t NetworkedMultiplayerENet::_gen_unique_id() const { int NetworkedMultiplayerENet::get_unique_id() const { - ERR_FAIL_COND_V(!active,0); + ERR_FAIL_COND_V(!active, 0); return unique_id; } void NetworkedMultiplayerENet::set_refuse_new_connections(bool p_enable) { - refuse_connections=p_enable; + refuse_connections = p_enable; } bool NetworkedMultiplayerENet::is_refusing_new_connections() const { @@ -539,79 +524,78 @@ bool NetworkedMultiplayerENet::is_refusing_new_connections() const { void NetworkedMultiplayerENet::set_compression_mode(CompressionMode p_mode) { - compression_mode=p_mode; + compression_mode = p_mode; } -NetworkedMultiplayerENet::CompressionMode NetworkedMultiplayerENet::get_compression_mode() const{ +NetworkedMultiplayerENet::CompressionMode NetworkedMultiplayerENet::get_compression_mode() const { return compression_mode; } -size_t NetworkedMultiplayerENet::enet_compress(void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit) { +size_t NetworkedMultiplayerENet::enet_compress(void *context, const ENetBuffer *inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 *outData, size_t outLimit) { - NetworkedMultiplayerENet *enet = (NetworkedMultiplayerENet*)(context); + NetworkedMultiplayerENet *enet = (NetworkedMultiplayerENet *)(context); - if (size_t(enet->src_compressor_mem.size())src_compressor_mem.resize( inLimit ); + if (size_t(enet->src_compressor_mem.size()) < inLimit) { + enet->src_compressor_mem.resize(inLimit); } int total = inLimit; - int ofs=0; - while(total) { - for(size_t i=0;isrc_compressor_mem[ofs],inBuffers[i].data,to_copy); - ofs+=to_copy; - total-=to_copy; + int ofs = 0; + while (total) { + for (size_t i = 0; i < inBufferCount; i++) { + int to_copy = MIN(total, int(inBuffers[i].dataLength)); + copymem(&enet->src_compressor_mem[ofs], inBuffers[i].data, to_copy); + ofs += to_copy; + total -= to_copy; } } Compression::Mode mode; - switch(enet->compression_mode) { + switch (enet->compression_mode) { case COMPRESS_FASTLZ: { - mode=Compression::MODE_FASTLZ; + mode = Compression::MODE_FASTLZ; } break; case COMPRESS_ZLIB: { - mode=Compression::MODE_DEFLATE; + mode = Compression::MODE_DEFLATE; } break; default: { ERR_FAIL_V(0); } } - int req_size = Compression::get_max_compressed_buffer_size(ofs,mode); - if (enet->dst_compressor_mem.size()dst_compressor_mem.size() < req_size) { enet->dst_compressor_mem.resize(req_size); } - int ret=Compression::compress(enet->dst_compressor_mem.ptr(),enet->src_compressor_mem.ptr(),ofs,mode); + int ret = Compression::compress(enet->dst_compressor_mem.ptr(), enet->src_compressor_mem.ptr(), ofs, mode); - if (ret<0) + if (ret < 0) return 0; - - if (ret>int(outLimit)) + if (ret > int(outLimit)) return 0; //do not bother - copymem(outData,enet->dst_compressor_mem.ptr(),ret); + copymem(outData, enet->dst_compressor_mem.ptr(), ret); return ret; } -size_t NetworkedMultiplayerENet::enet_decompress (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit){ +size_t NetworkedMultiplayerENet::enet_decompress(void *context, const enet_uint8 *inData, size_t inLimit, enet_uint8 *outData, size_t outLimit) { - NetworkedMultiplayerENet *enet = (NetworkedMultiplayerENet*)(context); + NetworkedMultiplayerENet *enet = (NetworkedMultiplayerENet *)(context); int ret = -1; - switch(enet->compression_mode) { + switch (enet->compression_mode) { case COMPRESS_FASTLZ: { - ret=Compression::decompress(outData,outLimit,inData,inLimit,Compression::MODE_FASTLZ); + ret = Compression::decompress(outData, outLimit, inData, inLimit, Compression::MODE_FASTLZ); } break; case COMPRESS_ZLIB: { - ret=Compression::decompress(outData,outLimit,inData,inLimit,Compression::MODE_DEFLATE); + ret = Compression::decompress(outData, outLimit, inData, inLimit, Compression::MODE_DEFLATE); } break; default: {} } - if (ret<0) { + if (ret < 0) { return 0; } else { return ret; @@ -620,11 +604,11 @@ size_t NetworkedMultiplayerENet::enet_decompress (void * context, const enet_uin void NetworkedMultiplayerENet::_setup_compressor() { - switch(compression_mode) { + switch (compression_mode) { case COMPRESS_NONE: { - enet_host_compress(host,NULL); + enet_host_compress(host, NULL); } break; case COMPRESS_RANGE_CODER: { enet_host_compress_with_range_coder(host); @@ -632,60 +616,58 @@ void NetworkedMultiplayerENet::_setup_compressor() { case COMPRESS_FASTLZ: case COMPRESS_ZLIB: { - enet_host_compress(host,&enet_compressor); + enet_host_compress(host, &enet_compressor); } break; } } -void NetworkedMultiplayerENet::enet_compressor_destroy(void * context){ +void NetworkedMultiplayerENet::enet_compressor_destroy(void *context) { //do none } - void NetworkedMultiplayerENet::_bind_methods() { - ClassDB::bind_method(D_METHOD("create_server","port","max_clients","in_bandwidth","out_bandwidth"),&NetworkedMultiplayerENet::create_server,DEFVAL(32),DEFVAL(0),DEFVAL(0)); - ClassDB::bind_method(D_METHOD("create_client","ip","port","in_bandwidth","out_bandwidth"),&NetworkedMultiplayerENet::create_client,DEFVAL(0),DEFVAL(0)); - ClassDB::bind_method(D_METHOD("close_connection"),&NetworkedMultiplayerENet::close_connection); - ClassDB::bind_method(D_METHOD("set_compression_mode","mode"),&NetworkedMultiplayerENet::set_compression_mode); - ClassDB::bind_method(D_METHOD("get_compression_mode"),&NetworkedMultiplayerENet::get_compression_mode); - ClassDB::bind_method(D_METHOD("set_bind_ip", "ip"),&NetworkedMultiplayerENet::set_bind_ip); - - BIND_CONSTANT( COMPRESS_NONE ); - BIND_CONSTANT( COMPRESS_RANGE_CODER ); - BIND_CONSTANT( COMPRESS_FASTLZ ); - BIND_CONSTANT( COMPRESS_ZLIB ); + ClassDB::bind_method(D_METHOD("create_server", "port", "max_clients", "in_bandwidth", "out_bandwidth"), &NetworkedMultiplayerENet::create_server, DEFVAL(32), DEFVAL(0), DEFVAL(0)); + ClassDB::bind_method(D_METHOD("create_client", "ip", "port", "in_bandwidth", "out_bandwidth"), &NetworkedMultiplayerENet::create_client, DEFVAL(0), DEFVAL(0)); + ClassDB::bind_method(D_METHOD("close_connection"), &NetworkedMultiplayerENet::close_connection); + ClassDB::bind_method(D_METHOD("set_compression_mode", "mode"), &NetworkedMultiplayerENet::set_compression_mode); + ClassDB::bind_method(D_METHOD("get_compression_mode"), &NetworkedMultiplayerENet::get_compression_mode); + ClassDB::bind_method(D_METHOD("set_bind_ip", "ip"), &NetworkedMultiplayerENet::set_bind_ip); + + BIND_CONSTANT(COMPRESS_NONE); + BIND_CONSTANT(COMPRESS_RANGE_CODER); + BIND_CONSTANT(COMPRESS_FASTLZ); + BIND_CONSTANT(COMPRESS_ZLIB); } - -NetworkedMultiplayerENet::NetworkedMultiplayerENet(){ - - active=false; - server=false; - refuse_connections=false; - unique_id=0; - target_peer=0; - current_packet.packet=NULL; - transfer_mode=TRANSFER_MODE_RELIABLE; - connection_status=CONNECTION_DISCONNECTED; - compression_mode=COMPRESS_NONE; - enet_compressor.context=this; - enet_compressor.compress=enet_compress; - enet_compressor.decompress=enet_decompress; - enet_compressor.destroy=enet_compressor_destroy; - - bind_ip=ENET_HOST_ANY; +NetworkedMultiplayerENet::NetworkedMultiplayerENet() { + + active = false; + server = false; + refuse_connections = false; + unique_id = 0; + target_peer = 0; + current_packet.packet = NULL; + transfer_mode = TRANSFER_MODE_RELIABLE; + connection_status = CONNECTION_DISCONNECTED; + compression_mode = COMPRESS_NONE; + enet_compressor.context = this; + enet_compressor.compress = enet_compress; + enet_compressor.decompress = enet_decompress; + enet_compressor.destroy = enet_compressor_destroy; + + bind_ip = ENET_HOST_ANY; } -NetworkedMultiplayerENet::~NetworkedMultiplayerENet(){ +NetworkedMultiplayerENet::~NetworkedMultiplayerENet() { close_connection(); } // sets IP for ENet to bind when using create_server // if no IP is set, then ENet bind to ENET_HOST_ANY -void NetworkedMultiplayerENet::set_bind_ip(const IP_Address& p_ip){ +void NetworkedMultiplayerENet::set_bind_ip(const IP_Address &p_ip) { ERR_FAIL_COND(!p_ip.is_ipv4()); - bind_ip=*(uint32_t *)p_ip.get_ipv4(); + bind_ip = *(uint32_t *)p_ip.get_ipv4(); } diff --git a/modules/enet/networked_multiplayer_enet.h b/modules/enet/networked_multiplayer_enet.h index dcf8c2429b..4e95adec10 100644 --- a/modules/enet/networked_multiplayer_enet.h +++ b/modules/enet/networked_multiplayer_enet.h @@ -29,13 +29,13 @@ #ifndef NETWORKED_MULTIPLAYER_ENET_H #define NETWORKED_MULTIPLAYER_ENET_H -#include "io/networked_multiplayer_peer.h" #include "enet/enet.h" #include "io/compression.h" +#include "io/networked_multiplayer_peer.h" class NetworkedMultiplayerENet : public NetworkedMultiplayerPeer { - GDCLASS(NetworkedMultiplayerENet,NetworkedMultiplayerPeer) + GDCLASS(NetworkedMultiplayerENet, NetworkedMultiplayerPeer) public: enum CompressionMode { COMPRESS_NONE, @@ -43,9 +43,8 @@ public: COMPRESS_FASTLZ, COMPRESS_ZLIB }; -private: - +private: enum { SYSMSG_ADD_PEER, SYSMSG_REMOVE_PEER @@ -74,7 +73,7 @@ private: ConnectionStatus connection_status; - Map peer_map; + Map peer_map; struct Packet { @@ -95,25 +94,24 @@ private: Vector dst_compressor_mem; ENetCompressor enet_compressor; - static size_t enet_compress(void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit); - static size_t enet_decompress (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit); - static void enet_compressor_destroy(void * context); + static size_t enet_compress(void *context, const ENetBuffer *inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 *outData, size_t outLimit); + static size_t enet_decompress(void *context, const enet_uint8 *inData, size_t inLimit, enet_uint8 *outData, size_t outLimit); + static void enet_compressor_destroy(void *context); void _setup_compressor(); enet_uint32 bind_ip; + protected: static void _bind_methods(); -public: +public: virtual void set_transfer_mode(TransferMode p_mode); virtual void set_target_peer(int p_peer); - virtual int get_packet_peer() const; - - Error create_server(int p_port, int p_max_peers=32, int p_in_bandwidth=0, int p_out_bandwidth=0); - Error create_client(const IP_Address& p_ip, int p_port, int p_in_bandwidth=0, int p_out_bandwidth=0); + Error create_server(int p_port, int p_max_peers = 32, int p_in_bandwidth = 0, int p_out_bandwidth = 0); + Error create_client(const IP_Address &p_ip, int p_port, int p_in_bandwidth = 0, int p_out_bandwidth = 0); void close_connection(); @@ -122,8 +120,8 @@ public: virtual bool is_server() const; virtual int get_available_packet_count() const; - virtual Error get_packet(const uint8_t **r_buffer,int &r_buffer_size) const; ///< buffer is GONE after next get_packet - virtual Error put_packet(const uint8_t *p_buffer,int p_buffer_size); + virtual Error get_packet(const uint8_t **r_buffer, int &r_buffer_size) const; ///< buffer is GONE after next get_packet + virtual Error put_packet(const uint8_t *p_buffer, int p_buffer_size); virtual int get_max_packet_size() const; @@ -140,10 +138,9 @@ public: NetworkedMultiplayerENet(); ~NetworkedMultiplayerENet(); - void set_bind_ip(const IP_Address& p_ip); + void set_bind_ip(const IP_Address &p_ip); }; VARIANT_ENUM_CAST(NetworkedMultiplayerENet::CompressionMode); - #endif // NETWORKED_MULTIPLAYER_ENET_H diff --git a/modules/enet/register_types.cpp b/modules/enet/register_types.cpp index 2b4dd35d33..0dea038520 100644 --- a/modules/enet/register_types.cpp +++ b/modules/enet/register_types.cpp @@ -30,14 +30,14 @@ #include "error_macros.h" #include "networked_multiplayer_enet.h" -static bool enet_ok=false; +static bool enet_ok = false; void register_enet_types() { - if (enet_initialize() !=0 ) { + if (enet_initialize() != 0) { ERR_PRINT("ENet initialization failure"); } else { - enet_ok=true; + enet_ok = true; } ClassDB::register_class(); @@ -47,5 +47,4 @@ void unregister_enet_types() { if (enet_ok) enet_deinitialize(); - } diff --git a/modules/etc1/image_etc.cpp b/modules/etc1/image_etc.cpp index 2d883bff0f..642ec027f3 100644 --- a/modules/etc1/image_etc.cpp +++ b/modules/etc1/image_etc.cpp @@ -28,175 +28,154 @@ /*************************************************************************/ #include "image_etc.h" #include "image.h" -#include "rg_etc1.h" -#include "print_string.h" #include "os/copymem.h" +#include "print_string.h" +#include "rg_etc1.h" static void _decompress_etc(Image *p_img) { - ERR_FAIL_COND(p_img->get_format()!=Image::FORMAT_ETC); + ERR_FAIL_COND(p_img->get_format() != Image::FORMAT_ETC); int imgw = p_img->get_width(); int imgh = p_img->get_height(); - PoolVector src=p_img->get_data(); + PoolVector src = p_img->get_data(); PoolVector dst; PoolVector::Read r = src.read(); - int mmc=p_img->get_mipmap_count(); + int mmc = p_img->get_mipmap_count(); + for (int i = 0; i <= mmc; i++) { - for(int i=0;i<=mmc;i++) { - - dst.resize(dst.size()+imgw*imgh*3); - const uint8_t *srcbr=&r[p_img->get_mipmap_offset(i)]; + dst.resize(dst.size() + imgw * imgh * 3); + const uint8_t *srcbr = &r[p_img->get_mipmap_offset(i)]; PoolVector::Write w = dst.write(); - uint8_t *wptr = &w[dst.size()-imgw*imgh*3]; - - int bw=MAX(imgw/4,1); - int bh=MAX(imgh/4,1); - - for(int y=0;y::Read(); + r = PoolVector::Read(); //print_line("Re Creating ETC into regular image: w "+itos(p_img->get_width())+" h "+itos(p_img->get_height())+" mm "+itos(p_img->get_mipmaps())); - *p_img=Image(p_img->get_width(),p_img->get_height(),p_img->has_mipmaps(),Image::FORMAT_RGB8,dst); + *p_img = Image(p_img->get_width(), p_img->get_height(), p_img->has_mipmaps(), Image::FORMAT_RGB8, dst); if (p_img->has_mipmaps()) p_img->generate_mipmaps(); - - } static void _compress_etc(Image *p_img) { Image img = *p_img; - int imgw=img.get_width(),imgh=img.get_height(); + int imgw = img.get_width(), imgh = img.get_height(); - ERR_FAIL_COND( nearest_power_of_2(imgw)!=imgw || nearest_power_of_2(imgh)!=imgh ); + ERR_FAIL_COND(nearest_power_of_2(imgw) != imgw || nearest_power_of_2(imgh) != imgh); - if (img.get_format()!=Image::FORMAT_RGB8) + if (img.get_format() != Image::FORMAT_RGB8) img.convert(Image::FORMAT_RGB8); - PoolVector res_data; PoolVector dst_data; PoolVector::Read r = img.get_data().read(); - int target_size = Image::get_image_data_size(p_img->get_width(),p_img->get_height(),Image::FORMAT_ETC,p_img->has_mipmaps()?-1:0); - int mmc = p_img->has_mipmaps() ? Image::get_image_required_mipmaps(p_img->get_width(),p_img->get_height(),Image::FORMAT_ETC) : 0; + int target_size = Image::get_image_data_size(p_img->get_width(), p_img->get_height(), Image::FORMAT_ETC, p_img->has_mipmaps() ? -1 : 0); + int mmc = p_img->has_mipmaps() ? Image::get_image_required_mipmaps(p_img->get_width(), p_img->get_height(), Image::FORMAT_ETC) : 0; dst_data.resize(target_size); - int mc=0; - int ofs=0; - PoolVector::Write w=dst_data.write(); - + int mc = 0; + int ofs = 0; + PoolVector::Write w = dst_data.write(); rg_etc1::etc1_pack_params pp; - pp.m_quality=rg_etc1::cLowQuality; - for(int i=0;i<=mmc;i++) { - + pp.m_quality = rg_etc1::cLowQuality; + for (int i = 0; i <= mmc; i++) { - int bw=MAX(imgw/4,1); - int bh=MAX(imgh/4,1); + int bw = MAX(imgw / 4, 1); + int bh = MAX(imgh / 4, 1); const uint8_t *src = &r[img.get_mipmap_offset(i)]; - int mmsize = MAX(bw,1)*MAX(bh,1)*8; + int mmsize = MAX(bw, 1) * MAX(bh, 1) * 8; uint8_t *dst = &w[ofs]; - ofs+=mmsize; - + ofs += mmsize; //print_line("bh: "+itos(bh)+" bw: "+itos(bw)); - for(int y=0;yget_width(),p_img->get_height(),(mc-1)?true:false,Image::FORMAT_ETC,dst_data); - - + *p_img = Image(p_img->get_width(), p_img->get_height(), (mc - 1) ? true : false, Image::FORMAT_ETC, dst_data); } void _register_etc1_compress_func() { rg_etc1::pack_etc1_block_init(); - Image::_image_compress_etc_func=_compress_etc; - Image::_image_decompress_etc=_decompress_etc; - - + Image::_image_compress_etc_func = _compress_etc; + Image::_image_decompress_etc = _decompress_etc; } diff --git a/modules/etc1/image_etc.h b/modules/etc1/image_etc.h index 6ab10126f8..18461819d6 100644 --- a/modules/etc1/image_etc.h +++ b/modules/etc1/image_etc.h @@ -29,7 +29,6 @@ #ifndef IMAGE_ETC1_H #define IMAGE_ETC1_H - void _register_etc1_compress_func(); #endif // IMAGE_ETC_H diff --git a/modules/etc1/register_types.cpp b/modules/etc1/register_types.cpp index d02ef83478..b3b6419d26 100644 --- a/modules/etc1/register_types.cpp +++ b/modules/etc1/register_types.cpp @@ -35,7 +35,7 @@ static ResourceFormatPKM *resource_loader_pkm = NULL; void register_etc1_types() { - resource_loader_pkm = memnew( ResourceFormatPKM ); + resource_loader_pkm = memnew(ResourceFormatPKM); ResourceLoader::add_resource_format_loader(resource_loader_pkm); _register_etc1_compress_func(); diff --git a/modules/etc1/texture_loader_pkm.cpp b/modules/etc1/texture_loader_pkm.cpp index b00e71c485..bce10e691e 100644 --- a/modules/etc1/texture_loader_pkm.cpp +++ b/modules/etc1/texture_loader_pkm.cpp @@ -32,38 +32,38 @@ #include struct ETC1Header { - char tag[6]; // "PKM 10" - uint16_t format; // Format == number of mips (== zero) - uint16_t texWidth; // Texture dimensions, multiple of 4 (big-endian) - uint16_t texHeight; - uint16_t origWidth; // Original dimensions (big-endian) - uint16_t origHeight; + char tag[6]; // "PKM 10" + uint16_t format; // Format == number of mips (== zero) + uint16_t texWidth; // Texture dimensions, multiple of 4 (big-endian) + uint16_t texHeight; + uint16_t origWidth; // Original dimensions (big-endian) + uint16_t origHeight; }; -RES ResourceFormatPKM::load(const String &p_path, const String& p_original_path, Error *r_error) { +RES ResourceFormatPKM::load(const String &p_path, const String &p_original_path, Error *r_error) { if (r_error) - *r_error=ERR_CANT_OPEN; + *r_error = ERR_CANT_OPEN; Error err; - FileAccess *f = FileAccess::open(p_path,FileAccess::READ,&err); + FileAccess *f = FileAccess::open(p_path, FileAccess::READ, &err); if (!f) return RES(); FileAccessRef fref(f); if (r_error) - *r_error=ERR_FILE_CORRUPT; + *r_error = ERR_FILE_CORRUPT; - ERR_EXPLAIN("Unable to open PKM texture file: "+p_path); - ERR_FAIL_COND_V(err!=OK,RES()); + ERR_EXPLAIN("Unable to open PKM texture file: " + p_path); + ERR_FAIL_COND_V(err != OK, RES()); // big endian f->set_endian_swap(true); ETC1Header h; - ERR_EXPLAIN("Invalid or Unsupported PKM texture file: "+p_path); - f->get_buffer((uint8_t *) &h.tag, sizeof(h.tag)); - if(strncmp(h.tag, "PKM 10", sizeof(h.tag))) + ERR_EXPLAIN("Invalid or Unsupported PKM texture file: " + p_path); + f->get_buffer((uint8_t *)&h.tag, sizeof(h.tag)); + if (strncmp(h.tag, "PKM 10", sizeof(h.tag))) ERR_FAIL_V(RES()); h.format = f->get_16(); @@ -77,20 +77,20 @@ RES ResourceFormatPKM::load(const String &p_path, const String& p_original_path, uint32_t size = h.texWidth * h.texHeight / 2; src_data.resize(size); PoolVector::Write wb = src_data.write(); - f->get_buffer(wb.ptr(),size); - wb=PoolVector::Write(); + f->get_buffer(wb.ptr(), size); + wb = PoolVector::Write(); int mipmaps = h.format; int width = h.origWidth; int height = h.origHeight; - Image img(width,height,mipmaps,Image::FORMAT_ETC,src_data); + Image img(width, height, mipmaps, Image::FORMAT_ETC, src_data); - Ref texture = memnew( ImageTexture ); + Ref texture = memnew(ImageTexture); texture->create_from_image(img); if (r_error) - *r_error=OK; + *r_error = OK; return texture; } @@ -100,14 +100,14 @@ void ResourceFormatPKM::get_recognized_extensions(List *p_extensions) co p_extensions->push_back("pkm"); } -bool ResourceFormatPKM::handles_type(const String& p_type) const { +bool ResourceFormatPKM::handles_type(const String &p_type) const { - return ClassDB::is_parent_class(p_type,"Texture"); + return ClassDB::is_parent_class(p_type, "Texture"); } String ResourceFormatPKM::get_resource_type(const String &p_path) const { - if (p_path.get_extension().to_lower()=="pkm") + if (p_path.get_extension().to_lower() == "pkm") return "ImageTexture"; return ""; } diff --git a/modules/etc1/texture_loader_pkm.h b/modules/etc1/texture_loader_pkm.h index 9be7b051d3..19d15d21fc 100644 --- a/modules/etc1/texture_loader_pkm.h +++ b/modules/etc1/texture_loader_pkm.h @@ -29,15 +29,14 @@ #ifndef TEXTURE_LOADER_PKM_H #define TEXTURE_LOADER_PKM_H -#include "scene/resources/texture.h" #include "io/resource_loader.h" +#include "scene/resources/texture.h" -class ResourceFormatPKM : public ResourceFormatLoader{ +class ResourceFormatPKM : public ResourceFormatLoader { public: - - virtual RES load(const String &p_path,const String& p_original_path="",Error *r_error=NULL); + virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL); virtual void get_recognized_extensions(List *p_extensions) const; - virtual bool handles_type(const String& p_type) const; + virtual bool handles_type(const String &p_type) const; virtual String get_resource_type(const String &p_path) const; virtual ~ResourceFormatPKM() {} diff --git a/modules/gdscript/gd_compiler.cpp b/modules/gdscript/gd_compiler.cpp index 398c2cf82a..9591740438 100644 --- a/modules/gdscript/gd_compiler.cpp +++ b/modules/gdscript/gd_compiler.cpp @@ -29,53 +29,51 @@ #include "gd_compiler.h" #include "gd_script.h" -bool GDCompiler::_is_class_member_property(CodeGen & codegen, const StringName & p_name) { +bool GDCompiler::_is_class_member_property(CodeGen &codegen, const StringName &p_name) { if (!codegen.function_node || codegen.function_node->_static) return false; - return _is_class_member_property(codegen.script,p_name); + return _is_class_member_property(codegen.script, p_name); } -bool GDCompiler::_is_class_member_property(GDScript *owner, const StringName & p_name) { - +bool GDCompiler::_is_class_member_property(GDScript *owner, const StringName &p_name) { GDScript *scr = owner; - GDNativeClass *nc=NULL; - while(scr) { + GDNativeClass *nc = NULL; + while (scr) { if (scr->native.is_valid()) - nc=scr->native.ptr(); - scr=scr->_base; + nc = scr->native.ptr(); + scr = scr->_base; } - ERR_FAIL_COND_V(!nc,false); + ERR_FAIL_COND_V(!nc, false); - return ClassDB::has_property(nc->get_name(),p_name); + return ClassDB::has_property(nc->get_name(), p_name); } +void GDCompiler::_set_error(const String &p_error, const GDParser::Node *p_node) { -void GDCompiler::_set_error(const String& p_error,const GDParser::Node *p_node) { - - if (error!="") + if (error != "") return; - error=p_error; + error = p_error; if (p_node) { - err_line=p_node->line; - err_column=p_node->column; + err_line = p_node->line; + err_column = p_node->column; } else { - err_line=0; - err_column=0; + err_line = 0; + err_column = 0; } } -bool GDCompiler::_create_unary_operator(CodeGen& codegen,const GDParser::OperatorNode *on,Variant::Operator op, int p_stack_level) { +bool GDCompiler::_create_unary_operator(CodeGen &codegen, const GDParser::OperatorNode *on, Variant::Operator op, int p_stack_level) { - ERR_FAIL_COND_V(on->arguments.size()!=1,false); + ERR_FAIL_COND_V(on->arguments.size() != 1, false); - int src_address_a = _parse_expression(codegen,on->arguments[0],p_stack_level); - if (src_address_a<0) + int src_address_a = _parse_expression(codegen, on->arguments[0], p_stack_level); + if (src_address_a < 0) return false; codegen.opcodes.push_back(GDFunction::OPCODE_OPERATOR); // perform operator @@ -86,22 +84,20 @@ bool GDCompiler::_create_unary_operator(CodeGen& codegen,const GDParser::Operato return true; } -bool GDCompiler::_create_binary_operator(CodeGen& codegen,const GDParser::OperatorNode *on,Variant::Operator op, int p_stack_level,bool p_initializer) { - - ERR_FAIL_COND_V(on->arguments.size()!=2,false); +bool GDCompiler::_create_binary_operator(CodeGen &codegen, const GDParser::OperatorNode *on, Variant::Operator op, int p_stack_level, bool p_initializer) { + ERR_FAIL_COND_V(on->arguments.size() != 2, false); - int src_address_a = _parse_expression(codegen,on->arguments[0],p_stack_level,false,p_initializer); - if (src_address_a<0) + int src_address_a = _parse_expression(codegen, on->arguments[0], p_stack_level, false, p_initializer); + if (src_address_a < 0) return false; - if (src_address_a&GDFunction::ADDR_TYPE_STACK<arguments[1],p_stack_level,false,p_initializer); - if (src_address_b<0) + int src_address_b = _parse_expression(codegen, on->arguments[1], p_stack_level, false, p_initializer); + if (src_address_b < 0) return false; - codegen.opcodes.push_back(GDFunction::OPCODE_OPERATOR); // perform operator codegen.opcodes.push_back(op); //which operator codegen.opcodes.push_back(src_address_a); // argument 1 @@ -109,7 +105,6 @@ bool GDCompiler::_create_binary_operator(CodeGen& codegen,const GDParser::Operat return true; } - /* int GDCompiler::_parse_subexpression(CodeGen& codegen,const GDParser::Node *p_expression) { @@ -128,55 +123,52 @@ int GDCompiler::_parse_subexpression(CodeGen& codegen,const GDParser::Node *p_ex } */ -int GDCompiler::_parse_assign_right_expression(CodeGen& codegen,const GDParser::OperatorNode *p_expression, int p_stack_level) { +int GDCompiler::_parse_assign_right_expression(CodeGen &codegen, const GDParser::OperatorNode *p_expression, int p_stack_level) { - Variant::Operator var_op=Variant::OP_MAX; + Variant::Operator var_op = Variant::OP_MAX; + switch (p_expression->op) { - switch(p_expression->op) { - - case GDParser::OperatorNode::OP_ASSIGN_ADD: var_op=Variant::OP_ADD; break; - case GDParser::OperatorNode::OP_ASSIGN_SUB: var_op=Variant::OP_SUBSTRACT; break; - case GDParser::OperatorNode::OP_ASSIGN_MUL: var_op=Variant::OP_MULTIPLY; break; - case GDParser::OperatorNode::OP_ASSIGN_DIV: var_op=Variant::OP_DIVIDE; break; - case GDParser::OperatorNode::OP_ASSIGN_MOD: var_op=Variant::OP_MODULE; break; - case GDParser::OperatorNode::OP_ASSIGN_SHIFT_LEFT: var_op=Variant::OP_SHIFT_LEFT; break; - case GDParser::OperatorNode::OP_ASSIGN_SHIFT_RIGHT: var_op=Variant::OP_SHIFT_RIGHT; break; - case GDParser::OperatorNode::OP_ASSIGN_BIT_AND: var_op=Variant::OP_BIT_AND; break; - case GDParser::OperatorNode::OP_ASSIGN_BIT_OR: var_op=Variant::OP_BIT_OR; break; - case GDParser::OperatorNode::OP_ASSIGN_BIT_XOR: var_op=Variant::OP_BIT_XOR; break; + case GDParser::OperatorNode::OP_ASSIGN_ADD: var_op = Variant::OP_ADD; break; + case GDParser::OperatorNode::OP_ASSIGN_SUB: var_op = Variant::OP_SUBSTRACT; break; + case GDParser::OperatorNode::OP_ASSIGN_MUL: var_op = Variant::OP_MULTIPLY; break; + case GDParser::OperatorNode::OP_ASSIGN_DIV: var_op = Variant::OP_DIVIDE; break; + case GDParser::OperatorNode::OP_ASSIGN_MOD: var_op = Variant::OP_MODULE; break; + case GDParser::OperatorNode::OP_ASSIGN_SHIFT_LEFT: var_op = Variant::OP_SHIFT_LEFT; break; + case GDParser::OperatorNode::OP_ASSIGN_SHIFT_RIGHT: var_op = Variant::OP_SHIFT_RIGHT; break; + case GDParser::OperatorNode::OP_ASSIGN_BIT_AND: var_op = Variant::OP_BIT_AND; break; + case GDParser::OperatorNode::OP_ASSIGN_BIT_OR: var_op = Variant::OP_BIT_OR; break; + case GDParser::OperatorNode::OP_ASSIGN_BIT_XOR: var_op = Variant::OP_BIT_XOR; break; case GDParser::OperatorNode::OP_INIT_ASSIGN: case GDParser::OperatorNode::OP_ASSIGN: { //none } break; - default: { + default: { ERR_FAIL_V(-1); } } - bool initializer = p_expression->op==GDParser::OperatorNode::OP_INIT_ASSIGN; + bool initializer = p_expression->op == GDParser::OperatorNode::OP_INIT_ASSIGN; - if (var_op==Variant::OP_MAX) { + if (var_op == Variant::OP_MAX) { - return _parse_expression(codegen,p_expression->arguments[1],p_stack_level,false,initializer); + return _parse_expression(codegen, p_expression->arguments[1], p_stack_level, false, initializer); } - if (!_create_binary_operator(codegen,p_expression,var_op,p_stack_level,initializer)) + if (!_create_binary_operator(codegen, p_expression, var_op, p_stack_level, initializer)) return -1; - int dst_addr=(p_stack_level)|(GDFunction::ADDR_TYPE_STACK<type) { + switch (p_expression->type) { //should parse variable declaration and adjust stack accordingly... case GDParser::Node::TYPE_IDENTIFIER: { //return identifier @@ -185,16 +177,15 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre //This could be made much simpler by just indexing "self", but done this way (with custom self-addressing modes) increases peformance a lot. - const GDParser::IdentifierNode *in = static_cast(p_expression); + const GDParser::IdentifierNode *in = static_cast(p_expression); StringName identifier = in->name; - - if (_is_class_member_property(codegen,identifier)) { + if (_is_class_member_property(codegen, identifier)) { //get property codegen.opcodes.push_back(GDFunction::OPCODE_GET_MEMBER); // perform operator codegen.opcodes.push_back(codegen.get_name_map_pos(identifier)); // argument 2 (unary only takes one parameter) - int dst_addr=(p_stack_level)|(GDFunction::ADDR_TYPE_STACK<_static) { @@ -215,7 +205,7 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre if (codegen.script->member_indices.has(identifier)) { int idx = codegen.script->member_indices[identifier].index; - return idx|(GDFunction::ADDR_TYPE_MEMBER<constants.has(identifier)) { //int idx=scr->constants[identifier]; int idx = codegen.get_name_map_pos(identifier); - return idx|(GDFunction::ADDR_TYPE_CLASS_CONSTANT<native.is_valid()) - nc=scr->native.ptr(); - scr=scr->_base; + nc = scr->native.ptr(); + scr = scr->_base; } // CLASS C++ Integer Constant if (nc) { - bool success=false; - int constant = ClassDB::get_integer_constant(nc->get_name(),identifier,&success); + bool success = false; + int constant = ClassDB::get_integer_constant(nc->get_name(), identifier, &success); if (success) { - Variant key=constant; + Variant key = constant; int idx; if (!codegen.constant_map.has(key)) { - idx=codegen.constant_map.size(); - codegen.constant_map[key]=idx; + idx = codegen.constant_map.size(); + codegen.constant_map[key] = idx; } else { - idx=codegen.constant_map[key]; + idx = codegen.constant_map[key]; } - return idx|(GDFunction::ADDR_TYPE_LOCAL_CONSTANT<_owner; + owner = owner->_owner; } /* @@ -278,58 +267,55 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre if (GDScriptLanguage::get_singleton()->get_global_map().has(identifier)) { int idx = GDScriptLanguage::get_singleton()->get_global_map()[identifier]; - return idx|(GDFunction::ADDR_TYPE_GLOBAL<(p_expression); - + const GDParser::ConstantNode *cn = static_cast(p_expression); int idx; if (!codegen.constant_map.has(cn->value)) { - idx=codegen.constant_map.size(); - codegen.constant_map[cn->value]=idx; + idx = codegen.constant_map.size(); + codegen.constant_map[cn->value] = idx; } else { - idx=codegen.constant_map[cn->value]; + idx = codegen.constant_map[cn->value]; } - - return idx|(GDFunction::ADDR_TYPE_LOCAL_CONSTANT<_static) { - _set_error("'self' not present in static function!",p_expression); + _set_error("'self' not present in static function!", p_expression); return -1; } - return (GDFunction::ADDR_TYPE_SELF<(p_expression); + const GDParser::ArrayNode *an = static_cast(p_expression); Vector values; - int slevel=p_stack_level; + int slevel = p_stack_level; - for(int i=0;ielements.size();i++) { + for (int i = 0; i < an->elements.size(); i++) { - int ret = _parse_expression(codegen,an->elements[i],slevel); - if (ret<0) + int ret = _parse_expression(codegen, an->elements[i], slevel); + if (ret < 0) return ret; - if (ret&GDFunction::ADDR_TYPE_STACK<(p_expression); + const GDParser::DictionaryNode *dn = static_cast(p_expression); Vector values; - int slevel=p_stack_level; + int slevel = p_stack_level; - for(int i=0;ielements.size();i++) { + for (int i = 0; i < dn->elements.size(); i++) { - int ret = _parse_expression(codegen,dn->elements[i].key,slevel); - if (ret<0) + int ret = _parse_expression(codegen, dn->elements[i].key, slevel); + if (ret < 0) return ret; - if (ret&GDFunction::ADDR_TYPE_STACK<elements[i].value,slevel); - if (ret<0) + ret = _parse_expression(codegen, dn->elements[i].value, slevel); + if (ret < 0) return ret; - if (ret&GDFunction::ADDR_TYPE_STACK<elements.size()); - for(int i=0;i(p_expression); - switch(on->op) { - + const GDParser::OperatorNode *on = static_cast(p_expression); + switch (on->op) { //call/constructor operator case GDParser::OperatorNode::OP_PARENT_CALL: { - - ERR_FAIL_COND_V(on->arguments.size()<1,-1); + ERR_FAIL_COND_V(on->arguments.size() < 1, -1); const GDParser::IdentifierNode *in = (const GDParser::IdentifierNode *)on->arguments[0]; - Vector arguments; int slevel = p_stack_level; - for(int i=1;iarguments.size();i++) { + for (int i = 1; i < on->arguments.size(); i++) { - int ret = _parse_expression(codegen,on->arguments[i],slevel); - if (ret<0) + int ret = _parse_expression(codegen, on->arguments[i], slevel); + if (ret < 0) return ret; - if (ret&GDFunction::ADDR_TYPE_STACK<name)); //instance codegen.opcodes.push_back(arguments.size()); //argument count codegen.alloc_call(arguments.size()); - for(int i=0;iarguments[0]->type==GDParser::Node::TYPE_TYPE) { + if (on->arguments[0]->type == GDParser::Node::TYPE_TYPE) { //construct a basic type - ERR_FAIL_COND_V(on->arguments.size()<1,-1); + ERR_FAIL_COND_V(on->arguments.size() < 1, -1); const GDParser::TypeNode *tn = (const GDParser::TypeNode *)on->arguments[0]; int vtype = tn->vtype; Vector arguments; int slevel = p_stack_level; - for(int i=1;iarguments.size();i++) { + for (int i = 1; i < on->arguments.size(); i++) { - int ret = _parse_expression(codegen,on->arguments[i],slevel); - if (ret<0) + int ret = _parse_expression(codegen, on->arguments[i], slevel); + if (ret < 0) return ret; - if (ret&GDFunction::ADDR_TYPE_STACK<arguments[0]->type==GDParser::Node::TYPE_BUILT_IN_FUNCTION) { + } else if (on->arguments[0]->type == GDParser::Node::TYPE_BUILT_IN_FUNCTION) { //built in function - ERR_FAIL_COND_V(on->arguments.size()<1,-1); - + ERR_FAIL_COND_V(on->arguments.size() < 1, -1); Vector arguments; int slevel = p_stack_level; - for(int i=1;iarguments.size();i++) { + for (int i = 1; i < on->arguments.size(); i++) { - int ret = _parse_expression(codegen,on->arguments[i],slevel); - if (ret<0) + int ret = _parse_expression(codegen, on->arguments[i], slevel); + if (ret < 0) return ret; - if (ret&GDFunction::ADDR_TYPE_STACK<(on->arguments[0])->function); - codegen.opcodes.push_back(on->arguments.size()-1); - codegen.alloc_call(on->arguments.size()-1); - for(int i=0;i(on->arguments[0])->function); + codegen.opcodes.push_back(on->arguments.size() - 1); + codegen.alloc_call(on->arguments.size() - 1); + for (int i = 0; i < arguments.size(); i++) codegen.opcodes.push_back(arguments[i]); } else { //regular function - ERR_FAIL_COND_V(on->arguments.size()<2,-1); + ERR_FAIL_COND_V(on->arguments.size() < 2, -1); const GDParser::Node *instance = on->arguments[0]; - if (instance->type==GDParser::Node::TYPE_SELF) { + if (instance->type == GDParser::Node::TYPE_SELF) { //room for optimization - } - Vector arguments; int slevel = p_stack_level; - for(int i=0;iarguments.size();i++) { + for (int i = 0; i < on->arguments.size(); i++) { int ret; - if (i==0 && on->arguments[i]->type==GDParser::Node::TYPE_SELF && codegen.function_node && codegen.function_node->_static) { + if (i == 0 && on->arguments[i]->type == GDParser::Node::TYPE_SELF && codegen.function_node && codegen.function_node->_static) { //static call to self - ret=(GDFunction::ADDR_TYPE_CLASS<arguments[i]->type!=GDParser::Node::TYPE_IDENTIFIER) { - _set_error("Attempt to call a non-identifier.",on); + if (on->arguments[i]->type != GDParser::Node::TYPE_IDENTIFIER) { + _set_error("Attempt to call a non-identifier.", on); return -1; } - GDParser::IdentifierNode *id = static_cast(on->arguments[i]); - ret=codegen.get_name_map_pos(id->name); + GDParser::IdentifierNode *id = static_cast(on->arguments[i]); + ret = codegen.get_name_map_pos(id->name); } else { - ret = _parse_expression(codegen,on->arguments[i],slevel); - if (ret<0) + ret = _parse_expression(codegen, on->arguments[i], slevel); + if (ret < 0) return ret; - if (ret&GDFunction::ADDR_TYPE_STACK<arguments.size()-2); - codegen.alloc_call(on->arguments.size()-2); - for(int i=0;iarguments.size() - 2); + codegen.alloc_call(on->arguments.size() - 2); + for (int i = 0; i < arguments.size(); i++) codegen.opcodes.push_back(arguments[i]); } } break; case GDParser::OperatorNode::OP_YIELD: { - - ERR_FAIL_COND_V(on->arguments.size() && on->arguments.size()!=2,-1); + ERR_FAIL_COND_V(on->arguments.size() && on->arguments.size() != 2, -1); Vector arguments; int slevel = p_stack_level; - for(int i=0;iarguments.size();i++) { + for (int i = 0; i < on->arguments.size(); i++) { - int ret = _parse_expression(codegen,on->arguments[i],slevel); - if (ret<0) + int ret = _parse_expression(codegen, on->arguments[i], slevel); + if (ret < 0) return ret; - if (ret&(GDFunction::ADDR_TYPE_STACK<arguments.size()!=2,-1); + ERR_FAIL_COND_V(on->arguments.size() != 2, -1); int slevel = p_stack_level; - bool named=(on->op==GDParser::OperatorNode::OP_INDEX_NAMED); + bool named = (on->op == GDParser::OperatorNode::OP_INDEX_NAMED); - int from = _parse_expression(codegen,on->arguments[0],slevel); - if (from<0) + int from = _parse_expression(codegen, on->arguments[0], slevel); + if (from < 0) return from; int index; if (named) { - if (on->arguments[0]->type==GDParser::Node::TYPE_SELF && codegen.script && codegen.function_node && !codegen.function_node->_static) { + if (on->arguments[0]->type == GDParser::Node::TYPE_SELF && codegen.script && codegen.function_node && !codegen.function_node->_static) { - GDParser::IdentifierNode* identifier = static_cast(on->arguments[1]); - const Map::Element *MI = codegen.script->member_indices.find(identifier->name); + GDParser::IdentifierNode *identifier = static_cast(on->arguments[1]); + const Map::Element *MI = codegen.script->member_indices.find(identifier->name); #ifdef DEBUG_ENABLED - if (MI && MI->get().getter==codegen.function_node->name) { - String n = static_cast(on->arguments[1])->name; - _set_error("Must use '"+n+"' instead of 'self."+n+"' in getter.",on); + if (MI && MI->get().getter == codegen.function_node->name) { + String n = static_cast(on->arguments[1])->name; + _set_error("Must use '" + n + "' instead of 'self." + n + "' in getter.", on); return -1; } #endif - if (MI && MI->get().getter=="") { + if (MI && MI->get().getter == "") { // Faster than indexing self (as if no self. had been used) - return (MI->get().index)|(GDFunction::ADDR_TYPE_MEMBER<get().index) | (GDFunction::ADDR_TYPE_MEMBER << GDFunction::ADDR_BITS); } } - index=codegen.get_name_map_pos(static_cast(on->arguments[1])->name); + index = codegen.get_name_map_pos(static_cast(on->arguments[1])->name); } else { - if (on->arguments[1]->type==GDParser::Node::TYPE_CONSTANT && static_cast(on->arguments[1])->value.get_type()==Variant::STRING) { + if (on->arguments[1]->type == GDParser::Node::TYPE_CONSTANT && static_cast(on->arguments[1])->value.get_type() == Variant::STRING) { //also, somehow, named (speed up anyway) - StringName name = static_cast(on->arguments[1])->value; - index=codegen.get_name_map_pos(name); - named=true; + StringName name = static_cast(on->arguments[1])->value; + index = codegen.get_name_map_pos(name); + named = true; } else { //regular indexing - if (from&GDFunction::ADDR_TYPE_STACK<arguments[1],slevel); - if (index<0) + index = _parse_expression(codegen, on->arguments[1], slevel); + if (index < 0) return index; } } - codegen.opcodes.push_back(named?GDFunction::OPCODE_GET_NAMED:GDFunction::OPCODE_GET); // perform operator + codegen.opcodes.push_back(named ? GDFunction::OPCODE_GET_NAMED : GDFunction::OPCODE_GET); // perform operator codegen.opcodes.push_back(from); // argument 1 codegen.opcodes.push_back(index); // argument 2 (unary only takes one parameter) @@ -636,66 +613,66 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre // AND operator with early out on failure - int res = _parse_expression(codegen,on->arguments[0],p_stack_level); - if (res<0) + int res = _parse_expression(codegen, on->arguments[0], p_stack_level); + if (res < 0) return res; codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT); codegen.opcodes.push_back(res); - int jump_fail_pos=codegen.opcodes.size(); + int jump_fail_pos = codegen.opcodes.size(); codegen.opcodes.push_back(0); - res = _parse_expression(codegen,on->arguments[1],p_stack_level); - if (res<0) + res = _parse_expression(codegen, on->arguments[1], p_stack_level); + if (res < 0) return res; codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT); codegen.opcodes.push_back(res); - int jump_fail_pos2=codegen.opcodes.size(); + int jump_fail_pos2 = codegen.opcodes.size(); codegen.opcodes.push_back(0); codegen.alloc_stack(p_stack_level); //it will be used.. codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN_TRUE); - codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<arguments[0],p_stack_level); - if (res<0) + int res = _parse_expression(codegen, on->arguments[0], p_stack_level); + if (res < 0) return res; codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF); codegen.opcodes.push_back(res); - int jump_success_pos=codegen.opcodes.size(); + int jump_success_pos = codegen.opcodes.size(); codegen.opcodes.push_back(0); - res = _parse_expression(codegen,on->arguments[1],p_stack_level); - if (res<0) + res = _parse_expression(codegen, on->arguments[1], p_stack_level); + if (res < 0) return res; codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF); codegen.opcodes.push_back(res); - int jump_success_pos2=codegen.opcodes.size(); + int jump_success_pos2 = codegen.opcodes.size(); codegen.opcodes.push_back(0); codegen.alloc_stack(p_stack_level); //it will be used.. codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN_FALSE); - codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<arguments[0],p_stack_level); - if (res<0) + int res = _parse_expression(codegen, on->arguments[0], p_stack_level); + if (res < 0) return res; codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT); codegen.opcodes.push_back(res); - int jump_fail_pos=codegen.opcodes.size(); + int jump_fail_pos = codegen.opcodes.size(); codegen.opcodes.push_back(0); - - res = _parse_expression(codegen,on->arguments[1],p_stack_level); - if (res<0) + res = _parse_expression(codegen, on->arguments[1], p_stack_level); + if (res < 0) return res; - + codegen.alloc_stack(p_stack_level); //it will be used.. codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN); - codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<arguments[2],p_stack_level); - if (res<0) + + codegen.opcodes[jump_fail_pos] = codegen.opcodes.size(); + res = _parse_expression(codegen, on->arguments[2], p_stack_level); + if (res < 0) return res; - + codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN); - codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<arguments.size()!=2,-1); - - - if (on->arguments[0]->type==GDParser::Node::TYPE_OPERATOR && (static_cast(on->arguments[0])->op==GDParser::OperatorNode::OP_INDEX || static_cast(on->arguments[0])->op==GDParser::OperatorNode::OP_INDEX_NAMED)) { - //SET (chained) MODE!! + ERR_FAIL_COND_V(on->arguments.size() != 2, -1); + if (on->arguments[0]->type == GDParser::Node::TYPE_OPERATOR && (static_cast(on->arguments[0])->op == GDParser::OperatorNode::OP_INDEX || static_cast(on->arguments[0])->op == GDParser::OperatorNode::OP_INDEX_NAMED)) { +//SET (chained) MODE!! #ifdef DEBUG_ENABLED - if (static_cast(on->arguments[0])->op==GDParser::OperatorNode::OP_INDEX_NAMED) { - const GDParser::OperatorNode* inon = static_cast(on->arguments[0]); - + if (static_cast(on->arguments[0])->op == GDParser::OperatorNode::OP_INDEX_NAMED) { + const GDParser::OperatorNode *inon = static_cast(on->arguments[0]); - if (inon->arguments[0]->type==GDParser::Node::TYPE_SELF && codegen.script && codegen.function_node && !codegen.function_node->_static) { + if (inon->arguments[0]->type == GDParser::Node::TYPE_SELF && codegen.script && codegen.function_node && !codegen.function_node->_static) { - const Map::Element *MI = codegen.script->member_indices.find(static_cast(inon->arguments[1])->name); - if (MI && MI->get().setter==codegen.function_node->name) { - String n = static_cast(inon->arguments[1])->name; - _set_error("Must use '"+n+"' instead of 'self."+n+"' in setter.",inon); + const Map::Element *MI = codegen.script->member_indices.find(static_cast(inon->arguments[1])->name); + if (MI && MI->get().setter == codegen.function_node->name) { + String n = static_cast(inon->arguments[1])->name; + _set_error("Must use '" + n + "' instead of 'self." + n + "' in setter.", inon); return -1; } } } #endif + int slevel = p_stack_level; - int slevel=p_stack_level; - - GDParser::OperatorNode* op = static_cast(on->arguments[0]); + GDParser::OperatorNode *op = static_cast(on->arguments[0]); /* Find chain of sets */ StringName assign_property; - List chain; + List chain; { //create get/set chain - GDParser::OperatorNode* n=op; - while(true) { + GDParser::OperatorNode *n = op; + while (true) { chain.push_back(n); - if (n->arguments[0]->type!=GDParser::Node::TYPE_OPERATOR) { + if (n->arguments[0]->type != GDParser::Node::TYPE_OPERATOR) { //check for a built-in property - if (n->arguments[0]->type==GDParser::Node::TYPE_IDENTIFIER) { + if (n->arguments[0]->type == GDParser::Node::TYPE_IDENTIFIER) { - GDParser::IdentifierNode *identifier = static_cast(n->arguments[0]); - if (_is_class_member_property(codegen,identifier->name)) { + GDParser::IdentifierNode *identifier = static_cast(n->arguments[0]); + if (_is_class_member_property(codegen, identifier->name)) { assign_property = identifier->name; - } - } break; } - n = static_cast(n->arguments[0]); - if (n->op!=GDParser::OperatorNode::OP_INDEX && n->op!=GDParser::OperatorNode::OP_INDEX_NAMED) + n = static_cast(n->arguments[0]); + if (n->op != GDParser::OperatorNode::OP_INDEX && n->op != GDParser::OperatorNode::OP_INDEX_NAMED) break; } } @@ -845,23 +859,21 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre /* Chain of gets */ //get at (potential) root stack pos, so it can be returned - int prev_pos = _parse_expression(codegen,chain.back()->get()->arguments[0],slevel); - if (prev_pos<0) + int prev_pos = _parse_expression(codegen, chain.back()->get()->arguments[0], slevel); + if (prev_pos < 0) return prev_pos; - int retval=prev_pos; + int retval = prev_pos; //print_line("retval: "+itos(retval)); - if (retval&GDFunction::ADDR_TYPE_STACK< setchain; - - if (assign_property!=StringName()) { + if (assign_property != StringName()) { // recover and assign at the end, this allows stuff like // position.x+=2.0 @@ -871,37 +883,34 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre setchain.push_back(GDFunction::OPCODE_SET_MEMBER); } - for(List::Element *E=chain.back();E;E=E->prev()) { + for (List::Element *E = chain.back(); E; E = E->prev()) { - - if (E==chain.front()) //ignore first + if (E == chain.front()) //ignore first break; - bool named = E->get()->op==GDParser::OperatorNode::OP_INDEX_NAMED; + bool named = E->get()->op == GDParser::OperatorNode::OP_INDEX_NAMED; int key_idx; if (named) { - key_idx = codegen.get_name_map_pos(static_cast(E->get()->arguments[1])->name); + key_idx = codegen.get_name_map_pos(static_cast(E->get()->arguments[1])->name); //printf("named key %x\n",key_idx); } else { - if (prev_pos&(GDFunction::ADDR_TYPE_STACK<get()->arguments[1]; - key_idx = _parse_expression(codegen,key,slevel); + key_idx = _parse_expression(codegen, key, slevel); //printf("expr key %x\n",key_idx); - //stack was raised here if retval was stack but.. - } - if (key_idx<0) //error + if (key_idx < 0) //error return key_idx; codegen.opcodes.push_back(named ? GDFunction::OPCODE_GET_NAMED : GDFunction::OPCODE_GET); @@ -909,134 +918,116 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre codegen.opcodes.push_back(key_idx); slevel++; codegen.alloc_stack(slevel); - int dst_pos = (GDFunction::ADDR_TYPE_STACK<(op)->op == GDParser::OperatorNode::OP_INDEX_NAMED) { - if (static_cast(op)->op==GDParser::OperatorNode::OP_INDEX_NAMED) { - - - set_index=codegen.get_name_map_pos(static_cast(op->arguments[1])->name); - named=true; + set_index = codegen.get_name_map_pos(static_cast(op->arguments[1])->name); + named = true; } else { - set_index = _parse_expression(codegen,op->arguments[1],slevel+1); - named=false; + set_index = _parse_expression(codegen, op->arguments[1], slevel + 1); + named = false; } - - if (set_index<0) //error + if (set_index < 0) //error return set_index; - if (set_index&GDFunction::ADDR_TYPE_STACK<arguments[0]->type==GDParser::Node::TYPE_IDENTIFIER && _is_class_member_property(codegen,static_cast(on->arguments[0])->name)) { + } else if (on->arguments[0]->type == GDParser::Node::TYPE_IDENTIFIER && _is_class_member_property(codegen, static_cast(on->arguments[0])->name)) { //assignment to member property int slevel = p_stack_level; - int src_address = _parse_assign_right_expression(codegen,on,slevel); - if (src_address<0) + int src_address = _parse_assign_right_expression(codegen, on, slevel); + if (src_address < 0) return -1; - StringName name = static_cast(on->arguments[0])->name; + StringName name = static_cast(on->arguments[0])->name; codegen.opcodes.push_back(GDFunction::OPCODE_SET_MEMBER); codegen.opcodes.push_back(codegen.get_name_map_pos(name)); codegen.opcodes.push_back(src_address); - return GDFunction::ADDR_TYPE_NIL<arguments[0],slevel,false,on->op==GDParser::OperatorNode::OP_INIT_ASSIGN); - if (dst_address_a<0) + int dst_address_a = _parse_expression(codegen, on->arguments[0], slevel, false, on->op == GDParser::OperatorNode::OP_INIT_ASSIGN); + if (dst_address_a < 0) return -1; - if (dst_address_a&GDFunction::ADDR_TYPE_STACK<arguments.size()!=2,false); - + ERR_FAIL_COND_V(on->arguments.size() != 2, false); int slevel = p_stack_level; - int src_address_a = _parse_expression(codegen,on->arguments[0],slevel); - if (src_address_a<0) + int src_address_a = _parse_expression(codegen, on->arguments[0], slevel); + if (src_address_a < 0) return -1; - if (src_address_a&GDFunction::ADDR_TYPE_STACK<arguments[1],slevel); - if (src_address_b<0) + int src_address_b = _parse_expression(codegen, on->arguments[1], slevel); + if (src_address_b < 0) return -1; codegen.opcodes.push_back(GDFunction::OPCODE_EXTENDS_TEST); // perform operator @@ -1046,14 +1037,13 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre } break; default: { - - ERR_EXPLAIN("Bug in bytecode compiler, unexpected operator #"+itos(on->op)+" in parse tree while parsing expression."); + ERR_EXPLAIN("Bug in bytecode compiler, unexpected operator #" + itos(on->op) + " in parse tree while parsing expression."); ERR_FAIL_V(0); //unreachable code } break; } - int dst_addr=(p_stack_level)|(GDFunction::ADDR_TYPE_STACK<line; + int new_identifiers = 0; + codegen.current_line = p_block->line; - for(int i=0;istatements.size();i++) { + for (int i = 0; i < p_block->statements.size(); i++) { const GDParser::Node *s = p_block->statements[i]; - - switch(s->type) { + switch (s->type) { case GDParser::Node::TYPE_NEWLINE: { #ifdef DEBUG_ENABLED - const GDParser::NewLineNode *nl = static_cast(s); + const GDParser::NewLineNode *nl = static_cast(s); codegen.opcodes.push_back(GDFunction::OPCODE_LINE); codegen.opcodes.push_back(nl->line); - codegen.current_line=nl->line; + codegen.current_line = nl->line; #endif } break; case GDParser::Node::TYPE_CONTROL_FLOW: { // try subblocks - const GDParser::ControlFlowNode *cf = static_cast(s); + const GDParser::ControlFlowNode *cf = static_cast(s); - switch(cf->cf_type) { + switch (cf->cf_type) { case GDParser::ControlFlowNode::CF_MATCH: { GDParser::MatchNode *match = cf->match; - + GDParser::IdentifierNode *id = memnew(GDParser::IdentifierNode); id->name = "#match_value"; - + // var #match_value // copied because there is no _parse_statement :( codegen.add_stack_identifier(id->name, p_stack_level++); @@ -1112,25 +1098,25 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo new_identifiers++; GDParser::OperatorNode *op = memnew(GDParser::OperatorNode); - op->op=GDParser::OperatorNode::OP_ASSIGN; + op->op = GDParser::OperatorNode::OP_ASSIGN; op->arguments.push_back(id); op->arguments.push_back(match->val_to_match); - + int ret = _parse_expression(codegen, op, p_stack_level); if (ret < 0) { return ERR_PARSE_ERROR; } - + // break address codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); codegen.opcodes.push_back(codegen.opcodes.size() + 3); int break_addr = codegen.opcodes.size(); codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); codegen.opcodes.push_back(0); // break addr - + for (int j = 0; j < match->compiled_pattern_branches.size(); j++) { GDParser::MatchNode::CompiledPatternBranch branch = match->compiled_pattern_branches[j]; - + // jump over continue // jump unconditionally // continue address @@ -1139,87 +1125,81 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo if (ret < 0) { return ERR_PARSE_ERROR; } - + codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF); codegen.opcodes.push_back(ret); codegen.opcodes.push_back(codegen.opcodes.size() + 3); int continue_addr = codegen.opcodes.size(); codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); codegen.opcodes.push_back(0); - - - + Error err = _parse_block(codegen, branch.body, p_stack_level, p_break_addr, continue_addr); if (err) { return ERR_PARSE_ERROR; } - + codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); codegen.opcodes.push_back(break_addr); - + codegen.opcodes[continue_addr + 1] = codegen.opcodes.size(); } - + codegen.opcodes[break_addr + 1] = codegen.opcodes.size(); - - + } break; - + case GDParser::ControlFlowNode::CF_IF: { #ifdef DEBUG_ENABLED codegen.opcodes.push_back(GDFunction::OPCODE_LINE); codegen.opcodes.push_back(cf->line); - codegen.current_line=cf->line; + codegen.current_line = cf->line; #endif - int ret = _parse_expression(codegen,cf->arguments[0],p_stack_level,false); - if (ret<0) + int ret = _parse_expression(codegen, cf->arguments[0], p_stack_level, false); + if (ret < 0) return ERR_PARSE_ERROR; codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT); codegen.opcodes.push_back(ret); - int else_addr=codegen.opcodes.size(); + int else_addr = codegen.opcodes.size(); codegen.opcodes.push_back(0); //temporary - Error err = _parse_block(codegen,cf->body,p_stack_level,p_break_addr,p_continue_addr); + Error err = _parse_block(codegen, cf->body, p_stack_level, p_break_addr, p_continue_addr); if (err) return err; if (cf->body_else) { codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); - int end_addr=codegen.opcodes.size(); + int end_addr = codegen.opcodes.size(); codegen.opcodes.push_back(0); - codegen.opcodes[else_addr]=codegen.opcodes.size(); + codegen.opcodes[else_addr] = codegen.opcodes.size(); - Error err = _parse_block(codegen,cf->body_else,p_stack_level,p_break_addr,p_continue_addr); + Error err = _parse_block(codegen, cf->body_else, p_stack_level, p_break_addr, p_continue_addr); if (err) return err; - codegen.opcodes[end_addr]=codegen.opcodes.size(); + codegen.opcodes[end_addr] = codegen.opcodes.size(); } else { //end without else - codegen.opcodes[else_addr]=codegen.opcodes.size(); - + codegen.opcodes[else_addr] = codegen.opcodes.size(); } } break; case GDParser::ControlFlowNode::CF_FOR: { - - - int slevel=p_stack_level; - int iter_stack_pos=slevel; - int iterator_pos = (slevel++)|(GDFunction::ADDR_TYPE_STACK<(cf->arguments[0])->name,iter_stack_pos); + codegen.push_stack_identifiers(); + codegen.add_stack_identifier(static_cast(cf->arguments[0])->name, iter_stack_pos); - int ret = _parse_expression(codegen,cf->arguments[1],slevel,false); - if (ret<0) + int ret = _parse_expression(codegen, cf->arguments[1], slevel, false); + if (ret < 0) return ERR_COMPILATION_FAILED; //assign container @@ -1231,32 +1211,29 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo codegen.opcodes.push_back(GDFunction::OPCODE_ITERATE_BEGIN); codegen.opcodes.push_back(counter_pos); codegen.opcodes.push_back(container_pos); - codegen.opcodes.push_back(codegen.opcodes.size()+4); + codegen.opcodes.push_back(codegen.opcodes.size() + 4); codegen.opcodes.push_back(iterator_pos); codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); //skip code for next - codegen.opcodes.push_back(codegen.opcodes.size()+8); + codegen.opcodes.push_back(codegen.opcodes.size() + 8); //break loop - int break_pos=codegen.opcodes.size(); + int break_pos = codegen.opcodes.size(); codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); //skip code for next codegen.opcodes.push_back(0); //skip code for next //next loop - int continue_pos=codegen.opcodes.size(); + int continue_pos = codegen.opcodes.size(); codegen.opcodes.push_back(GDFunction::OPCODE_ITERATE); codegen.opcodes.push_back(counter_pos); codegen.opcodes.push_back(container_pos); codegen.opcodes.push_back(break_pos); codegen.opcodes.push_back(iterator_pos); - - Error err = _parse_block(codegen,cf->body,slevel,break_pos,continue_pos); + Error err = _parse_block(codegen, cf->body, slevel, break_pos, continue_pos); if (err) return err; - codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); codegen.opcodes.push_back(continue_pos); - codegen.opcodes[break_pos+1]=codegen.opcodes.size(); - + codegen.opcodes[break_pos + 1] = codegen.opcodes.size(); codegen.pop_stack_identifiers(); @@ -1264,25 +1241,25 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo case GDParser::ControlFlowNode::CF_WHILE: { codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); - codegen.opcodes.push_back(codegen.opcodes.size()+3); - int break_addr=codegen.opcodes.size(); + codegen.opcodes.push_back(codegen.opcodes.size() + 3); + int break_addr = codegen.opcodes.size(); codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); codegen.opcodes.push_back(0); - int continue_addr=codegen.opcodes.size(); + int continue_addr = codegen.opcodes.size(); - int ret = _parse_expression(codegen,cf->arguments[0],p_stack_level,false); - if (ret<0) + int ret = _parse_expression(codegen, cf->arguments[0], p_stack_level, false); + if (ret < 0) return ERR_PARSE_ERROR; codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT); codegen.opcodes.push_back(ret); codegen.opcodes.push_back(break_addr); - Error err = _parse_block(codegen,cf->body,p_stack_level,break_addr,continue_addr); + Error err = _parse_block(codegen, cf->body, p_stack_level, break_addr, continue_addr); if (err) return err; codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); codegen.opcodes.push_back(continue_addr); - codegen.opcodes[break_addr+1]=codegen.opcodes.size(); + codegen.opcodes[break_addr + 1] = codegen.opcodes.size(); } break; case GDParser::ControlFlowNode::CF_SWITCH: { @@ -1290,9 +1267,9 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo } break; case GDParser::ControlFlowNode::CF_BREAK: { - if (p_break_addr<0) { + if (p_break_addr < 0) { - _set_error("'break'' not within loop",cf); + _set_error("'break'' not within loop", cf); return ERR_COMPILATION_FAILED; } codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); @@ -1301,9 +1278,9 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo } break; case GDParser::ControlFlowNode::CF_CONTINUE: { - if (p_continue_addr<0) { + if (p_continue_addr < 0) { - _set_error("'continue' not within loop",cf); + _set_error("'continue' not within loop", cf); return ERR_COMPILATION_FAILED; } @@ -1317,29 +1294,28 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo if (cf->arguments.size()) { - ret = _parse_expression(codegen,cf->arguments[0],p_stack_level,false); - if (ret<0) + ret = _parse_expression(codegen, cf->arguments[0], p_stack_level, false); + if (ret < 0) return ERR_PARSE_ERROR; } else { - ret=GDFunction::ADDR_TYPE_NIL << GDFunction::ADDR_BITS; + ret = GDFunction::ADDR_TYPE_NIL << GDFunction::ADDR_BITS; } codegen.opcodes.push_back(GDFunction::OPCODE_RETURN); codegen.opcodes.push_back(ret); } break; - } } break; case GDParser::Node::TYPE_ASSERT: { // try subblocks - const GDParser::AssertNode *as = static_cast(s); + const GDParser::AssertNode *as = static_cast(s); - int ret = _parse_expression(codegen,as->condition,p_stack_level,false); - if (ret<0) + int ret = _parse_expression(codegen, as->condition, p_stack_level, false); + if (ret < 0) return ERR_PARSE_ERROR; codegen.opcodes.push_back(GDFunction::OPCODE_ASSERT); @@ -1353,99 +1329,91 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo } break; case GDParser::Node::TYPE_LOCAL_VAR: { + const GDParser::LocalVarNode *lv = static_cast(s); - const GDParser::LocalVarNode *lv = static_cast(s); - - if (_is_class_member_property(codegen,lv->name)) { - _set_error("Name for local variable '"+String(lv->name)+"' can't shadow class property of the same name.",lv); + if (_is_class_member_property(codegen, lv->name)) { + _set_error("Name for local variable '" + String(lv->name) + "' can't shadow class property of the same name.", lv); return ERR_ALREADY_EXISTS; } - codegen.add_stack_identifier(lv->name,p_stack_level++); + codegen.add_stack_identifier(lv->name, p_stack_level++); codegen.alloc_stack(p_stack_level); new_identifiers++; } break; default: { //expression - int ret = _parse_expression(codegen,s,p_stack_level,true); - if (ret<0) + int ret = _parse_expression(codegen, s, p_stack_level, true); + if (ret < 0) return ERR_PARSE_ERROR; } break; - } - } codegen.pop_stack_identifiers(); return OK; } - -Error GDCompiler::_parse_function(GDScript *p_script,const GDParser::ClassNode *p_class,const GDParser::FunctionNode *p_func,bool p_for_ready) { +Error GDCompiler::_parse_function(GDScript *p_script, const GDParser::ClassNode *p_class, const GDParser::FunctionNode *p_func, bool p_for_ready) { Vector bytecode; CodeGen codegen; - codegen.class_node=p_class; - codegen.script=p_script; - codegen.function_node=p_func; - codegen.stack_max=0; - codegen.current_line=0; - codegen.call_max=0; - codegen.debug_stack=ScriptDebugger::get_singleton()!=NULL; + codegen.class_node = p_class; + codegen.script = p_script; + codegen.function_node = p_func; + codegen.stack_max = 0; + codegen.current_line = 0; + codegen.call_max = 0; + codegen.debug_stack = ScriptDebugger::get_singleton() != NULL; Vector argnames; - int stack_level=0; + int stack_level = 0; if (p_func) { - for(int i=0;iarguments.size();i++) { - if (_is_class_member_property(p_script,p_func->arguments[i])) { - _set_error("Name for argument '"+String(p_func->arguments[i])+"' can't shadow class property of the same name.",p_func); + for (int i = 0; i < p_func->arguments.size(); i++) { + if (_is_class_member_property(p_script, p_func->arguments[i])) { + _set_error("Name for argument '" + String(p_func->arguments[i]) + "' can't shadow class property of the same name.", p_func); return ERR_ALREADY_EXISTS; } - codegen.add_stack_identifier(p_func->arguments[i],i); + codegen.add_stack_identifier(p_func->arguments[i], i); #ifdef TOOLS_ENABLED argnames.push_back(p_func->arguments[i]); #endif } - stack_level=p_func->arguments.size(); + stack_level = p_func->arguments.size(); } codegen.alloc_stack(stack_level); /* Parse initializer -if applies- */ - bool is_initializer=!p_for_ready && !p_func; + bool is_initializer = !p_for_ready && !p_func; - if (is_initializer || (p_func && String(p_func->name)=="_init")) { + if (is_initializer || (p_func && String(p_func->name) == "_init")) { //parse initializer for class members - if (!p_func && p_class->extends_used && p_script->native.is_null()){ + if (!p_func && p_class->extends_used && p_script->native.is_null()) { //call implicit parent constructor codegen.opcodes.push_back(GDFunction::OPCODE_CALL_SELF_BASE); codegen.opcodes.push_back(codegen.get_name_map_pos("_init")); codegen.opcodes.push_back(0); - codegen.opcodes.push_back((GDFunction::ADDR_TYPE_STACK<initializer,stack_level); + Error err = _parse_block(codegen, p_class->initializer, stack_level); if (err) return err; - is_initializer=true; - + is_initializer = true; } - if (p_for_ready || (p_func && String(p_func->name)=="_ready")) { + if (p_for_ready || (p_func && String(p_func->name) == "_ready")) { //parse initializer for class members if (p_class->ready->statements.size()) { - Error err = _parse_block(codegen,p_class->ready,stack_level); + Error err = _parse_block(codegen, p_class->ready, stack_level); if (err) return err; } - } - /* Parse default argument code -if applies- */ Vector defarg_addr; @@ -1457,196 +1425,185 @@ Error GDCompiler::_parse_function(GDScript *p_script,const GDParser::ClassNode * codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_TO_DEF_ARGUMENT); defarg_addr.push_back(codegen.opcodes.size()); - for(int i=0;idefault_values.size();i++) { + for (int i = 0; i < p_func->default_values.size(); i++) { - _parse_expression(codegen,p_func->default_values[i],stack_level,true); + _parse_expression(codegen, p_func->default_values[i], stack_level, true); defarg_addr.push_back(codegen.opcodes.size()); } - defarg_addr.invert(); } - - - Error err = _parse_block(codegen,p_func->body,stack_level); + Error err = _parse_block(codegen, p_func->body, stack_level); if (err) return err; - func_name=p_func->name; + func_name = p_func->name; } else { if (p_for_ready) - func_name="_ready"; + func_name = "_ready"; else - func_name="_init"; + func_name = "_init"; } codegen.opcodes.push_back(GDFunction::OPCODE_END); - GDFunction *gdfunc=NULL; + GDFunction *gdfunc = NULL; /* if (String(p_func->name)=="") { //initializer func gdfunc = &p_script->initializer; */ //} else { //regular func - p_script->member_functions[func_name]=memnew(GDFunction); - gdfunc = p_script->member_functions[func_name]; + p_script->member_functions[func_name] = memnew(GDFunction); + gdfunc = p_script->member_functions[func_name]; //} if (p_func) { - gdfunc->_static=p_func->_static; - gdfunc->rpc_mode=p_func->rpc_mode; + gdfunc->_static = p_func->_static; + gdfunc->rpc_mode = p_func->rpc_mode; } #ifdef TOOLS_ENABLED - gdfunc->arg_names=argnames; + gdfunc->arg_names = argnames; #endif //constants if (codegen.constant_map.size()) { - gdfunc->_constant_count=codegen.constant_map.size(); + gdfunc->_constant_count = codegen.constant_map.size(); gdfunc->constants.resize(codegen.constant_map.size()); - gdfunc->_constants_ptr=&gdfunc->constants[0]; - const Variant *K=NULL; - while((K=codegen.constant_map.next(K))) { + gdfunc->_constants_ptr = &gdfunc->constants[0]; + const Variant *K = NULL; + while ((K = codegen.constant_map.next(K))) { int idx = codegen.constant_map[*K]; - gdfunc->constants[idx]=*K; + gdfunc->constants[idx] = *K; } } else { - gdfunc->_constants_ptr=NULL; - gdfunc->_constant_count=0; + gdfunc->_constants_ptr = NULL; + gdfunc->_constant_count = 0; } //global names if (codegen.name_map.size()) { gdfunc->global_names.resize(codegen.name_map.size()); gdfunc->_global_names_ptr = &gdfunc->global_names[0]; - for(Map::Element *E=codegen.name_map.front();E;E=E->next()) { + for (Map::Element *E = codegen.name_map.front(); E; E = E->next()) { - gdfunc->global_names[E->get()]=E->key(); + gdfunc->global_names[E->get()] = E->key(); } - gdfunc->_global_names_count=gdfunc->global_names.size(); + gdfunc->_global_names_count = gdfunc->global_names.size(); } else { gdfunc->_global_names_ptr = NULL; - gdfunc->_global_names_count =0; + gdfunc->_global_names_count = 0; } - if (codegen.opcodes.size()) { - gdfunc->code=codegen.opcodes; - gdfunc->_code_ptr=&gdfunc->code[0]; - gdfunc->_code_size=codegen.opcodes.size(); + gdfunc->code = codegen.opcodes; + gdfunc->_code_ptr = &gdfunc->code[0]; + gdfunc->_code_size = codegen.opcodes.size(); } else { - gdfunc->_code_ptr=NULL; - gdfunc->_code_size=0; + gdfunc->_code_ptr = NULL; + gdfunc->_code_size = 0; } if (defarg_addr.size()) { - gdfunc->default_arguments=defarg_addr; - gdfunc->_default_arg_count=defarg_addr.size()-1; - gdfunc->_default_arg_ptr=&gdfunc->default_arguments[0]; + gdfunc->default_arguments = defarg_addr; + gdfunc->_default_arg_count = defarg_addr.size() - 1; + gdfunc->_default_arg_ptr = &gdfunc->default_arguments[0]; } else { - gdfunc->_default_arg_count=0; - gdfunc->_default_arg_ptr=NULL; + gdfunc->_default_arg_count = 0; + gdfunc->_default_arg_ptr = NULL; } - gdfunc->_argument_count=p_func ? p_func->arguments.size() : 0; - gdfunc->_stack_size=codegen.stack_max; - gdfunc->_call_size=codegen.call_max; - gdfunc->name=func_name; + gdfunc->_argument_count = p_func ? p_func->arguments.size() : 0; + gdfunc->_stack_size = codegen.stack_max; + gdfunc->_call_size = codegen.call_max; + gdfunc->name = func_name; #ifdef DEBUG_ENABLED - if (ScriptDebugger::get_singleton()){ + if (ScriptDebugger::get_singleton()) { String signature; //path - if (p_script->get_path()!=String()) - signature+=p_script->get_path(); + if (p_script->get_path() != String()) + signature += p_script->get_path(); //loc if (p_func) { - signature+="::"+itos(p_func->body->line); + signature += "::" + itos(p_func->body->line); } else { - signature+="::0"; + signature += "::0"; } //funciton and class if (p_class->name) { - signature+="::"+String(p_class->name)+"."+String(func_name); + signature += "::" + String(p_class->name) + "." + String(func_name); } else { - signature+="::"+String(func_name); + signature += "::" + String(func_name); } - - - gdfunc->profile.signature=signature; + gdfunc->profile.signature = signature; } #endif - gdfunc->_script=p_script; - gdfunc->source=source; + gdfunc->_script = p_script; + gdfunc->source = source; #ifdef DEBUG_ENABLED { - gdfunc->func_cname=(String(source)+" - "+String(func_name)).utf8(); - gdfunc->_func_cname=gdfunc->func_cname.get_data(); - + gdfunc->func_cname = (String(source) + " - " + String(func_name)).utf8(); + gdfunc->_func_cname = gdfunc->func_cname.get_data(); } #endif if (p_func) { - gdfunc->_initial_line=p_func->line; + gdfunc->_initial_line = p_func->line; #ifdef TOOLS_ENABLED - p_script->member_lines[func_name]=p_func->line; + p_script->member_lines[func_name] = p_func->line; #endif } else { - gdfunc->_initial_line=0; + gdfunc->_initial_line = 0; } if (codegen.debug_stack) - gdfunc->stack_debug=codegen.stack_debug; + gdfunc->stack_debug = codegen.stack_debug; if (is_initializer) - p_script->initializer=gdfunc; - + p_script->initializer = gdfunc; return OK; } - - Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDParser::ClassNode *p_class, bool p_keep_state) { - Map > old_subclasses; + Map > old_subclasses; if (p_keep_state) { - old_subclasses=p_script->subclasses; + old_subclasses = p_script->subclasses; } - p_script->native=Ref(); - p_script->base=Ref(); - p_script->_base=NULL; + p_script->native = Ref(); + p_script->base = Ref(); + p_script->_base = NULL; p_script->members.clear(); p_script->constants.clear(); - for (Map::Element *E=p_script->member_functions.front();E;E=E->next()) { + for (Map::Element *E = p_script->member_functions.front(); E; E = E->next()) { memdelete(E->get()); } p_script->member_functions.clear(); p_script->member_indices.clear(); p_script->member_info.clear(); p_script->_signals.clear(); - p_script->initializer=NULL; + p_script->initializer = NULL; p_script->subclasses.clear(); - p_script->_owner=p_owner; - p_script->tool=p_class->tool; - p_script->name=p_class->name; - + p_script->_owner = p_owner; + p_script->tool = p_class->tool; + p_script->name = p_class->name; Ref native; @@ -1656,8 +1613,7 @@ Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDPa Ref script; - - if (path!="") { + if (path != "") { //path (and optionally subclasses) if (path.is_rel_path()) { @@ -1667,47 +1623,46 @@ Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDPa if (p_owner) { GDScript *current_class = p_owner; while (current_class != NULL) { - base=current_class->get_path(); - if (base=="") + base = current_class->get_path(); + if (base == "") current_class = current_class->_owner; else break; } - } - else { + } else { base = p_script->get_path(); } - if (base=="" || base.is_rel_path()) { - _set_error("Could not resolve relative path for parent class: "+path,p_class); + if (base == "" || base.is_rel_path()) { + _set_error("Could not resolve relative path for parent class: " + path, p_class); return ERR_FILE_NOT_FOUND; } - path=base.get_base_dir().plus_file(path).simplify_path(); + path = base.get_base_dir().plus_file(path).simplify_path(); } script = ResourceLoader::load(path); if (script.is_null()) { - _set_error("Could not load base class: "+path,p_class); + _set_error("Could not load base class: " + path, p_class); return ERR_FILE_NOT_FOUND; } if (!script->valid) { - _set_error("Script not fully loaded (cyclic preload?): "+path,p_class); + _set_error("Script not fully loaded (cyclic preload?): " + path, p_class); return ERR_BUSY; } //print_line("EXTENDS PATH: "+path+" script is "+itos(script.is_valid())+" indices is "+itos(script->member_indices.size())+" valid? "+itos(script->valid)); if (p_class->extends_class.size()) { - for(int i=0;iextends_class.size();i++) { + for (int i = 0; i < p_class->extends_class.size(); i++) { String sub = p_class->extends_class[i]; if (script->subclasses.has(sub)) { Ref