From 0b806ee0fc9097fa7bda7ac0109191c9c5e0a1ac Mon Sep 17 00:00:00 2001 From: Juan Linietsky Date: Sun, 9 Feb 2014 22:10:30 -0300 Subject: GODOT IS OPEN SOURCE --- scene/2d/SCsub | 7 + scene/2d/animated_sprite.cpp | 352 ++++++++++++ scene/2d/animated_sprite.h | 119 ++++ scene/2d/area_2d.cpp | 326 +++++++++++ scene/2d/area_2d.h | 122 ++++ scene/2d/camera_2d.cpp | 484 ++++++++++++++++ scene/2d/camera_2d.h | 118 ++++ scene/2d/canvas_item.cpp | 875 +++++++++++++++++++++++++++++ scene/2d/canvas_item.h | 209 +++++++ scene/2d/collision_object_2d.cpp | 282 ++++++++++ scene/2d/collision_object_2d.h | 89 +++ scene/2d/collision_polygon_2d.cpp | 187 +++++++ scene/2d/collision_polygon_2d.h | 75 +++ scene/2d/collision_shape_2d.cpp | 248 +++++++++ scene/2d/collision_shape_2d.h | 61 ++ scene/2d/joints_2d.cpp | 412 ++++++++++++++ scene/2d/joints_2d.h | 141 +++++ scene/2d/node_2d.cpp | 291 ++++++++++ scene/2d/node_2d.h | 89 +++ scene/2d/node_2d_singleton.cpp | 30 + scene/2d/node_2d_singleton.h | 33 ++ scene/2d/parallax_background.cpp | 200 +++++++ scene/2d/parallax_background.h | 78 +++ scene/2d/parallax_layer.cpp | 138 +++++ scene/2d/parallax_layer.h | 62 +++ scene/2d/particles_2d.cpp | 1045 +++++++++++++++++++++++++++++++++++ scene/2d/particles_2d.h | 231 ++++++++ scene/2d/path_2d.cpp | 92 +++ scene/2d/path_2d.h | 57 ++ scene/2d/physics_body_2d.cpp | 794 ++++++++++++++++++++++++++ scene/2d/physics_body_2d.h | 232 ++++++++ scene/2d/position_2d.cpp | 65 +++ scene/2d/position_2d.h | 49 ++ scene/2d/ray_cast_2d.cpp | 198 +++++++ scene/2d/ray_cast_2d.h | 68 +++ scene/2d/remote_transform_2d.cpp | 122 ++++ scene/2d/remote_transform_2d.h | 52 ++ scene/2d/sample_player_2d.cpp | 252 +++++++++ scene/2d/sample_player_2d.h | 92 +++ scene/2d/screen_button.cpp | 372 +++++++++++++ scene/2d/screen_button.h | 95 ++++ scene/2d/sound_player_2d.cpp | 123 +++++ scene/2d/sound_player_2d.h | 82 +++ scene/2d/sprite.cpp | 337 +++++++++++ scene/2d/sprite.h | 108 ++++ scene/2d/tile_map.cpp | 592 ++++++++++++++++++++ scene/2d/tile_map.h | 154 ++++++ scene/2d/visibility_notifier_2d.cpp | 322 +++++++++++ scene/2d/visibility_notifier_2d.h | 109 ++++ 49 files changed, 10671 insertions(+) create mode 100644 scene/2d/SCsub create mode 100644 scene/2d/animated_sprite.cpp create mode 100644 scene/2d/animated_sprite.h create mode 100644 scene/2d/area_2d.cpp create mode 100644 scene/2d/area_2d.h create mode 100644 scene/2d/camera_2d.cpp create mode 100644 scene/2d/camera_2d.h create mode 100644 scene/2d/canvas_item.cpp create mode 100644 scene/2d/canvas_item.h create mode 100644 scene/2d/collision_object_2d.cpp create mode 100644 scene/2d/collision_object_2d.h create mode 100644 scene/2d/collision_polygon_2d.cpp create mode 100644 scene/2d/collision_polygon_2d.h create mode 100644 scene/2d/collision_shape_2d.cpp create mode 100644 scene/2d/collision_shape_2d.h create mode 100644 scene/2d/joints_2d.cpp create mode 100644 scene/2d/joints_2d.h create mode 100644 scene/2d/node_2d.cpp create mode 100644 scene/2d/node_2d.h create mode 100644 scene/2d/node_2d_singleton.cpp create mode 100644 scene/2d/node_2d_singleton.h create mode 100644 scene/2d/parallax_background.cpp create mode 100644 scene/2d/parallax_background.h create mode 100644 scene/2d/parallax_layer.cpp create mode 100644 scene/2d/parallax_layer.h create mode 100644 scene/2d/particles_2d.cpp create mode 100644 scene/2d/particles_2d.h create mode 100644 scene/2d/path_2d.cpp create mode 100644 scene/2d/path_2d.h create mode 100644 scene/2d/physics_body_2d.cpp create mode 100644 scene/2d/physics_body_2d.h create mode 100644 scene/2d/position_2d.cpp create mode 100644 scene/2d/position_2d.h create mode 100644 scene/2d/ray_cast_2d.cpp create mode 100644 scene/2d/ray_cast_2d.h create mode 100644 scene/2d/remote_transform_2d.cpp create mode 100644 scene/2d/remote_transform_2d.h create mode 100644 scene/2d/sample_player_2d.cpp create mode 100644 scene/2d/sample_player_2d.h create mode 100644 scene/2d/screen_button.cpp create mode 100644 scene/2d/screen_button.h create mode 100644 scene/2d/sound_player_2d.cpp create mode 100644 scene/2d/sound_player_2d.h create mode 100644 scene/2d/sprite.cpp create mode 100644 scene/2d/sprite.h create mode 100644 scene/2d/tile_map.cpp create mode 100644 scene/2d/tile_map.h create mode 100644 scene/2d/visibility_notifier_2d.cpp create mode 100644 scene/2d/visibility_notifier_2d.h (limited to 'scene/2d') diff --git a/scene/2d/SCsub b/scene/2d/SCsub new file mode 100644 index 0000000000..055d2f2474 --- /dev/null +++ b/scene/2d/SCsub @@ -0,0 +1,7 @@ +Import('env') + +env.add_source_files(env.scene_sources,"*.cpp") + +Export('env') + + diff --git a/scene/2d/animated_sprite.cpp b/scene/2d/animated_sprite.cpp new file mode 100644 index 0000000000..316dffb3f9 --- /dev/null +++ b/scene/2d/animated_sprite.cpp @@ -0,0 +1,352 @@ +/*************************************************************************/ +/* animated_sprite.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "animated_sprite.h" + +void AnimatedSprite::edit_set_pivot(const Point2& p_pivot) { + + set_offset(p_pivot); +} + +Point2 AnimatedSprite::edit_get_pivot() const { + + return get_offset(); +} +bool AnimatedSprite::edit_has_pivot() const { + + return true; +} + + +void SpriteFrames::add_frame(const Ref& p_frame,int p_at_pos) { + + if (p_at_pos>=0 && p_at_pos=frames->get_frame_count()) + return; + + Ref texture = frames->get_frame(frame); + if (texture.is_null()) + return; + + //print_line("DECIDED TO DRAW"); + + RID ci = get_canvas_item(); + + /* + texture->draw(ci,Point2()); + break; + */ + + Size2i s; + s = texture->get_size(); + Point2i ofs=offset; + if (centered) + ofs-=s/2; + + Rect2i dst_rect(ofs,s); + + if (hflip) + dst_rect.size.x=-dst_rect.size.x; + if (vflip) + dst_rect.size.y=-dst_rect.size.y; + + texture->draw_rect(ci,dst_rect,false,modulate); +// VisualServer::get_singleton()->canvas_item_add_texture_rect_region(ci,dst_rect,texture->get_rid(),src_rect,modulate); + + } break; + } + +} + +void AnimatedSprite::set_sprite_frames(const Ref &p_frames) { + + if (frames.is_valid()) + frames->disconnect("changed",this,"_res_changed"); + frames=p_frames; + if (frames.is_valid()) + frames->connect("changed",this,"_res_changed"); + + if (!frames.is_valid()) { + frame=0; + + } else { + set_frame(frame); + } + update(); + +} + +Ref AnimatedSprite::get_sprite_frames() const { + + return frames; +} + +void AnimatedSprite::set_frame(int p_frame) { + + if (!frames.is_valid()) { + return; + } + if (p_frame>=frames->get_frame_count()) + p_frame=frames->get_frame_count()-1; + if (p_frame<0) + p_frame=0; + + if (frame==p_frame) + return; + + frame=p_frame; + update(); + _change_notify("frame"); + + +} +int AnimatedSprite::get_frame() const { + + return frame; +} + + +void AnimatedSprite::set_centered(bool p_center) { + + centered=p_center; + update(); + item_rect_changed(); +} + +bool AnimatedSprite::is_centered() const { + + return centered; +} + +void AnimatedSprite::set_offset(const Point2& p_offset) { + + offset=p_offset; + update(); + item_rect_changed(); +} +Point2 AnimatedSprite::get_offset() const { + + return offset; +} + +void AnimatedSprite::set_flip_h(bool p_flip) { + + hflip=p_flip; + update(); +} +bool AnimatedSprite::is_flipped_h() const { + + return hflip; +} + +void AnimatedSprite::set_flip_v(bool p_flip) { + + vflip=p_flip; + update(); +} +bool AnimatedSprite::is_flipped_v() const { + + return vflip; +} + + +void AnimatedSprite::set_modulate(const Color& p_color) { + + modulate=p_color; + update(); +} + +Color AnimatedSprite::get_modulate() const{ + + return modulate; +} + + +Rect2 AnimatedSprite::get_item_rect() const { + + if (!frames.is_valid() || !frames->get_frame_count() || frame<0 || frame>=frames->get_frame_count()) { + return Node2D::get_item_rect(); + } + + Ref t = frames->get_frame(frame); + if (t.is_null()) + return Node2D::get_item_rect(); + Size2i s = t->get_size(); + + Point2i ofs=offset; + if (centered) + ofs-=s/2; + + if (s==Size2(0,0)) + s=Size2(1,1); + + return Rect2(ofs,s); +} + +void AnimatedSprite::_res_changed() { + + set_frame(frame); + update(); +} + +void AnimatedSprite::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("set_sprite_frames","sprite_frames:SpriteFrames"),&AnimatedSprite::set_sprite_frames); + ObjectTypeDB::bind_method(_MD("get_sprite_frames:SpriteFrames"),&AnimatedSprite::get_sprite_frames); + + ObjectTypeDB::bind_method(_MD("set_centered","centered"),&AnimatedSprite::set_centered); + ObjectTypeDB::bind_method(_MD("is_centered"),&AnimatedSprite::is_centered); + + ObjectTypeDB::bind_method(_MD("set_offset","offset"),&AnimatedSprite::set_offset); + ObjectTypeDB::bind_method(_MD("get_offset"),&AnimatedSprite::get_offset); + + ObjectTypeDB::bind_method(_MD("set_flip_h","flip_h"),&AnimatedSprite::set_flip_h); + ObjectTypeDB::bind_method(_MD("is_flipped_h"),&AnimatedSprite::is_flipped_h); + + ObjectTypeDB::bind_method(_MD("set_flip_v","flip_v"),&AnimatedSprite::set_flip_v); + ObjectTypeDB::bind_method(_MD("is_flipped_v"),&AnimatedSprite::is_flipped_v); + + ObjectTypeDB::bind_method(_MD("set_frame","frame"),&AnimatedSprite::set_frame); + ObjectTypeDB::bind_method(_MD("get_frame"),&AnimatedSprite::get_frame); + + ObjectTypeDB::bind_method(_MD("set_modulate","modulate"),&AnimatedSprite::set_modulate); + ObjectTypeDB::bind_method(_MD("get_modulate"),&AnimatedSprite::get_modulate); + + + ObjectTypeDB::bind_method(_MD("_res_changed"),&AnimatedSprite::_res_changed); + + ADD_PROPERTYNZ( PropertyInfo( Variant::OBJECT, "frames",PROPERTY_HINT_RESOURCE_TYPE,"SpriteFrames"), _SCS("set_sprite_frames"),_SCS("get_sprite_frames")); + ADD_PROPERTYNZ( PropertyInfo( Variant::INT, "frame"), _SCS("set_frame"),_SCS("get_frame")); + ADD_PROPERTY( PropertyInfo( Variant::BOOL, "centered"), _SCS("set_centered"),_SCS("is_centered")); + ADD_PROPERTYNZ( PropertyInfo( Variant::VECTOR2, "offset"), _SCS("set_offset"),_SCS("get_offset")); + ADD_PROPERTY( PropertyInfo( Variant::BOOL, "flip_h"), _SCS("set_flip_h"),_SCS("is_flipped_h")); + ADD_PROPERTY( PropertyInfo( Variant::BOOL, "flip_v"), _SCS("set_flip_v"),_SCS("is_flipped_v")); + ADD_PROPERTY( PropertyInfo( Variant::COLOR, "modulate"), _SCS("set_modulate"),_SCS("get_modulate")); + +} + +AnimatedSprite::AnimatedSprite() { + + centered=true; + hflip=false; + vflip=false; + + frame=0; + + + modulate=Color(1,1,1,1); + + +} + + diff --git a/scene/2d/animated_sprite.h b/scene/2d/animated_sprite.h new file mode 100644 index 0000000000..78d738240f --- /dev/null +++ b/scene/2d/animated_sprite.h @@ -0,0 +1,119 @@ +/*************************************************************************/ +/* animated_sprite.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef ANIMATED_SPRITE_H +#define ANIMATED_SPRITE_H + +#include "scene/2d/node_2d.h" +#include "scene/resources/texture.h" + + +class SpriteFrames : public Resource { + + OBJ_TYPE(SpriteFrames,Resource); + + Vector< Ref > frames; + + Array _get_frames() const; + void _set_frames(const Array& p_frames); +protected: + + static void _bind_methods(); + +public: + + + void add_frame(const Ref& p_frame,int p_at_pos=-1); + int get_frame_count() const; + _FORCE_INLINE_ Ref get_frame(int p_idx) const { ERR_FAIL_INDEX_V(p_idx,frames.size(),Ref()); return frames[p_idx]; } + void set_frame(int p_idx,const Ref& p_frame){ ERR_FAIL_INDEX(p_idx,frames.size()); frames[p_idx]=p_frame; } + void remove_frame(int p_idx); + void clear(); + + SpriteFrames(); + +}; + + + +class AnimatedSprite : public Node2D { + + OBJ_TYPE(AnimatedSprite,Node2D); + + Ref frames; + int frame; + + bool centered; + Point2 offset; + + bool hflip; + bool vflip; + + Color modulate; + + void _res_changed(); +protected: + + static void _bind_methods(); + void _notification(int p_what); + +public: + + + virtual void edit_set_pivot(const Point2& p_pivot); + virtual Point2 edit_get_pivot() const; + virtual bool edit_has_pivot() const; + + void set_sprite_frames(const Ref &p_frames); + Ref get_sprite_frames() const; + + void set_frame(int p_frame); + int get_frame() const; + + void set_centered(bool p_center); + bool is_centered() const; + + void set_offset(const Point2& p_offset); + Point2 get_offset() const; + + void set_flip_h(bool p_flip); + bool is_flipped_h() const; + + void set_flip_v(bool p_flip); + bool is_flipped_v() const; + + void set_modulate(const Color& p_color); + Color get_modulate() const; + + virtual Rect2 get_item_rect() const; + + + AnimatedSprite(); +}; + +#endif // ANIMATED_SPRITE_H diff --git a/scene/2d/area_2d.cpp b/scene/2d/area_2d.cpp new file mode 100644 index 0000000000..70b5a652d5 --- /dev/null +++ b/scene/2d/area_2d.cpp @@ -0,0 +1,326 @@ +/*************************************************************************/ +/* area_2d.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "area_2d.h" +#include "scene/scene_string_names.h" +#include "servers/physics_2d_server.h" +void Area2D::set_space_override_mode(SpaceOverride p_mode) { + + space_override=p_mode; + Physics2DServer::get_singleton()->area_set_space_override_mode(get_rid(),Physics2DServer::AreaSpaceOverrideMode(p_mode)); + + +} +Area2D::SpaceOverride Area2D::get_space_override_mode() const{ + + return space_override; +} + +void Area2D::set_gravity_is_point(bool p_enabled){ + + gravity_is_point=p_enabled; + Physics2DServer::get_singleton()->area_set_param(get_rid(),Physics2DServer::AREA_PARAM_GRAVITY_IS_POINT,p_enabled); + +} +bool Area2D::is_gravity_a_point() const{ + + return gravity_is_point; +} + +void Area2D::set_gravity_vector(const Vector2& p_vec){ + + gravity_vec=p_vec; + Physics2DServer::get_singleton()->area_set_param(get_rid(),Physics2DServer::AREA_PARAM_GRAVITY_VECTOR,p_vec); + +} +Vector2 Area2D::get_gravity_vector() const{ + + return gravity_vec; +} + +void Area2D::set_gravity(real_t p_gravity){ + + gravity=p_gravity; + Physics2DServer::get_singleton()->area_set_param(get_rid(),Physics2DServer::AREA_PARAM_GRAVITY,p_gravity); +} +real_t Area2D::get_gravity() const{ + + return gravity; +} + +void Area2D::set_density(real_t p_density){ + + density=p_density; + Physics2DServer::get_singleton()->area_set_param(get_rid(),Physics2DServer::AREA_PARAM_DENSITY,p_density); +} +real_t Area2D::get_density() const{ + + return density; +} + +void Area2D::set_priority(real_t p_priority){ + + priority=p_priority; + Physics2DServer::get_singleton()->area_set_param(get_rid(),Physics2DServer::AREA_PARAM_PRIORITY,p_priority); +} +real_t Area2D::get_priority() const{ + + return priority; +} + + +void Area2D::_body_enter_scene(ObjectID p_id) { + + Object *obj = ObjectDB::get_instance(p_id); + Node *node = obj ? obj->cast_to() : NULL; + ERR_FAIL_COND(!node); + + Map::Element *E=body_map.find(p_id); + ERR_FAIL_COND(!E); + ERR_FAIL_COND(E->get().in_scene); + + E->get().in_scene=true; + emit_signal(SceneStringNames::get_singleton()->body_enter,node); + for(int i=0;iget().shapes.size();i++) { + + emit_signal(SceneStringNames::get_singleton()->body_enter_shape,p_id,node,E->get().shapes[i].body_shape,E->get().shapes[i].area_shape); + } + +} + +void Area2D::_body_exit_scene(ObjectID p_id) { + + Object *obj = ObjectDB::get_instance(p_id); + Node *node = obj ? obj->cast_to() : NULL; + ERR_FAIL_COND(!node); + Map::Element *E=body_map.find(p_id); + ERR_FAIL_COND(!E); + ERR_FAIL_COND(!E->get().in_scene); + E->get().in_scene=false; + emit_signal(SceneStringNames::get_singleton()->body_exit,node); + for(int i=0;iget().shapes.size();i++) { + + emit_signal(SceneStringNames::get_singleton()->body_exit_shape,p_id,node,E->get().shapes[i].body_shape,E->get().shapes[i].area_shape); + } + +} + +void Area2D::_body_inout(int p_status,const RID& p_body, int p_instance, int p_body_shape,int p_area_shape) { + + bool body_in = p_status==Physics2DServer::AREA_BODY_ADDED; + ObjectID objid=p_instance; + + Object *obj = ObjectDB::get_instance(objid); + Node *node = obj ? obj->cast_to() : NULL; + + Map::Element *E=body_map.find(objid); + + ERR_FAIL_COND(!body_in && !E); + + if (body_in) { + if (!E) { + + E = body_map.insert(objid,BodyState()); + E->get().rc=0; + E->get().in_scene=node && node->is_inside_scene(); + if (node) { + node->connect(SceneStringNames::get_singleton()->enter_scene,this,SceneStringNames::get_singleton()->_body_enter_scene,make_binds(objid)); + node->connect(SceneStringNames::get_singleton()->exit_scene,this,SceneStringNames::get_singleton()->_body_exit_scene,make_binds(objid)); + if (E->get().in_scene) { + emit_signal(SceneStringNames::get_singleton()->body_enter,node); + } + } + + } + E->get().rc++; + if (node) + E->get().shapes.insert(ShapePair(p_body_shape,p_area_shape)); + + + if (E->get().in_scene) { + emit_signal(SceneStringNames::get_singleton()->body_enter_shape,objid,node,p_body_shape,p_area_shape); + } + + } else { + + E->get().rc--; + + if (node) + E->get().shapes.erase(ShapePair(p_body_shape,p_area_shape)); + + bool eraseit=false; + + if (E->get().rc==0) { + + if (node) { + node->disconnect(SceneStringNames::get_singleton()->enter_scene,this,SceneStringNames::get_singleton()->_body_enter_scene); + node->disconnect(SceneStringNames::get_singleton()->exit_scene,this,SceneStringNames::get_singleton()->_body_exit_scene); + if (E->get().in_scene) + emit_signal(SceneStringNames::get_singleton()->body_exit,obj); + + } + + eraseit=true; + + } + if (node && E->get().in_scene) { + emit_signal(SceneStringNames::get_singleton()->body_exit_shape,objid,obj,p_body_shape,p_area_shape); + } + + if (eraseit) + body_map.erase(E); + + } + +} + + +void Area2D::_clear_monitoring() { + + + Map bmcopy = body_map; + body_map.clear(); + //disconnect all monitored stuff + + for (Map::Element *E=bmcopy.front();E;E=E->next()) { + + Object *obj = ObjectDB::get_instance(E->key()); + Node *node = obj ? obj->cast_to() : NULL; + ERR_CONTINUE(!node); + if (!E->get().in_scene) + continue; + + for(int i=0;iget().shapes.size();i++) { + + emit_signal(SceneStringNames::get_singleton()->body_exit_shape,E->key(),node,E->get().shapes[i].body_shape,E->get().shapes[i].area_shape); + } + + emit_signal(SceneStringNames::get_singleton()->body_exit,obj); + + node->disconnect(SceneStringNames::get_singleton()->enter_scene,this,SceneStringNames::get_singleton()->_body_enter_scene); + node->disconnect(SceneStringNames::get_singleton()->exit_scene,this,SceneStringNames::get_singleton()->_body_exit_scene); + } + +} + +void Area2D::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_EXIT_SCENE: { + + _clear_monitoring(); + } break; + } + +} + + +void Area2D::set_enable_monitoring(bool p_enable) { + + if (p_enable==monitoring) + return; + + monitoring=p_enable; + + if (monitoring) { + + Physics2DServer::get_singleton()->area_set_monitor_callback(get_rid(),this,"_body_inout"); + } else { + Physics2DServer::get_singleton()->area_set_monitor_callback(get_rid(),NULL,StringName()); + _clear_monitoring(); + + } +} + +bool Area2D::is_monitoring_enabled() const { + + return monitoring; +} + + +void Area2D::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_body_enter_scene","id"),&Area2D::_body_enter_scene); + ObjectTypeDB::bind_method(_MD("_body_exit_scene","id"),&Area2D::_body_exit_scene); + + ObjectTypeDB::bind_method(_MD("set_space_override_mode","enable"),&Area2D::set_space_override_mode); + ObjectTypeDB::bind_method(_MD("get_space_override_mode"),&Area2D::get_space_override_mode); + + ObjectTypeDB::bind_method(_MD("set_gravity_is_point","enable"),&Area2D::set_gravity_is_point); + ObjectTypeDB::bind_method(_MD("is_gravity_a_point"),&Area2D::is_gravity_a_point); + + ObjectTypeDB::bind_method(_MD("set_gravity_vector","vector"),&Area2D::set_gravity_vector); + ObjectTypeDB::bind_method(_MD("get_gravity_vector"),&Area2D::get_gravity_vector); + + ObjectTypeDB::bind_method(_MD("set_gravity","gravity"),&Area2D::set_gravity); + ObjectTypeDB::bind_method(_MD("get_gravity"),&Area2D::get_gravity); + + ObjectTypeDB::bind_method(_MD("set_density","density"),&Area2D::set_density); + ObjectTypeDB::bind_method(_MD("get_density"),&Area2D::get_density); + + ObjectTypeDB::bind_method(_MD("set_priority","priority"),&Area2D::set_priority); + ObjectTypeDB::bind_method(_MD("get_priority"),&Area2D::get_priority); + + ObjectTypeDB::bind_method(_MD("set_enable_monitoring","enable"),&Area2D::set_enable_monitoring); + ObjectTypeDB::bind_method(_MD("is_monitoring_enabled"),&Area2D::is_monitoring_enabled); + + ObjectTypeDB::bind_method(_MD("_body_inout"),&Area2D::_body_inout); + + + ADD_SIGNAL( MethodInfo("body_enter_shape",PropertyInfo(Variant::INT,"body_id"),PropertyInfo(Variant::OBJECT,"body"),PropertyInfo(Variant::INT,"body_shape"),PropertyInfo(Variant::INT,"area_shape"))); + ADD_SIGNAL( MethodInfo("body_exit_shape",PropertyInfo(Variant::INT,"body_id"),PropertyInfo(Variant::OBJECT,"body"),PropertyInfo(Variant::INT,"body_shape"),PropertyInfo(Variant::INT,"area_shape"))); + ADD_SIGNAL( MethodInfo("body_enter",PropertyInfo(Variant::OBJECT,"body"))); + ADD_SIGNAL( MethodInfo("body_exit",PropertyInfo(Variant::OBJECT,"body"))); + + ADD_PROPERTYNZ( PropertyInfo(Variant::INT,"space_override",PROPERTY_HINT_ENUM,"Disabled,Combine,Replace"),_SCS("set_space_override_mode"),_SCS("get_space_override_mode")); + ADD_PROPERTY( PropertyInfo(Variant::BOOL,"gravity_point"),_SCS("set_gravity_is_point"),_SCS("is_gravity_a_point")); + ADD_PROPERTY( PropertyInfo(Variant::VECTOR2,"gravity_vec"),_SCS("set_gravity_vector"),_SCS("get_gravity_vector")); + ADD_PROPERTY( PropertyInfo(Variant::REAL,"gravity",PROPERTY_HINT_RANGE,"-1024,1024,0.01"),_SCS("set_gravity"),_SCS("get_gravity")); + ADD_PROPERTY( PropertyInfo(Variant::REAL,"density",PROPERTY_HINT_RANGE,"0,1024,0.001"),_SCS("set_density"),_SCS("get_density")); + ADD_PROPERTYNZ( PropertyInfo(Variant::INT,"priority",PROPERTY_HINT_RANGE,"0,128,1"),_SCS("set_priority"),_SCS("get_priority")); + ADD_PROPERTY( PropertyInfo(Variant::BOOL,"monitoring"),_SCS("set_enable_monitoring"),_SCS("is_monitoring_enabled")); + +} + +Area2D::Area2D() : CollisionObject2D(Physics2DServer::get_singleton()->area_create(),true) { + + space_override=SPACE_OVERRIDE_DISABLED; + set_gravity(98);; + set_gravity_vector(Vector2(0,1)); + gravity_is_point=false; + density=0.1; + priority=0; + monitoring=false; + +} + +Area2D::~Area2D() { + + +} diff --git a/scene/2d/area_2d.h b/scene/2d/area_2d.h new file mode 100644 index 0000000000..b4c8edf138 --- /dev/null +++ b/scene/2d/area_2d.h @@ -0,0 +1,122 @@ +/*************************************************************************/ +/* area_2d.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef AREA_2D_H +#define AREA_2D_H + +#include "scene/2d/collision_object_2d.h" +#include "vset.h" + +class Area2D : public CollisionObject2D { + + OBJ_TYPE( Area2D, CollisionObject2D ); +public: + + enum SpaceOverride { + SPACE_OVERRIDE_DISABLED, + SPACE_OVERRIDE_COMBINE, + SPACE_OVERRIDE_REPLACE + }; +private: + + + SpaceOverride space_override; + Vector2 gravity_vec; + real_t gravity; + bool gravity_is_point; + real_t density; + int priority; + bool monitoring; + + void _body_inout(int p_status,const RID& p_body, int p_instance, int p_body_shape,int p_area_shape); + + void _body_enter_scene(ObjectID p_id); + void _body_exit_scene(ObjectID p_id); + + struct ShapePair { + + int body_shape; + int area_shape; + bool operator<(const ShapePair& p_sp) const { + if (body_shape==p_sp.body_shape) + return area_shape < p_sp.area_shape; + else + return body_shape < p_sp.body_shape; + } + + ShapePair() {} + ShapePair(int p_bs, int p_as) { body_shape=p_bs; area_shape=p_as; } + }; + + struct BodyState { + + int rc; + bool in_scene; + VSet shapes; + }; + + Map body_map; + + void _clear_monitoring(); + + +protected: + + void _notification(int p_what); + static void _bind_methods(); +public: + + void set_space_override_mode(SpaceOverride p_mode); + SpaceOverride get_space_override_mode() const; + + void set_gravity_is_point(bool p_enabled); + bool is_gravity_a_point() const; + + void set_gravity_vector(const Vector2& p_vec); + Vector2 get_gravity_vector() const; + + void set_gravity(real_t p_gravity); + real_t get_gravity() const; + + void set_density(real_t p_density); + real_t get_density() const; + + void set_priority(real_t p_priority); + real_t get_priority() const; + + void set_enable_monitoring(bool p_enable); + bool is_monitoring_enabled() const; + + + Area2D(); + ~Area2D(); +}; + +VARIANT_ENUM_CAST(Area2D::SpaceOverride); + +#endif // AREA_2D_H diff --git a/scene/2d/camera_2d.cpp b/scene/2d/camera_2d.cpp new file mode 100644 index 0000000000..1920ce0081 --- /dev/null +++ b/scene/2d/camera_2d.cpp @@ -0,0 +1,484 @@ +/*************************************************************************/ +/* camera_2d.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "camera_2d.h" +#include "scene/scene_string_names.h" +#include "servers/visual_server.h" + +void Camera2D::_update_scroll() { + + + if (!is_inside_scene()) + return; + + if (get_scene()->is_editor_hint()) { + update(); //will just be drawn + return; + } + + if (current) { + Matrix32 xform = get_camera_transform(); + + RID vp = viewport->get_viewport(); + if (viewport) { + viewport->set_canvas_transform( xform ); + } + get_scene()->call_group(SceneMainLoop::GROUP_CALL_REALTIME,group_name,"_camera_moved",xform); + }; + +} + +void Camera2D::set_zoom(const Vector2 &p_zoom) { + + zoom = p_zoom; + _update_scroll(); +}; + +Vector2 Camera2D::get_zoom() const { + + return zoom; +}; + + +Matrix32 Camera2D::get_camera_transform() { + + if (!get_scene()) + return Matrix32(); + + Size2 screen_size = get_viewport_rect().size; + screen_size=get_viewport_rect().size; + + + Point2 new_camera_pos = get_global_transform().get_origin(); + Point2 ret_camera_pos; + + if (!first) { + + + if (centered) { + + if (h_drag_enabled) { + camera_pos.x = MIN( camera_pos.x, (new_camera_pos.x + screen_size.x * 0.5 * drag_margin[MARGIN_RIGHT])); + camera_pos.x = MAX( camera_pos.x, (new_camera_pos.x - screen_size.x * 0.5 * drag_margin[MARGIN_LEFT])); + } else { + + if (h_ofs<0) { + camera_pos.x = new_camera_pos.x + screen_size.x * 0.5 * drag_margin[MARGIN_RIGHT] * h_ofs; + } else { + camera_pos.x = new_camera_pos.x + screen_size.x * 0.5 * drag_margin[MARGIN_LEFT] * h_ofs; + } + } + + if (v_drag_enabled) { + + camera_pos.y = MIN( camera_pos.y, (new_camera_pos.y + screen_size.y * 0.5 * drag_margin[MARGIN_BOTTOM])); + camera_pos.y = MAX( camera_pos.y, (new_camera_pos.y - screen_size.y * 0.5 * drag_margin[MARGIN_TOP])); + + } else { + + if (v_ofs<0) { + camera_pos.y = new_camera_pos.y + screen_size.y * 0.5 * drag_margin[MARGIN_TOP] * v_ofs; + } else { + camera_pos.y = new_camera_pos.y + screen_size.y * 0.5 * drag_margin[MARGIN_BOTTOM] * v_ofs; + } + } + + } + + + if (smoothing>0.0) { + + float c = smoothing*get_fixed_process_delta_time(); + smoothed_camera_pos = ((new_camera_pos-smoothed_camera_pos)*c)+smoothed_camera_pos; + ret_camera_pos=smoothed_camera_pos; +// camera_pos=camera_pos*(1.0-smoothing)+new_camera_pos*smoothing; + } else { + + ret_camera_pos=smoothed_camera_pos=camera_pos; + + } + + + + } else { + ret_camera_pos=smoothed_camera_pos=camera_pos=new_camera_pos; + first=false; + } + + + Point2 screen_offset = (centered ? (screen_size * 0.5 * zoom) : Point2());; + screen_offset+=offset; + + Rect2 screen_rect(-screen_offset+ret_camera_pos,screen_size); + if (screen_rect.pos.x + screen_rect.size.x > limit[MARGIN_RIGHT]) + screen_rect.pos.x = limit[MARGIN_RIGHT] - screen_rect.size.x; + + if (screen_rect.pos.y + screen_rect.size.y > limit[MARGIN_BOTTOM]) + screen_rect.pos.y = limit[MARGIN_BOTTOM] - screen_rect.size.y; + + + if (screen_rect.pos.x < limit[MARGIN_LEFT]) + screen_rect.pos.x=limit[MARGIN_LEFT]; + + if (screen_rect.pos.y < limit[MARGIN_TOP]) + screen_rect.pos.y =limit[MARGIN_TOP]; + + camera_screen_center=screen_rect.pos+screen_rect.size*0.5; + + Matrix32 xform; + xform.scale_basis(zoom); + xform.set_origin(screen_rect.pos/*.floor()*/); + + +/* + if (0) { + + xform = get_global_transform() * xform; + } else { + + xform.elements[2]+=get_global_transform().get_origin(); + } +*/ + + + return (xform).affine_inverse(); +} + + + +void Camera2D::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_FIXED_PROCESS: { + + _update_scroll(); + + } break; + case NOTIFICATION_TRANSFORM_CHANGED: { + + + if (!is_fixed_processing()) + _update_scroll(); + + } break; + case NOTIFICATION_ENTER_SCENE: { + + viewport = NULL; + Node *n=this; + while(n){ + + viewport = n->cast_to(); + if (viewport) + break; + n=n->get_parent(); + } + + canvas = get_canvas(); + + RID vp = viewport->get_viewport(); + + group_name = "__cameras_"+itos(vp.get_id()); + canvas_group_name ="__cameras_c"+itos(canvas.get_id()); + add_to_group(group_name); + add_to_group(canvas_group_name); + + _update_scroll(); + first=true; + + + } break; + case NOTIFICATION_EXIT_SCENE: { + + if (is_current()) { + if (viewport) { + viewport->set_canvas_transform( Matrix32() ); + } + } + remove_from_group(group_name); + remove_from_group(canvas_group_name); + viewport=NULL; + + } break; + } +} + +void Camera2D::set_offset(const Vector2& p_offset) { + + offset=p_offset; + _update_scroll(); + +} + +Vector2 Camera2D::get_offset() const{ + + return offset; +} + +void Camera2D::set_centered(bool p_centered){ + + centered=p_centered; + _update_scroll(); +} + +bool Camera2D::is_centered() const { + + return centered; +} + + +void Camera2D::_make_current(Object *p_which) { + + if (p_which==this) { + + current=true; + _update_scroll(); + } else { + current=false; + } +} + + +void Camera2D::_set_current(bool p_current) { + + if (p_current) + make_current(); + + current=p_current; +} + +bool Camera2D::is_current() const { + + return current; +} + +void Camera2D::make_current() { + + if (!is_inside_scene()) { + current=true; + } else { + get_scene()->call_group(SceneMainLoop::GROUP_CALL_REALTIME,group_name,"_make_current",this); + } +} + +void Camera2D::set_limit(Margin p_margin,int p_limit) { + + ERR_FAIL_INDEX(p_margin,4); + limit[p_margin]=p_limit; +} + +int Camera2D::get_limit(Margin p_margin) const{ + + ERR_FAIL_INDEX_V(p_margin,4,0); + return limit[p_margin]; + +} + +void Camera2D::set_drag_margin(Margin p_margin,float p_drag_margin) { + + ERR_FAIL_INDEX(p_margin,4); + drag_margin[p_margin]=p_drag_margin; +} + +float Camera2D::get_drag_margin(Margin p_margin) const{ + + ERR_FAIL_INDEX_V(p_margin,4,0); + return drag_margin[p_margin]; + +} + + +Vector2 Camera2D::get_camera_pos() const { + + + return camera_pos; +} + +void Camera2D::force_update_scroll() { + + + _update_scroll(); +} + + +void Camera2D::set_follow_smoothing(float p_speed) { + + smoothing=p_speed; + if (smoothing>0) + set_fixed_process(true); + else + set_fixed_process(false); +} + +float Camera2D::get_follow_smoothing() const{ + + return smoothing; +} + +Point2 Camera2D::get_camera_screen_center() const { + + return camera_screen_center; +} + + +void Camera2D::set_h_drag_enabled(bool p_enabled) { + + h_drag_enabled=p_enabled; +} + +bool Camera2D::is_h_drag_enabled() const{ + + return h_drag_enabled; +} + +void Camera2D::set_v_drag_enabled(bool p_enabled){ + + v_drag_enabled=p_enabled; +} + +bool Camera2D::is_v_drag_enabled() const{ + + return v_drag_enabled; +} + +void Camera2D::set_v_offset(float p_offset) { + + v_ofs=p_offset; +} + +float Camera2D::get_v_offset() const{ + + return v_ofs; +} + +void Camera2D::set_h_offset(float p_offset){ + + h_ofs=p_offset; +} +float Camera2D::get_h_offset() const{ + + return h_ofs; +} + + +void Camera2D::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("set_offset","offset"),&Camera2D::set_offset); + ObjectTypeDB::bind_method(_MD("get_offset"),&Camera2D::get_offset); + + ObjectTypeDB::bind_method(_MD("set_centered","centered"),&Camera2D::set_centered); + ObjectTypeDB::bind_method(_MD("is_centered"),&Camera2D::is_centered); + + ObjectTypeDB::bind_method(_MD("make_current"),&Camera2D::make_current); + ObjectTypeDB::bind_method(_MD("_make_current"),&Camera2D::_make_current); + + ObjectTypeDB::bind_method(_MD("_update_scroll"),&Camera2D::_update_scroll); + + + ObjectTypeDB::bind_method(_MD("_set_current","current"),&Camera2D::_set_current); + ObjectTypeDB::bind_method(_MD("is_current"),&Camera2D::is_current); + + ObjectTypeDB::bind_method(_MD("set_limit","margin","limit"),&Camera2D::set_limit); + ObjectTypeDB::bind_method(_MD("get_limit","margin"),&Camera2D::get_limit); + + ObjectTypeDB::bind_method(_MD("set_v_drag_enabled","enabled"),&Camera2D::set_v_drag_enabled); + ObjectTypeDB::bind_method(_MD("is_v_drag_enabled"),&Camera2D::is_v_drag_enabled); + + ObjectTypeDB::bind_method(_MD("set_h_drag_enabled","enabled"),&Camera2D::set_h_drag_enabled); + ObjectTypeDB::bind_method(_MD("is_h_drag_enabled"),&Camera2D::is_h_drag_enabled); + + ObjectTypeDB::bind_method(_MD("set_v_offset","ofs"),&Camera2D::set_v_offset); + ObjectTypeDB::bind_method(_MD("get_v_offset"),&Camera2D::get_v_offset); + + ObjectTypeDB::bind_method(_MD("set_h_offset","ofs"),&Camera2D::set_h_offset); + ObjectTypeDB::bind_method(_MD("get_h_offset"),&Camera2D::get_h_offset); + + ObjectTypeDB::bind_method(_MD("set_drag_margin","margin","drag_margin"),&Camera2D::set_drag_margin); + ObjectTypeDB::bind_method(_MD("get_drag_margin","margin"),&Camera2D::get_drag_margin); + + ObjectTypeDB::bind_method(_MD("get_camera_pos"),&Camera2D::get_camera_pos); + ObjectTypeDB::bind_method(_MD("get_camera_screen_center"),&Camera2D::get_camera_screen_center); + + ObjectTypeDB::bind_method(_MD("set_zoom"),&Camera2D::set_zoom); + ObjectTypeDB::bind_method(_MD("get_zoom"),&Camera2D::get_zoom); + + + ObjectTypeDB::bind_method(_MD("set_follow_smoothing","follow_smoothing"),&Camera2D::set_follow_smoothing); + ObjectTypeDB::bind_method(_MD("get_follow_smoothing"),&Camera2D::get_follow_smoothing); + + ObjectTypeDB::bind_method(_MD("force_update_scroll"),&Camera2D::force_update_scroll); + + + ADD_PROPERTYNZ( PropertyInfo(Variant::VECTOR2,"offset"),_SCS("set_offset"),_SCS("get_offset")); + ADD_PROPERTY( PropertyInfo(Variant::BOOL,"centered"),_SCS("set_centered"),_SCS("is_centered")); + ADD_PROPERTY( PropertyInfo(Variant::BOOL,"current"),_SCS("_set_current"),_SCS("is_current")); + ADD_PROPERTY( PropertyInfo(Variant::REAL,"smoothing"),_SCS("set_follow_smoothing"),_SCS("get_follow_smoothing") ); + ADD_PROPERTY( PropertyInfo(Variant::VECTOR2,"zoom"),_SCS("set_zoom"),_SCS("get_zoom") ); + + ADD_PROPERTYI( PropertyInfo(Variant::INT,"limit/left"),_SCS("set_limit"),_SCS("get_limit"),MARGIN_LEFT); + ADD_PROPERTYI( PropertyInfo(Variant::INT,"limit/top"),_SCS("set_limit"),_SCS("get_limit"),MARGIN_TOP); + ADD_PROPERTYI( PropertyInfo(Variant::INT,"limit/right"),_SCS("set_limit"),_SCS("get_limit"),MARGIN_RIGHT); + ADD_PROPERTYI( PropertyInfo(Variant::INT,"limit/bottom"),_SCS("set_limit"),_SCS("get_limit"),MARGIN_BOTTOM); + + ADD_PROPERTY( PropertyInfo(Variant::BOOL,"drag_margin/h_enabled"),_SCS("set_h_drag_enabled"),_SCS("is_h_drag_enabled") ); + ADD_PROPERTY( PropertyInfo(Variant::BOOL,"drag_margin/v_enabled"),_SCS("set_v_drag_enabled"),_SCS("is_v_drag_enabled") ); + + ADD_PROPERTYI( PropertyInfo(Variant::REAL,"drag_margin/left",PROPERTY_HINT_RANGE,"0,1,0.01"),_SCS("set_drag_margin"),_SCS("get_drag_margin"),MARGIN_LEFT); + ADD_PROPERTYI( PropertyInfo(Variant::REAL,"drag_margin/top",PROPERTY_HINT_RANGE,"0,1,0.01"),_SCS("set_drag_margin"),_SCS("get_drag_margin"),MARGIN_TOP); + ADD_PROPERTYI( PropertyInfo(Variant::REAL,"drag_margin/right",PROPERTY_HINT_RANGE,"0,1,0.01"),_SCS("set_drag_margin"),_SCS("get_drag_margin"),MARGIN_RIGHT); + ADD_PROPERTYI( PropertyInfo(Variant::REAL,"drag_margin/bottom",PROPERTY_HINT_RANGE,"0,1,0.01"),_SCS("set_drag_margin"),_SCS("get_drag_margin"),MARGIN_BOTTOM); + + + +} + +Camera2D::Camera2D() { + + + + centered=true; + current=false; + limit[MARGIN_LEFT]=-10000000; + limit[MARGIN_TOP]=-10000000; + limit[MARGIN_RIGHT]=10000000; + limit[MARGIN_BOTTOM]=10000000; + drag_margin[MARGIN_LEFT]=0.2; + drag_margin[MARGIN_TOP]=0.2; + drag_margin[MARGIN_RIGHT]=0.2; + drag_margin[MARGIN_BOTTOM]=0.2; + camera_pos=Vector2(); + + smoothing=0.0; + zoom = Vector2(1, 1); + + h_drag_enabled=true; + v_drag_enabled=true; + h_ofs=0; + v_ofs=0; + +} diff --git a/scene/2d/camera_2d.h b/scene/2d/camera_2d.h new file mode 100644 index 0000000000..9d06df2d1b --- /dev/null +++ b/scene/2d/camera_2d.h @@ -0,0 +1,118 @@ +/*************************************************************************/ +/* camera_2d.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef CAMERA_2D_H +#define CAMERA_2D_H + +#include "scene/2d/node_2d.h" +#include "scene/main/viewport.h" + + +class Camera2D : public Node2D { + + OBJ_TYPE( Camera2D, Node2D ); + +protected: + Point2 camera_pos; + Point2 smoothed_camera_pos; + bool first; + + Viewport *viewport; + + StringName group_name; + StringName canvas_group_name; + RID canvas; + Vector2 offset; + Vector2 zoom; + bool centered; + bool current; + float smoothing; + int limit[4]; + float drag_margin[4]; + + bool h_drag_enabled; + bool v_drag_enabled; + float h_ofs; + float v_ofs; + + + Point2 camera_screen_center; + void _update_scroll(); + + void _make_current(Object *p_which); + void _set_current(bool p_current); +protected: + + virtual Matrix32 get_camera_transform(); + void _notification(int p_what); + static void _bind_methods(); +public: + + void set_offset(const Vector2& p_offset); + Vector2 get_offset() const; + + void set_centered(bool p_centered); + bool is_centered() const; + + void set_limit(Margin p_margin,int p_limit); + int get_limit(Margin p_margin) const; + + + void set_h_drag_enabled(bool p_enabled); + bool is_h_drag_enabled() const; + + void set_v_drag_enabled(bool p_enabled); + bool is_v_drag_enabled() const; + + void set_drag_margin(Margin p_margin,float p_drag_margin); + float get_drag_margin(Margin p_margin) const; + + void set_v_offset(float p_offset); + float get_v_offset() const; + + void set_h_offset(float p_offset); + float get_h_offset() const; + + void set_follow_smoothing(float p_speed); + float get_follow_smoothing() const; + + void make_current(); + bool is_current() const; + + void set_zoom(const Vector2& p_zoom); + Vector2 get_zoom() const; + + Point2 get_camera_screen_center() const; + + Vector2 get_camera_pos() const; + void force_update_scroll(); + + Camera2D(); +}; + +#endif // CAMERA_2D_H diff --git a/scene/2d/canvas_item.cpp b/scene/2d/canvas_item.cpp new file mode 100644 index 0000000000..8a461c76fc --- /dev/null +++ b/scene/2d/canvas_item.cpp @@ -0,0 +1,875 @@ +/*************************************************************************/ +/* canvas_item.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "canvas_item.h" +#include "servers/visual_server.h" +#include "scene/main/viewport.h" +#include "scene/main/canvas_layer.h" +#include "message_queue.h" +#include "scene/scene_string_names.h" +#include "scene/resources/font.h" +#include "scene/resources/texture.h" +#include "scene/resources/style_box.h" + +bool CanvasItem::is_visible() const { + + if (!is_inside_scene()) + return false; + + const CanvasItem *p=this; + + while(p) { + if (p->hidden) + return false; + p=p->get_parent_item(); + } + + + return true; +} + +bool CanvasItem::is_hidden() const { + + /*if (!is_inside_scene()) + return false;*/ + + return hidden; +} + +void CanvasItem::_propagate_visibility_changed(bool p_visible) { + + notification(NOTIFICATION_VISIBILITY_CHANGED); + + if (p_visible) + update(); //todo optimize + else + emit_signal(SceneStringNames::get_singleton()->hide); + _block(); + + for(int i=0;icast_to(); + + if (c && c->hidden!=p_visible) //should the toplevels stop propagation? i think so but.. + c->_propagate_visibility_changed(p_visible); + } + + _unblock(); + +} + +void CanvasItem::show() { + + if (!hidden) + return; + + + hidden=false; + VisualServer::get_singleton()->canvas_item_set_visible(canvas_item,true); + + if (!is_inside_scene()) + return; + + if (is_visible()) { + _propagate_visibility_changed(true); + } +} + + +void CanvasItem::hide() { + + if (hidden) + return; + + bool propagate=is_inside_scene() && is_visible(); + hidden=true; + VisualServer::get_singleton()->canvas_item_set_visible(canvas_item,false); + + if (!is_inside_scene()) + return; + if (propagate) + _propagate_visibility_changed(false); + +} + + +Variant CanvasItem::edit_get_state() const { + + + return Variant(); +} +void CanvasItem::edit_set_state(const Variant& p_state) { + + +} + +void CanvasItem::edit_set_rect(const Rect2& p_edit_rect) { + + //used by editors, implement at will +} + +void CanvasItem::edit_rotate(float p_rot) { + + +} + +Size2 CanvasItem::edit_get_minimum_size() const { + + return Size2(-1,-1); //no limit +} + +void CanvasItem::_update_callback() { + + + + if (!is_inside_scene()) { + pending_update=false; + return; + } + + + VisualServer::get_singleton()->canvas_item_clear(get_canvas_item()); + //todo updating = true - only allow drawing here + if (is_visible()) { //todo optimize this!! + if (first_draw) { + notification(NOTIFICATION_VISIBILITY_CHANGED); + first_draw=false; + } + drawing=true; + notification(NOTIFICATION_DRAW); + emit_signal(SceneStringNames::get_singleton()->draw); + if (get_script_instance()) { + Variant::CallError err; + get_script_instance()->call_multilevel_reversed(SceneStringNames::get_singleton()->_draw,NULL,0); + } + drawing=false; + + } + //todo updating = false + pending_update=false; // don't change to false until finished drawing (avoid recursive update) +} + +Matrix32 CanvasItem::get_global_transform_with_canvas() const { + + const CanvasItem *ci = this; + Matrix32 xform; + const CanvasItem *last_valid=NULL; + + while(ci) { + + last_valid=ci; + xform = ci->get_transform() * xform; + ci=ci->get_parent_item(); + } + + if (last_valid->canvas_layer) + return last_valid->canvas_layer->get_transform() * xform; + else + return xform; +} + +Matrix32 CanvasItem::get_global_transform() const { + + + if (global_invalid) { + + const CanvasItem *pi = get_parent_item(); + if (pi) + global_transform = pi->get_global_transform() * get_transform(); + else + global_transform = get_transform(); + + global_invalid=false; + } + + return global_transform; + +} + + +void CanvasItem::_queue_sort_children() { + + if (pending_children_sort) + return; + + pending_children_sort=true; + MessageQueue::get_singleton()->push_call(this,"_sort_children"); +} + +void CanvasItem::_sort_children() { + + pending_children_sort=false; + + if (!is_inside_scene()) + return; + + for(int i=0;icast_to(); + + if (ci) { + if (ci->toplevel || ci->group!="") + continue; + VisualServer::get_singleton()->canvas_item_raise(n->cast_to()->canvas_item); + } + } +} + +void CanvasItem::_raise_self() { + + if (!is_inside_scene()) + return; + + VisualServer::get_singleton()->canvas_item_raise(canvas_item); +} + + +void CanvasItem::_enter_canvas() { + + if ((!get_parent() || !get_parent()->cast_to()) || toplevel) { + + Node *n = this; + viewport=NULL; + canvas_layer=NULL; + + while(n) { + + if (n->cast_to()) { + + viewport = n->cast_to(); + break; + } + if (!canvas_layer && n->cast_to()) { + + canvas_layer = n->cast_to(); + } + n=n->get_parent(); + } + + RID canvas; + if (canvas_layer) + canvas=canvas_layer->get_world_2d()->get_canvas(); + else + canvas=viewport->find_world_2d()->get_canvas(); + + VisualServer::get_singleton()->canvas_item_set_parent(canvas_item,canvas); + + group = "root_canvas"+itos(canvas.get_id()); + + add_to_group(group); + get_scene()->call_group(SceneMainLoop::GROUP_CALL_UNIQUE,group,"_raise_self"); + + } else { + + CanvasItem *parent = get_parent_item(); + viewport=parent->viewport; + VisualServer::get_singleton()->canvas_item_set_parent(canvas_item,parent->get_canvas_item()); + parent->_queue_sort_children(); + } + + if (!viewport) { + + print_line("no viewport wtf!"); + } + pending_update=false; + update(); + + notification(NOTIFICATION_ENTER_CANVAS); + +} + +void CanvasItem::_exit_canvas() { + + notification(NOTIFICATION_EXIT_CANVAS,true); //reverse the notification + VisualServer::get_singleton()->canvas_item_set_parent(canvas_item,RID()); + viewport=NULL; + canvas_layer=NULL; + group=""; + +} + + +void CanvasItem::_notification(int p_what) { + + + switch(p_what) { + case NOTIFICATION_ENTER_SCENE: { + + first_draw=true; + pending_children_sort=false; + if (get_parent()) { + CanvasItem *ci = get_parent()->cast_to(); + if (ci) + C=ci->children_items.push_back(this); + } + _enter_canvas(); + if (!block_transform_notify && !xform_change.in_list()) { + get_scene()->xform_change_list.add(&xform_change); + } + } break; + case NOTIFICATION_MOVED_IN_PARENT: { + + + if (group!="") { + get_scene()->call_group(SceneMainLoop::GROUP_CALL_UNIQUE,group,"_raise_self"); + } else { + CanvasItem *p = get_parent_item(); + ERR_FAIL_COND(!p); + p->_queue_sort_children(); + } + + + } break; + case NOTIFICATION_EXIT_SCENE: { + if (xform_change.in_list()) + get_scene()->xform_change_list.remove(&xform_change); + _exit_canvas(); + if (C) + get_parent()->cast_to()->children_items.erase(C); + } break; + case NOTIFICATION_DRAW: { + + } break; + case NOTIFICATION_TRANSFORM_CHANGED: { + + + } break; + case NOTIFICATION_VISIBILITY_CHANGED: { + + emit_signal(SceneStringNames::get_singleton()->visibility_changed); + } break; + + } +} + +void CanvasItem::_set_visible_(bool p_visible) { + + if (p_visible) + show(); + else + hide(); +} +bool CanvasItem::_is_visible_() const { + + return !is_hidden(); +} + + +void CanvasItem::update() { + + if (!is_inside_scene()) + return; + if (pending_update) + return; + + pending_update=true; + + MessageQueue::get_singleton()->push_call(this,"_update_callback"); +} + +void CanvasItem::set_opacity(float p_opacity) { + + opacity=p_opacity; + VisualServer::get_singleton()->canvas_item_set_opacity(canvas_item,opacity); + +} +float CanvasItem::get_opacity() const { + + return opacity; +} + + +void CanvasItem::set_as_toplevel(bool p_toplevel) { + + if (toplevel==p_toplevel) + return; + + if (!is_inside_scene()) { + toplevel=p_toplevel; + return; + } + + _exit_canvas(); + toplevel=p_toplevel; + _enter_canvas(); +} + +bool CanvasItem::is_set_as_toplevel() const { + + return toplevel; +} + +CanvasItem *CanvasItem::get_parent_item() const { + + if (toplevel) + return NULL; + + Node *parent = get_parent(); + if (!parent) + return NULL; + + return parent->cast_to(); +} + + +void CanvasItem::set_self_opacity(float p_self_opacity) { + + self_opacity=p_self_opacity; + VisualServer::get_singleton()->canvas_item_set_self_opacity(canvas_item,self_opacity); + +} +float CanvasItem::get_self_opacity() const { + + return self_opacity; +} + +void CanvasItem::set_blend_mode(BlendMode p_blend_mode) { + + ERR_FAIL_INDEX(p_blend_mode,4); + blend_mode=p_blend_mode; + VisualServer::get_singleton()->canvas_item_set_blend_mode(canvas_item,VS::MaterialBlendMode(blend_mode)); + +} + +CanvasItem::BlendMode CanvasItem::get_blend_mode() const { + + return blend_mode; +} + + + +void CanvasItem::item_rect_changed() { + + update(); + emit_signal(SceneStringNames::get_singleton()->item_rect_changed); +} + + +void CanvasItem::draw_line(const Point2& p_from, const Point2& p_to,const Color& p_color,float p_width) { + + if (!drawing) { + ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); + ERR_FAIL(); + } + + VisualServer::get_singleton()->canvas_item_add_line(canvas_item,p_from,p_to,p_color,p_width); +} + +void CanvasItem::draw_rect(const Rect2& p_rect, const Color& p_color) { + + if (!drawing) { + ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); + ERR_FAIL(); + } + + VisualServer::get_singleton()->canvas_item_add_rect(canvas_item,p_rect,p_color); + +} + +void CanvasItem::draw_circle(const Point2& p_pos, float p_radius, const Color& p_color) { + + if (!drawing) { + ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); + ERR_FAIL(); + } + + VisualServer::get_singleton()->canvas_item_add_circle(canvas_item,p_pos,p_radius,p_color); + +} + +void CanvasItem::draw_texture(const Ref& p_texture,const Point2& p_pos) { + + if (!drawing) { + ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); + ERR_FAIL(); + } + + ERR_FAIL_COND(p_texture.is_null()); + + p_texture->draw(canvas_item,p_pos); +} + +void CanvasItem::draw_texture_rect(const Ref& p_texture,const Rect2& p_rect, bool p_tile,const Color& p_modulate) { + + if (!drawing) { + ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); + ERR_FAIL(); + } + + ERR_FAIL_COND(p_texture.is_null()); + p_texture->draw_rect(canvas_item,p_rect,p_tile,p_modulate); + +} +void CanvasItem::draw_texture_rect_region(const Ref& p_texture,const Rect2& p_rect, const Rect2& p_src_rect,const Color& p_modulate) { + + if (!drawing) { + ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); + ERR_FAIL(); + } + ERR_FAIL_COND(p_texture.is_null()); + p_texture->draw_rect_region(canvas_item,p_rect,p_src_rect,p_modulate); +} + +void CanvasItem::draw_style_box(const Ref& p_style_box,const Rect2& p_rect) { + if (!drawing) { + ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); + ERR_FAIL(); + } + + ERR_FAIL_COND(p_style_box.is_null()); + + p_style_box->draw(canvas_item,p_rect); + +} +void CanvasItem::draw_primitive(const Vector& p_points, const Vector& p_colors,const Vector& p_uvs, Ref p_texture,float p_width) { + + if (!drawing) { + ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); + ERR_FAIL(); + } + + RID rid = p_texture.is_valid() ? p_texture->get_rid() : RID(); + + VisualServer::get_singleton()->canvas_item_add_primitive(canvas_item,p_points,p_colors,p_uvs,rid,p_width); +} +void CanvasItem::draw_set_transform(const Point2& p_offset, float p_rot, const Size2& p_scale) { + + if (!drawing) { + ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); + ERR_FAIL(); + } + + Matrix32 xform(p_rot,p_offset); + xform.scale_basis(p_scale); + VisualServer::get_singleton()->canvas_item_set_transform(canvas_item,xform); +} + +void CanvasItem::draw_polygon(const Vector& p_points, const Vector& p_colors,const Vector& p_uvs, Ref p_texture) { + + if (!drawing) { + ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); + ERR_FAIL(); + } + + RID rid = p_texture.is_valid() ? p_texture->get_rid() : RID(); + + VisualServer::get_singleton()->canvas_item_add_polygon(canvas_item,p_points,p_colors,p_uvs,rid); + + +} + +void CanvasItem::draw_colored_polygon(const Vector& p_points, const Color& p_color,const Vector& p_uvs, Ref p_texture) { + + if (!drawing) { + ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); + ERR_FAIL(); + } + + Vector colors; + colors.push_back(p_color); + RID rid = p_texture.is_valid() ? p_texture->get_rid() : RID(); + + VisualServer::get_singleton()->canvas_item_add_polygon(canvas_item,p_points,colors,p_uvs,rid); +} + +void CanvasItem::draw_string(const Ref& p_font,const Point2& p_pos, const String& p_text,const Color& p_modulate,int p_clip_w) { + + if (!drawing) { + ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); + ERR_FAIL(); + } + + ERR_FAIL_COND(p_font.is_null()); + p_font->draw(canvas_item,p_pos,p_text,p_modulate,p_clip_w); + +} + +float CanvasItem::draw_char(const Ref& p_font,const Point2& p_pos, const String& p_char,const String& p_next,const Color& p_modulate) { + + if (!drawing) { + ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); + ERR_FAIL_V(0); + } + + ERR_FAIL_COND_V(p_char.length()!=1,0); + ERR_FAIL_COND_V(p_font.is_null(),0); + + return p_font->draw_char(canvas_item,p_pos,p_char[0],p_next.c_str()[0],p_modulate); + +} + + +void CanvasItem::_notify_transform(CanvasItem *p_node) { + + if (p_node->xform_change.in_list() && p_node->global_invalid) + return; //nothing to do + + p_node->global_invalid=true; + + if (!p_node->xform_change.in_list()) { + if (!p_node->block_transform_notify) { + if (p_node->is_inside_scene()) + get_scene()->xform_change_list.add(&p_node->xform_change); + } + } + + + for(List::Element *E=p_node->children_items.front();E;E=E->next()) { + + CanvasItem* ci=E->get(); + if (ci->toplevel) + continue; + _notify_transform(ci); + } +} + + +Rect2 CanvasItem::get_viewport_rect() const { + + ERR_FAIL_COND_V(!is_inside_scene(),Rect2()); + return viewport->get_visible_rect(); +} + +RID CanvasItem::get_canvas() const { + + ERR_FAIL_COND_V(!is_inside_scene(),RID()); + + if (canvas_layer) + return canvas_layer->get_world_2d()->get_canvas(); + else + return viewport->find_world_2d()->get_canvas(); + + +} + +CanvasItem *CanvasItem::get_toplevel() const { + + CanvasItem *ci=const_cast(this); + while(!ci->toplevel && ci->get_parent() && ci->get_parent()->cast_to()) { + ci=ci->get_parent()->cast_to(); + } + + return ci; +} + +Viewport *CanvasItem::get_viewport() const { + + return viewport; +} + + +Ref CanvasItem::get_world_2d() const { + + ERR_FAIL_COND_V(!is_inside_scene(),Ref()); + + CanvasItem *tl=get_toplevel(); + + if (tl->canvas_layer) { + return tl->canvas_layer->get_world_2d(); + } else if (tl->viewport) { + return tl->viewport->find_world_2d(); + } else { + return Ref(); + } + +} + +RID CanvasItem::get_viewport_rid() const { + + ERR_FAIL_COND_V(!is_inside_scene(),RID()); + return viewport->get_viewport(); +} + +void CanvasItem::set_block_transform_notify(bool p_enable) { + block_transform_notify=p_enable; +} + +bool CanvasItem::is_block_transform_notify_enabled() const { + + return block_transform_notify; +} + +void CanvasItem::set_on_top(bool p_on_top) { + + if (on_top==p_on_top) + return; + on_top=p_on_top; + VisualServer::get_singleton()->canvas_item_set_on_top(canvas_item,on_top); +} + +bool CanvasItem::is_on_top() const { + + return on_top; +} + + +void CanvasItem::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_sort_children"),&CanvasItem::_sort_children); + ObjectTypeDB::bind_method(_MD("_raise_self"),&CanvasItem::_raise_self); + ObjectTypeDB::bind_method(_MD("_update_callback"),&CanvasItem::_update_callback); + ObjectTypeDB::bind_method(_MD("_set_visible_"),&CanvasItem::_set_visible_); + ObjectTypeDB::bind_method(_MD("_is_visible_"),&CanvasItem::_is_visible_); + + ObjectTypeDB::bind_method(_MD("edit_set_state","state"),&CanvasItem::edit_set_state); + ObjectTypeDB::bind_method(_MD("edit_get"),&CanvasItem::edit_get_state); + ObjectTypeDB::bind_method(_MD("edit_set_rect","rect"),&CanvasItem::edit_set_rect); + ObjectTypeDB::bind_method(_MD("edit_rotate","degrees"),&CanvasItem::edit_rotate); + + ObjectTypeDB::bind_method(_MD("get_item_rect"),&CanvasItem::get_item_rect); + //ObjectTypeDB::bind_method(_MD("get_transform"),&CanvasItem::get_transform); + ObjectTypeDB::bind_method(_MD("get_canvas_item"),&CanvasItem::get_canvas_item); + + ObjectTypeDB::bind_method(_MD("is_visible"),&CanvasItem::is_visible); + ObjectTypeDB::bind_method(_MD("is_hidden"),&CanvasItem::is_hidden); + ObjectTypeDB::bind_method(_MD("show"),&CanvasItem::show); + ObjectTypeDB::bind_method(_MD("hide"),&CanvasItem::hide); + + ObjectTypeDB::bind_method(_MD("update"),&CanvasItem::update); + + ObjectTypeDB::bind_method(_MD("set_as_toplevel","enable"),&CanvasItem::set_as_toplevel); + ObjectTypeDB::bind_method(_MD("is_set_as_toplevel"),&CanvasItem::is_set_as_toplevel); + + ObjectTypeDB::bind_method(_MD("set_blend_mode","blend_mode"),&CanvasItem::set_blend_mode); + ObjectTypeDB::bind_method(_MD("get_blend_mode"),&CanvasItem::get_blend_mode); + + ObjectTypeDB::bind_method(_MD("set_opacity","opacity"),&CanvasItem::set_opacity); + ObjectTypeDB::bind_method(_MD("get_opacity"),&CanvasItem::get_opacity); + ObjectTypeDB::bind_method(_MD("set_self_opacity","self_opacity"),&CanvasItem::set_self_opacity); + ObjectTypeDB::bind_method(_MD("get_self_opacity"),&CanvasItem::get_self_opacity); + + ObjectTypeDB::bind_method(_MD("set_on_top","on_top"),&CanvasItem::set_on_top); + ObjectTypeDB::bind_method(_MD("is_on_top"),&CanvasItem::is_on_top); + + //ObjectTypeDB::bind_method(_MD("get_transform"),&CanvasItem::get_transform); + + ObjectTypeDB::bind_method(_MD("draw_line","from","to","color","width"),&CanvasItem::draw_line,DEFVAL(1.0)); + ObjectTypeDB::bind_method(_MD("draw_rect","rect","color"),&CanvasItem::draw_rect); + ObjectTypeDB::bind_method(_MD("draw_circle","pos","radius","color"),&CanvasItem::draw_circle); + ObjectTypeDB::bind_method(_MD("draw_texture","texture:Texture","pos"),&CanvasItem::draw_texture); + ObjectTypeDB::bind_method(_MD("draw_texture_rect","texture:Texture","rect","tile","modulate"),&CanvasItem::draw_texture_rect,DEFVAL(false),DEFVAL(Color(1,1,1))); + ObjectTypeDB::bind_method(_MD("draw_texture_rect_region","texture:Texture","rect","src_rect","modulate"),&CanvasItem::draw_texture_rect_region,DEFVAL(Color(1,1,1))); + ObjectTypeDB::bind_method(_MD("draw_style_box","style_box:StyleBox","rect"),&CanvasItem::draw_style_box); + ObjectTypeDB::bind_method(_MD("draw_primitive","points","colors","uvs","texture:Texture","width"),&CanvasItem::draw_primitive,DEFVAL(Array()),DEFVAL(Ref()),DEFVAL(1.0)); + ObjectTypeDB::bind_method(_MD("draw_polygon","points","colors","uvs","texture:Texture"),&CanvasItem::draw_primitive,DEFVAL(Array()),DEFVAL(Ref())); + ObjectTypeDB::bind_method(_MD("draw_colored_polygon","points","color","uvs","texture:Texture"),&CanvasItem::draw_primitive,DEFVAL(Array()),DEFVAL(Ref())); + ObjectTypeDB::bind_method(_MD("draw_string","font:Font","pos","text","modulate","clip_w"),&CanvasItem::draw_string,DEFVAL(Color(1,1,1)),DEFVAL(-1)); + ObjectTypeDB::bind_method(_MD("draw_char","font:Font","pos","char","next","modulate"),&CanvasItem::draw_char,DEFVAL(Color(1,1,1))); + + ObjectTypeDB::bind_method(_MD("draw_set_transform","pos","rot","scale"),&CanvasItem::draw_set_transform); + ObjectTypeDB::bind_method(_MD("get_transform"),&CanvasItem::get_transform); + ObjectTypeDB::bind_method(_MD("get_global_transform"),&CanvasItem::get_global_transform); + ObjectTypeDB::bind_method(_MD("get_viewport_transform"),&CanvasItem::get_viewport_transform); + ObjectTypeDB::bind_method(_MD("get_viewport_rect"),&CanvasItem::get_viewport_rect); + ObjectTypeDB::bind_method(_MD("get_canvas"),&CanvasItem::get_canvas); + ObjectTypeDB::bind_method(_MD("get_world_2d"),&CanvasItem::get_world_2d); + ObjectTypeDB::bind_method(_MD("get_viewport"),&CanvasItem::get_viewport); + + BIND_VMETHOD(MethodInfo("_draw")); + + ADD_PROPERTY( PropertyInfo(Variant::BOOL,"visibility/visible"), _SCS("_set_visible_"),_SCS("_is_visible_") ); + ADD_PROPERTY( PropertyInfo(Variant::REAL,"visibility/opacity",PROPERTY_HINT_RANGE, "0,1,0.01"), _SCS("set_opacity"),_SCS("get_opacity") ); + ADD_PROPERTY( PropertyInfo(Variant::REAL,"visibility/self_opacity",PROPERTY_HINT_RANGE, "0,1,0.01"), _SCS("set_self_opacity"),_SCS("get_self_opacity") ); + ADD_PROPERTY( PropertyInfo(Variant::BOOL,"visibility/on_top"), _SCS("set_on_top"),_SCS("is_on_top") ); + + ADD_PROPERTYNZ( PropertyInfo(Variant::INT,"visibility/blend_mode",PROPERTY_HINT_ENUM, "Mix,Add,Sub,Mul"), _SCS("set_blend_mode"),_SCS("get_blend_mode") ); + //exporting these two things doesn't really make much sense i think + //ADD_PROPERTY( PropertyInfo(Variant::BOOL,"transform/toplevel"), _SCS("set_as_toplevel"),_SCS("is_set_as_toplevel") ); + //ADD_PROPERTY(PropertyInfo(Variant::BOOL,"transform/notify"),_SCS("set_transform_notify"),_SCS("is_transform_notify_enabled")); + + ADD_SIGNAL( MethodInfo("draw") ); + ADD_SIGNAL( MethodInfo("visibility_changed") ); + ADD_SIGNAL( MethodInfo("hide") ); + ADD_SIGNAL( MethodInfo("item_rect_changed") ); + + + + BIND_CONSTANT( BLEND_MODE_MIX ); + BIND_CONSTANT( BLEND_MODE_ADD ); + BIND_CONSTANT( BLEND_MODE_SUB ); + BIND_CONSTANT( BLEND_MODE_MUL ); + + + BIND_CONSTANT( NOTIFICATION_DRAW); + BIND_CONSTANT( NOTIFICATION_VISIBILITY_CHANGED ); + BIND_CONSTANT( NOTIFICATION_ENTER_CANVAS ); + BIND_CONSTANT( NOTIFICATION_EXIT_CANVAS ); + BIND_CONSTANT( NOTIFICATION_TRANSFORM_CHANGED ); + + +} + +Matrix32 CanvasItem::get_viewport_transform() const { + + ERR_FAIL_COND_V(!is_inside_scene(),Matrix32()); + + if (canvas_layer) { + + if (viewport) { + return viewport->get_final_transform() * canvas_layer->get_transform(); + } else { + return canvas_layer->get_transform(); + } + + } else if (viewport) { + return viewport->get_final_transform() * viewport->get_canvas_transform(); + } + + return Matrix32(); + +} + + +CanvasItem::CanvasItem() : xform_change(this) { + + + canvas_item=VisualServer::get_singleton()->canvas_item_create(); + hidden=false; + pending_update=false; + opacity=1; + self_opacity=1; + toplevel=false; + pending_children_sort=false; + first_draw=false; + blend_mode=BLEND_MODE_MIX; + drawing=false; + on_top=true; + block_transform_notify=false; + viewport=NULL; + canvas_layer=NULL; + global_invalid=true; + + C=NULL; + +} + +CanvasItem::~CanvasItem() { + + VisualServer::get_singleton()->free(canvas_item); +} diff --git a/scene/2d/canvas_item.h b/scene/2d/canvas_item.h new file mode 100644 index 0000000000..0da4aa3086 --- /dev/null +++ b/scene/2d/canvas_item.h @@ -0,0 +1,209 @@ +/*************************************************************************/ +/* canvas_item.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef CANVAS_ITEM_H +#define CANVAS_ITEM_H + +#include "scene/main/node.h" +#include "scene/resources/texture.h" +#include "scene/main/scene_main_loop.h" + +class CanvasLayer; +class Viewport; +class Font; + +class StyleBox; + +class CanvasItem : public Node { + + OBJ_TYPE( CanvasItem, Node ); +public: + + enum BlendMode { + + BLEND_MODE_MIX, //default + BLEND_MODE_ADD, + BLEND_MODE_SUB, + BLEND_MODE_MUL + }; + +private: + + mutable SelfList xform_change; + + RID canvas_item; + String group; + + Viewport *viewport; + CanvasLayer *canvas_layer; + + float opacity; + float self_opacity; + + List children_items; + List::Element *C; + + BlendMode blend_mode; + + bool first_draw; + bool hidden; + bool pending_update; + bool toplevel; + bool pending_children_sort; + bool drawing; + bool block_transform_notify; + bool on_top; + + mutable Matrix32 global_transform; + mutable bool global_invalid; + + + void _raise_self(); + + void _propagate_visibility_changed(bool p_visible); + + void _set_visible_(bool p_visible); + bool _is_visible_() const; + + void _update_callback(); + + void _enter_canvas(); + void _exit_canvas(); + + void _queue_sort_children(); + void _sort_children(); + + + + void _notify_transform(CanvasItem *p_node); + +protected: + + + + _FORCE_INLINE_ void _notify_transform() { if (!is_inside_scene()) return; _notify_transform(this); if (!block_transform_notify) notification(NOTIFICATION_LOCAL_TRANSFORM_CHANGED); } + + void item_rect_changed(); + + void _notification(int p_what); + static void _bind_methods(); +public: + + + enum { + NOTIFICATION_TRANSFORM_CHANGED=SceneMainLoop::NOTIFICATION_TRANSFORM_CHANGED, //unique + NOTIFICATION_DRAW=30, + NOTIFICATION_VISIBILITY_CHANGED=31, + NOTIFICATION_ENTER_CANVAS=32, + NOTIFICATION_EXIT_CANVAS=33, + NOTIFICATION_LOCAL_TRANSFORM_CHANGED=35, + NOTIFICATION_WORLD_2D_CHANGED=36, + + }; + + /* EDITOR */ + + virtual Variant edit_get_state() const; + virtual void edit_set_state(const Variant& p_state); + virtual void edit_set_rect(const Rect2& p_edit_rect); + virtual void edit_rotate(float p_rot); + virtual Size2 edit_get_minimum_size() const; + + /* VISIBILITY */ + + bool is_visible() const; + bool is_hidden() const; + void show(); + void hide(); + + void update(); + + void set_blend_mode(BlendMode p_blend_mode); + BlendMode get_blend_mode() const; + + void set_opacity(float p_opacity); + float get_opacity() const; + + void set_self_opacity(float p_self_opacity); + float get_self_opacity() const; + + /* DRAWING API */ + + void draw_line(const Point2& p_from, const Point2& p_to,const Color& p_color,float p_width=1.0); + void draw_rect(const Rect2& p_rect, const Color& p_color); + void draw_circle(const Point2& p_pos, float p_radius, const Color& p_color); + void draw_texture(const Ref& p_texture,const Point2& p_pos); + void draw_texture_rect(const Ref& p_texture, const Rect2& p_rect, bool p_tile=false,const Color& p_modulate=Color(1,1,1)); + void draw_texture_rect_region(const Ref& p_texture,const Rect2& p_rect, const Rect2& p_src_rect,const Color& p_modulate=Color(1,1,1)); + void draw_style_box(const Ref& p_style_box,const Rect2& p_rect); + void draw_primitive(const Vector& p_points, const Vector& p_colors,const Vector& p_uvs, Ref p_texture=Ref(),float p_width=1); + void draw_polygon(const Vector& p_points, const Vector& p_colors,const Vector& p_uvs=Vector(), Ref p_texture=Ref()); + void draw_colored_polygon(const Vector& p_points, const Color& p_color,const Vector& p_uvs=Vector(), Ref p_texture=Ref()); + + void draw_string(const Ref& p_font, const Point2& p_pos, const String& p_text,const Color& p_modulate=Color(1,1,1),int p_clip_w=-1); + float draw_char(const Ref& p_font,const Point2& p_pos, const String& p_char,const String& p_next="",const Color& p_modulate=Color(1,1,1)); + + void draw_set_transform(const Point2& p_offset, float p_rot, const Size2& p_scale); + + /* RECT / TRANSFORM */ + + void set_as_toplevel(bool p_toplevel); + bool is_set_as_toplevel() const; + + void set_on_top(bool p_on_top); + bool is_on_top() const; + + CanvasItem *get_parent_item() const; + + virtual Rect2 get_item_rect() const=0; + virtual Matrix32 get_transform() const=0; + + virtual Matrix32 get_global_transform() const; + virtual Matrix32 get_global_transform_with_canvas() const; + + CanvasItem *get_toplevel() const; + _FORCE_INLINE_ RID get_canvas_item() const { return canvas_item; } + + void set_block_transform_notify(bool p_enable); + bool is_block_transform_notify_enabled() const; + + Matrix32 get_viewport_transform() const; + Rect2 get_viewport_rect() const; + RID get_viewport_rid() const; + RID get_canvas() const; + Ref get_world_2d() const; + Viewport *get_viewport() const; + + + CanvasItem(); + ~CanvasItem(); +}; + +VARIANT_ENUM_CAST( CanvasItem::BlendMode ); + +#endif // CANVAS_ITEM_H diff --git a/scene/2d/collision_object_2d.cpp b/scene/2d/collision_object_2d.cpp new file mode 100644 index 0000000000..ab8c4551ee --- /dev/null +++ b/scene/2d/collision_object_2d.cpp @@ -0,0 +1,282 @@ +/*************************************************************************/ +/* collision_object_2d.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "collision_object_2d.h" +#include "servers/physics_2d_server.h" + +void CollisionObject2D::_update_shapes_from_children() { + + shapes.resize(0); + for(int i=0;icall("_add_to_collision_object",this); + } + +// _update_shapes(); +} + +void CollisionObject2D::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_ENTER_SCENE: { + + + RID space = get_world_2d()->get_space(); + if (area) { + Physics2DServer::get_singleton()->area_set_space(rid,space); + } else + Physics2DServer::get_singleton()->body_set_space(rid,space); + + //get space + } + + case NOTIFICATION_TRANSFORM_CHANGED: { + + if (area) + Physics2DServer::get_singleton()->area_set_transform(rid,get_global_transform()); + else + Physics2DServer::get_singleton()->body_set_state(rid,Physics2DServer::BODY_STATE_TRANSFORM,get_global_transform()); + + } break; + case NOTIFICATION_EXIT_SCENE: { + + if (area) { + Physics2DServer::get_singleton()->area_set_space(rid,RID()); + } else + Physics2DServer::get_singleton()->body_set_space(rid,RID()); + + } break; + } +} + +void CollisionObject2D::_update_shapes() { + + if (!rid.is_valid()) + return; + + if (area) + Physics2DServer::get_singleton()->area_clear_shapes(rid); + else + Physics2DServer::get_singleton()->body_clear_shapes(rid); + + for(int i=0;iarea_add_shape(rid,shapes[i].shape->get_rid(),shapes[i].xform); + else { + Physics2DServer::get_singleton()->body_add_shape(rid,shapes[i].shape->get_rid(),shapes[i].xform); + if (shapes[i].trigger) + Physics2DServer::get_singleton()->body_set_shape_as_trigger(rid,i,shapes[i].trigger); + } + } +} + + +bool CollisionObject2D::_set(const StringName& p_name, const Variant& p_value) { + String name=p_name; + + if (name=="shape_count") { + + shapes.resize(p_value); + _update_shapes(); + _change_notify(); + + } else if (name.begins_with("shapes/")) { + + int idx=name.get_slice("/",1).to_int(); + String what=name.get_slice("/",2); + if (what=="shape") + set_shape(idx,RefPtr(p_value)); + else if (what=="transform") + set_shape_transform(idx,p_value); + else if (what=="trigger") + set_shape_as_trigger(idx,p_value); + } else + return false; + + return true; + + +} + +bool CollisionObject2D::_get(const StringName& p_name,Variant &r_ret) const { + + String name=p_name; + + if (name=="shape_count") { + r_ret= shapes.size(); + } else if (name.begins_with("shapes/")) { + + int idx=name.get_slice("/",1).to_int(); + String what=name.get_slice("/",2); + if (what=="shape") + r_ret= get_shape(idx); + else if (what=="transform") + r_ret= get_shape_transform(idx); + else if (what=="trigger") + r_ret= is_shape_set_as_trigger(idx); + } else + return false; + + return true; +} + +void CollisionObject2D::_get_property_list( List *p_list) const { + + p_list->push_back( PropertyInfo(Variant::INT,"shape_count",PROPERTY_HINT_RANGE,"0,256,1",PROPERTY_USAGE_NOEDITOR) ); + + for(int i=0;ipush_back( PropertyInfo(Variant::OBJECT,path+"shape",PROPERTY_HINT_RESOURCE_TYPE,"Shape2D",PROPERTY_USAGE_NOEDITOR) ); + p_list->push_back( PropertyInfo(Variant::TRANSFORM,path+"transform",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR) ); + p_list->push_back( PropertyInfo(Variant::BOOL,path+"trigger",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR) ); + } +} + +void CollisionObject2D::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("add_shape","shape:Shape2D","transform"),&CollisionObject2D::add_shape,DEFVAL(Matrix32())); + ObjectTypeDB::bind_method(_MD("get_shape_count"),&CollisionObject2D::get_shape_count); + ObjectTypeDB::bind_method(_MD("set_shape","shape_idx","shape:Shape"),&CollisionObject2D::set_shape); + ObjectTypeDB::bind_method(_MD("set_shape_transform","shape_idx","transform"),&CollisionObject2D::set_shape_transform); + ObjectTypeDB::bind_method(_MD("set_shape_as_trigger","shape_idx","enable"),&CollisionObject2D::set_shape_as_trigger); + ObjectTypeDB::bind_method(_MD("get_shape:Shape2D","shape_idx"),&CollisionObject2D::get_shape); + ObjectTypeDB::bind_method(_MD("get_shape_transform","shape_idx"),&CollisionObject2D::get_shape_transform); + ObjectTypeDB::bind_method(_MD("is_shape_set_as_trigger","shape_idx"),&CollisionObject2D::is_shape_set_as_trigger); + ObjectTypeDB::bind_method(_MD("remove_shape","shape_idx"),&CollisionObject2D::remove_shape); + ObjectTypeDB::bind_method(_MD("clear_shapes"),&CollisionObject2D::clear_shapes); + ObjectTypeDB::bind_method(_MD("get_rid"),&CollisionObject2D::get_rid); + +} + + +void CollisionObject2D::add_shape(const Ref& p_shape, const Matrix32& p_transform) { + + ShapeData sdata; + sdata.shape=p_shape; + sdata.xform=p_transform; + sdata.trigger=false; + shapes.push_back(sdata); + _update_shapes(); + +} +int CollisionObject2D::get_shape_count() const { + + return shapes.size(); + +} +void CollisionObject2D::set_shape(int p_shape_idx, const Ref& p_shape) { + + ERR_FAIL_INDEX(p_shape_idx,shapes.size()); + shapes[p_shape_idx].shape=p_shape; + _update_shapes(); +} + +void CollisionObject2D::set_shape_transform(int p_shape_idx, const Matrix32& p_transform) { + + ERR_FAIL_INDEX(p_shape_idx,shapes.size()); + shapes[p_shape_idx].xform=p_transform; + + _update_shapes(); +} + +Ref CollisionObject2D::get_shape(int p_shape_idx) const { + + ERR_FAIL_INDEX_V(p_shape_idx,shapes.size(),Ref()); + return shapes[p_shape_idx].shape; + +} +Matrix32 CollisionObject2D::get_shape_transform(int p_shape_idx) const { + + ERR_FAIL_INDEX_V(p_shape_idx,shapes.size(),Matrix32()); + return shapes[p_shape_idx].xform; + +} +void CollisionObject2D::remove_shape(int p_shape_idx) { + + ERR_FAIL_INDEX(p_shape_idx,shapes.size()); + shapes.remove(p_shape_idx); + + _update_shapes(); +} + +void CollisionObject2D::set_shape_as_trigger(int p_shape_idx, bool p_trigger) { + + ERR_FAIL_INDEX(p_shape_idx,shapes.size()); + shapes[p_shape_idx].trigger=p_trigger; + if (!area && rid.is_valid()) { + + Physics2DServer::get_singleton()->body_set_shape_as_trigger(rid,p_shape_idx,p_trigger); + + } +} + +bool CollisionObject2D::is_shape_set_as_trigger(int p_shape_idx) const { + + ERR_FAIL_INDEX_V(p_shape_idx,shapes.size(),false); + return shapes[p_shape_idx].trigger; +} + +void CollisionObject2D::clear_shapes() { + + shapes.clear(); + + _update_shapes(); +} + + +CollisionObject2D::CollisionObject2D(RID p_rid, bool p_area) { + + rid=p_rid; + area=p_area; + if (p_area) { + Physics2DServer::get_singleton()->area_attach_object_instance_ID(rid,get_instance_ID()); + } else { + Physics2DServer::get_singleton()->body_attach_object_instance_ID(rid,get_instance_ID()); + } + + +} + + +CollisionObject2D::CollisionObject2D() { + + + //owner= + + +} + +CollisionObject2D::~CollisionObject2D() { + + Physics2DServer::get_singleton()->free(rid); +} diff --git a/scene/2d/collision_object_2d.h b/scene/2d/collision_object_2d.h new file mode 100644 index 0000000000..4a529ce062 --- /dev/null +++ b/scene/2d/collision_object_2d.h @@ -0,0 +1,89 @@ +/*************************************************************************/ +/* collision_object_2d.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef COLLISION_OBJECT_2D_H +#define COLLISION_OBJECT_2D_H + +#include "scene/2d/node_2d.h" +#include "scene/resources/shape_2d.h" + +class CollisionObject2D : public Node2D { + + OBJ_TYPE( CollisionObject2D, Node2D ); + + bool area; + RID rid; + + struct ShapeData { + Matrix32 xform; + Ref shape; + bool trigger; + + ShapeData() { + trigger=false; + } + }; + + + Vector shapes; + + void _update_shapes(); + +friend class CollisionShape2D; +friend class CollisionPolygon2D; + void _update_shapes_from_children(); +protected: + + CollisionObject2D(RID p_rid, bool p_area); + + void _notification(int p_what); + bool _set(const StringName& p_name, const Variant& p_value); + bool _get(const StringName& p_name,Variant &r_ret) const; + void _get_property_list( List *p_list) const; + static void _bind_methods(); +public: + + + void add_shape(const Ref& p_shape, const Matrix32& p_transform=Matrix32()); + int get_shape_count() const; + void set_shape(int p_shape_idx, const Ref& p_shape); + void set_shape_transform(int p_shape_idx, const Matrix32& p_transform); + Ref get_shape(int p_shape_idx) const; + Matrix32 get_shape_transform(int p_shape_idx) const; + void set_shape_as_trigger(int p_shape_idx, bool p_trigger); + bool is_shape_set_as_trigger(int p_shape_idx) const; + void remove_shape(int p_shape_idx); + void clear_shapes(); + + _FORCE_INLINE_ RID get_rid() const { return rid; } + + CollisionObject2D(); + ~CollisionObject2D(); +}; + +#endif // COLLISION_OBJECT_2D_H diff --git a/scene/2d/collision_polygon_2d.cpp b/scene/2d/collision_polygon_2d.cpp new file mode 100644 index 0000000000..5ab223a1b8 --- /dev/null +++ b/scene/2d/collision_polygon_2d.cpp @@ -0,0 +1,187 @@ +/*************************************************************************/ +/* collision_polygon_2d.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "collision_polygon_2d.h" +#include "collision_object_2d.h" +#include "scene/resources/concave_polygon_shape_2d.h" +#include "scene/resources/convex_polygon_shape_2d.h" + +void CollisionPolygon2D::_add_to_collision_object(Object *p_obj) { + + CollisionObject2D *co = p_obj->cast_to(); + ERR_FAIL_COND(!co); + + if (polygon.size()==0) + return; + + bool solids=build_mode==BUILD_SOLIDS; + + + if (solids) { + + //here comes the sun, lalalala + //decompose concave into multiple convex polygons and add them + Vector< Vector > decomp = Geometry::decompose_polygon(polygon); + for(int i=0;i convex = memnew( ConvexPolygonShape2D ); + convex->set_points(decomp[i]); + co->add_shape(convex,get_transform()); + + } + + } else { + + Ref concave = memnew( ConcavePolygonShape2D ); + + DVector segments; + segments.resize(polygon.size()*2); + DVector::Write w=segments.write(); + + for(int i=0;i::Write(); + concave->set_segments(segments); + + co->add_shape(concave,get_transform()); + + } + + + //co->add_shape(shape,get_transform()); +} + +void CollisionPolygon2D::_update_parent() { + + Node *parent = get_parent(); + if (!parent) + return; + CollisionObject2D *co = parent->cast_to(); + if (!co) + return; + co->_update_shapes_from_children(); +} + +void CollisionPolygon2D::_notification(int p_what) { + + + switch(p_what) { + case NOTIFICATION_LOCAL_TRANSFORM_CHANGED: { + + if (!is_inside_scene()) + break; + _update_parent(); + + } break; + + case NOTIFICATION_DRAW: { + for(int i=0;i > decomp = Geometry::decompose_polygon(polygon); +#define DEBUG_DECOMPOSE +#ifdef DEBUG_DECOMPOSE + Color c(0.4,0.9,0.1); + for(int i=0;i& p_polygon) { + + polygon=p_polygon; + + for(int i=0;i CollisionPolygon2D::get_polygon() const { + + return polygon; +} + +void CollisionPolygon2D::set_build_mode(BuildMode p_mode) { + + ERR_FAIL_INDEX(p_mode,2); + build_mode=p_mode; +} + +CollisionPolygon2D::BuildMode CollisionPolygon2D::get_build_mode() const{ + + return build_mode; +} + +Rect2 CollisionPolygon2D::get_item_rect() const { + + return aabb; +} + +void CollisionPolygon2D::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_add_to_collision_object"),&CollisionPolygon2D::_add_to_collision_object); + ObjectTypeDB::bind_method(_MD("set_polygon","polygon"),&CollisionPolygon2D::set_polygon); + ObjectTypeDB::bind_method(_MD("get_polygon"),&CollisionPolygon2D::get_polygon); + + ObjectTypeDB::bind_method(_MD("set_build_mode"),&CollisionPolygon2D::set_build_mode); + ObjectTypeDB::bind_method(_MD("get_build_mode"),&CollisionPolygon2D::get_build_mode); + + ADD_PROPERTY( PropertyInfo(Variant::INT,"build_mode",PROPERTY_HINT_ENUM,"Automatic,Segments,Solids"),_SCS("set_build_mode"),_SCS("get_build_mode")); + ADD_PROPERTY( PropertyInfo(Variant::VECTOR2_ARRAY,"polygon"),_SCS("set_polygon"),_SCS("get_polygon")); +} + +CollisionPolygon2D::CollisionPolygon2D() { + + aabb=Rect2(-10,-10,20,20); + build_mode=BUILD_SOLIDS; + + +} diff --git a/scene/2d/collision_polygon_2d.h b/scene/2d/collision_polygon_2d.h new file mode 100644 index 0000000000..09c2060088 --- /dev/null +++ b/scene/2d/collision_polygon_2d.h @@ -0,0 +1,75 @@ +/*************************************************************************/ +/* collision_polygon_2d.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef COLLISION_POLYGON_2D_H +#define COLLISION_POLYGON_2D_H + +#include "scene/2d/node_2d.h" +#include "scene/resources/shape_2d.h" + + + +class CollisionPolygon2D : public Node2D { + + OBJ_TYPE(CollisionPolygon2D,Node2D); +public: + + enum BuildMode { + BUILD_SOLIDS, + BUILD_SEGMENTS, + }; + +protected: + + + Rect2 aabb; + BuildMode build_mode; + Vector polygon; + + void _add_to_collision_object(Object *p_obj); + void _update_parent(); + +protected: + + void _notification(int p_what); + static void _bind_methods(); +public: + + void set_build_mode(BuildMode p_mode); + BuildMode get_build_mode() const; + + void set_polygon(const Vector& p_polygon); + Vector get_polygon() const; + + virtual Rect2 get_item_rect() const; + CollisionPolygon2D(); +}; + +VARIANT_ENUM_CAST( CollisionPolygon2D::BuildMode ); + +#endif // COLLISION_POLYGON_2D_H diff --git a/scene/2d/collision_shape_2d.cpp b/scene/2d/collision_shape_2d.cpp new file mode 100644 index 0000000000..4ae9b37c21 --- /dev/null +++ b/scene/2d/collision_shape_2d.cpp @@ -0,0 +1,248 @@ +/*************************************************************************/ +/* collision_shape_2d.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "collision_shape_2d.h" +#include "collision_object_2d.h" +#include "scene/resources/segment_shape_2d.h" +#include "scene/resources/shape_line_2d.h" +#include "scene/resources/circle_shape_2d.h" +#include "scene/resources/rectangle_shape_2d.h" +#include "scene/resources/capsule_shape_2d.h" +#include "scene/resources/convex_polygon_shape_2d.h" +#include "scene/resources/concave_polygon_shape_2d.h" + + +void CollisionShape2D::_add_to_collision_object(Object *p_obj) { + + CollisionObject2D *co = p_obj->cast_to(); + ERR_FAIL_COND(!co); + co->add_shape(shape,get_transform()); + if (trigger) + co->set_shape_as_trigger(co->get_shape_count()-1,true); + +} + +void CollisionShape2D::_shape_changed() { + + update(); + _update_parent(); +} + +void CollisionShape2D::_update_parent() { + + + Node *parent = get_parent(); + if (!parent) + return; + CollisionObject2D *co = parent->cast_to(); + if (!co) + return; + co->_update_shapes_from_children(); +} + +void CollisionShape2D::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_LOCAL_TRANSFORM_CHANGED: { + + if (!is_inside_scene()) + break; + _update_parent(); + + } break; + /* + case NOTIFICATION_TRANSFORM_CHANGED: { + + if (!is_inside_scene()) + break; + _update_parent(); + + } break;*/ + case NOTIFICATION_DRAW: { + + rect=Rect2(); + + Color draw_col=Color(0,0.6,0.7,0.5); + + if (shape->cast_to()) { + + LineShape2D *l = shape->cast_to(); + Vector2 point = l->get_d() * l->get_normal(); + + Vector2 l1[2]={point-l->get_normal().tangent()*100,point+l->get_normal().tangent()*100}; + draw_line(l1[0],l1[1],draw_col,3); + Vector2 l2[2]={point,point+l->get_normal()*30}; + draw_line(l2[0],l2[1],draw_col,3); + rect.pos=l1[0]; + rect.expand_to(l1[1]); + rect.expand_to(l2[0]); + rect.expand_to(l2[1]); + + } else if (shape->cast_to()) { + + SegmentShape2D *s = shape->cast_to(); + draw_line(s->get_a(),s->get_b(),draw_col,3); + rect.pos=s->get_a(); + rect.expand_to(s->get_b()); + + } else if (shape->cast_to()) { + + RayShape2D *s = shape->cast_to(); + + Vector2 tip = Vector2(0,s->get_length()); + draw_line(Vector2(),tip,draw_col,3); + Vector pts; + float tsize=4; + pts.push_back(tip+Vector2(0,tsize)); + pts.push_back(tip+Vector2(0.707*tsize,0)); + pts.push_back(tip+Vector2(-0.707*tsize,0)); + Vector cols; + for(int i=0;i<3;i++) + cols.push_back(draw_col); + + draw_primitive(pts,cols,Vector()); //small arrow + + rect.pos=Vector2(); + rect.expand_to(tip); + rect=rect.grow(0.707*tsize); + + } else if (shape->cast_to()) { + + CircleShape2D *s = shape->cast_to(); + Vector points; + for(int i=0;i<24;i++) { + + points.push_back(Vector2(Math::cos(i*Math_PI*2/24.0),Math::sin(i*Math_PI*2/24.0))*s->get_radius()); + } + + draw_colored_polygon(points,draw_col); + rect.pos=-Point2(s->get_radius(),s->get_radius()); + rect.size=Point2(s->get_radius(),s->get_radius())*2.0; + + } else if (shape->cast_to()) { + + RectangleShape2D *s = shape->cast_to(); + Vector2 he = s->get_extents(); + rect=Rect2(-he,he*2.0); + draw_rect(rect,draw_col);; + + } else if (shape->cast_to()) { + + CapsuleShape2D *s = shape->cast_to(); + + Vector points; + for(int i=0;i<24;i++) { + Vector2 ofs = Vector2(0,(i>6 && i<=18) ? -s->get_height()*0.5 : s->get_height()*0.5); + + points.push_back(Vector2(Math::sin(i*Math_PI*2/24.0),Math::cos(i*Math_PI*2/24.0))*s->get_radius() + ofs); + if (i==6 || i==18) + points.push_back(Vector2(Math::sin(i*Math_PI*2/24.0),Math::cos(i*Math_PI*2/24.0))*s->get_radius() - ofs); + } + + draw_colored_polygon(points,draw_col); + Vector2 he=Point2(s->get_radius(),s->get_radius()+s->get_height()*0.5); + rect.pos=-he; + rect.size=he*2.0; + + } else if (shape->cast_to()) { + + ConvexPolygonShape2D *s = shape->cast_to(); + + Vector points = s->get_points(); + for(int i=0;i& p_shape) { + + if (shape.is_valid()) + shape->disconnect("changed",this,"_shape_changed"); + shape=p_shape; + update(); + _update_parent(); + if (shape.is_valid()) + shape->connect("changed",this,"_shape_changed"); + +} + +Ref CollisionShape2D::get_shape() const { + + return shape; +} + +Rect2 CollisionShape2D::get_item_rect() const { + + return rect; +} + +void CollisionShape2D::set_trigger(bool p_trigger) { + + trigger=p_trigger; + _update_parent(); +} + +bool CollisionShape2D::is_trigger() const{ + + return trigger; +} + +void CollisionShape2D::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("set_shape","shape"),&CollisionShape2D::set_shape); + ObjectTypeDB::bind_method(_MD("get_shape"),&CollisionShape2D::get_shape); + ObjectTypeDB::bind_method(_MD("_shape_changed"),&CollisionShape2D::_shape_changed); + ObjectTypeDB::bind_method(_MD("_add_to_collision_object"),&CollisionShape2D::_add_to_collision_object); + ObjectTypeDB::bind_method(_MD("set_trigger","enable"),&CollisionShape2D::set_trigger); + ObjectTypeDB::bind_method(_MD("is_trigger"),&CollisionShape2D::is_trigger); + + ADD_PROPERTYNZ(PropertyInfo(Variant::OBJECT,"shape",PROPERTY_HINT_RESOURCE_TYPE,"Shape2D"),_SCS("set_shape"),_SCS("get_shape")); + ADD_PROPERTY(PropertyInfo(Variant::BOOL,"trigger"),_SCS("set_trigger"),_SCS("is_trigger")); +} + +CollisionShape2D::CollisionShape2D() { + + rect=Rect2(-Point2(10,10),Point2(20,20)); + + trigger=false; +} diff --git a/scene/2d/collision_shape_2d.h b/scene/2d/collision_shape_2d.h new file mode 100644 index 0000000000..2e2023f54d --- /dev/null +++ b/scene/2d/collision_shape_2d.h @@ -0,0 +1,61 @@ +/*************************************************************************/ +/* collision_shape_2d.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef COLLISION_SHAPE_2D_H +#define COLLISION_SHAPE_2D_H + +#include "scene/2d/node_2d.h" +#include "scene/resources/shape_2d.h" + +class CollisionShape2D : public Node2D { + + OBJ_TYPE(CollisionShape2D,Node2D); + Ref shape; + Rect2 rect; + bool trigger; + + void _shape_changed(); +protected: + + void _update_parent(); + void _notification(int p_what); + static void _bind_methods(); + + void _add_to_collision_object(Object *p_obj); +public: + + void set_shape(const Ref& p_shape); + Ref get_shape() const; + virtual Rect2 get_item_rect() const; + void set_trigger(bool p_trigger); + bool is_trigger() const; + + CollisionShape2D(); +}; + +#endif // COLLISION_SHAPE_2D_H diff --git a/scene/2d/joints_2d.cpp b/scene/2d/joints_2d.cpp new file mode 100644 index 0000000000..0e673ff791 --- /dev/null +++ b/scene/2d/joints_2d.cpp @@ -0,0 +1,412 @@ +/*************************************************************************/ +/* joints_2d.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "joints_2d.h" +#include "servers/physics_2d_server.h" +#include "physics_body_2d.h" + +void Joint2D::_update_joint() { + + if (!is_inside_scene()) + return; + + if (joint.is_valid()) { + Physics2DServer::get_singleton()->free(joint); + } + + joint=RID(); + + + joint = _configure_joint(); + Physics2DServer::get_singleton()->get_singleton()->joint_set_param(joint,Physics2DServer::JOINT_PARAM_BIAS,bias); + + +} + + +void Joint2D::set_node_a(const NodePath& p_node_a) { + + + if (a==p_node_a) + return; + + a=p_node_a; + _update_joint(); +} + +NodePath Joint2D::get_node_a() const{ + + return a; +} + +void Joint2D::set_node_b(const NodePath& p_node_b){ + + if (b==p_node_b) + return; + b=p_node_b; + _update_joint(); + +} +NodePath Joint2D::get_node_b() const{ + + + return b; +} + + +void Joint2D::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_READY: { + _update_joint(); + } break; + case NOTIFICATION_EXIT_SCENE: { + if (joint.is_valid()) { + + Physics2DServer::get_singleton()->free(joint); + joint=RID(); + } + } break; + + } + +} + +void Joint2D::set_bias(real_t p_bias) { + + bias=p_bias; + if (joint.is_valid()) + Physics2DServer::get_singleton()->get_singleton()->joint_set_param(joint,Physics2DServer::JOINT_PARAM_BIAS,bias); +} + +real_t Joint2D::get_bias() const{ + + + return bias; +} + + +void Joint2D::_bind_methods() { + + + ObjectTypeDB::bind_method( _MD("set_node_a","node"), &Joint2D::set_node_a ); + ObjectTypeDB::bind_method( _MD("get_node_a"), &Joint2D::get_node_a ); + + ObjectTypeDB::bind_method( _MD("set_node_b","node"), &Joint2D::set_node_b ); + ObjectTypeDB::bind_method( _MD("get_node_b"), &Joint2D::get_node_b ); + + ObjectTypeDB::bind_method( _MD("set_bias","bias"), &Joint2D::set_bias ); + ObjectTypeDB::bind_method( _MD("get_bias"), &Joint2D::get_bias ); + + ADD_PROPERTY( PropertyInfo( Variant::NODE_PATH, "node_a"), _SCS("set_node_a"),_SCS("get_node_a") ); + ADD_PROPERTY( PropertyInfo( Variant::NODE_PATH, "node_b"), _SCS("set_node_b"),_SCS("get_node_b") ); + ADD_PROPERTY( PropertyInfo( Variant::REAL, "bias/bias",PROPERTY_HINT_RANGE,"0,0.9,0.01"), _SCS("set_bias"),_SCS("get_bias") ); + +} + + + +Joint2D::Joint2D() { + + bias=0; +} + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +void PinJoint2D::_notification(int p_what) { + + switch(p_what) { + case NOTIFICATION_DRAW: { + if (is_inside_scene() && get_scene()->is_editor_hint()) { + + draw_line(Point2(-10,0),Point2(+10,0),Color(0.7,0.6,0.0,0.5),3); + draw_line(Point2(0,-10),Point2(0,+10),Color(0.7,0.6,0.0,0.5),3); + } + } break; + } + +} + +RID PinJoint2D::_configure_joint() { + + Node *node_a = has_node( get_node_a() ) ? get_node( get_node_a() ) : (Node*)NULL; + Node *node_b = has_node( get_node_b() ) ? get_node( get_node_b() ) : (Node*)NULL; + + if (!node_a && !node_b) + return RID(); + + PhysicsBody2D *body_a=node_a ? node_a->cast_to() : (PhysicsBody2D*)NULL; + PhysicsBody2D *body_b=node_b ? node_b->cast_to() : (PhysicsBody2D*)NULL; + + if (!body_a && !body_b) + return RID(); + + if (!body_a) { + SWAP(body_a,body_b); + } else if (body_b) { + //add a collision exception between both + Physics2DServer::get_singleton()->body_add_collision_exception(body_a->get_rid(),body_b->get_rid()); + } + + return Physics2DServer::get_singleton()->pin_joint_create(get_global_transform().get_origin(),body_a->get_rid(),body_b?body_b->get_rid():RID()); + +} + + +PinJoint2D::PinJoint2D() { + + +} + + + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + + +void GrooveJoint2D::_notification(int p_what) { + + switch(p_what) { + case NOTIFICATION_DRAW: { + if (is_inside_scene() && get_scene()->is_editor_hint()) { + + draw_line(Point2(-10,0),Point2(+10,0),Color(0.7,0.6,0.0,0.5),3); + draw_line(Point2(-10,length),Point2(+10,length),Color(0.7,0.6,0.0,0.5),3); + draw_line(Point2(0,0),Point2(0,length),Color(0.7,0.6,0.0,0.5),3); + draw_line(Point2(-10,initial_offset),Point2(+10,initial_offset),Color(0.8,0.8,0.9,0.5),5); + } + } break; + } +} + +RID GrooveJoint2D::_configure_joint(){ + + + Node *node_a = has_node( get_node_a() ) ? get_node( get_node_a() ) : (Node*)NULL; + Node *node_b = has_node( get_node_b() ) ? get_node( get_node_b() ) : (Node*)NULL; + + if (!node_a || !node_b) + return RID(); + + PhysicsBody2D *body_a=node_a->cast_to(); + PhysicsBody2D *body_b=node_b->cast_to(); + + if (!body_a || !body_b) + return RID(); + + Physics2DServer::get_singleton()->body_add_collision_exception(body_a->get_rid(),body_b->get_rid()); + + Matrix32 gt = get_global_transform(); + Vector2 groove_A1 = gt.get_origin(); + Vector2 groove_A2 = gt.xform( Vector2(0,length) ); + Vector2 anchor_B = gt.xform( Vector2(0,initial_offset) ); + + + return Physics2DServer::get_singleton()->groove_joint_create(groove_A1,groove_A2,anchor_B,body_a->get_rid(),body_b->get_rid()); +} + + +void GrooveJoint2D::set_length(real_t p_length) { + + length=p_length; + update(); +} + +real_t GrooveJoint2D::get_length() const { + + return length; +} + + +void GrooveJoint2D::set_initial_offset(real_t p_initial_offset) { + + initial_offset=p_initial_offset; + update(); +} + +real_t GrooveJoint2D::get_initial_offset() const { + + return initial_offset; +} + + + +void GrooveJoint2D::_bind_methods() { + + + ObjectTypeDB::bind_method(_MD("set_length","length"),&GrooveJoint2D::set_length); + ObjectTypeDB::bind_method(_MD("get_length"),&GrooveJoint2D::get_length); + ObjectTypeDB::bind_method(_MD("set_initial_offset","offset"),&GrooveJoint2D::set_initial_offset); + ObjectTypeDB::bind_method(_MD("get_initial_offset"),&GrooveJoint2D::get_initial_offset); + + ADD_PROPERTY( PropertyInfo( Variant::REAL, "length", PROPERTY_HINT_EXP_RANGE,"1,65535,1"), _SCS("set_length"),_SCS("get_length")); + ADD_PROPERTY( PropertyInfo( Variant::REAL, "initial_offset", PROPERTY_HINT_EXP_RANGE,"1,65535,1"), _SCS("set_initial_offset"),_SCS("get_initial_offset")); +} + +GrooveJoint2D::GrooveJoint2D() { + + length=50; + initial_offset=25; +} + + + + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + + + +void DampedSpringJoint2D::_notification(int p_what) { + + switch(p_what) { + case NOTIFICATION_DRAW: { + if (is_inside_scene() && get_scene()->is_editor_hint()) { + + draw_line(Point2(-10,0),Point2(+10,0),Color(0.7,0.6,0.0,0.5),3); + draw_line(Point2(-10,length),Point2(+10,length),Color(0.7,0.6,0.0,0.5),3); + draw_line(Point2(0,0),Point2(0,length),Color(0.7,0.6,0.0,0.5),3); + } + } break; + } +} + +RID DampedSpringJoint2D::_configure_joint(){ + + + Node *node_a = has_node( get_node_a() ) ? get_node( get_node_a() ) : (Node*)NULL; + Node *node_b = has_node( get_node_b() ) ? get_node( get_node_b() ) : (Node*)NULL; + + if (!node_a || !node_b) + return RID(); + + PhysicsBody2D *body_a=node_a->cast_to(); + PhysicsBody2D *body_b=node_b->cast_to(); + + if (!body_a || !body_b) + return RID(); + + Physics2DServer::get_singleton()->body_add_collision_exception(body_a->get_rid(),body_b->get_rid()); + + Matrix32 gt = get_global_transform(); + Vector2 anchor_A = gt.get_origin(); + Vector2 anchor_B = gt.xform( Vector2(0,length) ); + + RID dsj = Physics2DServer::get_singleton()->damped_spring_joint_create(anchor_A,anchor_B,body_a->get_rid(),body_b->get_rid()); + if (rest_length) + Physics2DServer::get_singleton()->damped_string_joint_set_param(dsj,Physics2DServer::DAMPED_STRING_REST_LENGTH,rest_length); + Physics2DServer::get_singleton()->damped_string_joint_set_param(dsj,Physics2DServer::DAMPED_STRING_STIFFNESS,stiffness); + Physics2DServer::get_singleton()->damped_string_joint_set_param(dsj,Physics2DServer::DAMPED_STRING_DAMPING,damping); + + return dsj; +} + + +void DampedSpringJoint2D::set_length(real_t p_length) { + + length=p_length; + update(); +} + +real_t DampedSpringJoint2D::get_length() const { + + return length; +} + +void DampedSpringJoint2D::set_rest_length(real_t p_rest_length) { + + rest_length=p_rest_length; + update(); + if (get_joint().is_valid()) + Physics2DServer::get_singleton()->damped_string_joint_set_param(get_joint(),Physics2DServer::DAMPED_STRING_REST_LENGTH,p_rest_length?p_rest_length:length); + +} + +real_t DampedSpringJoint2D::get_rest_length() const { + + return rest_length; +} + +void DampedSpringJoint2D::set_stiffness(real_t p_stiffness) { + + stiffness=p_stiffness; + update(); + if (get_joint().is_valid()) + Physics2DServer::get_singleton()->damped_string_joint_set_param(get_joint(),Physics2DServer::DAMPED_STRING_STIFFNESS,p_stiffness); +} + +real_t DampedSpringJoint2D::get_stiffness() const { + + return stiffness; +} + +void DampedSpringJoint2D::set_damping(real_t p_damping) { + + damping=p_damping; + update(); + if (get_joint().is_valid()) + Physics2DServer::get_singleton()->damped_string_joint_set_param(get_joint(),Physics2DServer::DAMPED_STRING_DAMPING,p_damping); +} + +real_t DampedSpringJoint2D::get_damping() const { + + return damping; +} + + +void DampedSpringJoint2D::_bind_methods() { + + + ObjectTypeDB::bind_method(_MD("set_length","length"),&DampedSpringJoint2D::set_length); + ObjectTypeDB::bind_method(_MD("get_length"),&DampedSpringJoint2D::get_length); + ObjectTypeDB::bind_method(_MD("set_rest_length","rest_length"),&DampedSpringJoint2D::set_rest_length); + ObjectTypeDB::bind_method(_MD("get_rest_length"),&DampedSpringJoint2D::get_rest_length); + ObjectTypeDB::bind_method(_MD("set_stiffness","stiffness"),&DampedSpringJoint2D::set_stiffness); + ObjectTypeDB::bind_method(_MD("get_stiffness"),&DampedSpringJoint2D::get_stiffness); + ObjectTypeDB::bind_method(_MD("set_damping","damping"),&DampedSpringJoint2D::set_damping); + ObjectTypeDB::bind_method(_MD("get_damping"),&DampedSpringJoint2D::get_damping); + + ADD_PROPERTY( PropertyInfo( Variant::REAL, "length", PROPERTY_HINT_EXP_RANGE,"1,65535,1"), _SCS("set_length"),_SCS("get_length")); + ADD_PROPERTY( PropertyInfo( Variant::REAL, "rest_length", PROPERTY_HINT_EXP_RANGE,"0,65535,1"), _SCS("set_rest_length"),_SCS("get_rest_length")); + ADD_PROPERTY( PropertyInfo( Variant::REAL, "stiffness", PROPERTY_HINT_EXP_RANGE,"0.1,64,0.1"), _SCS("set_stiffness"),_SCS("get_stiffness")); + ADD_PROPERTY( PropertyInfo( Variant::REAL, "damping", PROPERTY_HINT_EXP_RANGE,"0.01,16,0.01"), _SCS("set_damping"),_SCS("get_damping")); + +} + +DampedSpringJoint2D::DampedSpringJoint2D() { + + length=50; + rest_length=0; + stiffness=20; + damping=1; +} diff --git a/scene/2d/joints_2d.h b/scene/2d/joints_2d.h new file mode 100644 index 0000000000..7027e4386a --- /dev/null +++ b/scene/2d/joints_2d.h @@ -0,0 +1,141 @@ +/*************************************************************************/ +/* joints_2d.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef JOINTS_2D_H +#define JOINTS_2D_H + + +#include "node_2d.h" + +class Joint2D : public Node2D { + + OBJ_TYPE(Joint2D,Node2D); + + RID joint; + + NodePath a; + NodePath b; + real_t bias; + + +protected: + + void _update_joint(); + + void _notification(int p_what); + virtual RID _configure_joint()=0; + + static void _bind_methods(); +public: + + void set_node_a(const NodePath& p_node_a); + NodePath get_node_a() const; + + void set_node_b(const NodePath& p_node_b); + NodePath get_node_b() const; + + void set_bias(real_t p_bias); + real_t get_bias() const; + + RID get_joint() const { return joint; } + Joint2D(); + +}; + + +class PinJoint2D : public Joint2D { + + OBJ_TYPE(PinJoint2D,Joint2D); + +protected: + + void _notification(int p_what); + virtual RID _configure_joint(); +public: + + + + PinJoint2D(); +}; + +class GrooveJoint2D : public Joint2D { + + OBJ_TYPE(GrooveJoint2D,Joint2D); + + real_t length; + real_t initial_offset; + +protected: + + void _notification(int p_what); + virtual RID _configure_joint(); + static void _bind_methods(); +public: + + void set_length(real_t p_length); + real_t get_length() const; + + void set_initial_offset(real_t p_initial_offset); + real_t get_initial_offset() const; + + GrooveJoint2D(); +}; + +class DampedSpringJoint2D : public Joint2D { + + OBJ_TYPE(DampedSpringJoint2D,Joint2D); + + real_t stiffness; + real_t damping; + real_t rest_length; + real_t length; + +protected: + + void _notification(int p_what); + virtual RID _configure_joint(); + static void _bind_methods(); +public: + + void set_length(real_t p_length); + real_t get_length() const; + + void set_rest_length(real_t p_rest_length); + real_t get_rest_length() const; + + void set_damping(real_t p_damping); + real_t get_damping() const; + + void set_stiffness(real_t p_stiffness); + real_t get_stiffness() const; + + DampedSpringJoint2D(); +}; + + +#endif // JOINTS_2D_H diff --git a/scene/2d/node_2d.cpp b/scene/2d/node_2d.cpp new file mode 100644 index 0000000000..9b2994ef84 --- /dev/null +++ b/scene/2d/node_2d.cpp @@ -0,0 +1,291 @@ +/*************************************************************************/ +/* node_2d.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "node_2d.h" + +#include "servers/visual_server.h" +#include "scene/gui/control.h" +#include "scene/main/viewport.h" +#include "message_queue.h" + + +void Node2D::edit_set_pivot(const Point2& p_pivot) { + + +} + +Point2 Node2D::edit_get_pivot() const { + + return Point2(); +} +bool Node2D::edit_has_pivot() const { + + return false; +} + +Variant Node2D::edit_get_state() const { + + Array state; + state.push_back(pos); + state.push_back(angle); + state.push_back(scale); + + return state; + +} +void Node2D::edit_set_state(const Variant& p_state) { + + Array state = p_state; + ERR_FAIL_COND( state.size() != 3); + + pos = state[0]; + angle = state[1]; + scale = state[2]; + _update_transform(); + _change_notify("transform/rot"); + _change_notify("transform/scale"); + _change_notify("transform/pos"); + +} + +void Node2D::edit_set_rect(const Rect2& p_edit_rect) { + + Rect2 r = get_item_rect(); + + Vector2 zero_offset; + if (r.size.x!=0) + zero_offset.x = -r.pos.x / r.size.x; + if (r.size.y!=0) + zero_offset.y = -r.pos.y / r.size.y; + + Size2 new_scale(1,1); + + if (r.size.x!=0) + new_scale.x = p_edit_rect.size.x / r.size.x; + if (r.size.y!=0) + new_scale.y = p_edit_rect.size.y / r.size.y; + + Point2 new_pos = p_edit_rect.pos + p_edit_rect.size*zero_offset;//p_edit_rect.pos - r.pos; + + Matrix32 postxf; + postxf.set_rotation_and_scale(angle,scale); + new_pos = postxf.xform(new_pos); + + pos+=new_pos; + scale*=new_scale; + + _update_transform(); + _change_notify("transform/scale"); + _change_notify("transform/pos"); + +} + + +void Node2D::edit_rotate(float p_rot) { + + angle+=p_rot; + _update_transform(); + _change_notify("transform/rot"); +} + + +void Node2D::_update_xform_values() { + + pos=_mat.elements[2]; + angle=_mat.get_rotation(); + scale=_mat.get_scale(); + _xform_dirty=false; +} + +void Node2D::_update_transform() { + + Matrix32 mat(angle,pos); + _mat.set_rotation_and_scale(angle,scale); + _mat.elements[2]=pos; + + VisualServer::get_singleton()->canvas_item_set_transform(get_canvas_item(),_mat); + + if (!is_inside_scene()) + return; + + + _notify_transform(); +} + +void Node2D::set_pos(const Point2& p_pos) { + + if (_xform_dirty) + ((Node2D*)this)->_update_xform_values(); + pos=p_pos; + _update_transform(); + _change_notify("transform/pos"); + + +} + +void Node2D::set_rot(float p_angle) { + + if (_xform_dirty) + ((Node2D*)this)->_update_xform_values(); + angle=p_angle; + _update_transform(); + _change_notify("transform/rot"); +} + +void Node2D::set_scale(const Size2& p_scale) { + + if (_xform_dirty) + ((Node2D*)this)->_update_xform_values(); + scale=p_scale; + _update_transform(); + _change_notify("transform/scale"); + +} + +Point2 Node2D::get_pos() const { + + if (_xform_dirty) + ((Node2D*)this)->_update_xform_values(); + return pos; +} +float Node2D::get_rot() const { + if (_xform_dirty) + ((Node2D*)this)->_update_xform_values(); + + return angle; +} +Size2 Node2D::get_scale() const { + if (_xform_dirty) + ((Node2D*)this)->_update_xform_values(); + + return scale; +} + +void Node2D::_set_rotd(float p_angle) { + + set_rot(Math::deg2rad(p_angle)); +} + +float Node2D::_get_rotd() const { + + return Math::rad2deg(get_rot()); +} + + +void Node2D::_notification(int p_what) { + + switch(p_what) { + + } +} + +Matrix32 Node2D::get_transform() const { + + return _mat; +} + +Rect2 Node2D::get_item_rect() const { + + if (get_script_instance()) { + Variant::CallError err; + Rect2 r = get_script_instance()->call("_get_item_rect",NULL,0,err); + if (err.error==Variant::CallError::CALL_OK) + return r; + } + return Rect2(Point2(-32,-32),Size2(64,64)); +} + +Point2 Node2D::get_global_pos() const { + + return get_global_transform().get_origin(); +} + +void Node2D::set_transform(const Matrix32& p_transform) { + + _mat=p_transform; + _xform_dirty=true; + + VisualServer::get_singleton()->canvas_item_set_transform(get_canvas_item(),_mat); + + if (!is_inside_scene()) + return; + + _notify_transform(); +} + +void Node2D::set_global_transform(const Matrix32& p_transform) { + + CanvasItem *pi = get_parent_item(); + if (pi) + set_transform( pi->get_global_transform().affine_inverse() * p_transform); + else + set_transform(p_transform); + + +} + +void Node2D::_bind_methods() { + + + + ObjectTypeDB::bind_method(_MD("_get_rotd"),&Node2D::_get_rotd); + ObjectTypeDB::bind_method(_MD("_set_rotd"),&Node2D::_set_rotd); + + ObjectTypeDB::bind_method(_MD("set_pos","pos"),&Node2D::set_pos); + ObjectTypeDB::bind_method(_MD("set_rot","rot"),&Node2D::set_rot); + ObjectTypeDB::bind_method(_MD("set_scale","scale"),&Node2D::set_scale); + + ObjectTypeDB::bind_method(_MD("get_pos"),&Node2D::get_pos); + ObjectTypeDB::bind_method(_MD("get_rot"),&Node2D::get_rot); + ObjectTypeDB::bind_method(_MD("get_scale"),&Node2D::get_scale); + + ObjectTypeDB::bind_method(_MD("get_global_pos"),&Node2D::get_global_pos); + + ObjectTypeDB::bind_method(_MD("set_transform","xform"),&Node2D::set_transform); + ObjectTypeDB::bind_method(_MD("set_global_transform","xform"),&Node2D::set_global_transform); + + ObjectTypeDB::bind_method(_MD("edit_set_pivot"),&Node2D::edit_set_pivot); + + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2,"transform/pos"),_SCS("set_pos"),_SCS("get_pos")); + ADD_PROPERTY(PropertyInfo(Variant::REAL,"transform/rot",PROPERTY_HINT_RANGE,"-1440,1440,0.1"),_SCS("_set_rotd"),_SCS("_get_rotd")); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2,"transform/scale"),_SCS("set_scale"),_SCS("get_scale")); + + + +} + + +Node2D::Node2D() { + + + angle=0; + scale=Vector2(1,1); + _xform_dirty=false; + +} + diff --git a/scene/2d/node_2d.h b/scene/2d/node_2d.h new file mode 100644 index 0000000000..8da441dc63 --- /dev/null +++ b/scene/2d/node_2d.h @@ -0,0 +1,89 @@ +/*************************************************************************/ +/* node_2d.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef NODE2D_H +#define NODE2D_H + +#include "scene/2d/canvas_item.h" + +class Node2D : public CanvasItem { + + OBJ_TYPE(Node2D, CanvasItem ); + + Point2 pos; + float angle; + Size2 scale; + + Matrix32 _mat; + + bool _xform_dirty; + + void _update_transform(); + + void _set_rotd(float p_angle); + float _get_rotd() const; + + void _update_xform_values(); + +protected: + + + void _notification(int p_what); + + static void _bind_methods(); +public: + + virtual Variant edit_get_state() const; + virtual void edit_set_state(const Variant& p_state); + virtual void edit_set_rect(const Rect2& p_edit_rect); + virtual void edit_rotate(float p_rot); + virtual void edit_set_pivot(const Point2& p_pivot); + virtual Point2 edit_get_pivot() const; + virtual bool edit_has_pivot() const; + + void set_pos(const Point2& p_pos); + void set_rot(float p_angle); + void set_scale(const Size2& p_scale); + + Point2 get_pos() const; + float get_rot() const; + Size2 get_scale() const; + + Point2 get_global_pos() const; + virtual Rect2 get_item_rect() const; + + void set_transform(const Matrix32& p_transform); + void set_global_transform(const Matrix32& p_transform); + + + Matrix32 get_transform() const; + + Node2D(); +}; + +#endif // NODE2D_H diff --git a/scene/2d/node_2d_singleton.cpp b/scene/2d/node_2d_singleton.cpp new file mode 100644 index 0000000000..58e078101d --- /dev/null +++ b/scene/2d/node_2d_singleton.cpp @@ -0,0 +1,30 @@ +/*************************************************************************/ +/* node_2d_singleton.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "node_2d_singleton.h" + diff --git a/scene/2d/node_2d_singleton.h b/scene/2d/node_2d_singleton.h new file mode 100644 index 0000000000..b1d1e65b8b --- /dev/null +++ b/scene/2d/node_2d_singleton.h @@ -0,0 +1,33 @@ +/*************************************************************************/ +/* node_2d_singleton.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef NODE_2D_SINGLETON_H +#define NODE_2D_SINGLETON_H + + +#endif // NODE_2D_SINGLETON_H diff --git a/scene/2d/parallax_background.cpp b/scene/2d/parallax_background.cpp new file mode 100644 index 0000000000..55607bd4eb --- /dev/null +++ b/scene/2d/parallax_background.cpp @@ -0,0 +1,200 @@ +/*************************************************************************/ +/* parallax_background.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "parallax_background.h" +#include "parallax_layer.h" + + + +void ParallaxBackground::_notification(int p_what) { + + switch(p_what) { + + + case NOTIFICATION_ENTER_SCENE: { + + group_name = "__cameras_"+itos(get_viewport().get_id()); + add_to_group(group_name); + + } break; + case NOTIFICATION_EXIT_SCENE: { + + remove_from_group(group_name); + } break; + } + +} + +void ParallaxBackground::_camera_moved(const Matrix32& p_transform) { + + + set_scroll_offset(p_transform.get_origin()); + set_scroll_scale(p_transform.get_scale().dot(Vector2(0.5,0.5))); +} + + +void ParallaxBackground::set_scroll_scale(float p_scale) { + + scale=p_scale; +} + +float ParallaxBackground::get_scroll_scale() const{ + + return scale; +} + + +void ParallaxBackground::set_scroll_offset(const Point2& p_ofs) { + + offset=p_ofs; + + _update_scroll(); +} + +void ParallaxBackground::_update_scroll() { + + if (!is_inside_scene()) + return; + + Vector2 ofs = base_offset+offset*base_scale; + + Size2 vps = get_viewport_size(); + + ofs = -ofs; + if (limit_begin.x < limit_end.x) { + + if (ofs.x < limit_begin.x) + ofs.x=limit_begin.x; + else if (ofs.x+vps.x > limit_end.x) + ofs.x=limit_end.x-vps.x; + } + + + if (limit_begin.y < limit_end.y) { + + if (ofs.y < limit_begin.y) + ofs.y=limit_begin.y; + else if (ofs.y+vps.y > limit_end.y) + ofs.y=limit_end.y-vps.y; + } + ofs = -ofs; + + for(int i=0;icast_to(); + if (!l) + continue; + + l->set_base_offset_and_scale(ofs,scale); + } +} + +Point2 ParallaxBackground::get_scroll_offset() const { + + return offset; +} + +void ParallaxBackground::set_scroll_base_offset(const Point2& p_ofs) { + + base_offset=p_ofs; + _update_scroll(); +} + +Point2 ParallaxBackground::get_scroll_base_offset() const{ + + return base_offset; +} + +void ParallaxBackground::set_scroll_base_scale(const Point2& p_ofs) { + + base_scale=p_ofs; + _update_scroll(); +} + +Point2 ParallaxBackground::get_scroll_base_scale() const{ + + return base_scale; +} + + +void ParallaxBackground::set_limit_begin(const Point2& p_ofs) { + + limit_begin=p_ofs; + _update_scroll(); +} + +Point2 ParallaxBackground::get_limit_begin() const { + + return limit_begin; +} + +void ParallaxBackground::set_limit_end(const Point2& p_ofs) { + + limit_end=p_ofs; + _update_scroll(); + +} + +Point2 ParallaxBackground::get_limit_end() const { + + return limit_end; +} + +void ParallaxBackground::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_camera_moved"),&ParallaxBackground::_camera_moved); + ObjectTypeDB::bind_method(_MD("set_scroll_offset","ofs"),&ParallaxBackground::set_scroll_offset); + ObjectTypeDB::bind_method(_MD("get_scroll_offset"),&ParallaxBackground::get_scroll_offset); + ObjectTypeDB::bind_method(_MD("set_scroll_base_offset","ofs"),&ParallaxBackground::set_scroll_base_offset); + ObjectTypeDB::bind_method(_MD("get_scroll_base_offset"),&ParallaxBackground::get_scroll_base_offset); + ObjectTypeDB::bind_method(_MD("set_scroll_base_scale","scale"),&ParallaxBackground::set_scroll_base_scale); + ObjectTypeDB::bind_method(_MD("get_scroll_base_scale"),&ParallaxBackground::get_scroll_base_scale); + ObjectTypeDB::bind_method(_MD("set_limit_begin","ofs"),&ParallaxBackground::set_limit_begin); + ObjectTypeDB::bind_method(_MD("get_limit_begin"),&ParallaxBackground::get_limit_begin); + ObjectTypeDB::bind_method(_MD("set_limit_end","ofs"),&ParallaxBackground::set_limit_end); + ObjectTypeDB::bind_method(_MD("get_limit_end"),&ParallaxBackground::get_limit_end); + + + ADD_PROPERTY( PropertyInfo(Variant::VECTOR2,"scroll/offset"),_SCS("set_scroll_offset"),_SCS("get_scroll_offset")); + ADD_PROPERTY( PropertyInfo(Variant::VECTOR2,"scroll/base_offset"),_SCS("set_scroll_base_offset"),_SCS("get_scroll_base_offset")); + ADD_PROPERTY( PropertyInfo(Variant::VECTOR2,"scroll/base_scale"),_SCS("set_scroll_base_scale"),_SCS("get_scroll_base_scale")); + ADD_PROPERTY( PropertyInfo(Variant::VECTOR2,"scroll/limit_begin"),_SCS("set_limit_begin"),_SCS("get_limit_begin")); + ADD_PROPERTY( PropertyInfo(Variant::VECTOR2,"scroll/limit_end"),_SCS("set_limit_end"),_SCS("get_limit_end")); + +} + + + + + +ParallaxBackground::ParallaxBackground() { + + base_scale=Vector2(1,1); + scale=1.0; + set_layer(-1); //behind all by default +} diff --git a/scene/2d/parallax_background.h b/scene/2d/parallax_background.h new file mode 100644 index 0000000000..ed6747f01c --- /dev/null +++ b/scene/2d/parallax_background.h @@ -0,0 +1,78 @@ +/*************************************************************************/ +/* parallax_background.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef PARALLAX_BACKGROUND_H +#define PARALLAX_BACKGROUND_H + +#include "scene/main/canvas_layer.h" +#include "scene/2d/node_2d.h" +#include "scene/2d/camera_2d.h" + +class ParallaxBackground : public CanvasLayer { + + OBJ_TYPE( ParallaxBackground, CanvasLayer ); + + Point2 offset; + float scale; + Point2 base_offset; + Point2 base_scale; + String group_name; + Point2 limit_begin; + Point2 limit_end; + + void _update_scroll(); +protected: + + void _camera_moved(const Matrix32& p_transform); + + void _notification(int p_what); + static void _bind_methods(); +public: + + void set_scroll_offset(const Point2& p_ofs); + Point2 get_scroll_offset() const; + + void set_scroll_scale(float p_ofs); + float get_scroll_scale() const; + + void set_scroll_base_offset(const Point2& p_ofs); + Point2 get_scroll_base_offset() const; + + void set_scroll_base_scale(const Point2& p_ofs); + Point2 get_scroll_base_scale() const; + + void set_limit_begin(const Point2& p_ofs); + Point2 get_limit_begin() const; + + void set_limit_end(const Point2& p_ofs); + Point2 get_limit_end() const; + + ParallaxBackground(); +}; + +#endif // PARALLAX_BACKGROUND_H diff --git a/scene/2d/parallax_layer.cpp b/scene/2d/parallax_layer.cpp new file mode 100644 index 0000000000..2cda51dccb --- /dev/null +++ b/scene/2d/parallax_layer.cpp @@ -0,0 +1,138 @@ +/*************************************************************************/ +/* parallax_layer.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "parallax_layer.h" +#include "parallax_background.h" + +void ParallaxLayer::set_motion_scale(const Size2& p_scale) { + + motion_scale=p_scale; +} + +Size2 ParallaxLayer::get_motion_scale() const { + + return motion_scale; + +} + + +void ParallaxLayer::_update_mirroring() { + + if (!get_parent()) + return; + + ParallaxBackground *pb = get_parent()->cast_to(); + if (pb) { + + RID c = pb->get_world_2d()->get_canvas(); + RID ci = get_canvas_item(); + VisualServer::get_singleton()->canvas_set_item_mirroring(c,ci,mirroring); + } + +} + +void ParallaxLayer::set_mirroring(const Size2& p_mirroring) { + + mirroring=p_mirroring; + _update_mirroring(); + +} + +Size2 ParallaxLayer::get_mirroring() const{ + + return mirroring; +} + + + +void ParallaxLayer::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_ENTER_SCENE: { + + orig_offset=get_pos(); + orig_scale=get_scale(); + _update_mirroring(); + } break; + } +} + +void ParallaxLayer::set_base_offset_and_scale(const Point2& p_offset,float p_scale) { + + if (!is_inside_scene()) + return; + if (get_scene()->is_editor_hint()) + return; + Point2 new_ofs = ((orig_offset+p_offset)*motion_scale)*p_scale; + + if (mirroring.x) { + + while( new_ofs.x>=0) { + new_ofs.x -= mirroring.x*p_scale; + } + while(new_ofs.x < -mirroring.x*p_scale) { + new_ofs.x += mirroring.x*p_scale; + } + } + + if (mirroring.y) { + + while( new_ofs.y>=0) { + new_ofs.y -= mirroring.y*p_scale; + } + while(new_ofs.y < -mirroring.y*p_scale) { + new_ofs.y += mirroring.y*p_scale; + } + } + + + set_pos(new_ofs); + set_scale(Vector2(1,1)*p_scale); + + +} + +void ParallaxLayer::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("set_motion_scale","scale"),&ParallaxLayer::set_motion_scale); + ObjectTypeDB::bind_method(_MD("get_motion_scale"),&ParallaxLayer::get_motion_scale); + ObjectTypeDB::bind_method(_MD("set_mirroring","mirror"),&ParallaxLayer::set_mirroring); + ObjectTypeDB::bind_method(_MD("get_mirroring"),&ParallaxLayer::get_mirroring); + + ADD_PROPERTY( PropertyInfo(Variant::VECTOR2,"motion/scale"),_SCS("set_motion_scale"),_SCS("get_motion_scale")); + ADD_PROPERTY( PropertyInfo(Variant::VECTOR2,"motion/mirroring"),_SCS("set_mirroring"),_SCS("get_mirroring")); + +} + + + +ParallaxLayer::ParallaxLayer() +{ + motion_scale=Size2(1,1); +} diff --git a/scene/2d/parallax_layer.h b/scene/2d/parallax_layer.h new file mode 100644 index 0000000000..fccd8509b1 --- /dev/null +++ b/scene/2d/parallax_layer.h @@ -0,0 +1,62 @@ +/*************************************************************************/ +/* parallax_layer.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef PARALLAX_LAYER_H +#define PARALLAX_LAYER_H + +#include "scene/2d/node_2d.h" + +class ParallaxLayer : public Node2D { + + OBJ_TYPE( ParallaxLayer, Node2D ); + + Point2 orig_offset; + Point2 orig_scale; + Size2 motion_scale; + Vector2 mirroring; + void _update_mirroring(); + +protected: + + void _notification(int p_what); + static void _bind_methods(); + +public: + + void set_motion_scale(const Size2& p_scale); + Size2 get_motion_scale() const; + + void set_mirroring(const Size2& p_mirroring); + Size2 get_mirroring() const; + + void set_base_offset_and_scale(const Point2& p_offsetf,float p_scale); + + ParallaxLayer(); +}; + +#endif // PARALLAX_LAYER_H diff --git a/scene/2d/particles_2d.cpp b/scene/2d/particles_2d.cpp new file mode 100644 index 0000000000..c10f60f78b --- /dev/null +++ b/scene/2d/particles_2d.cpp @@ -0,0 +1,1045 @@ +/*************************************************************************/ +/* particles_2d.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "particles_2d.h" + + + +void ParticleAttractor2D::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_ENTER_SCENE: { + + _update_owner(); + + } break; + case NOTIFICATION_DRAW: { + + if (!get_scene()->is_editor_hint()) + return; + + Vector2 pv; + float dr = MIN(disable_radius,radius); + for(int i=0;i<=32;i++) { + Vector2 v(Math::sin(i/32.0*Math_PI*2),Math::cos(i/32.0*Math_PI*2)); + if (i>0) { + draw_line(pv*radius,v*radius,Color(0,0,0.5,0.9)); + if (dr>0) { + draw_line(pv*dr,v*dr,Color(0.5,0,0.0,0.9)); + } + } + pv=v; + } + + } break; + case NOTIFICATION_EXIT_SCENE: { + if (owner) { + _set_owner(NULL); + } + + } break; + } +} + +void ParticleAttractor2D::_owner_exited() { + + ERR_FAIL_COND(!owner); + owner->attractors.erase(this); + owner=NULL; +} + +void ParticleAttractor2D::_update_owner() { + + if (!is_inside_scene() || !has_node(path)) { + _set_owner(NULL); + return; + } + + Node *n = get_node(path); + ERR_FAIL_COND(!n); + Particles2D *pn = n->cast_to(); + if (!pn) { + _set_owner(NULL); + return; + } + + _set_owner(pn); +} + +void ParticleAttractor2D::_set_owner(Particles2D* p_owner) { + + if (owner==p_owner) + return; + + if (owner) { + owner->disconnect("exit_scene",this,"_owner_exited"); + owner->attractors.erase(this); + owner=NULL; + } + owner=p_owner; + + if (owner) { + + owner->connect("exit_scene",this,"_owner_exited",varray(),CONNECT_ONESHOT); + owner->attractors.insert(this); + } +} + +void ParticleAttractor2D::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("set_enabled","enabled"),&ParticleAttractor2D::set_enabled); + ObjectTypeDB::bind_method(_MD("is_enabled"),&ParticleAttractor2D::is_enabled); + + ObjectTypeDB::bind_method(_MD("set_radius","radius"),&ParticleAttractor2D::set_radius); + ObjectTypeDB::bind_method(_MD("get_radius"),&ParticleAttractor2D::get_radius); + + ObjectTypeDB::bind_method(_MD("set_disable_radius","radius"),&ParticleAttractor2D::set_disable_radius); + ObjectTypeDB::bind_method(_MD("get_disable_radius"),&ParticleAttractor2D::get_disable_radius); + + ObjectTypeDB::bind_method(_MD("set_gravity","gravity"),&ParticleAttractor2D::set_gravity); + ObjectTypeDB::bind_method(_MD("get_gravity"),&ParticleAttractor2D::get_gravity); + + ObjectTypeDB::bind_method(_MD("set_absorption","absorption"),&ParticleAttractor2D::set_absorption); + ObjectTypeDB::bind_method(_MD("get_absorption"),&ParticleAttractor2D::get_absorption); + + ObjectTypeDB::bind_method(_MD("set_particles_path","path"),&ParticleAttractor2D::set_particles_path); + ObjectTypeDB::bind_method(_MD("get_particles_path"),&ParticleAttractor2D::get_particles_path); + + ADD_PROPERTY(PropertyInfo(Variant::BOOL,"enabled"),_SCS("set_enabled"),_SCS("is_enabled")); + ADD_PROPERTY(PropertyInfo(Variant::REAL,"radius",PROPERTY_HINT_RANGE,"0.1,16000,0.1"),_SCS("set_radius"),_SCS("get_radius")); + ADD_PROPERTY(PropertyInfo(Variant::REAL,"disable_radius",PROPERTY_HINT_RANGE,"0.1,16000,0.1"),_SCS("set_disable_radius"),_SCS("get_disable_radius")); + ADD_PROPERTY(PropertyInfo(Variant::REAL,"gravity",PROPERTY_HINT_RANGE,"-512,512,0.01"),_SCS("set_gravity"),_SCS("get_gravity")); + ADD_PROPERTY(PropertyInfo(Variant::REAL,"absorption",PROPERTY_HINT_RANGE,"0,512,0.01"),_SCS("set_absorption"),_SCS("get_absorption")); + ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH,"particles_path",PROPERTY_HINT_RESOURCE_TYPE,"Particles2D"),_SCS("set_particles_path"),_SCS("get_particles_path")); + + + +} + + +void ParticleAttractor2D::set_enabled(bool p_enabled) { + + enabled=p_enabled; +} + +bool ParticleAttractor2D::is_enabled() const{ + + return enabled; +} + +void ParticleAttractor2D::set_radius(float p_radius) { + + radius = p_radius; + update(); +} + +float ParticleAttractor2D::get_radius() const { + + return radius; +} + +void ParticleAttractor2D::set_disable_radius(float p_disable_radius) { + + disable_radius = p_disable_radius; + update(); +} +float ParticleAttractor2D::get_disable_radius() const { + + return disable_radius; +} + +void ParticleAttractor2D::set_gravity(float p_gravity) { + + gravity=p_gravity; + +} +float ParticleAttractor2D::get_gravity() const { + + return gravity; +} + +void ParticleAttractor2D::set_absorption(float p_absorption) { + + absorption=p_absorption; + +} +float ParticleAttractor2D::get_absorption() const { + + return absorption; +} + +void ParticleAttractor2D::set_particles_path(NodePath p_path) { + + path=p_path; + _update_owner(); +} +NodePath ParticleAttractor2D::get_particles_path() const { + + return path; +} + + + +ParticleAttractor2D::ParticleAttractor2D() { + + owner=NULL; + radius=50; + disable_radius=0; + gravity=100; + absorption=0; + path=String(".."); + enabled=true; +} + +/****************************************/ + +_FORCE_INLINE_ static float _rand_from_seed(uint32_t *seed) { + + uint32_t k; + uint32_t s = (*seed); + if (s == 0) + s = 0x12345987; + k = s / 127773; + s = 16807 * (s - k * 127773) - 2836 * k; + if (s < 0) + s += 2147483647; + (*seed) = s; + + float v=((float)((*seed) & 0xFFFFF))/(float)0xFFFFF; + v=v*2.0-1.0; + return v; +} + +void Particles2D::_process_particles(float p_delta) { + + if (particles.size()==0 || lifetime==0) + return; + + p_delta*=time_scale; + + float frame_time=p_delta; + + if (emit_timeout > 0) { + time_to_live -= frame_time; + if (time_to_live < 0) { + + emitting = false; + }; + }; + + float next_time = time+frame_time; + + if (next_time > lifetime) + next_time=Math::fmod(next_time,lifetime); + + + Particle *pdata=&particles[0]; + int particle_count=particles.size(); + Matrix32 xform; + if (!local_space) + xform=get_global_transform(); + + active_count=0; + + DVector::Read r; + int emission_point_count=0; + if (emission_points.size()) { + + emission_point_count=emission_points.size(); + r=emission_points.read(); + } + + int attractor_count=0; + AttractorCache *attractor_ptr=NULL; + + if (attractors.size()) { + if (attractors.size()!=attractor_cache.size()) { + attractor_cache.resize(attractors.size()); + } + + int idx=0; + Matrix32 m; + if (local_space) { + m= get_global_transform().affine_inverse(); + } + for (Set::Element *E=attractors.front();E;E=E->next()) { + + attractor_cache[idx].pos=m.xform( E->get()->get_global_pos() ); + attractor_cache[idx].attractor=E->get(); + idx++; + } + + attractor_ptr=attractor_cache.ptr(); + attractor_count=attractor_cache.size(); + } + + for(int i=0;i time || restart_time < next_time ) + restart=true; + + } else if (restart_time > time && restart_time < next_time ) { + restart=true; + } + + if (restart) { + + + if (emitting) { + + p.pos=emissor_offset; + if (emission_point_count) { + + + Vector2 ep = r[Math::rand()%emission_point_count]; + if (!local_space) { + p.pos=xform.xform(p.pos+ep*extents); + } else { + p.pos+=ep*extents; + } + } else { + if (!local_space) { + p.pos=xform.xform(p.pos+Vector2(Math::random(-extents.x,extents.x),Math::random(-extents.y,extents.y))); + } else { + p.pos+=Vector2(Math::random(-extents.x,extents.x),Math::random(-extents.y,extents.y)); + } + } + p.seed=Math::rand() % 12345678; + uint32_t rand_seed=p.seed*(i+1); + + float angle = Math::deg2rad(param[PARAM_DIRECTION]+_rand_from_seed(&rand_seed)*param[PARAM_SPREAD]); + + p.velocity=Vector2( Math::sin(angle), Math::cos(angle) ); + if (!local_space) { + + p.velocity = xform.basis_xform(p.velocity).normalized(); + } + + p.velocity*=param[PARAM_LINEAR_VELOCITY]+param[PARAM_LINEAR_VELOCITY]*_rand_from_seed(&rand_seed)*randomness[PARAM_LINEAR_VELOCITY]; + p.velocity+=initial_velocity; + p.active=true; + p.rot=0; + active_count++; + + + } else { + + p.active=false; + } + + } else { + + if (!p.active) + continue; + + uint32_t rand_seed=p.seed*(i+1); + + Vector2 force; + + //apply gravity + float gravity_dir = Math::deg2rad( param[PARAM_GRAVITY_DIRECTION]+180*randomness[PARAM_GRAVITY_DIRECTION]*_rand_from_seed(&rand_seed)); + force+=Vector2( Math::sin(gravity_dir), Math::cos(gravity_dir) ) * (param[PARAM_GRAVITY_STRENGTH]+param[PARAM_GRAVITY_STRENGTH]*randomness[PARAM_GRAVITY_STRENGTH]*_rand_from_seed(&rand_seed)); + //apply radial + Vector2 rvec = (p.pos - emissor_offset).normalized(); + force+=rvec*(param[PARAM_RADIAL_ACCEL]+param[PARAM_RADIAL_ACCEL]*randomness[PARAM_RADIAL_ACCEL]*_rand_from_seed(&rand_seed)); + //apply orbit + float orbitvel = (param[PARAM_ORBIT_VELOCITY]+param[PARAM_ORBIT_VELOCITY]*randomness[PARAM_ORBIT_VELOCITY]*_rand_from_seed(&rand_seed)); + if (orbitvel!=0) { + Vector2 rel = p.pos - xform.elements[2]; + Matrix32 rot(orbitvel*frame_time,Vector2()); + p.pos = rot.xform(rel) + xform.elements[2]; + + } + + Vector2 tvec=rvec.tangent(); + force+=tvec*(param[PARAM_TANGENTIAL_ACCEL]+param[PARAM_TANGENTIAL_ACCEL]*randomness[PARAM_TANGENTIAL_ACCEL]*_rand_from_seed(&rand_seed)); + + for(int j=0;jenabled || vl==0 || vl > attractor_ptr[j].attractor->radius) + continue; + + + + force+=vec*attractor_ptr[j].attractor->gravity; + float fvl = p.velocity.length(); + if (fvl && attractor_ptr[j].attractor->absorption) { + Vector2 target = vec.normalized(); + p.velocity = p.velocity.normalized().linear_interpolate(target,MIN(frame_time*attractor_ptr[j].attractor->absorption,1))*fvl; + } + + if (attractor_ptr[j].attractor->disable_radius && vl < attractor_ptr[j].attractor->disable_radius) { + p.active=false; + } + } + + p.velocity+=force*frame_time; + + if (param[PARAM_DAMPING]) { + float dmp = param[PARAM_DAMPING]+param[PARAM_DAMPING]*randomness[PARAM_DAMPING]*_rand_from_seed(&rand_seed); + float v = p.velocity.length(); + v -= dmp * frame_time; + if (v<=0) { + p.velocity=Vector2(); + } else { + p.velocity=p.velocity.normalized() * v; + } + + } + + p.pos+=p.velocity*frame_time; + p.rot+=Math::lerp(param[PARAM_SPIN_VELOCITY],param[PARAM_SPIN_VELOCITY]*randomness[PARAM_SPIN_VELOCITY]*_rand_from_seed(&rand_seed),randomness[PARAM_SPIN_VELOCITY])*frame_time; + + active_count++; + + } + + + } + + + + time=Math::fmod( time+frame_time, lifetime ); + if (!emitting && active_count==0) { + set_process(false); + + } + + update(); + + +} + + +void Particles2D::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_PROCESS: { + + _process_particles( get_process_delta_time() ); + } break; + + case NOTIFICATION_ENTER_SCENE: { + + float ppt=preprocess; + while(ppt>0) { + _process_particles(0.1); + ppt-=0.1; + } + } break; + case NOTIFICATION_DRAW: { + + + if (particles.size()==0 || lifetime==0) + return; + + RID ci=get_canvas_item(); + Size2 size(1,1); + Point2 center; + + if (!texture.is_null()) { + size=texture->get_size(); + } + + + float time_pos=(time/lifetime); + + Particle *pdata=&particles[0]; + int particle_count=particles.size(); + Rect2 r(Point2(),size); + RID texrid; + + if (texture.is_valid()) + texrid = texture->get_rid(); + + Matrix32 invxform; + if (!local_space) + invxform=get_global_transform().affine_inverse(); + + int col_count=0; + float last=-1; + ColorPhase cphase[MAX_COLOR_PHASES]; + + for(int i=0;i ptime) + break; + cpos++; + } + + cpos--; + + Color color; + //could be faster.. + if (cpos==-1) + color=Color(1,1,1,1); + else { + if (cpos==col_count-1) + color=cphase[cpos].color; + else { + float diff = (cphase[cpos+1].pos-cphase[cpos].pos); + if (diff>0) + color=cphase[cpos].color.linear_interpolate(cphase[cpos+1].color, (ptime - cphase[cpos].pos) / diff ); + else + color=cphase[cpos+1].color; + } + } + + + { + float huerand=_rand_from_seed(&rand_seed); + float huerot = param[PARAM_HUE_VARIATION] + randomness[PARAM_HUE_VARIATION] * huerand; + + if (Math::abs(huerot) > CMP_EPSILON) { + + float h=color.get_h(); + float s=color.get_s(); + float v=color.get_v(); + float a=color.a; + //float preh=h; + h+=huerot; + h=Math::abs(Math::fposmod(h,1.0)); + //print_line("rand: "+rtos(randomness[PARAM_HUE_VARIATION])+" rand: "+rtos(huerand)); + //print_line(itos(i)+":hue: "+rtos(preh)+" + "+rtos(huerot)+" = "+rtos(h)); + color.set_hsv(h,s,v); + color.a=a; + } + } + + float initial_size = param[PARAM_INITIAL_SIZE]+param[PARAM_INITIAL_SIZE]*_rand_from_seed(&rand_seed)*randomness[PARAM_FINAL_SIZE]; + float final_size = param[PARAM_FINAL_SIZE]+param[PARAM_FINAL_SIZE]*_rand_from_seed(&rand_seed)*randomness[PARAM_FINAL_SIZE]; + + float size_mult=initial_size*(1.0-ptime) + final_size*ptime; + + //Size2 rectsize=size * size_mult; + //rectsize=rectsize.floor(); + + //Rect2 r = Rect2(Vecto,rectsize); + + Matrix32 xform; + + if (p.rot) { + + xform.set_rotation(p.rot); + xform.translate(-size*size_mult/2.0); + xform.elements[2]+=p.pos; + } else { + xform.elements[2]=-size*size_mult/2.0; + xform.elements[2]+=p.pos; + } + + if (!local_space) { + xform = invxform * xform; + } + + + xform.scale_basis(Size2(size_mult,size_mult)); + + + VisualServer::get_singleton()->canvas_item_add_set_transform(ci,xform); + + + if (texrid.is_valid()) { + + VisualServer::get_singleton()->canvas_item_add_texture_rect(ci,r,texrid,false,color); + } else { + VisualServer::get_singleton()->canvas_item_add_rect(ci,r,color); + + } + + } + + + } break; + + } + +} + +static const char* _particlesframe_property_names[Particles2D::PARAM_MAX]={ + "params/direction", + "params/spread", + "params/linear_velocity", + "params/spin_velocity", + "params/orbit_velocity", + "params/gravity_direction", + "params/gravity_strength", + "params/radial_accel", + "params/tangential_accel", + "params/damping", + "params/initial_size", + "params/final_size", + "params/hue_variation" +}; + +static const char* _particlesframe_property_rnames[Particles2D::PARAM_MAX]={ + "randomness/direction", + "randomness/spread", + "randomness/linear_velocity", + "randomness/spin_velocity", + "randomness/orbit_velocity", + "randomness/gravity_direction", + "randomness/gravity_strength", + "randomness/radial_accel", + "randomness/tangential_accel", + "randomness/damping", + "randomness/initial_size", + "randomness/final_size", + "randomness/hue_variation" +}; + +static const char* _particlesframe_property_ranges[Particles2D::PARAM_MAX]={ + "0,360,0.01", + "0,180,0.01", + "-1024,1024,0.01", + "-1024,1024,0.01", + "-1024,1024,0.01", + "0,360,0.01", + "0,1024,0.01", + "-128,128,0.01", + "-128,128,0.01", + "0,1024,0.001", + "0,1024,0.01", + "0,1024,0.01", + "0,1,0.01" +}; + + +void Particles2D::set_emitting(bool p_emitting) { + + if (emitting==p_emitting) + return; + + if (p_emitting) { + + if (active_count==0) + time=0; + set_process(true); + time_to_live = emit_timeout; + }; + emitting=p_emitting; +} + +bool Particles2D::is_emitting() const { + + return emitting; +} + +void Particles2D::set_amount(int p_amount) { + + ERR_FAIL_INDEX(p_amount,1024); + + particles.resize(p_amount); +} +int Particles2D::get_amount() const { + + return particles.size(); +} + +void Particles2D::set_emit_timeout(float p_timeout) { + + emit_timeout = p_timeout; + time_to_live = p_timeout; +}; + +float Particles2D::get_emit_timeout() const { + + return emit_timeout; +}; + +void Particles2D::set_lifetime(float p_lifetime) { + + ERR_FAIL_INDEX(p_lifetime,3600); + + lifetime=p_lifetime; +} +float Particles2D::get_lifetime() const { + + return lifetime; +} + +void Particles2D::set_time_scale(float p_time_scale) { + + time_scale=p_time_scale; +} +float Particles2D::get_time_scale() const { + + return time_scale; +} + +void Particles2D::set_pre_process_time(float p_pre_process_time) { + + preprocess=p_pre_process_time; +} + +float Particles2D::get_pre_process_time() const{ + + return preprocess; +} + + +void Particles2D::set_param(Parameter p_param, float p_value) { + + ERR_FAIL_INDEX(p_param,PARAM_MAX); + param[p_param]=p_value; +} +float Particles2D::get_param(Parameter p_param) const { + + ERR_FAIL_INDEX_V(p_param,PARAM_MAX,0); + return param[p_param]; +} + +void Particles2D::set_randomness(Parameter p_param, float p_value) { + + ERR_FAIL_INDEX(p_param,PARAM_MAX); + randomness[p_param]=p_value; + +} +float Particles2D::get_randomness(Parameter p_param) const { + + ERR_FAIL_INDEX_V(p_param,PARAM_MAX,0); + return randomness[p_param]; + +} + +void Particles2D::set_texture(const Ref& p_texture) { + + texture=p_texture; +} + +Ref Particles2D::get_texture() const { + + return texture; +} + +void Particles2D::set_emissor_offset(const Point2& p_offset) { + + emissor_offset=p_offset; +} + +Point2 Particles2D::get_emissor_offset() const { + + return emissor_offset; +} + + +void Particles2D::set_use_local_space(bool p_use) { + + local_space=p_use; +} + +bool Particles2D::is_using_local_space() const { + + return local_space; +} + + +void Particles2D::set_color_phases(int p_phases) { + + ERR_FAIL_INDEX(p_phases,MAX_COLOR_PHASES+1); + color_phase_count=p_phases; +} + +int Particles2D::get_color_phases() const { + + return color_phase_count; +} + +void Particles2D::set_color_phase_color(int p_phase,const Color& p_color) { + + ERR_FAIL_INDEX(p_phase,MAX_COLOR_PHASES); + color_phases[p_phase].color=p_color; + +} +Color Particles2D::get_color_phase_color(int p_phase) const { + + ERR_FAIL_INDEX_V(p_phase,MAX_COLOR_PHASES,Color()); + return color_phases[p_phase].color; +} + +void Particles2D::set_color_phase_pos(int p_phase,float p_pos) { + ERR_FAIL_INDEX(p_phase,MAX_COLOR_PHASES); + ERR_FAIL_COND(p_pos<0.0 || p_pos>1.0); + color_phases[p_phase].pos=p_pos; + +} +float Particles2D::get_color_phase_pos(int p_phase) const { + + ERR_FAIL_INDEX_V(p_phase,MAX_COLOR_PHASES,0); + return color_phases[p_phase].pos; +} + +void Particles2D::set_emission_half_extents(const Vector2& p_extents) { + + extents=p_extents; +} + +Vector2 Particles2D::get_emission_half_extents() const { + + return extents; +} + +void Particles2D::testee(int a, int b, int c, int d, int e) { + + print_line(itos(a)); + print_line(itos(b)); + print_line(itos(c)); + print_line(itos(d)); + print_line(itos(e)); +} + +void Particles2D::set_initial_velocity(const Vector2& p_velocity) { + + + initial_velocity=p_velocity; +} +Vector2 Particles2D::get_initial_velocity() const{ + + return initial_velocity; +} + + +void Particles2D::pre_process(float p_delta) { + + _process_particles(p_delta); +} + + +void Particles2D::set_explosiveness(float p_value) { + + explosiveness=p_value; +} + +float Particles2D::get_explosiveness() const{ + + return explosiveness; +} + +void Particles2D::set_emission_points(const DVector& p_points) { + + emission_points=p_points; +} + +DVector Particles2D::get_emission_points() const{ + + return emission_points; +} + +void Particles2D::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("set_emitting","active"),&Particles2D::set_emitting); + ObjectTypeDB::bind_method(_MD("is_emitting"),&Particles2D::is_emitting); + + ObjectTypeDB::bind_method(_MD("set_amount","amount"),&Particles2D::set_amount); + ObjectTypeDB::bind_method(_MD("get_amount"),&Particles2D::get_amount); + + ObjectTypeDB::bind_method(_MD("set_lifetime","lifetime"),&Particles2D::set_lifetime); + ObjectTypeDB::bind_method(_MD("get_lifetime"),&Particles2D::get_lifetime); + + ObjectTypeDB::bind_method(_MD("set_time_scale","time_scale"),&Particles2D::set_time_scale); + ObjectTypeDB::bind_method(_MD("get_time_scale"),&Particles2D::get_time_scale); + + ObjectTypeDB::bind_method(_MD("set_pre_process_time","time"),&Particles2D::set_pre_process_time); + ObjectTypeDB::bind_method(_MD("get_pre_process_time"),&Particles2D::get_pre_process_time); + + ObjectTypeDB::bind_method(_MD("set_emit_timeout","value"),&Particles2D::set_emit_timeout); + ObjectTypeDB::bind_method(_MD("get_emit_timeout"),&Particles2D::get_emit_timeout); + + ObjectTypeDB::bind_method(_MD("set_param","param","value"),&Particles2D::set_param); + ObjectTypeDB::bind_method(_MD("get_param","param"),&Particles2D::get_param); + + ObjectTypeDB::bind_method(_MD("set_randomness","param","value"),&Particles2D::set_randomness); + ObjectTypeDB::bind_method(_MD("get_randomness","param"),&Particles2D::get_randomness); + + ObjectTypeDB::bind_method(_MD("set_texture:Texture","texture"),&Particles2D::set_texture); + ObjectTypeDB::bind_method(_MD("get_texture:Texture"),&Particles2D::get_texture); + + ObjectTypeDB::bind_method(_MD("set_emissor_offset","offset"),&Particles2D::set_emissor_offset); + ObjectTypeDB::bind_method(_MD("get_emissor_offset"),&Particles2D::get_emissor_offset); + + ObjectTypeDB::bind_method(_MD("set_emission_half_extents","extents"),&Particles2D::set_emission_half_extents); + ObjectTypeDB::bind_method(_MD("get_emission_half_extents"),&Particles2D::get_emission_half_extents); + + ObjectTypeDB::bind_method(_MD("set_color_phases","phases"),&Particles2D::set_color_phases); + ObjectTypeDB::bind_method(_MD("get_color_phases"),&Particles2D::get_color_phases); + + ObjectTypeDB::bind_method(_MD("set_color_phase_color","phase","color"),&Particles2D::set_color_phase_color); + ObjectTypeDB::bind_method(_MD("get_color_phase_color","phase"),&Particles2D::get_color_phase_color); + + ObjectTypeDB::bind_method(_MD("set_color_phase_pos","phase","pos"),&Particles2D::set_color_phase_pos); + ObjectTypeDB::bind_method(_MD("get_color_phase_pos","phase"),&Particles2D::get_color_phase_pos); + + ObjectTypeDB::bind_method(_MD("pre_process","time"),&Particles2D::pre_process); + + ObjectTypeDB::bind_method(_MD("set_use_local_space","enable"),&Particles2D::set_use_local_space); + ObjectTypeDB::bind_method(_MD("is_using_local_space"),&Particles2D::is_using_local_space); + + ObjectTypeDB::bind_method(_MD("set_initial_velocity","velocity"),&Particles2D::set_initial_velocity); + ObjectTypeDB::bind_method(_MD("get_initial_velocity"),&Particles2D::get_initial_velocity); + + ObjectTypeDB::bind_method(_MD("set_explosiveness","amount"),&Particles2D::set_explosiveness); + ObjectTypeDB::bind_method(_MD("get_explosiveness"),&Particles2D::get_explosiveness); + + ObjectTypeDB::bind_method(_MD("set_emission_points","points"),&Particles2D::set_emission_points); + ObjectTypeDB::bind_method(_MD("get_emission_points"),&Particles2D::get_emission_points); + + ADD_PROPERTY(PropertyInfo(Variant::INT,"config/amount",PROPERTY_HINT_EXP_RANGE,"1,1024"),_SCS("set_amount"),_SCS("get_amount") ); + ADD_PROPERTY(PropertyInfo(Variant::REAL,"config/lifetime",PROPERTY_HINT_EXP_RANGE,"0.1,3600,0.1"),_SCS("set_lifetime"),_SCS("get_lifetime") ); + ADD_PROPERTY(PropertyInfo(Variant::REAL,"config/time_scale",PROPERTY_HINT_EXP_RANGE,"0.01,128,0.01"),_SCS("set_time_scale"),_SCS("get_time_scale") ); + ADD_PROPERTY(PropertyInfo(Variant::REAL,"config/preprocess",PROPERTY_HINT_EXP_RANGE,"0.1,3600,0.1"),_SCS("set_pre_process_time"),_SCS("get_pre_process_time") ); + ADD_PROPERTY(PropertyInfo(Variant::REAL,"config/emit_timeout",PROPERTY_HINT_RANGE,"0,3600,0.1"),_SCS("set_emit_timeout"),_SCS("get_emit_timeout") ); + ADD_PROPERTY(PropertyInfo(Variant::BOOL,"config/emitting"),_SCS("set_emitting"),_SCS("is_emitting") ); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2,"config/offset"),_SCS("set_emissor_offset"),_SCS("get_emissor_offset")); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2,"config/half_extents"),_SCS("set_emission_half_extents"),_SCS("get_emission_half_extents")); + ADD_PROPERTY(PropertyInfo(Variant::BOOL,"config/local_space"),_SCS("set_use_local_space"),_SCS("is_using_local_space")); + ADD_PROPERTY(PropertyInfo(Variant::REAL,"config/explosiveness",PROPERTY_HINT_RANGE,"0,1,0.01"),_SCS("set_explosiveness"),_SCS("get_explosiveness")); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT,"config/texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),_SCS("set_texture"),_SCS("get_texture")); + + + for(int i=0;i particles; + int color_phase_count; + struct ColorPhase { + Color color; + float pos; + } color_phases[MAX_COLOR_PHASES]; + + struct AttractorCache { + + Vector2 pos; + ParticleAttractor2D *attractor; + }; + + Vector attractor_cache; + + float explosiveness; + float preprocess; + float lifetime; + bool emitting; + bool local_space; + float emit_timeout; + float time_to_live; + float time_scale; + Point2 emissor_offset; + Vector2 initial_velocity; + Vector2 extents; + DVector emission_points; + + float time; + int active_count; + + Ref texture; + + + void testee(int a, int b, int c, int d, int e); + void _process_particles(float p_delta); +friend class ParticleAttractor2D; + + Set attractors; + +protected: + + void _notification(int p_what); + static void _bind_methods(); + +public: + + void set_emitting(bool p_emitting); + bool is_emitting() const; + + void set_amount(int p_amount); + int get_amount() const; + + void set_lifetime(float p_lifetime); + float get_lifetime() const; + + void set_time_scale(float p_time_scale); + float get_time_scale() const; + + void set_pre_process_time(float p_pre_process_time); + float get_pre_process_time() const; + + void set_emit_timeout(float p_timeout); + float get_emit_timeout() const; + + void set_emission_half_extents(const Vector2& p_extents); + Vector2 get_emission_half_extents() const; + + void set_param(Parameter p_param, float p_value); + float get_param(Parameter p_param) const; + + void set_randomness(Parameter p_randomness, float p_value); + float get_randomness(Parameter p_randomness) const; + + void set_explosiveness(float p_value); + float get_explosiveness() const; + + void set_color_phases(int p_phases); + int get_color_phases() const; + + void set_color_phase_color(int p_phase,const Color& p_color); + Color get_color_phase_color(int p_phase) const; + + void set_color_phase_pos(int p_phase,float p_pos); + float get_color_phase_pos(int p_phase) const; + + void set_texture(const Ref& p_texture); + Ref get_texture() const; + + void set_emissor_offset(const Point2& p_offset); + Point2 get_emissor_offset() const; + + void set_use_local_space(bool p_use); + bool is_using_local_space() const; + + void set_initial_velocity(const Vector2& p_velocity); + Vector2 get_initial_velocity() const; + + void set_emission_points(const DVector& p_points); + DVector get_emission_points() const; + + void pre_process(float p_delta); + + Particles2D(); +}; + +VARIANT_ENUM_CAST( Particles2D::Parameter ); + +#endif // PARTICLES_FRAME_H diff --git a/scene/2d/path_2d.cpp b/scene/2d/path_2d.cpp new file mode 100644 index 0000000000..22d56609ee --- /dev/null +++ b/scene/2d/path_2d.cpp @@ -0,0 +1,92 @@ +/*************************************************************************/ +/* path_2d.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "path_2d.h" + + +void Path2D::_notification(int p_what) { + + if (p_what==NOTIFICATION_DRAW && curve.is_valid() && is_inside_scene() && get_scene()->is_editor_hint()) { + //draw the curve!! + + for(int i=0;iget_point_count();i++) { + + Vector2 prev_p=curve->get_point_pos(i); + + for(int j=1;j<=8;j++) { + + real_t frac = j/8.0; + Vector2 p = curve->interpolate(i,frac); + draw_line(prev_p,p,Color(0.5,0.6,1.0,0.7),2); + prev_p=p; + } + } + } +} + +void Path2D::_curve_changed() { + + + if (is_inside_scene() && get_scene()->is_editor_hint()) + update(); + +} + + +void Path2D::set_curve(const Ref& p_curve) { + + if (curve.is_valid()) { + curve->disconnect("changed",this,"_curve_changed"); + } + + curve=p_curve; + + if (curve.is_valid()) { + curve->connect("changed",this,"_curve_changed"); + } + +} + +Ref Path2D::get_curve() const{ + + return curve; +} + +void Path2D::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("set_curve","curve:Curve2D"),&Path2D::set_curve); + ObjectTypeDB::bind_method(_MD("get_curve:Curve2D","curve"),&Path2D::get_curve); + ObjectTypeDB::bind_method(_MD("_curve_changed"),&Path2D::_curve_changed); + + ADD_PROPERTY( PropertyInfo( Variant::OBJECT, "curve", PROPERTY_HINT_RESOURCE_TYPE, "Curve2D"), _SCS("set_curve"),_SCS("get_curve")); +} + +Path2D::Path2D() { + + set_curve(Ref( memnew( Curve2D ))); //create one by default +} diff --git a/scene/2d/path_2d.h b/scene/2d/path_2d.h new file mode 100644 index 0000000000..f401f9da4c --- /dev/null +++ b/scene/2d/path_2d.h @@ -0,0 +1,57 @@ +/*************************************************************************/ +/* path_2d.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef PATH_2D_H +#define PATH_2D_H + +#include "scene/resources/curve.h" +#include "scene/2d/node_2d.h" + +class Path2D : public Node2D { + + OBJ_TYPE( Path2D, Node2D ); + + Ref curve; + + void _curve_changed(); + + +protected: + + void _notification(int p_what); + static void _bind_methods(); +public: + + void set_curve(const Ref& p_curve); + Ref get_curve() const; + + + Path2D(); +}; + +#endif // PATH_2D_H diff --git a/scene/2d/physics_body_2d.cpp b/scene/2d/physics_body_2d.cpp new file mode 100644 index 0000000000..945e50ff51 --- /dev/null +++ b/scene/2d/physics_body_2d.cpp @@ -0,0 +1,794 @@ +/*************************************************************************/ +/* physics_body_2d.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "physics_body_2d.h" +#include "scene/scene_string_names.h" + +void PhysicsBody2D::_notification(int p_what) { + +/* + switch(p_what) { + + case NOTIFICATION_TRANSFORM_CHANGED: { + + Physics2DServer::get_singleton()->body_set_state(get_rid(),Physics2DServer::BODY_STATE_TRANSFORM,get_global_transform()); + + } break; + } + */ +} + +PhysicsBody2D::PhysicsBody2D(Physics2DServer::BodyMode p_mode) : CollisionObject2D( Physics2DServer::get_singleton()->body_create(p_mode), false) { + + + +} + +void StaticBody2D::set_constant_linear_velocity(const Vector2& p_vel) { + + constant_linear_velocity=p_vel; + Physics2DServer::get_singleton()->body_set_state(get_rid(),Physics2DServer::BODY_STATE_LINEAR_VELOCITY,constant_linear_velocity); + +} + +void StaticBody2D::set_constant_angular_velocity(real_t p_vel) { + + constant_angular_velocity=p_vel; + Physics2DServer::get_singleton()->body_set_state(get_rid(),Physics2DServer::BODY_STATE_ANGULAR_VELOCITY,constant_angular_velocity); +} + +Vector2 StaticBody2D::get_constant_linear_velocity() const { + + return constant_linear_velocity; +} +real_t StaticBody2D::get_constant_angular_velocity() const { + + return constant_angular_velocity; +} + + +void StaticBody2D::_state_notify(Object *p_object) { + + if (!pre_xform) + return; + + Physics2DDirectBodyState *p2d = (Physics2DDirectBodyState*)p_object; + setting=true; + + Matrix32 new_xform = p2d->get_transform(); + *pre_xform=new_xform; + set_block_transform_notify(true); + set_global_transform(new_xform); + set_block_transform_notify(false); + + setting=false; + + +} + +void StaticBody2D::_update_xform() { + + if (!pre_xform || !pending) + return; + + setting=true; + + + Matrix32 new_xform = get_global_transform(); //obtain the new one + + set_block_transform_notify(true); + Physics2DServer::get_singleton()->body_set_state(get_rid(),Physics2DServer::BODY_STATE_TRANSFORM,*pre_xform); //then simulate motion! + set_global_transform(*pre_xform); //but restore state to previous one in both visual and physics + set_block_transform_notify(false); + + Physics2DServer::get_singleton()->body_static_simulate_motion(get_rid(),new_xform); //then simulate motion! + + setting=false; + pending=false; + +} + +void StaticBody2D::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_ENTER_SCENE: { + + if (pre_xform) + *pre_xform = get_global_transform(); + pending=false; + } break; + case NOTIFICATION_TRANSFORM_CHANGED: { + + if (simulating_motion && !pending && is_inside_scene() && !setting && !get_scene()->is_editor_hint()) { + + + call_deferred(SceneStringNames::get_singleton()->_update_xform); + pending=true; + } + + } break; + } + + +} + +void StaticBody2D::set_simulate_motion(bool p_enable) { + + if (p_enable==simulating_motion) + return; + simulating_motion=p_enable; + + if (p_enable) { + pre_xform = memnew( Matrix32 ); + if (is_inside_scene()) + *pre_xform=get_transform(); +// query = Physics2DServer::get_singleton()->query_create(this,"_state_notify",Variant()); + // Physics2DServer::get_singleton()->query_body_direct_state(query,get_rid()); + Physics2DServer::get_singleton()->body_set_force_integration_callback(get_rid(),this,"_state_notify"); + + } else { + memdelete( pre_xform ); + pre_xform=NULL; + Physics2DServer::get_singleton()->body_set_force_integration_callback(get_rid(),NULL,StringName()); + pending=false; + } +} + +bool StaticBody2D::is_simulating_motion() const { + + return simulating_motion; +} + + +void StaticBody2D::set_friction(real_t p_friction){ + + ERR_FAIL_COND(p_friction<0 || p_friction>1); + + friction=p_friction; + Physics2DServer::get_singleton()->body_set_param(get_rid(),Physics2DServer::BODY_PARAM_FRICTION,friction); + +} +real_t StaticBody2D::get_friction() const{ + + return friction; +} + +void StaticBody2D::set_bounce(real_t p_bounce){ + + ERR_FAIL_COND(p_bounce<0 || p_bounce>1); + + bounce=p_bounce; + Physics2DServer::get_singleton()->body_set_param(get_rid(),Physics2DServer::BODY_PARAM_BOUNCE,bounce); + +} +real_t StaticBody2D::get_bounce() const{ + + return bounce; +} + +void StaticBody2D::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("set_simulate_motion","enabled"),&StaticBody2D::set_simulate_motion); + ObjectTypeDB::bind_method(_MD("is_simulating_motion"),&StaticBody2D::is_simulating_motion); + ObjectTypeDB::bind_method(_MD("_update_xform"),&StaticBody2D::_update_xform); + ObjectTypeDB::bind_method(_MD("_state_notify"),&StaticBody2D::_state_notify); + ObjectTypeDB::bind_method(_MD("set_constant_linear_velocity","vel"),&StaticBody2D::set_constant_linear_velocity); + ObjectTypeDB::bind_method(_MD("set_constant_angular_velocity","vel"),&StaticBody2D::set_constant_angular_velocity); + ObjectTypeDB::bind_method(_MD("get_constant_linear_velocity"),&StaticBody2D::get_constant_linear_velocity); + ObjectTypeDB::bind_method(_MD("get_constant_angular_velocity"),&StaticBody2D::get_constant_angular_velocity); + ObjectTypeDB::bind_method(_MD("set_friction","friction"),&StaticBody2D::set_friction); + ObjectTypeDB::bind_method(_MD("get_friction"),&StaticBody2D::get_friction); + + ObjectTypeDB::bind_method(_MD("set_bounce","bounce"),&StaticBody2D::set_bounce); + ObjectTypeDB::bind_method(_MD("get_bounce"),&StaticBody2D::get_bounce); + + ADD_PROPERTY(PropertyInfo(Variant::BOOL,"simulate_motion"),_SCS("set_simulate_motion"),_SCS("is_simulating_motion")); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2,"constant_linear_velocity"),_SCS("set_constant_linear_velocity"),_SCS("get_constant_linear_velocity")); + ADD_PROPERTY(PropertyInfo(Variant::REAL,"constant_angular_velocity"),_SCS("set_constant_angular_velocity"),_SCS("get_constant_angular_velocity")); + ADD_PROPERTY( PropertyInfo(Variant::REAL,"friction",PROPERTY_HINT_RANGE,"0,1,0.01"),_SCS("set_friction"),_SCS("get_friction")); + ADD_PROPERTY( PropertyInfo(Variant::REAL,"bounce",PROPERTY_HINT_RANGE,"0,1,0.01"),_SCS("set_bounce"),_SCS("get_bounce")); +} + +StaticBody2D::StaticBody2D() : PhysicsBody2D(Physics2DServer::BODY_MODE_STATIC) { + + simulating_motion=false; + pre_xform=NULL; + setting=false; + pending=false; + constant_angular_velocity=0; + bounce=0; + friction=1; + + +} + +StaticBody2D::~StaticBody2D() { + + if (pre_xform) + memdelete(pre_xform); + //if (query.is_valid()) + // Physics2DServer::get_singleton()->free(query); +} + + + + +void RigidBody2D::_body_enter_scene(ObjectID p_id) { + + Object *obj = ObjectDB::get_instance(p_id); + Node *node = obj ? obj->cast_to() : NULL; + ERR_FAIL_COND(!node); + + Map::Element *E=contact_monitor->body_map.find(p_id); + ERR_FAIL_COND(!E); + ERR_FAIL_COND(E->get().in_scene); + + E->get().in_scene=true; + emit_signal(SceneStringNames::get_singleton()->body_enter,node); + + for(int i=0;iget().shapes.size();i++) { + + emit_signal(SceneStringNames::get_singleton()->body_enter_shape,p_id,node,E->get().shapes[i].body_shape,E->get().shapes[i].local_shape); + } + +} + +void RigidBody2D::_body_exit_scene(ObjectID p_id) { + + Object *obj = ObjectDB::get_instance(p_id); + Node *node = obj ? obj->cast_to() : NULL; + ERR_FAIL_COND(!node); + Map::Element *E=contact_monitor->body_map.find(p_id); + ERR_FAIL_COND(!E); + ERR_FAIL_COND(!E->get().in_scene); + E->get().in_scene=false; + emit_signal(SceneStringNames::get_singleton()->body_exit,node); + for(int i=0;iget().shapes.size();i++) { + + emit_signal(SceneStringNames::get_singleton()->body_exit_shape,p_id,node,E->get().shapes[i].body_shape,E->get().shapes[i].local_shape); + } +} + +void RigidBody2D::_body_inout(int p_status, ObjectID p_instance, int p_body_shape,int p_local_shape) { + + bool body_in = p_status==1; + ObjectID objid=p_instance; + + Object *obj = ObjectDB::get_instance(objid); + Node *node = obj ? obj->cast_to() : NULL; + + Map::Element *E=contact_monitor->body_map.find(objid); + + ERR_FAIL_COND(!body_in && !E); + + if (body_in) { + if (!E) { + + E = contact_monitor->body_map.insert(objid,BodyState()); + E->get().rc=0; + E->get().in_scene=node && node->is_inside_scene(); + if (node) { + node->connect(SceneStringNames::get_singleton()->enter_scene,this,SceneStringNames::get_singleton()->_body_enter_scene,make_binds(objid)); + node->connect(SceneStringNames::get_singleton()->exit_scene,this,SceneStringNames::get_singleton()->_body_exit_scene,make_binds(objid)); + if (E->get().in_scene) { + emit_signal(SceneStringNames::get_singleton()->body_enter,node); + } + } + + } + E->get().rc++; + if (node) + E->get().shapes.insert(ShapePair(p_body_shape,p_local_shape)); + + + if (E->get().in_scene) { + emit_signal(SceneStringNames::get_singleton()->body_enter_shape,objid,node,p_body_shape,p_local_shape); + } + + } else { + + E->get().rc--; + + if (node) + E->get().shapes.erase(ShapePair(p_body_shape,p_local_shape)); + + if (E->get().rc==0) { + + if (node) { + node->disconnect(SceneStringNames::get_singleton()->enter_scene,this,SceneStringNames::get_singleton()->_body_enter_scene); + node->disconnect(SceneStringNames::get_singleton()->exit_scene,this,SceneStringNames::get_singleton()->_body_exit_scene); + if (E->get().in_scene) + emit_signal(SceneStringNames::get_singleton()->body_exit,obj); + + } + + contact_monitor->body_map.erase(E); + } + if (node && E->get().in_scene) { + emit_signal(SceneStringNames::get_singleton()->body_exit_shape,objid,obj,p_body_shape,p_local_shape); + } + + } + +} + + +struct _RigidBody2DInOut { + + ObjectID id; + int shape; + int local_shape; +}; + +void RigidBody2D::_direct_state_changed(Object *p_state) { + + //eh.. fuck +#ifdef DEBUG_ENABLED + + state=p_state->cast_to(); +#else + state=(Physics2DDirectBodyState*)p_state; //trust it +#endif + + if (contact_monitor) { + + //untag all + int rc=0; + for( Map::Element *E=contact_monitor->body_map.front();E;E=E->next()) { + + for(int i=0;iget().shapes.size();i++) { + + E->get().shapes[i].tagged=false; + rc++; + } + } + + _RigidBody2DInOut *toadd=(_RigidBody2DInOut*)alloca(state->get_contact_count()*sizeof(_RigidBody2DInOut)); + int toadd_count=0;//state->get_contact_count(); + RigidBody2D_RemoveAction *toremove=(RigidBody2D_RemoveAction*)alloca(rc*sizeof(RigidBody2D_RemoveAction)); + int toremove_count=0; + + //put the ones to add + + for(int i=0;iget_contact_count();i++) { + + ObjectID obj = state->get_contact_collider_id(i); + int local_shape = state->get_contact_local_shape(i); + int shape = state->get_contact_collider_shape(i); + toadd[i].local_shape=local_shape; + toadd[i].id=obj; + toadd[i].shape=shape; + + bool found=false; + + Map::Element *E=contact_monitor->body_map.find(obj); + if (!E) { + toadd_count++; + continue; + } + + ShapePair sp( shape,local_shape ); + int idx = E->get().shapes.find(sp); + if (idx==-1) { + + toadd_count++; + continue; + } + + E->get().shapes[idx].tagged=true; + } + + //put the ones to remove + + for( Map::Element *E=contact_monitor->body_map.front();E;E=E->next()) { + + for(int i=0;iget().shapes.size();i++) { + + if (!E->get().shapes[i].tagged) { + + toremove[toremove_count].body_id=E->key(); + toremove[toremove_count].pair=E->get().shapes[i]; + toremove_count++; + } + } + } + + + //process remotions + + for(int i=0;iget_transform()); + linear_velocity=state->get_linear_velocity(); + angular_velocity=state->get_angular_velocity(); + active=!state->is_sleeping(); + if (get_script_instance()) + get_script_instance()->call("_integrate_forces",state); + set_block_transform_notify(false); // want it back + + state=NULL; +} + +void RigidBody2D::_notification(int p_what) { + + +} + +void RigidBody2D::set_mode(Mode p_mode) { + + mode=p_mode; + switch(p_mode) { + + case MODE_RIGID: { + + Physics2DServer::get_singleton()->body_set_mode(get_rid(),Physics2DServer::BODY_MODE_RIGID); + } break; + case MODE_STATIC: { + + Physics2DServer::get_singleton()->body_set_mode(get_rid(),Physics2DServer::BODY_MODE_STATIC); + + } break; + case MODE_STATIC_ACTIVE: { + + Physics2DServer::get_singleton()->body_set_mode(get_rid(),Physics2DServer::BODY_MODE_STATIC_ACTIVE); + + } break; + case MODE_CHARACTER: { + Physics2DServer::get_singleton()->body_set_mode(get_rid(),Physics2DServer::BODY_MODE_CHARACTER); + + } break; + + } +} + +RigidBody2D::Mode RigidBody2D::get_mode() const{ + + return mode; +} + +void RigidBody2D::set_mass(real_t p_mass){ + + ERR_FAIL_COND(p_mass<=0); + mass=p_mass; + _change_notify("mass"); + _change_notify("weight"); + Physics2DServer::get_singleton()->body_set_param(get_rid(),Physics2DServer::BODY_PARAM_MASS,mass); + +} +real_t RigidBody2D::get_mass() const{ + + return mass; +} + +void RigidBody2D::set_weight(real_t p_weight){ + + set_mass(p_weight/9.8); +} +real_t RigidBody2D::get_weight() const{ + + return mass*9.8; +} + + +void RigidBody2D::set_friction(real_t p_friction){ + + ERR_FAIL_COND(p_friction<0 || p_friction>1); + + friction=p_friction; + Physics2DServer::get_singleton()->body_set_param(get_rid(),Physics2DServer::BODY_PARAM_FRICTION,friction); + +} +real_t RigidBody2D::get_friction() const{ + + return friction; +} + +void RigidBody2D::set_bounce(real_t p_bounce){ + + ERR_FAIL_COND(p_bounce<0 || p_bounce>1); + + bounce=p_bounce; + Physics2DServer::get_singleton()->body_set_param(get_rid(),Physics2DServer::BODY_PARAM_BOUNCE,bounce); + +} +real_t RigidBody2D::get_bounce() const{ + + return bounce; +} + +void RigidBody2D::set_axis_velocity(const Vector2& p_axis) { + + Vector2 v = state? state->get_linear_velocity() : linear_velocity; + Vector2 axis = p_axis.normalized(); + v-=axis*axis.dot(v); + v+=p_axis; + if (state) { + set_linear_velocity(v); + } else { + Physics2DServer::get_singleton()->body_set_axis_velocity(get_rid(),p_axis); + linear_velocity=v; + } +} + +void RigidBody2D::set_linear_velocity(const Vector2& p_velocity){ + + linear_velocity=p_velocity; + if (state) + state->set_linear_velocity(linear_velocity); + else { + + Physics2DServer::get_singleton()->body_set_state(get_rid(),Physics2DServer::BODY_STATE_LINEAR_VELOCITY,linear_velocity); + } + +} + +Vector2 RigidBody2D::get_linear_velocity() const{ + + return linear_velocity; +} + +void RigidBody2D::set_angular_velocity(real_t p_velocity){ + + angular_velocity=p_velocity; + if (state) + state->set_angular_velocity(angular_velocity); + else + Physics2DServer::get_singleton()->body_set_state(get_rid(),Physics2DServer::BODY_STATE_ANGULAR_VELOCITY,angular_velocity); +} +real_t RigidBody2D::get_angular_velocity() const{ + + return angular_velocity; +} + +void RigidBody2D::set_use_custom_integrator(bool p_enable){ + + if (custom_integrator==p_enable) + return; + + custom_integrator=p_enable; + Physics2DServer::get_singleton()->body_set_omit_force_integration(get_rid(),p_enable); + + +} +bool RigidBody2D::is_using_custom_integrator(){ + + return custom_integrator; +} + +void RigidBody2D::set_active(bool p_active) { + + active=p_active; + Physics2DServer::get_singleton()->body_set_state(get_rid(),Physics2DServer::BODY_STATE_SLEEPING,!active); + +} + +void RigidBody2D::set_can_sleep(bool p_active) { + + can_sleep=p_active; + Physics2DServer::get_singleton()->body_set_state(get_rid(),Physics2DServer::BODY_STATE_CAN_SLEEP,p_active); +} + +bool RigidBody2D::is_able_to_sleep() const { + + return can_sleep; +} + +bool RigidBody2D::is_active() const { + + return active; +} + +void RigidBody2D::set_max_contacts_reported(int p_amount) { + + max_contacts_reported=p_amount; + Physics2DServer::get_singleton()->body_set_max_contacts_reported(get_rid(),p_amount); +} + +int RigidBody2D::get_max_contacts_reported() const{ + + return max_contacts_reported; +} + +void RigidBody2D::apply_impulse(const Vector2& p_pos, const Vector2& p_impulse) { + + Physics2DServer::get_singleton()->body_apply_impulse(get_rid(),p_pos,p_impulse); +} + +void RigidBody2D::set_applied_force(const Vector2& p_force) { + + Physics2DServer::get_singleton()->body_set_applied_force(get_rid(), p_force); +}; + +Vector2 RigidBody2D::get_applied_force() const { + + return Physics2DServer::get_singleton()->body_get_applied_force(get_rid()); +}; + +void RigidBody2D::set_use_continuous_collision_detection(bool p_enable) { + + ccd=p_enable; + Physics2DServer::get_singleton()->body_set_enable_continuous_collision_detection(get_rid(),p_enable); +} + +bool RigidBody2D::is_using_continuous_collision_detection() const { + + + return ccd; +} + + +void RigidBody2D::set_contact_monitor(bool p_enabled) { + + if (p_enabled==is_contact_monitor_enabled()) + return; + + if (!p_enabled) { + + for(Map::Element *E=contact_monitor->body_map.front();E;E=E->next()) { + + //clean up mess + } + + memdelete( contact_monitor ); + contact_monitor=NULL; + } else { + + contact_monitor = memnew( ContactMonitor ); + } + +} + +bool RigidBody2D::is_contact_monitor_enabled() const { + + return contact_monitor!=NULL; +} + + + +void RigidBody2D::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("set_mode","mode"),&RigidBody2D::set_mode); + ObjectTypeDB::bind_method(_MD("get_mode"),&RigidBody2D::get_mode); + + ObjectTypeDB::bind_method(_MD("set_mass","mass"),&RigidBody2D::set_mass); + ObjectTypeDB::bind_method(_MD("get_mass"),&RigidBody2D::get_mass); + + ObjectTypeDB::bind_method(_MD("set_weight","weight"),&RigidBody2D::set_weight); + ObjectTypeDB::bind_method(_MD("get_weight"),&RigidBody2D::get_weight); + + ObjectTypeDB::bind_method(_MD("set_friction","friction"),&RigidBody2D::set_friction); + ObjectTypeDB::bind_method(_MD("get_friction"),&RigidBody2D::get_friction); + + ObjectTypeDB::bind_method(_MD("set_bounce","bounce"),&RigidBody2D::set_bounce); + ObjectTypeDB::bind_method(_MD("get_bounce"),&RigidBody2D::get_bounce); + + ObjectTypeDB::bind_method(_MD("set_linear_velocity","linear_velocity"),&RigidBody2D::set_linear_velocity); + ObjectTypeDB::bind_method(_MD("get_linear_velocity"),&RigidBody2D::get_linear_velocity); + + ObjectTypeDB::bind_method(_MD("set_angular_velocity","angular_velocity"),&RigidBody2D::set_angular_velocity); + ObjectTypeDB::bind_method(_MD("get_angular_velocity"),&RigidBody2D::get_angular_velocity); + + ObjectTypeDB::bind_method(_MD("set_max_contacts_reported","amount"),&RigidBody2D::set_max_contacts_reported); + ObjectTypeDB::bind_method(_MD("get_max_contacts_reported"),&RigidBody2D::get_max_contacts_reported); + + ObjectTypeDB::bind_method(_MD("set_use_custom_integrator","enable"),&RigidBody2D::set_use_custom_integrator); + ObjectTypeDB::bind_method(_MD("is_using_custom_integrator"),&RigidBody2D::is_using_custom_integrator); + + ObjectTypeDB::bind_method(_MD("set_contact_monitor","enabled"),&RigidBody2D::set_contact_monitor); + ObjectTypeDB::bind_method(_MD("is_contact_monitor_enabled"),&RigidBody2D::is_contact_monitor_enabled); + + ObjectTypeDB::bind_method(_MD("set_use_continuous_collision_detection","enable"),&RigidBody2D::set_use_continuous_collision_detection); + ObjectTypeDB::bind_method(_MD("is_using_continuous_collision_detection"),&RigidBody2D::is_using_continuous_collision_detection); + + ObjectTypeDB::bind_method(_MD("set_axis_velocity","axis_velocity"),&RigidBody2D::set_axis_velocity); + ObjectTypeDB::bind_method(_MD("apply_impulse","pos","impulse"),&RigidBody2D::apply_impulse); + + ObjectTypeDB::bind_method(_MD("set_applied_force","force"),&RigidBody2D::set_applied_force); + ObjectTypeDB::bind_method(_MD("get_applied_force"),&RigidBody2D::get_applied_force); + + ObjectTypeDB::bind_method(_MD("set_active","active"),&RigidBody2D::set_active); + ObjectTypeDB::bind_method(_MD("is_active"),&RigidBody2D::is_active); + + ObjectTypeDB::bind_method(_MD("set_can_sleep","able_to_sleep"),&RigidBody2D::set_can_sleep); + ObjectTypeDB::bind_method(_MD("is_able_to_sleep"),&RigidBody2D::is_able_to_sleep); + + ObjectTypeDB::bind_method(_MD("_direct_state_changed"),&RigidBody2D::_direct_state_changed); + ObjectTypeDB::bind_method(_MD("_body_enter_scene"),&RigidBody2D::_body_enter_scene); + ObjectTypeDB::bind_method(_MD("_body_exit_scene"),&RigidBody2D::_body_exit_scene); + + BIND_VMETHOD(MethodInfo("_integrate_forces",PropertyInfo(Variant::OBJECT,"state:Physics2DDirectBodyState"))); + + ADD_PROPERTY( PropertyInfo(Variant::INT,"mode",PROPERTY_HINT_ENUM,"Rigid,Static,Character,Static Active"),_SCS("set_mode"),_SCS("get_mode")); + ADD_PROPERTY( PropertyInfo(Variant::REAL,"mass",PROPERTY_HINT_EXP_RANGE,"0.01,65535,0.01"),_SCS("set_mass"),_SCS("get_mass")); + ADD_PROPERTY( PropertyInfo(Variant::REAL,"weight",PROPERTY_HINT_EXP_RANGE,"0.01,65535,0.01",PROPERTY_USAGE_EDITOR),_SCS("set_weight"),_SCS("get_weight")); + ADD_PROPERTY( PropertyInfo(Variant::REAL,"friction",PROPERTY_HINT_RANGE,"0,1,0.01"),_SCS("set_friction"),_SCS("get_friction")); + ADD_PROPERTY( PropertyInfo(Variant::REAL,"bounce",PROPERTY_HINT_RANGE,"0,1,0.01"),_SCS("set_bounce"),_SCS("get_bounce")); + ADD_PROPERTY( PropertyInfo(Variant::BOOL,"custom_integrator"),_SCS("set_use_custom_integrator"),_SCS("is_using_custom_integrator")); + ADD_PROPERTY( PropertyInfo(Variant::BOOL,"continuous_cd"),_SCS("set_use_continuous_collision_detection"),_SCS("is_using_continuous_collision_detection")); + ADD_PROPERTY( PropertyInfo(Variant::INT,"contacts_reported"),_SCS("set_max_contacts_reported"),_SCS("get_max_contacts_reported")); + ADD_PROPERTY( PropertyInfo(Variant::BOOL,"contact_monitor"),_SCS("set_contact_monitor"),_SCS("is_contact_monitor_enabled")); + ADD_PROPERTY( PropertyInfo(Variant::BOOL,"active"),_SCS("set_active"),_SCS("is_active")); + ADD_PROPERTY( PropertyInfo(Variant::BOOL,"can_sleep"),_SCS("set_can_sleep"),_SCS("is_able_to_sleep")); + ADD_PROPERTY( PropertyInfo(Variant::VECTOR2,"velocity/linear"),_SCS("set_linear_velocity"),_SCS("get_linear_velocity")); + ADD_PROPERTY( PropertyInfo(Variant::REAL,"velocity/angular"),_SCS("set_angular_velocity"),_SCS("get_angular_velocity")); + + ADD_SIGNAL( MethodInfo("body_enter_shape",PropertyInfo(Variant::INT,"body_id"),PropertyInfo(Variant::OBJECT,"body"),PropertyInfo(Variant::INT,"body_shape"),PropertyInfo(Variant::INT,"local_shape"))); + ADD_SIGNAL( MethodInfo("body_exit_shape",PropertyInfo(Variant::INT,"body_id"),PropertyInfo(Variant::OBJECT,"body"),PropertyInfo(Variant::INT,"body_shape"),PropertyInfo(Variant::INT,"local_shape"))); + ADD_SIGNAL( MethodInfo("body_enter",PropertyInfo(Variant::OBJECT,"body"))); + ADD_SIGNAL( MethodInfo("body_exit",PropertyInfo(Variant::OBJECT,"body"))); + + BIND_CONSTANT( MODE_STATIC ); + BIND_CONSTANT( MODE_STATIC_ACTIVE ); + BIND_CONSTANT( MODE_RIGID ); + BIND_CONSTANT( MODE_CHARACTER ); +} + +RigidBody2D::RigidBody2D() : PhysicsBody2D(Physics2DServer::BODY_MODE_RIGID) { + + mode=MODE_RIGID; + + bounce=0; + mass=1; + friction=1; + max_contacts_reported=0; + state=NULL; + + angular_velocity=0; + active=true; + ccd=false; + + custom_integrator=false; + contact_monitor=NULL; + can_sleep=true; + + Physics2DServer::get_singleton()->body_set_force_integration_callback(get_rid(),this,"_direct_state_changed"); +} + +RigidBody2D::~RigidBody2D() { + + if (contact_monitor) + memdelete( contact_monitor ); + + + +} + diff --git a/scene/2d/physics_body_2d.h b/scene/2d/physics_body_2d.h new file mode 100644 index 0000000000..9eff59d8a7 --- /dev/null +++ b/scene/2d/physics_body_2d.h @@ -0,0 +1,232 @@ +/*************************************************************************/ +/* physics_body_2d.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef PHYSICS_BODY_2D_H +#define PHYSICS_BODY_2D_H + +#include "scene/2d/collision_object_2d.h" +#include "servers/physics_2d_server.h" +#include "vset.h" + + +class PhysicsBody2D : public CollisionObject2D { + + OBJ_TYPE(PhysicsBody2D,CollisionObject2D); + +protected: + + void _notification(int p_what); + PhysicsBody2D(Physics2DServer::BodyMode p_mode); +public: + + PhysicsBody2D(); + +}; + +class StaticBody2D : public PhysicsBody2D { + + OBJ_TYPE(StaticBody2D,PhysicsBody2D); + + Matrix32 *pre_xform; + //RID query; + bool setting; + bool pending; + bool simulating_motion; + Vector2 constant_linear_velocity; + real_t constant_angular_velocity; + void _update_xform(); + void _state_notify(Object *p_object); + + real_t bounce; + real_t friction; + + +protected: + + void _notification(int p_what); + static void _bind_methods(); + +public: + + void set_friction(real_t p_friction); + real_t get_friction() const; + + void set_bounce(real_t p_bounce); + real_t get_bounce() const; + + void set_simulate_motion(bool p_enable); + bool is_simulating_motion() const; + + void set_constant_linear_velocity(const Vector2& p_vel); + void set_constant_angular_velocity(real_t p_vel); + + Vector2 get_constant_linear_velocity() const; + real_t get_constant_angular_velocity() const; + + StaticBody2D(); + ~StaticBody2D(); + +}; + +class RigidBody2D : public PhysicsBody2D { + + OBJ_TYPE(RigidBody2D,PhysicsBody2D); +public: + + enum Mode { + MODE_RIGID, + MODE_STATIC, + MODE_CHARACTER, + MODE_STATIC_ACTIVE, + }; +private: + + bool can_sleep; + Physics2DDirectBodyState *state; + Mode mode; + + real_t bounce; + real_t mass; + real_t friction; + + Vector2 linear_velocity; + real_t angular_velocity; + bool active; + bool ccd; + + + int max_contacts_reported; + + bool custom_integrator; + + + struct ShapePair { + + int body_shape; + int local_shape; + bool tagged; + bool operator<(const ShapePair& p_sp) const { + if (body_shape==p_sp.body_shape) + return local_shape < p_sp.local_shape; + else + return body_shape < p_sp.body_shape; + } + + ShapePair() {} + ShapePair(int p_bs, int p_ls) { body_shape=p_bs; local_shape=p_ls; } + }; + struct RigidBody2D_RemoveAction { + + + ObjectID body_id; + ShapePair pair; + + }; + struct BodyState { + + int rc; + bool in_scene; + VSet shapes; + }; + + struct ContactMonitor { + + + Map body_map; + + }; + + + ContactMonitor *contact_monitor; + void _body_enter_scene(ObjectID p_id); + void _body_exit_scene(ObjectID p_id); + + + void _body_inout(int p_status, ObjectID p_instance, int p_body_shape,int p_local_shape); + void _direct_state_changed(Object *p_state); + + +protected: + + void _notification(int p_what); + static void _bind_methods(); +public: + + void set_mode(Mode p_mode); + Mode get_mode() const; + + void set_mass(real_t p_mass); + real_t get_mass() const; + + void set_weight(real_t p_weight); + real_t get_weight() const; + + void set_friction(real_t p_friction); + real_t get_friction() const; + + void set_bounce(real_t p_bounce); + real_t get_bounce() const; + + void set_linear_velocity(const Vector2& p_velocity); + Vector2 get_linear_velocity() const; + + void set_axis_velocity(const Vector2& p_axis); + + void set_angular_velocity(real_t p_velocity); + real_t get_angular_velocity() const; + + void set_use_custom_integrator(bool p_enable); + bool is_using_custom_integrator(); + + void set_active(bool p_active); + bool is_active() const; + + void set_can_sleep(bool p_active); + bool is_able_to_sleep() const; + + void set_contact_monitor(bool p_enabled); + bool is_contact_monitor_enabled() const; + + void set_max_contacts_reported(int p_amount); + int get_max_contacts_reported() const; + + void set_use_continuous_collision_detection(bool p_enable); + bool is_using_continuous_collision_detection() const; + + void apply_impulse(const Vector2& p_pos, const Vector2& p_impulse); + + void set_applied_force(const Vector2& p_force); + Vector2 get_applied_force() const; + + RigidBody2D(); + ~RigidBody2D(); + +}; + +VARIANT_ENUM_CAST(RigidBody2D::Mode); +#endif // PHYSICS_BODY_2D_H diff --git a/scene/2d/position_2d.cpp b/scene/2d/position_2d.cpp new file mode 100644 index 0000000000..ca3be9aa8f --- /dev/null +++ b/scene/2d/position_2d.cpp @@ -0,0 +1,65 @@ +/*************************************************************************/ +/* position_2d.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "position_2d.h" +#include "scene/resources/texture.h" + +void Position2D::_draw_cross() { + + draw_line(Point2(-10,0),Point2(+10,0),Color(1,0.5,0.5)); + draw_line(Point2(0,-10),Point2(0,+10),Color(0.5,1,0.5)); + +} + +Rect2 Position2D::get_item_rect() const { + + return Rect2(Point2(-10,-10),Size2(20,20)); +} + +void Position2D::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_ENTER_SCENE: { + + update(); + } break; + case NOTIFICATION_DRAW: { + if (!is_inside_scene()) + break; + if (get_scene()->is_editor_hint()) + _draw_cross(); + + } break; + } + +} + +Position2D::Position2D() +{ +} diff --git a/scene/2d/position_2d.h b/scene/2d/position_2d.h new file mode 100644 index 0000000000..caabf98eae --- /dev/null +++ b/scene/2d/position_2d.h @@ -0,0 +1,49 @@ +/*************************************************************************/ +/* position_2d.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef POSITION_2D_H +#define POSITION_2D_H + + +#include "scene/2d/node_2d.h" + +class Position2D : public Node2D { + + OBJ_TYPE(Position2D,Node2D) + + void _draw_cross(); +protected: + + void _notification(int p_what); +public: + + virtual Rect2 get_item_rect() const; + Position2D(); +}; + +#endif // POSITION_2D_H diff --git a/scene/2d/ray_cast_2d.cpp b/scene/2d/ray_cast_2d.cpp new file mode 100644 index 0000000000..a2c57b8ffb --- /dev/null +++ b/scene/2d/ray_cast_2d.cpp @@ -0,0 +1,198 @@ +/*************************************************************************/ +/* ray_cast_2d.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "ray_cast_2d.h" +#include "servers/physics_2d_server.h" + +void RayCast2D::set_cast_to(const Vector2& p_point) { + + cast_to=p_point; + if (is_inside_scene() && get_scene()->is_editor_hint()) + update(); + +} + +Vector2 RayCast2D::get_cast_to() const{ + + return cast_to; +} + +bool RayCast2D::is_colliding() const{ + + return collided; +} +Object *RayCast2D::get_collider() const{ + + if (against==0) + return NULL; + + return ObjectDB::get_instance(against); +} + +int RayCast2D::get_collider_shape() const { + + return against_shape; +} +Vector2 RayCast2D::get_collision_point() const{ + + return collision_point; +} +Vector2 RayCast2D::get_collision_normal() const{ + + return collision_normal; +} + + +void RayCast2D::set_enabled(bool p_enabled) { + + enabled=p_enabled; + if (is_inside_scene() && !get_scene()->is_editor_hint()) + set_fixed_process(p_enabled); + if (!p_enabled) + collided=false; + +} + + +bool RayCast2D::is_enabled() const { + + + return enabled; +} + + +void RayCast2D::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_ENTER_SCENE: { + + if (enabled && !get_scene()->is_editor_hint()) + set_fixed_process(true); + else + set_fixed_process(false); + + } break; + case NOTIFICATION_EXIT_SCENE: { + + if (enabled) + set_fixed_process(false); + + } break; +#ifdef TOOLS_ENABLED + case NOTIFICATION_DRAW: { + + if (!get_scene()->is_editor_hint()) + break; + Matrix32 xf; + xf.rotate(cast_to.atan2()); + xf.translate(Vector2(0,cast_to.length())); + + //Vector2 tip = Vector2(0,s->get_length()); + Color dcol(0.9,0.2,0.2,0.4); + draw_line(Vector2(),cast_to,dcol,3); + Vector pts; + float tsize=4; + pts.push_back(xf.xform(Vector2(0,tsize))); + pts.push_back(xf.xform(Vector2(0.707*tsize,0))); + pts.push_back(xf.xform(Vector2(-0.707*tsize,0))); + Vector cols; + for(int i=0;i<3;i++) + cols.push_back(dcol); + + draw_primitive(pts,cols,Vector()); //small arrow + + } break; +#endif + + case NOTIFICATION_FIXED_PROCESS: { + + if (!enabled) + break; + + + + Ref w2d = get_world_2d(); + ERR_BREAK( w2d.is_null() ); + + Physics2DDirectSpaceState *dss = Physics2DServer::get_singleton()->space_get_direct_state(w2d->get_space()); + ERR_BREAK( !dss ); + + Matrix32 gt = get_global_transform(); + + Vector2 to = cast_to; + if (to==Vector2()) + to=Vector2(0,0.01); + + Physics2DDirectSpaceState::RayResult rr; + + if (dss->intersect_ray(gt.get_origin(),gt.xform(to),rr)) { + + collided=true; + against=rr.collider_id; + collision_point=rr.position; + collision_normal=rr.normal; + against_shape=rr.shape; + } else { + collided=false; + } + + + + } break; + } +} + +void RayCast2D::_bind_methods() { + + + ObjectTypeDB::bind_method(_MD("set_enabled","enabled"),&RayCast2D::set_enabled); + ObjectTypeDB::bind_method(_MD("is_enabled"),&RayCast2D::is_enabled); + + ObjectTypeDB::bind_method(_MD("set_cast_to","local_point"),&RayCast2D::set_cast_to); + ObjectTypeDB::bind_method(_MD("get_cast_to"),&RayCast2D::get_cast_to); + + ObjectTypeDB::bind_method(_MD("is_colliding"),&RayCast2D::is_colliding); + + ObjectTypeDB::bind_method(_MD("get_collider"),&RayCast2D::get_collider); + ObjectTypeDB::bind_method(_MD("get_collider_shape"),&RayCast2D::get_collider_shape); + ObjectTypeDB::bind_method(_MD("get_collision_point"),&RayCast2D::get_collision_point); + ObjectTypeDB::bind_method(_MD("get_collision_normal"),&RayCast2D::get_collision_normal); + + ADD_PROPERTY(PropertyInfo(Variant::BOOL,"enabled"),_SCS("set_enabled"),_SCS("is_enabled")); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2,"cast_to"),_SCS("set_cast_to"),_SCS("get_cast_to")); +} + +RayCast2D::RayCast2D() { + + enabled=false; + against=0; + collided=false; + against_shape=0; + cast_to=Vector2(0,50); +} diff --git a/scene/2d/ray_cast_2d.h b/scene/2d/ray_cast_2d.h new file mode 100644 index 0000000000..62bcb946a6 --- /dev/null +++ b/scene/2d/ray_cast_2d.h @@ -0,0 +1,68 @@ +/*************************************************************************/ +/* ray_cast_2d.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef RAY_CAST_2D_H +#define RAY_CAST_2D_H + +#include "scene/2d/node_2d.h" + +class RayCast2D : public Node2D { + + OBJ_TYPE(RayCast2D,Node2D); + + + bool enabled; + bool collided; + ObjectID against; + int against_shape; + Vector2 collision_point; + Vector2 collision_normal; + + Vector2 cast_to; +protected: + + void _notification(int p_what); + static void _bind_methods(); +public: + + void set_enabled(bool p_enabled); + bool is_enabled() const; + + void set_cast_to(const Vector2& p_point); + Vector2 get_cast_to() const; + + bool is_colliding() const; + Object *get_collider() const; + int get_collider_shape() const; + Vector2 get_collision_point() const; + Vector2 get_collision_normal() const; + + RayCast2D(); +}; + +#endif // RAY_CAST_2D_H diff --git a/scene/2d/remote_transform_2d.cpp b/scene/2d/remote_transform_2d.cpp new file mode 100644 index 0000000000..80d038f6f8 --- /dev/null +++ b/scene/2d/remote_transform_2d.cpp @@ -0,0 +1,122 @@ +/*************************************************************************/ +/* remote_transform_2d.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "remote_transform_2d.h" +#include "scene/scene_string_names.h" + +void RemoteTransform2D::_update_cache() { + + cache=0; + if (has_node(remote_node)) { + Node *node = get_node(remote_node); + if (!node || this==node || node->is_a_parent_of(this) || this->is_a_parent_of(node)) { + return; + } + + cache=node->get_instance_ID(); + } +} + +void RemoteTransform2D::_update_remote() { + + + if (!is_inside_scene()) + return; + + if (!cache) + return; + + Object *obj = ObjectDB::get_instance(cache); + if (!obj) + return; + + Node2D *n = obj->cast_to(); + if (!n) + return; + + if (!n->is_inside_scene()) + return; + + //todo make faster + n->set_global_transform(get_global_transform()); + +} + +void RemoteTransform2D::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_READY: { + + _update_cache(); + + } break; + case NOTIFICATION_TRANSFORM_CHANGED: { + if (!is_inside_scene()) + break; + + if (cache) { + + _update_remote(); + + } + + } break; + + } +} + + +void RemoteTransform2D::set_remote_node(const NodePath& p_remote_node) { + + remote_node=p_remote_node; + if (is_inside_scene()) + _update_cache(); +} + +NodePath RemoteTransform2D::get_remote_node() const{ + + return remote_node; +} + + +void RemoteTransform2D::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("set_remote_node","path"),&RemoteTransform2D::set_remote_node); + ObjectTypeDB::bind_method(_MD("get_remote_node"),&RemoteTransform2D::get_remote_node); + + ADD_PROPERTY( PropertyInfo(Variant::NODE_PATH,"remote_path"),_SCS("set_remote_node"),_SCS("get_remote_node")); +} + +RemoteTransform2D::RemoteTransform2D() { + + cache=0; + +} + + diff --git a/scene/2d/remote_transform_2d.h b/scene/2d/remote_transform_2d.h new file mode 100644 index 0000000000..9561e72255 --- /dev/null +++ b/scene/2d/remote_transform_2d.h @@ -0,0 +1,52 @@ +/*************************************************************************/ +/* remote_transform_2d.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "scene/2d/node_2d.h" + +class RemoteTransform2D : public Node2D { + + OBJ_TYPE(RemoteTransform2D,Node2D); + + NodePath remote_node; + + ObjectID cache; + + void _update_remote(); + void _update_cache(); + void _node_exited_scene(); +protected: + + static void _bind_methods(); + void _notification(int p_what); +public: + + void set_remote_node(const NodePath& p_remote_node); + NodePath get_remote_node() const; + + RemoteTransform2D(); +}; diff --git a/scene/2d/sample_player_2d.cpp b/scene/2d/sample_player_2d.cpp new file mode 100644 index 0000000000..bc1734ec06 --- /dev/null +++ b/scene/2d/sample_player_2d.cpp @@ -0,0 +1,252 @@ +/*************************************************************************/ +/* sample_player_2d.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "sample_player_2d.h" + +#include "servers/audio_server.h" +#include "servers/audio_server.h" +#include "servers/spatial_sound_server.h" + + +bool SamplePlayer2D::_set(const StringName& p_name, const Variant& p_value) { + + String name=p_name; + + if (name=="play/play") { + if (library.is_valid()) { + + String what=p_value; + if (what=="") + stop_all(); + else + play(what); + + played_back=what; + } + } else + return false; + + return true; +} + +bool SamplePlayer2D::_get(const StringName& p_name,Variant &r_ret) const { + + + String name=p_name; + + if (name=="play/play") { + r_ret=played_back; + } else + return false; + + return true; +} + +void SamplePlayer2D::_get_property_list(List *p_list) const { + + String en=""; + if (library.is_valid()) { + List samples; + Ref ncl=library; + ncl->get_sample_list(&samples); + for (List::Element *E=samples.front();E;E=E->next()) { + + en+=","; + en+=E->get(); + } + } + + p_list->push_back( PropertyInfo( Variant::STRING, "play/play", PROPERTY_HINT_ENUM, en,PROPERTY_USAGE_EDITOR)); +} + +void SamplePlayer2D::_notification(int p_what) { + + + switch(p_what) { + + case NOTIFICATION_ENTER_SCENE: { + + SpatialSound2DServer::get_singleton()->source_set_polyphony(get_source_rid(),polyphony); + + + } break; + } + +} + +void SamplePlayer2D::set_sample_library(const Ref& p_library) { + + library=p_library; +} + +Ref SamplePlayer2D::get_sample_library() const { + + return library; +} + +void SamplePlayer2D::set_polyphony(int p_voice_count) { + + ERR_FAIL_COND(p_voice_count<0 || p_voice_count>64); + polyphony=p_voice_count; + if (get_source_rid().is_valid()) + SpatialSound2DServer::get_singleton()->source_set_polyphony(get_source_rid(),polyphony); + +} + +int SamplePlayer2D::get_polyphony() const { + + return polyphony; +} + +SamplePlayer2D::VoiceID SamplePlayer2D::play(const String& p_sample,int p_voice) { + + if (!get_source_rid().is_valid()) + return INVALID_VOICE; + if (library.is_null()) + return INVALID_VOICE; + if (!library->has_sample(p_sample)) + return INVALID_VOICE; + Ref sample = library->get_sample(p_sample); + float vol_change = library->sample_get_volume_db(p_sample); + float pitch_change = library->sample_get_pitch_scale(p_sample); + + VoiceID vid = SpatialSound2DServer::get_singleton()->source_play_sample(get_source_rid(),sample->get_rid(),sample->get_mix_rate()*pitch_change,p_voice); + if (vol_change) + SpatialSound2DServer::get_singleton()->source_voice_set_volume_scale_db(get_source_rid(),vid,vol_change); + + + if (random_pitch_scale) { + float ps = Math::random(-random_pitch_scale,random_pitch_scale); + if (ps>0) + ps=1.0+ps; + else + ps=1.0/(1.0-ps); + SpatialSound2DServer::get_singleton()->source_voice_set_pitch_scale(get_source_rid(),vid,ps*pitch_change); + + } + + return vid; +} +//voices +void SamplePlayer2D::voice_set_pitch_scale(VoiceID p_voice, float p_pitch_scale) { + + if (!get_source_rid().is_valid()) + return; + + SpatialSound2DServer::get_singleton()->source_voice_set_pitch_scale(get_source_rid(),p_voice,p_pitch_scale); + +} + +void SamplePlayer2D::voice_set_volume_scale_db(VoiceID p_voice, float p_volume_db) { + + if (!get_source_rid().is_valid()) + return; + SpatialSound2DServer::get_singleton()->source_voice_set_volume_scale_db(get_source_rid(),p_voice,p_volume_db); + +} + +bool SamplePlayer2D::is_voice_active(VoiceID p_voice) const { + + if (!get_source_rid().is_valid()) + return false; + return SpatialSound2DServer::get_singleton()->source_is_voice_active(get_source_rid(),p_voice); + +} + +void SamplePlayer2D::stop_voice(VoiceID p_voice) { + + if (!get_source_rid().is_valid()) + return; + SpatialSound2DServer::get_singleton()->source_stop_voice(get_source_rid(),p_voice); + +} + +void SamplePlayer2D::stop_all() { + + if (!get_source_rid().is_valid()) + return; + + for(int i=0;isource_stop_voice(get_source_rid(),i); + } +} + +void SamplePlayer2D::set_random_pitch_scale(float p_scale) { + random_pitch_scale=p_scale; +} + +float SamplePlayer2D::get_random_pitch_scale() const { + + return random_pitch_scale; +} + + +void SamplePlayer2D::_bind_methods() { + + + ObjectTypeDB::bind_method(_MD("set_sample_library","library:SampleLibrary"),&SamplePlayer2D::set_sample_library); + ObjectTypeDB::bind_method(_MD("get_sample_library:SampleLibrary"),&SamplePlayer2D::get_sample_library); + + ObjectTypeDB::bind_method(_MD("set_polyphony","voices"),&SamplePlayer2D::set_polyphony); + ObjectTypeDB::bind_method(_MD("get_polyphony"),&SamplePlayer2D::get_polyphony); + + ObjectTypeDB::bind_method(_MD("play","sample","voice"),&SamplePlayer2D::play,DEFVAL(NEXT_VOICE)); + //voices,DEV + ObjectTypeDB::bind_method(_MD("voice_set_pitch_scale","voice","ratio"),&SamplePlayer2D::voice_set_pitch_scale); + ObjectTypeDB::bind_method(_MD("voice_set_volume_scale_db","voice","db"),&SamplePlayer2D::voice_set_volume_scale_db); + + ObjectTypeDB::bind_method(_MD("is_voice_active","voice"),&SamplePlayer2D::is_voice_active); + ObjectTypeDB::bind_method(_MD("stop_voice","voice"),&SamplePlayer2D::stop_voice); + ObjectTypeDB::bind_method(_MD("stop_all"),&SamplePlayer2D::stop_all); + + ObjectTypeDB::bind_method(_MD("set_random_pitch_scale","val"),&SamplePlayer2D::set_random_pitch_scale); + ObjectTypeDB::bind_method(_MD("get_random_pitch_scale"),&SamplePlayer2D::get_random_pitch_scale); + + BIND_CONSTANT( INVALID_VOICE ); + BIND_CONSTANT( NEXT_VOICE ); + + ADD_PROPERTY( PropertyInfo( Variant::INT, "config/polyphony", PROPERTY_HINT_RANGE, "1,64,1"),_SCS("set_polyphony"),_SCS("get_polyphony")); + ADD_PROPERTY( PropertyInfo( Variant::OBJECT, "config/samples", PROPERTY_HINT_RESOURCE_TYPE,"SampleLibrary"),_SCS("set_sample_library"),_SCS("get_sample_library")); + ADD_PROPERTY( PropertyInfo( Variant::REAL, "config/pitch_random", PROPERTY_HINT_RESOURCE_TYPE,"SampleLibrary"),_SCS("set_random_pitch_scale"),_SCS("get_random_pitch_scale")); + + +} + + +SamplePlayer2D::SamplePlayer2D() { + + polyphony=1; + random_pitch_scale=0; + +} + +SamplePlayer2D::~SamplePlayer2D() { + + +} diff --git a/scene/2d/sample_player_2d.h b/scene/2d/sample_player_2d.h new file mode 100644 index 0000000000..d04abae244 --- /dev/null +++ b/scene/2d/sample_player_2d.h @@ -0,0 +1,92 @@ +/*************************************************************************/ +/* sample_player_2d.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef SAMPLE_PLAYER_2D_H +#define SAMPLE_PLAYER_2D_H + +#include "scene/2d/sound_player_2d.h" +#include "scene/resources/sample_library.h" + +class SamplePlayer2D : public SoundPlayer2D { + + OBJ_TYPE(SamplePlayer2D,SoundPlayer2D); +public: + + enum { + + INVALID_VOICE=SpatialSoundServer::SOURCE_INVALID_VOICE, + NEXT_VOICE=SpatialSoundServer::SOURCE_NEXT_VOICE + }; + + typedef int VoiceID; + + +private: + + Ref library; + int polyphony; + String played_back; + float random_pitch_scale; + +protected: + + bool _set(const StringName& p_name, const Variant& p_value); + bool _get(const StringName& p_name,Variant &r_ret) const; + void _get_property_list(List *p_list) const; + + void _notification(int p_what); + + static void _bind_methods(); + +public: + + void set_sample_library(const Ref& p_library); + Ref get_sample_library() const; + + void set_polyphony(int p_voice_count); + int get_polyphony() const; + + VoiceID play(const String& p_sample,int p_voice=NEXT_VOICE); + //voices + void voice_set_pitch_scale(VoiceID p_voice, float p_pitch_scale); + void voice_set_volume_scale_db(VoiceID p_voice, float p_volume_db); + + bool is_voice_active(VoiceID p_voice) const; + void stop_voice(VoiceID p_voice); + void stop_all(); + + void set_random_pitch_scale(float p_scale); + float get_random_pitch_scale() const; + + SamplePlayer2D(); + ~SamplePlayer2D(); + + +}; + +#endif // SAMPLE_PLAYER_2D_H diff --git a/scene/2d/screen_button.cpp b/scene/2d/screen_button.cpp new file mode 100644 index 0000000000..f386dc63e8 --- /dev/null +++ b/scene/2d/screen_button.cpp @@ -0,0 +1,372 @@ +/*************************************************************************/ +/* screen_button.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "screen_button.h" +#include "os/os.h" +#include "input_map.h" +#include "os/input.h" + +void TouchScreenButton::set_texture(const Ref& p_texture) { + + texture=p_texture; + update(); +} + +Ref TouchScreenButton::get_texture() const{ + + return texture; +} + +void TouchScreenButton::set_texture_pressed(const Ref& p_texture_pressed) { + + texture_pressed=p_texture_pressed; + update(); +} + +Ref TouchScreenButton::get_texture_pressed() const{ + + return texture_pressed; +} + +void TouchScreenButton::set_bitmask(const Ref& p_bitmask){ + + bitmask=p_bitmask; +} + +Ref TouchScreenButton::get_bitmask() const{ + + return bitmask; +} + +void TouchScreenButton::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_DRAW: { + + if (!is_inside_scene()) + return; + if (!get_scene()->is_editor_hint() && !OS::get_singleton()->has_touchscreen_ui_hint() && visibility==VISIBILITY_TOUCHSCREEN_ONLY) + return; + + if (finger_pressed!=-1) { + + if (texture_pressed.is_valid()) + draw_texture(texture_pressed,Point2()); + else if (texture.is_valid()) + draw_texture(texture,Point2()); + + } else { + if (texture.is_valid()) + draw_texture(texture,Point2()); + } + + } break; + case NOTIFICATION_ENTER_SCENE: { + + if (!get_scene()->is_editor_hint() && !OS::get_singleton()->has_touchscreen_ui_hint() && visibility==VISIBILITY_TOUCHSCREEN_ONLY) + return; + update(); + set_process_input(true); + if (action.operator String()!="" && InputMap::get_singleton()->has_action(action)) { + action_id=InputMap::get_singleton()->get_action_id(action); + } else { + action_id=-1; + } + } break; + } +} + + +bool TouchScreenButton::is_pressed() const{ + + return finger_pressed!=-1; +} + +void TouchScreenButton::set_action(const String& p_action) { + + action=p_action; + if (action.operator String()!="" && InputMap::get_singleton()->has_action(action)) { + action_id=InputMap::get_singleton()->get_action_id(action); + } else { + action_id=-1; + } + +} + +String TouchScreenButton::get_action() const { + + return action; +} + +void TouchScreenButton::_input(const InputEvent& p_event) { + + if (!get_scene()) + return; + + if (passby_press) { + + if (p_event.type==InputEvent::SCREEN_TOUCH && !p_event.screen_touch.pressed && finger_pressed==p_event.screen_touch.index) { + + emit_signal("released"); + + if (action_id!=-1) { + + Input::get_singleton()->action_release(action); + InputEvent ie; + ie.type=InputEvent::ACTION; + ie.ID=0; + ie.action.action=action_id; + ie.action.pressed=false; + get_scene()->input_event(ie); + } + finger_pressed=-1; + + update(); + + } + + if ((p_event.type==InputEvent::SCREEN_TOUCH && p_event.screen_touch.pressed)|| p_event.type==InputEvent::SCREEN_DRAG) { + + if (finger_pressed==-1 || p_event.screen_touch.index==finger_pressed) { + + Point2 coord = (get_viewport_transform() * get_global_transform()).affine_inverse().xform(Point2(p_event.screen_touch.x,p_event.screen_touch.y)); + + bool touched=false; + if (bitmask.is_valid()) { + + if (Rect2(Point2(),bitmask->get_size()).has_point(coord)) { + + if (bitmask->get_bit(coord)) + touched=true; + } + } else { + + touched=Rect2(Point2(),texture->get_size()).has_point(coord); + } + + + + if (touched) { + + if (finger_pressed==-1) { + finger_pressed=p_event.screen_touch.index; + //emit change stuff + emit_signal("pressed"); + if (action_id!=-1) { + + Input::get_singleton()->action_press(action); + InputEvent ie; + ie.type=InputEvent::ACTION; + ie.ID=0; + ie.action.action=action_id; + ie.action.pressed=true; + get_scene()->input_event(ie); + } + + update(); + } + + } else { + + if (finger_pressed!=-1) { + + emit_signal("released"); + + if (action_id!=-1) { + + Input::get_singleton()->action_release(action); + InputEvent ie; + ie.type=InputEvent::ACTION; + ie.ID=0; + ie.action.action=action_id; + ie.action.pressed=false; + get_scene()->input_event(ie); + } + finger_pressed=-1; + + update(); + } + } + + } + + + } + + } else { + + if (p_event.type==InputEvent::SCREEN_TOUCH) { + + if (p_event.screen_touch.pressed) { + + if (!is_visible()) + return; + + if (finger_pressed!=-1) + return; //already fingering + + Point2 coord = (get_viewport_transform() * get_global_transform()).affine_inverse().xform(Point2(p_event.screen_touch.x,p_event.screen_touch.y)); + + bool touched=false; + if (bitmask.is_valid()) { + + if (Rect2(Point2(),bitmask->get_size()).has_point(coord)) { + + if (bitmask->get_bit(coord)) + touched=true; + } + } else { + + touched=Rect2(Point2(),texture->get_size()).has_point(coord); + } + + + + if (touched) { + + finger_pressed=p_event.screen_touch.index; + //emit change stuff + emit_signal("pressed"); + if (action_id!=-1) { + + Input::get_singleton()->action_press(action); + InputEvent ie; + ie.type=InputEvent::ACTION; + ie.ID=0; + ie.action.action=action_id; + ie.action.pressed=true; + get_scene()->input_event(ie); + } + update(); + + } + } else { + + + if (p_event.screen_touch.index==finger_pressed) { + //untouch + + emit_signal("released"); + + if (action_id!=-1) { + + Input::get_singleton()->action_release(action); + InputEvent ie; + ie.type=InputEvent::ACTION; + ie.ID=0; + ie.action.action=action_id; + ie.action.pressed=false; + get_scene()->input_event(ie); + } + finger_pressed=-1; + update(); + } + } + } + } +} + +Rect2 TouchScreenButton::get_item_rect() const { + + if (texture.is_null()) + return Rect2(0,0,1,1); + //if (texture.is_null()) + // return CanvasItem::get_item_rect(); + + return Rect2(Size2(),texture->get_size()); +} + + +void TouchScreenButton::set_visibility_mode(VisibilityMode p_mode) { + visibility=p_mode; + update(); +} + +TouchScreenButton::VisibilityMode TouchScreenButton::get_visibility_mode() const { + + return visibility; +} + +void TouchScreenButton::set_passby_press(bool p_enable) { + + passby_press=p_enable; +} + +bool TouchScreenButton::is_passby_press_enabled() const{ + + return passby_press; +} + + + +void TouchScreenButton::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("set_texture","texture"),&TouchScreenButton::set_texture); + ObjectTypeDB::bind_method(_MD("get_texture"),&TouchScreenButton::get_texture); + + ObjectTypeDB::bind_method(_MD("set_texture_pressed","texture_pressed"),&TouchScreenButton::set_texture_pressed); + ObjectTypeDB::bind_method(_MD("get_texture_pressed"),&TouchScreenButton::get_texture_pressed); + + ObjectTypeDB::bind_method(_MD("set_bitmask","bitmask"),&TouchScreenButton::set_bitmask); + ObjectTypeDB::bind_method(_MD("get_bitmask"),&TouchScreenButton::get_bitmask); + + ObjectTypeDB::bind_method(_MD("set_action","action"),&TouchScreenButton::set_action); + ObjectTypeDB::bind_method(_MD("get_action"),&TouchScreenButton::get_action); + + ObjectTypeDB::bind_method(_MD("set_visibility_mode","mode"),&TouchScreenButton::set_visibility_mode); + ObjectTypeDB::bind_method(_MD("get_visibility_mode"),&TouchScreenButton::get_visibility_mode); + + ObjectTypeDB::bind_method(_MD("set_passby_press","enabled"),&TouchScreenButton::set_passby_press); + ObjectTypeDB::bind_method(_MD("is_passby_press_enabled"),&TouchScreenButton::is_passby_press_enabled); + + ObjectTypeDB::bind_method(_MD("is_pressed"),&TouchScreenButton::is_pressed); + + ObjectTypeDB::bind_method(_MD("_input"),&TouchScreenButton::_input); + + ADD_PROPERTY( PropertyInfo(Variant::OBJECT,"normal",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),_SCS("set_texture"),_SCS("get_texture")); + ADD_PROPERTY( PropertyInfo(Variant::OBJECT,"pressed",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),_SCS("set_texture_pressed"),_SCS("get_texture_pressed")); + ADD_PROPERTY( PropertyInfo(Variant::OBJECT,"bitmask",PROPERTY_HINT_RESOURCE_TYPE,"BitMap"),_SCS("set_bitmask"),_SCS("get_bitmask")); + ADD_PROPERTY( PropertyInfo(Variant::BOOL,"passby_press"),_SCS("set_passby_press"),_SCS("is_passby_press_enabled")); + ADD_PROPERTY( PropertyInfo(Variant::STRING,"action"),_SCS("set_action"),_SCS("get_action")); + ADD_PROPERTY( PropertyInfo(Variant::INT,"visibility_mode",PROPERTY_HINT_ENUM,"Always,TouchScreen Only"),_SCS("set_visibility_mode"),_SCS("get_visibility_mode")); + + ADD_SIGNAL( MethodInfo("pressed" ) ); + ADD_SIGNAL( MethodInfo("release" ) ); + + + +} + +TouchScreenButton::TouchScreenButton() { + + finger_pressed=-1; + action_id=-1; + passby_press=false; + visibility=VISIBILITY_ALWAYS; +} diff --git a/scene/2d/screen_button.h b/scene/2d/screen_button.h new file mode 100644 index 0000000000..7305fd29fe --- /dev/null +++ b/scene/2d/screen_button.h @@ -0,0 +1,95 @@ +/*************************************************************************/ +/* screen_button.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef SCREEN_BUTTON_H +#define SCREEN_BUTTON_H + +#include "scene/2d/node_2d.h" +#include "scene/resources/texture.h" +#include "scene/resources/bit_mask.h" + +class TouchScreenButton : public Node2D { + + OBJ_TYPE(TouchScreenButton,Node2D); +public: + + enum VisibilityMode { + VISIBILITY_ALWAYS, + VISIBILITY_TOUCHSCREEN_ONLY + }; + +private: + Ref texture; + Ref texture_pressed; + Ref bitmask; + + StringName action; + bool passby_press; + int finger_pressed; + int action_id; + + VisibilityMode visibility; + + void _input(const InputEvent& p_Event); + +protected: + + void _notification(int p_what); + static void _bind_methods(); +public: + + + void set_texture(const Ref& p_texture); + Ref get_texture() const; + + void set_texture_pressed(const Ref& p_texture_pressed); + Ref get_texture_pressed() const; + + void set_bitmask(const Ref& p_bitmask); + Ref get_bitmask() const; + + void set_action(const String& p_action); + String get_action() const; + + void set_passby_press(bool p_enable); + bool is_passby_press_enabled() const; + + void set_visibility_mode(VisibilityMode p_mode); + VisibilityMode get_visibility_mode() const; + + bool is_pressed() const; + + Rect2 get_item_rect() const; + + + TouchScreenButton(); +}; + +VARIANT_ENUM_CAST(TouchScreenButton::VisibilityMode); + +#endif // SCREEN_BUTTON_H diff --git a/scene/2d/sound_player_2d.cpp b/scene/2d/sound_player_2d.cpp new file mode 100644 index 0000000000..2fffef4e51 --- /dev/null +++ b/scene/2d/sound_player_2d.cpp @@ -0,0 +1,123 @@ +/*************************************************************************/ +/* sound_player_2d.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "sound_player_2d.h" + +#include "servers/audio_server.h" + +#include "servers/spatial_sound_2d_server.h" +#include "scene/resources/surface_tool.h" + + +void SoundPlayer2D::_notification(int p_what) { + + + switch(p_what) { + + case NOTIFICATION_ENTER_SCENE: { + //find the sound space + + source_rid = SpatialSound2DServer::get_singleton()->source_create(get_world_2d()->get_sound_space()); + + for(int i=0;isource_set_transform(source_rid,get_global_transform()); + + + } break; + case NOTIFICATION_TRANSFORM_CHANGED: { + + SpatialSound2DServer::get_singleton()->source_set_transform(source_rid,get_global_transform()); + + } break; + case NOTIFICATION_EXIT_SCENE: { + + if (source_rid.is_valid()) + SpatialSound2DServer::get_singleton()->free(source_rid); + + } break; + } + +} + + +void SoundPlayer2D::set_param( Param p_param, float p_value) { + + ERR_FAIL_INDEX(p_param,PARAM_MAX); + params[p_param]=p_value; + if (source_rid.is_valid()) + SpatialSound2DServer::get_singleton()->source_set_param(source_rid,(SpatialSound2DServer::SourceParam)p_param,p_value); + +} + +float SoundPlayer2D::get_param( Param p_param) const { + + ERR_FAIL_INDEX_V(p_param,PARAM_MAX,0); + return params[p_param]; + +} + + +void SoundPlayer2D::_bind_methods() { + + + ObjectTypeDB::bind_method(_MD("set_param","param","value"),&SoundPlayer2D::set_param); + ObjectTypeDB::bind_method(_MD("get_param","param"),&SoundPlayer2D::get_param); + + BIND_CONSTANT( PARAM_VOLUME_DB ); + BIND_CONSTANT( PARAM_PITCH_SCALE ); + BIND_CONSTANT( PARAM_ATTENUATION_MIN_DISTANCE ); + BIND_CONSTANT( PARAM_ATTENUATION_MAX_DISTANCE ); + BIND_CONSTANT( PARAM_ATTENUATION_DISTANCE_EXP ); + BIND_CONSTANT( PARAM_MAX ); + + ADD_PROPERTYI( PropertyInfo( Variant::REAL, "params/volume_db",PROPERTY_HINT_RANGE, "-80,24,0.01"),_SCS("set_param"),_SCS("get_param"),PARAM_VOLUME_DB); + ADD_PROPERTYI( PropertyInfo( Variant::REAL, "params/pitch_scale",PROPERTY_HINT_RANGE, "0.001,32,0.001"),_SCS("set_param"),_SCS("get_param"),PARAM_PITCH_SCALE); + ADD_PROPERTYI( PropertyInfo( Variant::REAL, "params/attenuation/min_distance",PROPERTY_HINT_EXP_RANGE, "16,16384,1"),_SCS("set_param"),_SCS("get_param"),PARAM_ATTENUATION_MIN_DISTANCE); + ADD_PROPERTYI( PropertyInfo( Variant::REAL, "params/attenuation/max_distance",PROPERTY_HINT_EXP_RANGE, "16,16384,1"),_SCS("set_param"),_SCS("get_param"),PARAM_ATTENUATION_MAX_DISTANCE); + ADD_PROPERTYI( PropertyInfo( Variant::REAL, "params/attenuation/distance_exp",PROPERTY_HINT_EXP_EASING, "attenuation"),_SCS("set_param"),_SCS("get_param"),PARAM_ATTENUATION_DISTANCE_EXP); + +} + + +SoundPlayer2D::SoundPlayer2D() { + + params[PARAM_VOLUME_DB]=0.0; + params[PARAM_PITCH_SCALE]=1.0; + params[PARAM_ATTENUATION_MIN_DISTANCE]=1; + params[PARAM_ATTENUATION_MAX_DISTANCE]=2048; + params[PARAM_ATTENUATION_DISTANCE_EXP]=1.0; //linear (and not really good) + + +} + +SoundPlayer2D::~SoundPlayer2D() { + + +} diff --git a/scene/2d/sound_player_2d.h b/scene/2d/sound_player_2d.h new file mode 100644 index 0000000000..9578c6b323 --- /dev/null +++ b/scene/2d/sound_player_2d.h @@ -0,0 +1,82 @@ +/*************************************************************************/ +/* sound_player_2d.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef SOUND_PLAYER_2D_H +#define SOUND_PLAYER_2D_H + + +#include "scene/2d/node_2d.h" +#include "scene/resources/sample_library.h" +#include "servers/spatial_sound_2d_server.h" +#include "scene/main/viewport.h" + +class SoundPlayer2D : public Node2D { + + OBJ_TYPE(SoundPlayer2D,Node2D); +public: + + + enum Param { + + PARAM_VOLUME_DB=SpatialSound2DServer::SOURCE_PARAM_VOLUME_DB, + PARAM_PITCH_SCALE=SpatialSound2DServer::SOURCE_PARAM_PITCH_SCALE, + PARAM_ATTENUATION_MIN_DISTANCE=SpatialSound2DServer::SOURCE_PARAM_ATTENUATION_MIN_DISTANCE, + PARAM_ATTENUATION_MAX_DISTANCE=SpatialSound2DServer::SOURCE_PARAM_ATTENUATION_MAX_DISTANCE, + PARAM_ATTENUATION_DISTANCE_EXP=SpatialSound2DServer::SOURCE_PARAM_ATTENUATION_DISTANCE_EXP, + PARAM_MAX=SpatialSound2DServer::SOURCE_PARAM_MAX + }; + +private: + + float params[PARAM_MAX]; + RID source_rid; + + +protected: + + _FORCE_INLINE_ RID get_source_rid() const { return source_rid; } + + void _notification(int p_what); + + static void _bind_methods(); + +public: + + void set_param( Param p_param, float p_value); + float get_param( Param p_param) const; + + + SoundPlayer2D(); + ~SoundPlayer2D(); + + +}; + +VARIANT_ENUM_CAST(SoundPlayer2D::Param ); + +#endif // SOUND_PLAYER_2D_H diff --git a/scene/2d/sprite.cpp b/scene/2d/sprite.cpp new file mode 100644 index 0000000000..0265ec4df2 --- /dev/null +++ b/scene/2d/sprite.cpp @@ -0,0 +1,337 @@ +/*************************************************************************/ +/* sprite.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "sprite.h" +#include "core/core_string_names.h" +#include "scene/scene_string_names.h" +void Sprite::edit_set_pivot(const Point2& p_pivot) { + + set_offset(p_pivot); +} + +Point2 Sprite::edit_get_pivot() const { + + return get_offset(); +} +bool Sprite::edit_has_pivot() const { + + return true; +} + +void Sprite::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_DRAW: { + + if (texture.is_null()) + return; + + + + + RID ci = get_canvas_item(); + + /* + texture->draw(ci,Point2()); + break; + */ + + Size2i s; + Rect2i src_rect; + + if (region) { + + s=region_rect.size; + src_rect=region_rect; + } else { + s = texture->get_size(); + s=s/Size2i(hframes,vframes); + + src_rect.size=s; + src_rect.pos.x+=(frame%hframes)*s.x; + src_rect.pos.y+=(frame/hframes)*s.y; + + } + + Point2i ofs=offset; + if (centered) + ofs-=s/2; + + Rect2i dst_rect(ofs,s); + + if (hflip) + dst_rect.size.x=-dst_rect.size.x; + if (vflip) + dst_rect.size.y=-dst_rect.size.y; + + texture->draw_rect_region(ci,dst_rect,src_rect,modulate); + + } break; + } +} + +void Sprite::set_texture(const Ref& p_texture) { + + if (p_texture==texture) + return; + if (texture.is_valid()) { + texture->disconnect(CoreStringNames::get_singleton()->changed,this,SceneStringNames::get_singleton()->update); + } + texture=p_texture; + if (texture.is_valid()) { + texture->set_flags(texture->get_flags()&(~Texture::FLAG_REPEAT)); //remove repeat from texture, it looks bad in sprites + texture->connect(CoreStringNames::get_singleton()->changed,this,SceneStringNames::get_singleton()->update); + } + update(); + item_rect_changed(); +} + +Ref Sprite::get_texture() const { + + return texture; +} + +void Sprite::set_centered(bool p_center) { + + centered=p_center; + update(); + item_rect_changed(); +} + +bool Sprite::is_centered() const { + + return centered; +} + +void Sprite::set_offset(const Point2& p_offset) { + + offset=p_offset; + update(); + item_rect_changed(); +} +Point2 Sprite::get_offset() const { + + return offset; +} + +void Sprite::set_flip_h(bool p_flip) { + + hflip=p_flip; + update(); +} +bool Sprite::is_flipped_h() const { + + return hflip; +} + +void Sprite::set_flip_v(bool p_flip) { + + vflip=p_flip; + update(); +} +bool Sprite::is_flipped_v() const { + + return vflip; +} + +void Sprite::set_region(bool p_region) { + + if (p_region==region) + return; + + region=p_region; + update(); +} + +bool Sprite::is_region() const{ + + return region; +} + +void Sprite::set_region_rect(const Rect2& p_region_rect) { + + bool changed=region_rect!=p_region_rect; + region_rect=p_region_rect; + if (region && changed) { + update(); + item_rect_changed(); + } +} + +Rect2 Sprite::get_region_rect() const { + + return region_rect; +} + +void Sprite::set_frame(int p_frame) { + + ERR_FAIL_INDEX(p_frame,vframes*hframes); + + if (frame != p_frame) + item_rect_changed(); + + frame=p_frame; +} + +int Sprite::get_frame() const { + + return frame; +} + +void Sprite::set_vframes(int p_amount) { + + ERR_FAIL_COND(p_amount<1); + vframes=p_amount; + update(); + item_rect_changed(); + _change_notify("frame"); +} +int Sprite::get_vframes() const { + + return vframes; +} + +void Sprite::set_hframes(int p_amount) { + + ERR_FAIL_COND(p_amount<1); + hframes=p_amount; + update(); + item_rect_changed(); + _change_notify("frame"); +} +int Sprite::get_hframes() const { + + return hframes; +} + +void Sprite::set_modulate(const Color& p_color) { + + modulate=p_color; + update(); +} + +Color Sprite::get_modulate() const{ + + return modulate; +} + + +Rect2 Sprite::get_item_rect() const { + + if (texture.is_null()) + return Rect2(0,0,1,1); + //if (texture.is_null()) + // return CanvasItem::get_item_rect(); + + Size2i s; + + if (region) { + + s=region_rect.size; + } else { + s = texture->get_size(); + s=s/Point2(hframes,vframes); + } + + Point2i ofs=offset; + if (centered) + ofs-=s/2; + + if (s==Size2(0,0)) + s=Size2(1,1); + + return Rect2(ofs,s); +} + + +void Sprite::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("set_texture","texture:Texture"),&Sprite::set_texture); + ObjectTypeDB::bind_method(_MD("get_texture:Texture"),&Sprite::get_texture); + + ObjectTypeDB::bind_method(_MD("set_centered","centered"),&Sprite::set_centered); + ObjectTypeDB::bind_method(_MD("is_centered"),&Sprite::is_centered); + + ObjectTypeDB::bind_method(_MD("set_offset","offset"),&Sprite::set_offset); + ObjectTypeDB::bind_method(_MD("get_offset"),&Sprite::get_offset); + + ObjectTypeDB::bind_method(_MD("set_flip_h","flip_h"),&Sprite::set_flip_h); + ObjectTypeDB::bind_method(_MD("is_flipped_h"),&Sprite::is_flipped_h); + + ObjectTypeDB::bind_method(_MD("set_flip_v","flip_v"),&Sprite::set_flip_v); + ObjectTypeDB::bind_method(_MD("is_flipped_v"),&Sprite::is_flipped_v); + + ObjectTypeDB::bind_method(_MD("set_region","enabled"),&Sprite::set_region); + ObjectTypeDB::bind_method(_MD("is_region"),&Sprite::is_region); + + ObjectTypeDB::bind_method(_MD("set_region_rect","rect"),&Sprite::set_region_rect); + ObjectTypeDB::bind_method(_MD("get_region_rect"),&Sprite::get_region_rect); + + ObjectTypeDB::bind_method(_MD("set_frame","frame"),&Sprite::set_frame); + ObjectTypeDB::bind_method(_MD("get_frame"),&Sprite::get_frame); + + ObjectTypeDB::bind_method(_MD("set_vframes","vframes"),&Sprite::set_vframes); + ObjectTypeDB::bind_method(_MD("get_vframes"),&Sprite::get_vframes); + + ObjectTypeDB::bind_method(_MD("set_hframes","hframes"),&Sprite::set_hframes); + ObjectTypeDB::bind_method(_MD("get_hframes"),&Sprite::get_hframes); + + ObjectTypeDB::bind_method(_MD("set_modulate","modulate"),&Sprite::set_modulate); + ObjectTypeDB::bind_method(_MD("get_modulate"),&Sprite::get_modulate); + + ADD_PROPERTY( PropertyInfo( Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE,"Texture"), _SCS("set_texture"),_SCS("get_texture")); + ADD_PROPERTY( PropertyInfo( Variant::BOOL, "centered"), _SCS("set_centered"),_SCS("is_centered")); + ADD_PROPERTY( PropertyInfo( Variant::VECTOR2, "offset"), _SCS("set_offset"),_SCS("get_offset")); + ADD_PROPERTY( PropertyInfo( Variant::BOOL, "flip_h"), _SCS("set_flip_h"),_SCS("is_flipped_h")); + ADD_PROPERTY( PropertyInfo( Variant::BOOL, "flip_v"), _SCS("set_flip_v"),_SCS("is_flipped_v")); + ADD_PROPERTY( PropertyInfo( Variant::INT, "vframes"), _SCS("set_vframes"),_SCS("get_vframes")); + ADD_PROPERTY( PropertyInfo( Variant::INT, "hframes"), _SCS("set_hframes"),_SCS("get_hframes")); + ADD_PROPERTY( PropertyInfo( Variant::INT, "frame"), _SCS("set_frame"),_SCS("get_frame")); + ADD_PROPERTY( PropertyInfo( Variant::COLOR, "modulate"), _SCS("set_modulate"),_SCS("get_modulate")); + ADD_PROPERTY( PropertyInfo( Variant::BOOL, "region"), _SCS("set_region"),_SCS("is_region")); + ADD_PROPERTY( PropertyInfo( Variant::RECT2, "region_rect"), _SCS("set_region_rect"),_SCS("get_region_rect")); + +} + +Sprite::Sprite() { + + centered=true; + hflip=false; + vflip=false; + region=false; + + frame=0; + + vframes=1; + hframes=1; + + modulate=Color(1,1,1,1); + + +} diff --git a/scene/2d/sprite.h b/scene/2d/sprite.h new file mode 100644 index 0000000000..42f737fa91 --- /dev/null +++ b/scene/2d/sprite.h @@ -0,0 +1,108 @@ +/*************************************************************************/ +/* sprite.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef SPRITE_H +#define SPRITE_H + +#include "scene/2d/node_2d.h" +#include "scene/resources/texture.h" + + +class Sprite : public Node2D { + + OBJ_TYPE( Sprite, Node2D ); + + Ref texture; + + bool centered; + Point2 offset; + + bool hflip; + bool vflip; + bool region; + Rect2 region_rect; + + int frame; + + int vframes; + int hframes; + + Color modulate; + + +protected: + + void _notification(int p_what); + + static void _bind_methods();; + +public: + + virtual void edit_set_pivot(const Point2& p_pivot); + virtual Point2 edit_get_pivot() const; + virtual bool edit_has_pivot() const; + + void set_texture(const Ref& p_texture); + Ref get_texture() const; + + void set_centered(bool p_center); + bool is_centered() const; + + void set_offset(const Point2& p_offset); + Point2 get_offset() const; + + void set_flip_h(bool p_flip); + bool is_flipped_h() const; + + void set_flip_v(bool p_flip); + bool is_flipped_v() const; + + void set_region(bool p_region); + bool is_region() const; + + void set_region_rect(const Rect2& p_region_rect); + Rect2 get_region_rect() const; + + void set_frame(int p_frame); + int get_frame() const; + + void set_vframes(int p_amount); + int get_vframes() const; + + void set_hframes(int p_amount); + int get_hframes() const; + + void set_modulate(const Color& p_color); + Color get_modulate() const; + + virtual Rect2 get_item_rect() const; + + Sprite(); +}; + +#endif // SPRITE_H diff --git a/scene/2d/tile_map.cpp b/scene/2d/tile_map.cpp new file mode 100644 index 0000000000..26efa99a88 --- /dev/null +++ b/scene/2d/tile_map.cpp @@ -0,0 +1,592 @@ +/*************************************************************************/ +/* tile_map.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "tile_map.h" +#include "io/marshalls.h" +#include "servers/physics_2d_server.h" +void TileMap::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_ENTER_SCENE: { + + pending_update=true; + _update_dirty_quadrants(); + RID space = get_world_2d()->get_space(); + _update_quadrant_transform(); + _update_quadrant_space(space); + + + } break; + case NOTIFICATION_EXIT_SCENE: { + + _update_quadrant_space(RID()); + + } break; + case NOTIFICATION_TRANSFORM_CHANGED: { + + //move stuff + _update_quadrant_transform(); + + } break; + } +} + +void TileMap::_update_quadrant_space(const RID& p_space) { + + for (Map::Element *E=quadrant_map.front();E;E=E->next()) { + + Quadrant &q=E->get(); + Physics2DServer::get_singleton()->body_set_space(q.static_body,p_space); + } +} + +void TileMap::_update_quadrant_transform() { + + if (!is_inside_scene()) + return; + + Matrix32 global_transform = get_global_transform(); + + for (Map::Element *E=quadrant_map.front();E;E=E->next()) { + + Quadrant &q=E->get(); + Matrix32 xform; + xform.set_origin( q.pos ); + xform = global_transform * xform; + Physics2DServer::get_singleton()->body_set_state(q.static_body,Physics2DServer::BODY_STATE_TRANSFORM,xform); + } +} + +void TileMap::set_tileset(const Ref& p_tileset) { + + if (tile_set.is_valid()) + tile_set->disconnect("changed",this,"_recreate_quadrants"); + + _clear_quadrants(); + tile_set=p_tileset; + + if (tile_set.is_valid()) + tile_set->connect("changed",this,"_recreate_quadrants"); + else + clear(); + + _recreate_quadrants(); + +} + +Ref TileMap::get_tileset() const { + + return tile_set; +} + +void TileMap::set_cell_size(int p_size) { + + ERR_FAIL_COND(p_size<1); + + _clear_quadrants(); + cell_size=p_size; + _recreate_quadrants(); + + +} +int TileMap::get_cell_size() const { + + return cell_size; +} +void TileMap::set_quadrant_size(int p_size) { + + ERR_FAIL_COND(p_size<1); + + _clear_quadrants(); + quadrant_size=p_size; + _recreate_quadrants(); + +} +int TileMap::get_quadrant_size() const { + + return quadrant_size; +} + +void TileMap::set_center_x(bool p_enable) { + + center_x=p_enable; + _recreate_quadrants(); + +} +bool TileMap::get_center_x() const { + + return center_x; +} +void TileMap::set_center_y(bool p_enable) { + + center_y=p_enable; + _recreate_quadrants(); + +} +bool TileMap::get_center_y() const { + + return center_y; +} + +void TileMap::_update_dirty_quadrants() { + + if (!pending_update) + return; + if (!is_inside_scene()) + return; + if (!tile_set.is_valid()) + return; + + VisualServer *vs = VisualServer::get_singleton(); + Physics2DServer *ps = Physics2DServer::get_singleton(); + + while (dirty_quadrant_list.first()) { + + Quadrant &q = *dirty_quadrant_list.first()->self(); + + vs->canvas_item_clear(q.canvas_item); + ps->body_clear_shapes(q.static_body); + + for(int i=0;i::Element *E=tile_map.find( q.cells[i] ); + Cell &c=E->get(); + //moment of truth + if (!tile_set->has_tile(c.id)) + continue; + Ref tex = tile_set->tile_get_texture(c.id); + Vector2 tile_ofs = tile_set->tile_get_offset(c.id); + + Vector2 offset = Point2( E->key().x, E->key().y )*cell_size - q.pos; + + if (!tex.is_valid()) + continue; + + + Rect2 r = tile_set->tile_get_region(c.id); + Size2 s = tex->get_size(); + + if (r==Rect2()) + s = tex->get_size(); + else { + s = r.size; + r.pos.x+=fp_adjust; + r.pos.y+=fp_adjust; + r.size.x-=fp_adjust*2.0; + r.size.y-=fp_adjust*2.0; + } + + Rect2 rect; + rect.pos=offset.floor(); + rect.size=s; + + rect.size.x+=fp_adjust; + rect.size.y+=fp_adjust; + + if (c.flip_h) + rect.size.x=-rect.size.x; + if (c.flip_v) + rect.size.y=-rect.size.y; + + + if (r==Rect2()) { + + tex->draw_rect(q.canvas_item,rect); + } else { + + tex->draw_rect_region(q.canvas_item,rect,r); + } + + Vector< Ref > shapes = tile_set->tile_get_shapes(c.id); + + + for(int i=0;i shape = shapes[i]; + if (shape.is_valid()) { + + Matrix32 xform; + xform.set_origin(offset.floor()); + if (c.flip_h) { + xform.elements[0]=-xform.elements[0]; + xform.elements[2].x+=s.x; + } + if (c.flip_v) { + xform.elements[1]=-xform.elements[1]; + xform.elements[2].y+=s.y; + } + + ps->body_add_shape(q.static_body,shape->get_rid(),xform); + } + } + } + + dirty_quadrant_list.remove( dirty_quadrant_list.first() ); + } + + + + pending_update=false; + + _recompute_rect_cache(); + +} + +void TileMap::_recompute_rect_cache() { + + +#ifdef DEBUG_ENABLED + + if (!rect_cache_dirty) + return; + + Rect2 r_total; + for (Map::Element *E=quadrant_map.front();E;E=E->next()) { + + + Rect2 r( Point2(E->key().x, E->key().y)*cell_size*quadrant_size, Size2(1,1)*cell_size*quadrant_size ); + if (E==quadrant_map.front()) + r_total=r; + else + r_total=r_total.merge(r); + + } + if (r_total==Rect2()) { + rect_cache=Rect2(-10,-10,20,20); + } else { + rect_cache=r_total; + } + + item_rect_changed(); + + rect_cache_dirty=false; +#endif + + +} + +Map::Element *TileMap::_create_quadrant(const PosKey& p_qk) { + + Matrix32 xform; + xform.set_origin(Point2(p_qk.x,p_qk.y)*quadrant_size*cell_size); + Quadrant q; + q.canvas_item = VisualServer::get_singleton()->canvas_item_create(); + VisualServer::get_singleton()->canvas_item_set_parent( q.canvas_item, get_canvas_item() ); + VisualServer::get_singleton()->canvas_item_set_transform( q.canvas_item, xform ); + q.static_body=Physics2DServer::get_singleton()->body_create(Physics2DServer::BODY_MODE_STATIC); + if (is_inside_scene()) { + xform = get_global_transform() * xform; + RID space = get_world_2d()->get_space(); + Physics2DServer::get_singleton()->body_set_space(q.static_body,space); + } + + Physics2DServer::get_singleton()->body_set_state(q.static_body,Physics2DServer::BODY_STATE_TRANSFORM,xform); + q.pos=Vector2(p_qk.x,p_qk.y)*quadrant_size*cell_size; + + rect_cache_dirty=true; + return quadrant_map.insert(p_qk,q); +} + +void TileMap::_erase_quadrant(Map::Element *Q) { + + Quadrant &q=Q->get(); + Physics2DServer::get_singleton()->free(q.static_body); + VisualServer::get_singleton()->free(q.canvas_item); + if (q.dirty_list.in_list()) + dirty_quadrant_list.remove(&q.dirty_list); + + quadrant_map.erase(Q); + rect_cache_dirty=true; +} + +void TileMap::_make_quadrant_dirty(Map::Element *Q) { + + Quadrant &q=Q->get(); + if (!q.dirty_list.in_list()) + dirty_quadrant_list.add(&q.dirty_list); + + if (pending_update) + return; + pending_update=true; + if (!is_inside_scene()) + return; + call_deferred("_update_dirty_quadrants"); +} + + +void TileMap::set_cell(int p_x,int p_y,int p_tile,bool p_flip_x,bool p_flip_y) { + + PosKey pk(p_x,p_y); + + Map::Element *E=tile_map.find(pk); + if (!E && p_tile==INVALID_CELL) + return; //nothing to do + + PosKey qk(p_x/quadrant_size,p_y/quadrant_size); + if (p_tile==INVALID_CELL) { + //erase existing + tile_map.erase(pk); + Map::Element *Q = quadrant_map.find(qk); + ERR_FAIL_COND(!Q); + Quadrant &q=Q->get(); + q.cells.erase(pk); + if (q.cells.size()==0) + _erase_quadrant(Q); + else + _make_quadrant_dirty(Q); + + return; + } + + Map::Element *Q = quadrant_map.find(qk); + + if (!E) { + E=tile_map.insert(pk,Cell()); + if (!Q) + Q=_create_quadrant(qk); + Quadrant &q=Q->get(); + q.cells.insert(pk); + } else { + ERR_FAIL_COND(!Q); // quadrant should exist... + + if (E->get().id==p_tile && E->get().flip_h==p_flip_x && E->get().flip_v==p_flip_y) + return; //nothing changed + + } + + + Cell &c = E->get(); + + c.id=p_tile; + c.flip_h=p_flip_x; + c.flip_v=p_flip_y; + + _make_quadrant_dirty(Q); + +} + +int TileMap::get_cell(int p_x,int p_y) const { + + PosKey pk(p_x,p_y); + + const Map::Element *E=tile_map.find(pk); + + if (!E) + return INVALID_CELL; + + return E->get().id; + +} +bool TileMap::is_cell_x_flipped(int p_x,int p_y) const { + + PosKey pk(p_x,p_y); + + const Map::Element *E=tile_map.find(pk); + + if (!E) + return false; + + return E->get().flip_h; +} +bool TileMap::is_cell_y_flipped(int p_x,int p_y) const { + + PosKey pk(p_x,p_y); + + const Map::Element *E=tile_map.find(pk); + + if (!E) + return false; + + return E->get().flip_v; +} + + +void TileMap::_recreate_quadrants() { + + _clear_quadrants(); + + for (Map::Element *E=tile_map.front();E;E=E->next()) { + + PosKey qk(E->key().x/quadrant_size,E->key().y/quadrant_size); + + Map::Element *Q=quadrant_map.find(qk); + if (!Q) { + Q=_create_quadrant(qk); + dirty_quadrant_list.add(&Q->get().dirty_list); + } + + Q->get().cells.insert(E->key()); + + } +} + +void TileMap::_clear_quadrants() { + + while (quadrant_map.size()) { + _erase_quadrant( quadrant_map.front() ); + } +} + +void TileMap::clear() { + + _clear_quadrants(); + tile_map.clear(); +} + +void TileMap::_set_tile_data(const DVector& p_data) { + + int c=p_data.size(); + DVector::Read r = p_data.read(); + + + for(int i=0;i4000 || y>4000) +// continue; + set_cell(x,y,v,flip_h,flip_v); + } + +} + +DVector TileMap::_get_tile_data() const { + + DVector data; + data.resize(tile_map.size()*2); + DVector::Write w = data.write(); + + int idx=0; + for(const Map::Element *E=tile_map.front();E;E=E->next()) { + + uint8_t *ptr = (uint8_t*)&w[idx]; + encode_uint16(E->key().x,&ptr[0]); + encode_uint16(E->key().y,&ptr[2]); + uint32_t val = E->get().id; + if (E->get().flip_h) + val|=(1<<29); + if (E->get().flip_v) + val|=(1<<30); + + encode_uint32(val,&ptr[4]); + idx+=2; + } + + + w = DVector::Write(); + + return data; + +} + +Rect2 TileMap::get_item_rect() const { + + const_cast(this)->_update_dirty_quadrants(); + return rect_cache; +} + +void TileMap::_bind_methods() { + + + ObjectTypeDB::bind_method(_MD("set_tileset","tileset:TileSet"),&TileMap::set_tileset); + ObjectTypeDB::bind_method(_MD("get_tileset:TileSet"),&TileMap::get_tileset); + + + ObjectTypeDB::bind_method(_MD("set_cell_size","size"),&TileMap::set_cell_size); + ObjectTypeDB::bind_method(_MD("get_cell_size"),&TileMap::get_cell_size); + + ObjectTypeDB::bind_method(_MD("set_quadrant_size","size"),&TileMap::set_quadrant_size); + ObjectTypeDB::bind_method(_MD("get_quadrant_size"),&TileMap::get_quadrant_size); + + ObjectTypeDB::bind_method(_MD("set_center_x","enable"),&TileMap::set_center_x); + ObjectTypeDB::bind_method(_MD("get_center_x"),&TileMap::get_center_x); + + ObjectTypeDB::bind_method(_MD("set_center_y","enable"),&TileMap::set_center_y); + ObjectTypeDB::bind_method(_MD("get_center_y"),&TileMap::get_center_y); + + + ObjectTypeDB::bind_method(_MD("set_cell","x","y","tile","flip_x","flip_y"),&TileMap::set_cell,DEFVAL(false),DEFVAL(false)); + ObjectTypeDB::bind_method(_MD("get_cell","x","y"),&TileMap::get_cell); + ObjectTypeDB::bind_method(_MD("is_cell_x_flipped","x","y"),&TileMap::is_cell_x_flipped); + ObjectTypeDB::bind_method(_MD("is_cell_y_flipped","x","y"),&TileMap::is_cell_y_flipped); + + ObjectTypeDB::bind_method(_MD("clear"),&TileMap::clear); + + ObjectTypeDB::bind_method(_MD("_clear_quadrants"),&TileMap::_clear_quadrants); + ObjectTypeDB::bind_method(_MD("_recreate_quadrants"),&TileMap::_recreate_quadrants); + ObjectTypeDB::bind_method(_MD("_update_dirty_quadrants"),&TileMap::_update_dirty_quadrants); + + ObjectTypeDB::bind_method(_MD("_set_tile_data"),&TileMap::_set_tile_data); + ObjectTypeDB::bind_method(_MD("_get_tile_data"),&TileMap::_get_tile_data); + + ADD_PROPERTY( PropertyInfo(Variant::INT,"cell_size",PROPERTY_HINT_RANGE,"1,8192,1"),_SCS("set_cell_size"),_SCS("get_cell_size")); + ADD_PROPERTY( PropertyInfo(Variant::INT,"quadrant_size",PROPERTY_HINT_RANGE,"1,128,1"),_SCS("set_quadrant_size"),_SCS("get_quadrant_size")); + ADD_PROPERTY( PropertyInfo(Variant::OBJECT,"tile_set",PROPERTY_HINT_RESOURCE_TYPE,"TileSet"),_SCS("set_tileset"),_SCS("get_tileset")); + ADD_PROPERTY( PropertyInfo(Variant::OBJECT,"tile_data",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),_SCS("_set_tile_data"),_SCS("_get_tile_data")); + + BIND_CONSTANT( INVALID_CELL ); +} + +TileMap::TileMap() { + + + + rect_cache_dirty=true; + pending_update=false; + quadrant_size=16; + cell_size=64; + center_x=false; + center_y=false; + + fp_adjust=0.4; + fp_adjust=0.4; +} + +TileMap::~TileMap() { + + clear(); +} diff --git a/scene/2d/tile_map.h b/scene/2d/tile_map.h new file mode 100644 index 0000000000..a2414382c6 --- /dev/null +++ b/scene/2d/tile_map.h @@ -0,0 +1,154 @@ +/*************************************************************************/ +/* tile_map.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef TILE_MAP_H +#define TILE_MAP_H + +#include "scene/2d/node_2d.h" +#include "scene/resources/tile_set.h" +#include "self_list.h" +#include "vset.h" + +class TileMap : public Node2D { + + OBJ_TYPE( TileMap, Node2D ); + + + Ref tile_set; + int cell_size; + int quadrant_size; + bool center_x,center_y; + + union PosKey { + + struct { + int16_t x; + int16_t y; + }; + + uint32_t key; + bool operator<(const PosKey& pk) const { return key tile_map; + struct Quadrant { + + Vector2 pos; + RID canvas_item; + RID static_body; + + SelfList dirty_list; + + VSet cells; + + void operator=(const Quadrant& q) { pos=q.pos; canvas_item=q.canvas_item; static_body=q.static_body; cells=q.cells; } + Quadrant(const Quadrant& q) : dirty_list(this) { pos=q.pos; canvas_item=q.canvas_item; static_body=q.static_body; cells=q.cells;} + Quadrant() : dirty_list(this) {} + }; + + Map quadrant_map; + + SelfList::List dirty_quadrant_list; + + bool pending_update; + + Rect2 rect_cache; + bool rect_cache_dirty; + float fp_adjust; + + + Map::Element *_create_quadrant(const PosKey& p_qk); + void _erase_quadrant(Map::Element *Q); + void _make_quadrant_dirty(Map::Element *Q); + void _recreate_quadrants(); + void _clear_quadrants(); + void _update_dirty_quadrants(); + void _update_quadrant_space(const RID& p_space); + void _update_quadrant_transform(); + void _recompute_rect_cache(); + + void _set_tile_data(const DVector& p_data); + DVector _get_tile_data() const; +protected: + + + void _notification(int p_what); + static void _bind_methods(); + +public: + + enum { + INVALID_CELL=-1 + }; + + void set_tileset(const Ref& p_tileset); + Ref get_tileset() const; + + void set_cell_size(int p_size); + int get_cell_size() const; + + void set_quadrant_size(int p_size); + int get_quadrant_size() const; + + void set_center_x(bool p_enable); + bool get_center_x() const; + void set_center_y(bool p_enable); + bool get_center_y() const; + + void set_cell(int p_x,int p_y,int p_tile,bool p_flip_x=false,bool p_flip_y=false); + int get_cell(int p_x,int p_y) const; + bool is_cell_x_flipped(int p_x,int p_y) const; + bool is_cell_y_flipped(int p_x,int p_y) const; + + Rect2 get_item_rect() const; + + void clear(); + + TileMap(); + ~TileMap(); +}; + +#endif // TILE_MAP_H diff --git a/scene/2d/visibility_notifier_2d.cpp b/scene/2d/visibility_notifier_2d.cpp new file mode 100644 index 0000000000..323d02df4b --- /dev/null +++ b/scene/2d/visibility_notifier_2d.cpp @@ -0,0 +1,322 @@ +/*************************************************************************/ +/* visibility_notifier_2d.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "visibility_notifier_2d.h" + +#include "scene/scene_string_names.h" +#include "scene/2d/physics_body_2d.h" +#include "scene/animation/animation_player.h" +#include "scene/scene_string_names.h" + +void VisibilityNotifier2D::_enter_viewport(Viewport* p_viewport) { + + ERR_FAIL_COND(viewports.has(p_viewport)); + viewports.insert(p_viewport); + if (viewports.size()==1) { + emit_signal(SceneStringNames::get_singleton()->enter_screen); + _screen_enter(); + + + } + emit_signal(SceneStringNames::get_singleton()->enter_viewport,p_viewport); + +} + +void VisibilityNotifier2D::_exit_viewport(Viewport* p_viewport){ + + ERR_FAIL_COND(!viewports.has(p_viewport)); + viewports.erase(p_viewport); + + emit_signal(SceneStringNames::get_singleton()->exit_viewport,p_viewport); + if (viewports.size()==0) { + emit_signal(SceneStringNames::get_singleton()->exit_screen); + + _screen_exit(); + } +} + + +void VisibilityNotifier2D::set_rect(const Rect2& p_rect){ + + rect=p_rect; + if (is_inside_scene()) + get_world_2d()->_update_notifier(this,get_global_transform().xform(rect)); + + _change_notify("rect"); +} + +Rect2 VisibilityNotifier2D::get_item_rect() const { + + return rect; +} + +Rect2 VisibilityNotifier2D::get_rect() const{ + + return rect; +} + + +void VisibilityNotifier2D::_notification(int p_what) { + + + switch(p_what) { + case NOTIFICATION_ENTER_SCENE: { + + //get_world_2d()-> + get_world_2d()->_register_notifier(this,get_global_transform().xform(rect)); + } break; + case NOTIFICATION_TRANSFORM_CHANGED: { + + //get_world_2d()-> + get_world_2d()->_update_notifier(this,get_global_transform().xform(rect)); + } break; + case NOTIFICATION_DRAW: { + + if (get_scene()->is_editor_hint()) { + + draw_rect(rect,Color(1,0.5,1,0.2)); + } + } break; + case NOTIFICATION_EXIT_SCENE: { + + get_world_2d()->_remove_notifier(this); + } break; + } +} + +bool VisibilityNotifier2D::is_on_screen() const { + + return viewports.size()>0; +} + +void VisibilityNotifier2D::_bind_methods(){ + + ObjectTypeDB::bind_method(_MD("set_rect","rect"),&VisibilityNotifier2D::set_rect); + ObjectTypeDB::bind_method(_MD("get_rect"),&VisibilityNotifier2D::get_rect); + ObjectTypeDB::bind_method(_MD("is_on_screen"),&VisibilityNotifier2D::is_on_screen); + + ADD_PROPERTY( PropertyInfo(Variant::RECT2,"rect"),_SCS("set_rect"),_SCS("get_rect")); + + ADD_SIGNAL( MethodInfo("enter_viewport",PropertyInfo(Variant::OBJECT,"viewport",PROPERTY_HINT_RESOURCE_TYPE,"Viewport")) ); + ADD_SIGNAL( MethodInfo("exit_viewport",PropertyInfo(Variant::OBJECT,"viewport",PROPERTY_HINT_RESOURCE_TYPE,"Viewport")) ); + ADD_SIGNAL( MethodInfo("enter_screen")); + ADD_SIGNAL( MethodInfo("exit_screen")); +} + + +VisibilityNotifier2D::VisibilityNotifier2D() { + + rect=Rect2(-10,-10,20,20); +} + + + + + +////////////////////////////////////// + + +void VisibilityEnabler2D::_screen_enter() { + + + for(Map::Element *E=nodes.front();E;E=E->next()) { + + _change_node_state(E->key(),true); + } + + visible=true; +} + +void VisibilityEnabler2D::_screen_exit(){ + + for(Map::Element *E=nodes.front();E;E=E->next()) { + + _change_node_state(E->key(),false); + } + + visible=false; +} + +void VisibilityEnabler2D::_find_nodes(Node* p_node) { + + + bool add=false; + Variant meta; + + if (enabler[ENABLER_FREEZE_BODIES]) { + + RigidBody2D *rb2d = p_node->cast_to(); + if (rb2d && ((rb2d->get_mode()==RigidBody2D::MODE_CHARACTER || (rb2d->get_mode()==RigidBody2D::MODE_RIGID && !rb2d->is_able_to_sleep())))) { + + + add=true; + meta=rb2d->get_mode(); + } + } + + if (enabler[ENABLER_PAUSE_ANIMATIONS]) { + + AnimationPlayer *ap = p_node->cast_to(); + if (ap) { + add=true; + } + + } + + if (add) { + + p_node->connect(SceneStringNames::get_singleton()->exit_scene,this,"_node_removed",varray(p_node),CONNECT_ONESHOT); + nodes[p_node]=meta; + _change_node_state(p_node,false); + } + + for(int i=0;iget_child_count();i++) { + Node *c = p_node->get_child(i); + if (c->get_filename()!=String()) + continue; //skip, instance + + _find_nodes(c); + } + +} + +void VisibilityEnabler2D::_notification(int p_what){ + + if (p_what==NOTIFICATION_ENTER_SCENE) { + + if (get_scene()->is_editor_hint()) + return; + + + Node *from = this; + //find where current scene starts + while(from->get_parent() && from->get_filename()==String()) + from=from->get_parent(); + + _find_nodes(from); + + } + + if (p_what==NOTIFICATION_EXIT_SCENE) { + + if (get_scene()->is_editor_hint()) + return; + + + Node *from = this; + //find where current scene starts + + for (Map::Element *E=nodes.front();E;E=E->next()) { + + if (!visible) + _change_node_state(E->key(),true); + E->key()->disconnect(SceneStringNames::get_singleton()->exit_scene,this,"_node_removed"); + } + + nodes.clear(); + + } +} + +void VisibilityEnabler2D::_change_node_state(Node* p_node,bool p_enabled) { + + ERR_FAIL_COND(!nodes.has(p_node)); + + { + RigidBody2D *rb = p_node->cast_to(); + if (rb) { + + if (p_enabled) { + RigidBody2D::Mode mode = RigidBody2D::Mode(nodes[p_node].operator int()); + //rb->set_mode(mode); + rb->set_active(true); + } else { + //rb->set_mode(RigidBody2D::MODE_STATIC); + rb->set_active(false); + } + } + } + + { + AnimationPlayer *ap=p_node->cast_to(); + + if (ap) { + + ap->set_active(p_enabled); + } + } + +} + + +void VisibilityEnabler2D::_node_removed(Node* p_node) { + + if (!visible) + _change_node_state(p_node,true); + //changed to one shot, not needed + //p_node->disconnect(SceneStringNames::get_singleton()->exit_scene,this,"_node_removed"); + nodes.erase(p_node); + +} + +void VisibilityEnabler2D::_bind_methods(){ + + ObjectTypeDB::bind_method(_MD("set_enabler","enabler","enabled"),&VisibilityEnabler2D::set_enabler); + ObjectTypeDB::bind_method(_MD("is_enabler_enabled","enabler"),&VisibilityEnabler2D::is_enabler_enabled); + ObjectTypeDB::bind_method(_MD("_node_removed"),&VisibilityEnabler2D::_node_removed); + + ADD_PROPERTYI( PropertyInfo(Variant::BOOL,"enabler/pause_animations"),_SCS("set_enabler"),_SCS("is_enabler_enabled"), ENABLER_PAUSE_ANIMATIONS ); + ADD_PROPERTYI( PropertyInfo(Variant::BOOL,"enabler/freeze_bodies"),_SCS("set_enabler"),_SCS("is_enabler_enabled"), ENABLER_FREEZE_BODIES); + + BIND_CONSTANT( ENABLER_FREEZE_BODIES ); + BIND_CONSTANT( ENABLER_PAUSE_ANIMATIONS ); + BIND_CONSTANT( ENABLER_MAX); +} + +void VisibilityEnabler2D::set_enabler(Enabler p_enabler,bool p_enable){ + + ERR_FAIL_INDEX(p_enabler,ENABLER_MAX); + enabler[p_enabler]=p_enable; + +} +bool VisibilityEnabler2D::is_enabler_enabled(Enabler p_enabler) const{ + + ERR_FAIL_INDEX_V(p_enabler,ENABLER_MAX,false); + return enabler[p_enabler]; + +} + +VisibilityEnabler2D::VisibilityEnabler2D() { + + for(int i=0;i viewports; + + Rect2 rect; + +protected: +friend class SpatialIndexer2D; + + void _enter_viewport(Viewport* p_viewport); + void _exit_viewport(Viewport* p_viewport); + + + virtual void _screen_enter() {} + virtual void _screen_exit() {} + + void _notification(int p_what); + static void _bind_methods(); +public: + + void set_rect(const Rect2& p_rect); + Rect2 get_rect() const; + + bool is_on_screen() const; + + virtual Rect2 get_item_rect() const; + + VisibilityNotifier2D(); +}; + + +class VisibilityEnabler2D : public VisibilityNotifier2D { + + OBJ_TYPE(VisibilityEnabler2D,VisibilityNotifier2D); +public: + + enum Enabler { + ENABLER_PAUSE_ANIMATIONS, + ENABLER_FREEZE_BODIES, + ENABLER_MAX + }; + +protected: + + virtual void _screen_enter(); + virtual void _screen_exit(); + + bool visible; + + void _find_nodes(Node* p_node); + + Map nodes; + void _node_removed(Node* p_node); + bool enabler[ENABLER_MAX]; + + void _change_node_state(Node* p_node,bool p_enabled); + + void _notification(int p_what); + static void _bind_methods(); + +public: + + void set_enabler(Enabler p_enabler,bool p_enable); + bool is_enabler_enabled(Enabler p_enabler) const; + + VisibilityEnabler2D(); + +}; + +VARIANT_ENUM_CAST(VisibilityEnabler2D::Enabler); + + +#endif // VISIBILITY_NOTIFIER_2D_H -- cgit v1.2.3