22 files changed, 1231 insertions, 146 deletions

diff --git a/scene/3d/SCsub b/scene/3d/SCsub
index 3c2144bedc..116e641593 100644
--- a/scene/3d/SCsub
+++ b/scene/3d/SCsub
@@ -4,10 +4,8 @@ Import('env')
 if (env["disable_3d"]=="yes"):
 
 	env.scene_sources.append("3d/spatial.cpp")
-	env.scene_sources.append("3d/skeleton.cpp")        
+	env.scene_sources.append("3d/skeleton.cpp")
 else:
 	env.add_source_files(env.scene_sources,"*.cpp")
 
 Export('env')
-
-
diff --git a/scene/3d/area.cpp b/scene/3d/area.cpp
index d49ffff729..ff35837bc0 100644
--- a/scene/3d/area.cpp
+++ b/scene/3d/area.cpp
@@ -52,6 +52,17 @@ bool Area::is_gravity_a_point() const{
 	return gravity_is_point;
 }
 
+void Area::set_gravity_distance_scale(real_t p_scale){
+
+	gravity_distance_scale=p_scale;
+	PhysicsServer::get_singleton()->area_set_param(get_rid(),PhysicsServer::AREA_PARAM_GRAVITY_DISTANCE_SCALE,p_scale);
+
+}
+
+real_t Area::get_gravity_distance_scale() const{
+	return gravity_distance_scale;
+}
+
 void Area::set_gravity_vector(const Vector3& p_vec){
 
 	gravity_vec=p_vec;
@@ -72,15 +83,25 @@ real_t Area::get_gravity() const{
 
 	return gravity;
 }
+void Area::set_linear_damp(real_t p_linear_damp){
+
+	linear_damp=p_linear_damp;
+	PhysicsServer::get_singleton()->area_set_param(get_rid(),PhysicsServer::AREA_PARAM_LINEAR_DAMP,p_linear_damp);
+}
+real_t Area::get_linear_damp() const{
+
+	return linear_damp;
+}
 
-void Area::set_density(real_t p_density){
+void Area::set_angular_damp(real_t p_angular_damp){
 
-	density=p_density;
-	PhysicsServer::get_singleton()->area_set_param(get_rid(),PhysicsServer::AREA_PARAM_DENSITY,p_density);
+	angular_damp=p_angular_damp;
+	PhysicsServer::get_singleton()->area_set_param(get_rid(),PhysicsServer::AREA_PARAM_ANGULAR_DAMP,p_angular_damp);
 }
-real_t Area::get_density() const{
 
-	return density;
+real_t Area::get_angular_damp() const{
+
+	return angular_damp;
 }
 
 void Area::set_priority(real_t p_priority){
@@ -214,27 +235,56 @@ void Area::_clear_monitoring() {
 	}
 	ERR_FAIL_COND(locked);
 
-	Map<ObjectID,BodyState> bmcopy = body_map;
-	body_map.clear();
-	//disconnect all monitored stuff
+	{
+		Map<ObjectID,BodyState> bmcopy = body_map;
+		body_map.clear();
+		//disconnect all monitored stuff
 
-	for (Map<ObjectID,BodyState>::Element *E=bmcopy.front();E;E=E->next()) {
+		for (Map<ObjectID,BodyState>::Element *E=bmcopy.front();E;E=E->next()) {
 
-		Object *obj = ObjectDB::get_instance(E->key());
-		Node *node = obj ? obj->cast_to<Node>() : NULL;
-		ERR_CONTINUE(!node);
-		if (!E->get().in_tree)
-			continue;
+			Object *obj = ObjectDB::get_instance(E->key());
+			Node *node = obj ? obj->cast_to<Node>() : NULL;
+			ERR_CONTINUE(!node);
+			if (!E->get().in_tree)
+				continue;
+
+			for(int i=0;i<E->get().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);
+			}
 
-		for(int i=0;i<E->get().shapes.size();i++) {
+			emit_signal(SceneStringNames::get_singleton()->body_exit,obj);
 
-			emit_signal(SceneStringNames::get_singleton()->body_exit_shape,E->key(),node,E->get().shapes[i].body_shape,E->get().shapes[i].area_shape);
+			node->disconnect(SceneStringNames::get_singleton()->enter_tree,this,SceneStringNames::get_singleton()->_body_enter_tree);
+			node->disconnect(SceneStringNames::get_singleton()->exit_tree,this,SceneStringNames::get_singleton()->_body_exit_tree);
 		}
 
-		emit_signal(SceneStringNames::get_singleton()->body_exit,obj);
+	}
+
+	{
+
+		Map<ObjectID,AreaState> bmcopy = area_map;
+		area_map.clear();
+		//disconnect all monitored stuff
+
+		for (Map<ObjectID,AreaState>::Element *E=bmcopy.front();E;E=E->next()) {
+
+			Object *obj = ObjectDB::get_instance(E->key());
+			Node *node = obj ? obj->cast_to<Node>() : NULL;
+			ERR_CONTINUE(!node);
+			if (!E->get().in_tree)
+				continue;
 
-		node->disconnect(SceneStringNames::get_singleton()->enter_tree,this,SceneStringNames::get_singleton()->_body_enter_tree);
-		node->disconnect(SceneStringNames::get_singleton()->exit_tree,this,SceneStringNames::get_singleton()->_body_exit_tree);
+			for(int i=0;i<E->get().shapes.size();i++) {
+
+				emit_signal(SceneStringNames::get_singleton()->area_exit_shape,E->key(),node,E->get().shapes[i].area_shape,E->get().shapes[i].self_shape);
+			}
+
+			emit_signal(SceneStringNames::get_singleton()->area_exit,obj);
+
+			node->disconnect(SceneStringNames::get_singleton()->enter_tree,this,SceneStringNames::get_singleton()->_area_enter_tree);
+			node->disconnect(SceneStringNames::get_singleton()->exit_tree,this,SceneStringNames::get_singleton()->_area_exit_tree);
+		}
 	}
 
 }
@@ -259,11 +309,128 @@ void Area::set_enable_monitoring(bool p_enable) {
 
 	if (monitoring) {
 
-		PhysicsServer::get_singleton()->area_set_monitor_callback(get_rid(),this,"_body_inout");
+		PhysicsServer::get_singleton()->area_set_monitor_callback(get_rid(),this,SceneStringNames::get_singleton()->_body_inout);
+		PhysicsServer::get_singleton()->area_set_area_monitor_callback(get_rid(),this,SceneStringNames::get_singleton()->_area_inout);
 	} else {
 		PhysicsServer::get_singleton()->area_set_monitor_callback(get_rid(),NULL,StringName());
+		PhysicsServer::get_singleton()->area_set_area_monitor_callback(get_rid(),NULL,StringName());
 		_clear_monitoring();
+
+	}
+}
+
+
+void Area::_area_enter_tree(ObjectID p_id) {
+
+	Object *obj = ObjectDB::get_instance(p_id);
+	Node *node = obj ? obj->cast_to<Node>() : NULL;
+	ERR_FAIL_COND(!node);
+
+	Map<ObjectID,AreaState>::Element *E=area_map.find(p_id);
+	ERR_FAIL_COND(!E);
+	ERR_FAIL_COND(E->get().in_tree);
+
+	E->get().in_tree=true;
+	emit_signal(SceneStringNames::get_singleton()->area_enter,node);
+	for(int i=0;i<E->get().shapes.size();i++) {
+
+		emit_signal(SceneStringNames::get_singleton()->area_enter_shape,p_id,node,E->get().shapes[i].area_shape,E->get().shapes[i].self_shape);
+	}
+
+}
+
+void Area::_area_exit_tree(ObjectID p_id) {
+
+	Object *obj = ObjectDB::get_instance(p_id);
+	Node *node = obj ? obj->cast_to<Node>() : NULL;
+	ERR_FAIL_COND(!node);
+	Map<ObjectID,AreaState>::Element *E=area_map.find(p_id);
+	ERR_FAIL_COND(!E);
+	ERR_FAIL_COND(!E->get().in_tree);
+	E->get().in_tree=false;
+	emit_signal(SceneStringNames::get_singleton()->area_exit,node);
+	for(int i=0;i<E->get().shapes.size();i++) {
+
+		emit_signal(SceneStringNames::get_singleton()->area_exit_shape,p_id,node,E->get().shapes[i].area_shape,E->get().shapes[i].self_shape);
+	}
+
+}
+
+void Area::_area_inout(int p_status,const RID& p_area, int p_instance, int p_area_shape,int p_self_shape) {
+
+
+	bool area_in = p_status==PhysicsServer::AREA_BODY_ADDED;
+	ObjectID objid=p_instance;
+
+	Object *obj = ObjectDB::get_instance(objid);
+	Node *node = obj ? obj->cast_to<Node>() : NULL;
+
+	Map<ObjectID,AreaState>::Element *E=area_map.find(objid);
+
+	ERR_FAIL_COND(!area_in && !E);
+
+	locked=true;
+
+	if (area_in) {
+		if (!E) {
+
+			E = area_map.insert(objid,AreaState());
+			E->get().rc=0;
+			E->get().in_tree=node && node->is_inside_tree();
+			if (node) {
+				node->connect(SceneStringNames::get_singleton()->enter_tree,this,SceneStringNames::get_singleton()->_area_enter_tree,make_binds(objid));
+				node->connect(SceneStringNames::get_singleton()->exit_tree,this,SceneStringNames::get_singleton()->_area_exit_tree,make_binds(objid));
+				if (E->get().in_tree) {
+					emit_signal(SceneStringNames::get_singleton()->area_enter,node);
+
+				}
+			}
+
+		}
+		E->get().rc++;
+		if (node)
+			E->get().shapes.insert(AreaShapePair(p_area_shape,p_self_shape));
+
+
+		if (!node || E->get().in_tree) {
+			emit_signal(SceneStringNames::get_singleton()->area_enter_shape,objid,node,p_area_shape,p_self_shape);
+		}
+
+	} else {
+
+		E->get().rc--;
+
+		if (node)
+			E->get().shapes.erase(AreaShapePair(p_area_shape,p_self_shape));
+
+		bool eraseit=false;
+
+		if (E->get().rc==0) {
+
+			if (node) {
+				node->disconnect(SceneStringNames::get_singleton()->enter_tree,this,SceneStringNames::get_singleton()->_area_enter_tree);
+				node->disconnect(SceneStringNames::get_singleton()->exit_tree,this,SceneStringNames::get_singleton()->_area_exit_tree);
+				if (E->get().in_tree) {
+					emit_signal(SceneStringNames::get_singleton()->area_exit,obj);
+				}
+
+			}
+
+			eraseit=true;
+
+		}
+		if (!node || E->get().in_tree) {
+			emit_signal(SceneStringNames::get_singleton()->area_exit_shape,objid,obj,p_area_shape,p_self_shape);
+		}
+
+		if (eraseit)
+			area_map.erase(E);
+
 	}
+
+	locked=false;
+
+
 }
 
 bool Area::is_monitoring_enabled() const {
@@ -291,36 +458,115 @@ Array Area::get_overlapping_bodies() const {
 	return ret;
 }
 
+void Area::set_monitorable(bool p_enable) {
+
+	if (locked) {
+		ERR_EXPLAIN("This function can't be used during the in/out signal.");
+	}
+	ERR_FAIL_COND(locked);
+
+	if (p_enable==monitorable)
+		return;
+
+	monitorable=p_enable;
+
+	PhysicsServer::get_singleton()->area_set_monitorable(get_rid(),monitorable);
+}
+
+bool Area::is_monitorable() const {
+
+	return monitorable;
+}
+
+
+Array Area::get_overlapping_areas() const {
+
+	ERR_FAIL_COND_V(!monitoring,Array());
+	Array ret;
+	ret.resize(area_map.size());
+	int idx=0;
+	for (const Map<ObjectID,AreaState>::Element *E=area_map.front();E;E=E->next()) {
+		Object *obj = ObjectDB::get_instance(E->key());
+		if (!obj) {
+			ret.resize( ret.size() -1 ); //ops
+		} else {
+			ret[idx++]=obj;
+		}
+
+	}
+
+	return ret;
+}
+
+bool Area::overlaps_area(Node* p_area) const {
+
+	ERR_FAIL_NULL_V(p_area,false);
+	const Map<ObjectID,AreaState>::Element *E=area_map.find(p_area->get_instance_ID());
+	if (!E)
+		return false;
+	return E->get().in_tree;
+
+
+
+}
+
+bool Area::overlaps_body(Node* p_body) const{
+
+	ERR_FAIL_NULL_V(p_body,false);
+	const Map<ObjectID,BodyState>::Element *E=body_map.find(p_body->get_instance_ID());
+	if (!E)
+		return false;
+	return E->get().in_tree;
+
+}
+
 void Area::_bind_methods() {
 
 	ObjectTypeDB::bind_method(_MD("_body_enter_tree","id"),&Area::_body_enter_tree);
 	ObjectTypeDB::bind_method(_MD("_body_exit_tree","id"),&Area::_body_exit_tree);
 
+	ObjectTypeDB::bind_method(_MD("_area_enter_tree","id"),&Area::_area_enter_tree);
+	ObjectTypeDB::bind_method(_MD("_area_exit_tree","id"),&Area::_area_exit_tree);
+
 	ObjectTypeDB::bind_method(_MD("set_space_override_mode","enable"),&Area::set_space_override_mode);
 	ObjectTypeDB::bind_method(_MD("get_space_override_mode"),&Area::get_space_override_mode);
 
 	ObjectTypeDB::bind_method(_MD("set_gravity_is_point","enable"),&Area::set_gravity_is_point);
 	ObjectTypeDB::bind_method(_MD("is_gravity_a_point"),&Area::is_gravity_a_point);
 
+	ObjectTypeDB::bind_method(_MD("set_gravity_distance_scale","distance_scale"),&Area::set_gravity_distance_scale);
+	ObjectTypeDB::bind_method(_MD("get_gravity_distance_scale"),&Area::get_gravity_distance_scale);
+
 	ObjectTypeDB::bind_method(_MD("set_gravity_vector","vector"),&Area::set_gravity_vector);
 	ObjectTypeDB::bind_method(_MD("get_gravity_vector"),&Area::get_gravity_vector);
 
 	ObjectTypeDB::bind_method(_MD("set_gravity","gravity"),&Area::set_gravity);
 	ObjectTypeDB::bind_method(_MD("get_gravity"),&Area::get_gravity);
 
-	ObjectTypeDB::bind_method(_MD("set_density","density"),&Area::set_density);
-	ObjectTypeDB::bind_method(_MD("get_density"),&Area::get_density);
+	ObjectTypeDB::bind_method(_MD("set_angular_damp","angular_damp"),&Area::set_angular_damp);
+	ObjectTypeDB::bind_method(_MD("get_angular_damp"),&Area::get_angular_damp);
+
+	ObjectTypeDB::bind_method(_MD("set_linear_damp","linear_damp"),&Area::set_linear_damp);
+	ObjectTypeDB::bind_method(_MD("get_linear_damp"),&Area::get_linear_damp);
 
 	ObjectTypeDB::bind_method(_MD("set_priority","priority"),&Area::set_priority);
 	ObjectTypeDB::bind_method(_MD("get_priority"),&Area::get_priority);
 
+	ObjectTypeDB::bind_method(_MD("set_monitorable","enable"),&Area::set_monitorable);
+	ObjectTypeDB::bind_method(_MD("is_monitorable"),&Area::is_monitorable);
+
 
 	ObjectTypeDB::bind_method(_MD("set_enable_monitoring","enable"),&Area::set_enable_monitoring);
 	ObjectTypeDB::bind_method(_MD("is_monitoring_enabled"),&Area::is_monitoring_enabled);
 
 	ObjectTypeDB::bind_method(_MD("get_overlapping_bodies"),&Area::get_overlapping_bodies);
+	ObjectTypeDB::bind_method(_MD("get_overlapping_areas"),&Area::get_overlapping_areas);
+
+	ObjectTypeDB::bind_method(_MD("overlaps_body:PhysicsBody","body"),&Area::overlaps_body);
+	ObjectTypeDB::bind_method(_MD("overlaps_area:Area","area"),&Area::overlaps_area);
 
 	ObjectTypeDB::bind_method(_MD("_body_inout"),&Area::_body_inout);
+	ObjectTypeDB::bind_method(_MD("_area_inout"),&Area::_area_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")));
@@ -328,13 +574,21 @@ void Area::_bind_methods() {
 	ADD_SIGNAL( MethodInfo("body_enter",PropertyInfo(Variant::OBJECT,"body")));
 	ADD_SIGNAL( MethodInfo("body_exit",PropertyInfo(Variant::OBJECT,"body")));
 
+	ADD_SIGNAL( MethodInfo("area_enter_shape",PropertyInfo(Variant::INT,"area_id"),PropertyInfo(Variant::OBJECT,"area",PROPERTY_HINT_RESOURCE_TYPE,"Area"),PropertyInfo(Variant::INT,"area_shape"),PropertyInfo(Variant::INT,"area_shape")));
+	ADD_SIGNAL( MethodInfo("area_exit_shape",PropertyInfo(Variant::INT,"area_id"),PropertyInfo(Variant::OBJECT,"area",PROPERTY_HINT_RESOURCE_TYPE,"Area"),PropertyInfo(Variant::INT,"area_shape"),PropertyInfo(Variant::INT,"area_shape")));
+	ADD_SIGNAL( MethodInfo("area_enter",PropertyInfo(Variant::OBJECT,"area",PROPERTY_HINT_RESOURCE_TYPE,"Area")));
+	ADD_SIGNAL( MethodInfo("area_exit",PropertyInfo(Variant::OBJECT,"area",PROPERTY_HINT_RESOURCE_TYPE,"Area")));
+
 	ADD_PROPERTY( 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::REAL,"gravity_distance_scale", PROPERTY_HINT_RANGE,"0,1024,0.001"),_SCS("set_gravity_distance_scale"),_SCS("get_gravity_distance_scale"));
 	ADD_PROPERTY( PropertyInfo(Variant::VECTOR3,"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_PROPERTY( PropertyInfo(Variant::REAL,"linear_damp",PROPERTY_HINT_RANGE,"0,1024,0.001"),_SCS("set_linear_damp"),_SCS("get_linear_damp"));
+	ADD_PROPERTY( PropertyInfo(Variant::REAL,"angular_damp",PROPERTY_HINT_RANGE,"0,1024,0.001"),_SCS("set_angular_damp"),_SCS("get_angular_damp"));
 	ADD_PROPERTY( 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"));
+	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"monitorable"),_SCS("set_monitorable"),_SCS("is_monitorable"));
 
 }
 
@@ -345,11 +599,14 @@ Area::Area() : CollisionObject(PhysicsServer::get_singleton()->area_create(),tru
 	locked=false;
 	set_gravity_vector(Vector3(0,-1,0));
 	gravity_is_point=false;
-	density=0.1;
+	gravity_distance_scale=0;
+	linear_damp=0.1;
+	angular_damp=1;
 	priority=0;
 	monitoring=false;
 	set_ray_pickable(false);
 	set_enable_monitoring(true);
+	set_monitorable(true);
 
 }
 
diff --git a/scene/3d/area.h b/scene/3d/area.h
index 493c71c595..f03955d1e7 100644
--- a/scene/3d/area.h
+++ b/scene/3d/area.h
@@ -49,9 +49,12 @@ private:
 	Vector3 gravity_vec;
 	real_t gravity;
 	bool gravity_is_point;
-	real_t density;
+	real_t gravity_distance_scale;
+	real_t angular_damp;
+	real_t linear_damp;
 	int priority;
 	bool monitoring;
+	bool monitorable;
 	bool locked;
 
 
@@ -83,6 +86,36 @@ private:
 	};
 
 	Map<ObjectID,BodyState> body_map;
+
+
+	void _area_inout(int p_status,const RID& p_area, int p_instance, int p_area_shape,int p_self_shape);
+
+	void _area_enter_tree(ObjectID p_id);
+	void _area_exit_tree(ObjectID p_id);
+
+	struct AreaShapePair {
+
+		int area_shape;
+		int self_shape;
+		bool operator<(const AreaShapePair& p_sp) const {
+			if (area_shape==p_sp.area_shape)
+				return self_shape < p_sp.self_shape;
+			else
+				return area_shape < p_sp.area_shape;
+		}
+
+		AreaShapePair() {}
+		AreaShapePair(int p_bs, int p_as) { area_shape=p_bs; self_shape=p_as; }
+	};
+
+	struct AreaState {
+
+		int rc;
+		bool in_tree;
+		VSet<AreaShapePair> shapes;
+	};
+
+	Map<ObjectID,AreaState> area_map;
 	void _clear_monitoring();
 
 
@@ -98,14 +131,20 @@ public:
 	void set_gravity_is_point(bool p_enabled);
 	bool is_gravity_a_point() const;
 
+	void set_gravity_distance_scale(real_t p_scale);
+	real_t get_gravity_distance_scale() const;
+
 	void set_gravity_vector(const Vector3& p_vec);
 	Vector3 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_angular_damp(real_t p_angular_damp);
+	real_t get_angular_damp() const;
+
+	void set_linear_damp(real_t p_linear_damp);
+	real_t get_linear_damp() const;
 
 	void set_priority(real_t p_priority);
 	real_t get_priority() const;
@@ -113,7 +152,14 @@ public:
 	void set_enable_monitoring(bool p_enable);
 	bool is_monitoring_enabled() const;
 
+	void set_monitorable(bool p_enable);
+	bool is_monitorable() const;
+
 	Array get_overlapping_bodies() const;
+	Array get_overlapping_areas() const; //function for script
+
+	bool overlaps_area(Node* p_area) const;
+	bool overlaps_body(Node* p_body) const;
 
 
 	Area();
diff --git a/scene/3d/baked_light_instance.cpp b/scene/3d/baked_light_instance.cpp
index b55093a779..1ae7866f0b 100644
--- a/scene/3d/baked_light_instance.cpp
+++ b/scene/3d/baked_light_instance.cpp
@@ -81,7 +81,7 @@ float BakedLightSampler::get_param(Param p_param) const{
 
 void BakedLightSampler::set_resolution(int p_resolution){
 
-	ERR_FAIL_COND(p_resolution<4 && p_resolution>32);
+    ERR_FAIL_COND(p_resolution<4 || p_resolution>32);
 	resolution=p_resolution;
 	VS::get_singleton()->baked_light_sampler_set_resolution(base,resolution);
 }
diff --git a/scene/3d/body_shape.cpp b/scene/3d/body_shape.cpp
index c49d1b028c..b54cbfe0f9 100644
--- a/scene/3d/body_shape.cpp
+++ b/scene/3d/body_shape.cpp
@@ -43,7 +43,10 @@
 
 void CollisionShape::_update_body() {
 
-
+	if (!is_inside_tree() || !can_update_body)
+		return;
+	if (!get_tree()->is_editor_hint())
+		return;
 	if (get_parent() && get_parent()->cast_to<CollisionObject>())
 		get_parent()->cast_to<CollisionObject>()->_update_shapes_from_children();
 
@@ -310,10 +313,13 @@ void CollisionShape::_add_to_collision_object(Object* p_cshape) {
 
 	if (shape.is_valid()) {
 
+		update_shape_index=co->get_shape_count();
 		co->add_shape(shape,get_transform());
-        if (trigger)
-            co->set_shape_as_trigger( co->get_shape_count() -1, true );
-    }
+		if (trigger)
+			co->set_shape_as_trigger( co->get_shape_count() -1, true );
+	} else {
+		update_shape_index=-1;
+	}
 }
 
 void CollisionShape::_notification(int p_what) {
@@ -322,12 +328,18 @@ void CollisionShape::_notification(int p_what) {
 
 		case NOTIFICATION_ENTER_TREE: {
 			unparenting=false;
+			can_update_body=get_tree()->is_editor_hint();
+			set_notify_local_transform(!can_update_body);
+
+			if (get_tree()->is_debugging_collisions_hint()) {
+				_create_debug_shape();
+			}
 
 			//indicator_instance = VisualServer::get_singleton()->instance_create2(indicator,get_world()->get_scenario());
 		} break;
 		case NOTIFICATION_TRANSFORM_CHANGED: {
 		//	VisualServer::get_singleton()->instance_set_transform(indicator_instance,get_global_transform());
-			if (updating_body) {
+			if (can_update_body && updating_body) {
 				_update_body();
 			}
 		} break;
@@ -336,16 +348,34 @@ void CollisionShape::_notification(int p_what) {
 				VisualServer::get_singleton()->free(indicator_instance);
 				indicator_instance=RID();
 			}*/
+			can_update_body=false;
+			set_notify_local_transform(false);
+			if (debug_shape) {
+				debug_shape->queue_delete();
+				debug_shape=NULL;
+			}
 		} break;
 		case NOTIFICATION_UNPARENTED: {
 			unparenting=true;
-			if (updating_body)
+			if (can_update_body && updating_body)
 				_update_body();
 		} break;
 		case NOTIFICATION_PARENTED: {
-			if (updating_body)
+			if (can_update_body && updating_body)
 				_update_body();
 		} break;
+		case NOTIFICATION_LOCAL_TRANSFORM_CHANGED: {
+
+			if (!can_update_body && update_shape_index>=0) {
+
+				CollisionObject *co = get_parent()->cast_to<CollisionObject>();
+				if (co) {
+					co->set_shape_transform(update_shape_index,get_transform());
+				}
+			}
+
+		} break;
+
 	}
 }
 
@@ -357,6 +387,18 @@ void CollisionShape::resource_changed(RES res) {
 
 }
 
+void CollisionShape::_set_update_shape_index(int p_index) {
+
+
+	update_shape_index=p_index;
+}
+
+int CollisionShape::_get_update_shape_index() const{
+
+	return update_shape_index;
+}
+
+
 void CollisionShape::_bind_methods() {
 
 	//not sure if this should do anything
@@ -368,10 +410,14 @@ void CollisionShape::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("is_trigger"),&CollisionShape::is_trigger);
 	ObjectTypeDB::bind_method(_MD("make_convex_from_brothers"),&CollisionShape::make_convex_from_brothers);
 	ObjectTypeDB::set_method_flags("CollisionShape","make_convex_from_brothers",METHOD_FLAGS_DEFAULT|METHOD_FLAG_EDITOR);
+	ObjectTypeDB::bind_method(_MD("_set_update_shape_index","index"),&CollisionShape::_set_update_shape_index);
+	ObjectTypeDB::bind_method(_MD("_get_update_shape_index"),&CollisionShape::_get_update_shape_index);
 
+	ObjectTypeDB::bind_method(_MD("get_collision_object_shape_index"),&CollisionShape::get_collision_object_shape_index);
 
 	ADD_PROPERTY( PropertyInfo( Variant::OBJECT, "shape", PROPERTY_HINT_RESOURCE_TYPE, "Shape"), _SCS("set_shape"), _SCS("get_shape"));
-    ADD_PROPERTY(PropertyInfo(Variant::BOOL,"trigger"),_SCS("set_trigger"),_SCS("is_trigger"));
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL,"trigger"),_SCS("set_trigger"),_SCS("is_trigger"));
+	ADD_PROPERTY( PropertyInfo( Variant::INT, "_update_shape_index", PROPERTY_HINT_NONE, "",PROPERTY_USAGE_NOEDITOR), _SCS("_set_update_shape_index"), _SCS("_get_update_shape_index"));
 }
 
 
@@ -383,8 +429,15 @@ void CollisionShape::set_shape(const Ref<Shape> &p_shape) {
 	if (!shape.is_null())
 		shape->register_owner(this);
 	update_gizmo();
-	if (updating_body)
+	if (updating_body) {
 		_update_body();
+	} else if (can_update_body && update_shape_index>=0 && is_inside_tree()){
+		CollisionObject *co = get_parent()->cast_to<CollisionObject>();
+		if (co) {
+			co->set_shape(update_shape_index,p_shape);
+		}
+
+	}
 }
 
 Ref<Shape> CollisionShape::get_shape() const {
@@ -405,8 +458,14 @@ bool CollisionShape::is_updating_body() const {
 void CollisionShape::set_trigger(bool p_trigger) {
 
     trigger=p_trigger;
-    if (updating_body)
+    if (updating_body) {
         _update_body();
+    } else if (can_update_body && update_shape_index>=0 && is_inside_tree()){
+	    CollisionObject *co = get_parent()->cast_to<CollisionObject>();
+	    if (co) {
+		    co->set_shape_as_trigger(update_shape_index,p_trigger);
+	    }
+    }
 }
 
 bool CollisionShape::is_trigger() const{
@@ -419,7 +478,10 @@ CollisionShape::CollisionShape() {
 	//indicator = VisualServer::get_singleton()->mesh_create();
 	updating_body=true;
 	unparenting=false;
-    trigger=false;
+	update_shape_index=-1;
+	trigger=false;
+	can_update_body=false;
+	debug_shape=NULL;
 }
 
 CollisionShape::~CollisionShape() {
@@ -428,6 +490,30 @@ CollisionShape::~CollisionShape() {
 	//VisualServer::get_singleton()->free(indicator);
 }
 
+void CollisionShape::_create_debug_shape() {
+
+
+	if (debug_shape) {
+		debug_shape->queue_delete();;
+		debug_shape=NULL;
+	}
+
+	Ref<Shape> s = get_shape();
+
+	if (s.is_null())
+		return;
+
+
+	Ref<Mesh> mesh = s->get_debug_mesh();
+
+	MeshInstance *mi = memnew( MeshInstance );
+	mi->set_mesh(mesh);
+
+	add_child(mi);
+	debug_shape=mi;
+
+}
+
 #if 0
 #include "body_volume.h"
 
diff --git a/scene/3d/body_shape.h b/scene/3d/body_shape.h
index b3c0006d79..6c0b89da56 100644
--- a/scene/3d/body_shape.h
+++ b/scene/3d/body_shape.h
@@ -50,14 +50,26 @@ class CollisionShape : public Spatial {
 	RID indicator_instance;
 	*/
 
+	Node* debug_shape;
+
 	void resource_changed(RES res);
 
 	bool updating_body;
 	bool unparenting;
 	bool trigger;
 
+	bool can_update_body;
+
+	int update_shape_index;
+
 	void _update_body();
 	void _add_to_collision_object(Object* p_cshape);
+
+	void _set_update_shape_index(int p_index);
+	int _get_update_shape_index() const;
+
+	void _create_debug_shape();
+
 protected:
 
 	void _notification(int p_what);
@@ -73,8 +85,10 @@ public:
 	void set_updating_body(bool p_update);
 	bool is_updating_body() const;
 
-    void set_trigger(bool p_trigger);
-    bool is_trigger() const;
+	void set_trigger(bool p_trigger);
+	bool is_trigger() const;
+
+	int get_collision_object_shape_index() const { return _get_update_shape_index(); }
 
 	CollisionShape();
 	~CollisionShape();
diff --git a/scene/3d/collision_object.cpp b/scene/3d/collision_object.cpp
index efc5db50e1..5ecadb48b8 100644
--- a/scene/3d/collision_object.cpp
+++ b/scene/3d/collision_object.cpp
@@ -122,8 +122,8 @@ bool CollisionObject::_set(const StringName& p_name, const Variant& p_value) {
 
 	} else if (name.begins_with("shapes/")) {
 
-		int idx=name.get_slice("/",1).to_int();
-		String what=name.get_slice("/",2);
+		int idx=name.get_slicec('/',1).to_int();
+		String what=name.get_slicec('/',2);
 		if (what=="shape")
 			set_shape(idx,RefPtr(p_value));
 		else if (what=="transform")
@@ -148,8 +148,8 @@ bool CollisionObject::_get(const StringName& p_name,Variant &r_ret) const {
 		r_ret= shapes.size();
 	} else if (name.begins_with("shapes/")) {
 
-		int idx=name.get_slice("/",1).to_int();
-		String what=name.get_slice("/",2);
+		int idx=name.get_slicec('/',1).to_int();
+		String what=name.get_slicec('/',2);
 		if (what=="shape")
 			r_ret= get_shape(idx);
 		else if (what=="transform")
diff --git a/scene/3d/collision_polygon.cpp b/scene/3d/collision_polygon.cpp
index 4ab1a1a1ab..bb0a1fca12 100644
--- a/scene/3d/collision_polygon.cpp
+++ b/scene/3d/collision_polygon.cpp
@@ -6,6 +6,8 @@
 
 void CollisionPolygon::_add_to_collision_object(Object *p_obj) {
 
+	if (!can_update_body)
+		return;
 
 	CollisionObject *co = p_obj->cast_to<CollisionObject>();
 	ERR_FAIL_COND(!co);
@@ -23,6 +25,7 @@ void CollisionPolygon::_add_to_collision_object(Object *p_obj) {
 
 		//here comes the sun, lalalala
 		//decompose concave into multiple convex polygons and add them
+		shape_from=co->get_shape_count();
 		for(int i=0;i<decomp.size();i++) {
 			Ref<ConvexPolygonShape> convex = memnew( ConvexPolygonShape );
 			DVector<Vector3> cp;
@@ -43,6 +46,11 @@ void CollisionPolygon::_add_to_collision_object(Object *p_obj) {
 			co->add_shape(convex,get_transform());
 
 		}
+		shape_to=co->get_shape_count()-1;
+		if (shape_to<shape_from) {
+			shape_from=-1;
+			shape_to=-1;
+		}
 
 	} else {
 #if 0
@@ -71,6 +79,9 @@ void CollisionPolygon::_add_to_collision_object(Object *p_obj) {
 
 void CollisionPolygon::_update_parent() {
 
+	if (!can_update_body)
+		return;
+
 	Node *parent = get_parent();
 	if (!parent)
 		return;
@@ -80,15 +91,50 @@ void CollisionPolygon::_update_parent() {
 	co->_update_shapes_from_children();
 }
 
+void CollisionPolygon::_set_shape_range(const Vector2& p_range) {
+
+	shape_from=p_range.x;
+	shape_to=p_range.y;
+}
+
+Vector2 CollisionPolygon::_get_shape_range() const {
+
+	return Vector2(shape_from,shape_to);
+}
+
 void CollisionPolygon::_notification(int p_what) {
 
 
 	switch(p_what) {
+		case NOTIFICATION_ENTER_TREE: {
+			can_update_body=get_tree()->is_editor_hint();
+			set_notify_local_transform(!can_update_body);
+
+			//indicator_instance = VisualServer::get_singleton()->instance_create2(indicator,get_world()->get_scenario());
+		} break;
+		case NOTIFICATION_EXIT_TREE: {
+			can_update_body=false;
+			set_notify_local_transform(false);
+		} break;
 		case NOTIFICATION_TRANSFORM_CHANGED: {
 
 			if (!is_inside_tree())
 				break;
-			_update_parent();
+			if (can_update_body) {
+				_update_parent();
+			}
+
+		} break;
+		case NOTIFICATION_LOCAL_TRANSFORM_CHANGED: {
+            if (!can_update_body && shape_from>=0 && shape_to>=0) {
+
+				CollisionObject *co = get_parent()->cast_to<CollisionObject>();
+				if (co) {
+					for(int i=shape_from;i<=shape_to;i++) {
+						co->set_shape_transform(i,get_transform());
+					}
+				}
+			}
 
 		} break;
 #if 0
@@ -119,29 +165,31 @@ void CollisionPolygon::_notification(int p_what) {
 void CollisionPolygon::set_polygon(const Vector<Point2>& p_polygon) {
 
 	polygon=p_polygon;
+	if (can_update_body) {
 
-	for(int i=0;i<polygon.size();i++) {
+		for(int i=0;i<polygon.size();i++) {
 
-		Vector3 p1(polygon[i].x,polygon[i].y,depth*0.5);
+			Vector3 p1(polygon[i].x,polygon[i].y,depth*0.5);
 
-		if (i==0)
-			aabb=AABB(p1,Vector3());
-		else
-			aabb.expand_to(p1);
+			if (i==0)
+				aabb=AABB(p1,Vector3());
+			else
+				aabb.expand_to(p1);
 
-		Vector3 p2(polygon[i].x,polygon[i].y,-depth*0.5);
-		aabb.expand_to(p2);
+			Vector3 p2(polygon[i].x,polygon[i].y,-depth*0.5);
+			aabb.expand_to(p2);
 
 
-	}
-	if (aabb==AABB()) {
+		}
+		if (aabb==AABB()) {
 
-		aabb=AABB(Vector3(-1,-1,-1),Vector3(2,2,2));
-	} else {
-		aabb.pos-=aabb.size*0.3;
-		aabb.size+=aabb.size*0.6;
+			aabb=AABB(Vector3(-1,-1,-1),Vector3(2,2,2));
+		} else {
+			aabb.pos-=aabb.size*0.3;
+			aabb.size+=aabb.size*0.6;
+		}
+		_update_parent();
 	}
-	_update_parent();
 	update_gizmo();
 }
 
@@ -154,6 +202,8 @@ void CollisionPolygon::set_build_mode(BuildMode p_mode) {
 
 	ERR_FAIL_INDEX(p_mode,2);
 	build_mode=p_mode;
+	if (!can_update_body)
+		return;
 	_update_parent();
 }
 
@@ -170,6 +220,8 @@ AABB CollisionPolygon::get_item_rect() const {
 void CollisionPolygon::set_depth(float p_depth) {
 
 	depth=p_depth;
+	if (!can_update_body)
+		return;
 	_update_parent();
 	update_gizmo();
 }
@@ -183,22 +235,34 @@ float CollisionPolygon::get_depth() const {
 void CollisionPolygon::_bind_methods() {
 
 	ObjectTypeDB::bind_method(_MD("_add_to_collision_object"),&CollisionPolygon::_add_to_collision_object);
-	ObjectTypeDB::bind_method(_MD("set_polygon","polygon"),&CollisionPolygon::set_polygon);
-	ObjectTypeDB::bind_method(_MD("get_polygon"),&CollisionPolygon::get_polygon);
+
+	ObjectTypeDB::bind_method(_MD("set_build_mode"),&CollisionPolygon::set_build_mode);
+	ObjectTypeDB::bind_method(_MD("get_build_mode"),&CollisionPolygon::get_build_mode);
 
 	ObjectTypeDB::bind_method(_MD("set_depth","depth"),&CollisionPolygon::set_depth);
 	ObjectTypeDB::bind_method(_MD("get_depth"),&CollisionPolygon::get_depth);
 
-	ObjectTypeDB::bind_method(_MD("set_build_mode"),&CollisionPolygon::set_build_mode);
-	ObjectTypeDB::bind_method(_MD("get_build_mode"),&CollisionPolygon::get_build_mode);
+	ObjectTypeDB::bind_method(_MD("set_polygon","polygon"),&CollisionPolygon::set_polygon);
+	ObjectTypeDB::bind_method(_MD("get_polygon"),&CollisionPolygon::get_polygon);
+
+	ObjectTypeDB::bind_method(_MD("_set_shape_range","shape_range"),&CollisionPolygon::_set_shape_range);
+	ObjectTypeDB::bind_method(_MD("_get_shape_range"),&CollisionPolygon::_get_shape_range);
+
+	ObjectTypeDB::bind_method(_MD("get_collision_object_first_shape"),&CollisionPolygon::get_collision_object_first_shape);
+	ObjectTypeDB::bind_method(_MD("get_collision_object_last_shape"),&CollisionPolygon::get_collision_object_last_shape);
 
 	ADD_PROPERTY( PropertyInfo(Variant::INT,"build_mode",PROPERTY_HINT_ENUM,"Solids,Triangles"),_SCS("set_build_mode"),_SCS("get_build_mode"));
-	ADD_PROPERTY( PropertyInfo(Variant::VECTOR2_ARRAY,"polygon"),_SCS("set_polygon"),_SCS("get_polygon"));
 	ADD_PROPERTY( PropertyInfo(Variant::REAL,"depth"),_SCS("set_depth"),_SCS("get_depth"));
+	ADD_PROPERTY( PropertyInfo(Variant::VECTOR2_ARRAY,"polygon"),_SCS("set_polygon"),_SCS("get_polygon"));
+	ADD_PROPERTY( PropertyInfo(Variant::VECTOR2,"shape_range",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),_SCS("_set_shape_range"),_SCS("_get_shape_range"));
 }
 
 CollisionPolygon::CollisionPolygon() {
 
+	shape_from=-1;
+	shape_to=-1;
+	can_update_body=false;
+
 	aabb=AABB(Vector3(-1,-1,-1),Vector3(2,2,2));
 	build_mode=BUILD_SOLIDS;
 	depth=1.0;
diff --git a/scene/3d/collision_polygon.h b/scene/3d/collision_polygon.h
index efb3666778..9b9afea34f 100644
--- a/scene/3d/collision_polygon.h
+++ b/scene/3d/collision_polygon.h
@@ -24,9 +24,17 @@ protected:
 	BuildMode build_mode;
 	Vector<Point2> polygon;
 
+
 	void _add_to_collision_object(Object *p_obj);
 	void _update_parent();
 
+	bool can_update_body;
+	int shape_from;
+	int shape_to;
+
+	void _set_shape_range(const Vector2& p_range);
+	Vector2 _get_shape_range() const;
+
 protected:
 
 	void _notification(int p_what);
@@ -43,6 +51,10 @@ public:
 	Vector<Point2> get_polygon() const;
 
 	virtual AABB get_item_rect() const;
+
+	int get_collision_object_first_shape() const { return shape_from; }
+	int get_collision_object_last_shape() const { return shape_to; }
+
 	CollisionPolygon();
 };
 
diff --git a/scene/3d/navigation.cpp b/scene/3d/navigation.cpp
index 48820706dd..ce28350be0 100644
--- a/scene/3d/navigation.cpp
+++ b/scene/3d/navigation.cpp
@@ -85,9 +85,14 @@ void Navigation::_navmesh_link(int p_id) {
 			} else {
 
 				if (C->get().B!=NULL) {
-					print_line(String()+_get_vertex(ek.a)+" -> "+_get_vertex(ek.b));
+					ConnectionPending pending;
+					pending.polygon=&p;
+					pending.edge=j;
+					p.edges[j].P=C->get().pending.push_back(pending);
+					continue;
+					//print_line(String()+_get_vertex(ek.a)+" -> "+_get_vertex(ek.b));
 				}
-				ERR_CONTINUE(C->get().B!=NULL); //wut
+				//ERR_CONTINUE(C->get().B!=NULL); //wut
 
 				C->get().B=&p;
 				C->get().B_edge=j;
@@ -126,8 +131,13 @@ void Navigation::_navmesh_unlink(int p_id) {
 
 			EdgeKey ek(edges[i].point,edges[next].point);
 			Map<EdgeKey,Connection>::Element *C=connections.find(ek);
+
 			ERR_CONTINUE(!C);
-			if (C->get().B) {
+
+			if (edges[i].P) {
+				C->get().pending.erase(edges[i].P);
+				edges[i].P=NULL;
+			} else if (C->get().B) {
 				//disconnect
 
 				C->get().B->edges[C->get().B_edge].C=NULL;
@@ -143,6 +153,20 @@ void Navigation::_navmesh_unlink(int p_id) {
 				C->get().B=NULL;
 				C->get().B_edge=-1;
 
+				if (C->get().pending.size()) {
+					//reconnect if something is pending
+					ConnectionPending cp = C->get().pending.front()->get();
+					C->get().pending.pop_front();
+
+					C->get().B=cp.polygon;
+					C->get().B_edge=cp.edge;
+					C->get().A->edges[C->get().A_edge].C=cp.polygon;
+					C->get().A->edges[C->get().A_edge].C_edge=cp.edge;
+					cp.polygon->edges[cp.edge].C=C->get().A;
+					cp.polygon->edges[cp.edge].C_edge=C->get().A_edge;
+					cp.polygon->edges[cp.edge].P=NULL;
+				}
+
 			} else {
 				connections.erase(C);
 				//erase
@@ -271,12 +295,14 @@ Vector<Vector3> Navigation::get_simple_path(const Vector3& p_start, const Vector
 		}
 	}
 
+
 	if (!begin_poly || !end_poly) {
 
 		//print_line("No Path Path");
 		return Vector<Vector3>(); //no path
 	}
 
+
 	if (begin_poly==end_poly) {
 
 		Vector<Vector3> path;
diff --git a/scene/3d/navigation.h b/scene/3d/navigation.h
index 0f7f67571f..f8434aaf72 100644
--- a/scene/3d/navigation.h
+++ b/scene/3d/navigation.h
@@ -42,6 +42,13 @@ class Navigation : public Spatial {
 
 
 	struct NavMesh;
+	struct Polygon;
+
+	struct ConnectionPending {
+
+		Polygon *polygon;
+		int edge;
+	};
 
 
 	struct Polygon {
@@ -50,7 +57,8 @@ class Navigation : public Spatial {
 			Point point;
 			Polygon *C; //connection
 			int C_edge;
-			Edge() { C=NULL; C_edge=-1; }
+			List<ConnectionPending>::Element *P;
+			Edge() { C=NULL; C_edge=-1; P=NULL; }
 		};
 
 		Vector<Edge> edges;
@@ -72,6 +80,9 @@ class Navigation : public Spatial {
 		int A_edge;
 		Polygon *B;
 		int B_edge;
+
+		List<ConnectionPending> pending;
+
 		Connection() { A=NULL; B=NULL; A_edge=-1; B_edge=-1;}
 	};
 
diff --git a/scene/3d/navigation_mesh.cpp b/scene/3d/navigation_mesh.cpp
index 8c52d4c35c..a238a8ff22 100644
--- a/scene/3d/navigation_mesh.cpp
+++ b/scene/3d/navigation_mesh.cpp
@@ -1,6 +1,6 @@
 #include "navigation_mesh.h"
 #include "navigation.h"
-
+#include "mesh_instance.h"
 
 void NavigationMesh::create_from_mesh(const Ref<Mesh>& p_mesh) {
 
@@ -87,6 +87,97 @@ void NavigationMesh::clear_polygons(){
 	polygons.clear();
 }
 
+Ref<Mesh> NavigationMesh::get_debug_mesh() {
+
+	if (debug_mesh.is_valid())
+		return debug_mesh;
+
+
+
+	DVector<Vector3> vertices = get_vertices();
+	DVector<Vector3>::Read vr=vertices.read();
+	List<Face3> faces;
+	for(int i=0;i<get_polygon_count();i++) {
+		Vector<int> p = get_polygon(i);
+
+		for(int j=2;j<p.size();j++) {
+			Face3 f;
+			f.vertex[0]=vr[p[0]];
+			f.vertex[1]=vr[p[j-1]];
+			f.vertex[2]=vr[p[j]];
+
+			faces.push_back(f);
+		}
+	}
+
+
+	Map<_EdgeKey,bool> edge_map;
+	DVector<Vector3> tmeshfaces;
+	tmeshfaces.resize(faces.size()*3);
+
+	{
+		DVector<Vector3>::Write tw=tmeshfaces.write();
+		int tidx=0;
+
+
+		for(List<Face3>::Element *E=faces.front();E;E=E->next()) {
+
+			const Face3 &f = E->get();
+
+			for(int j=0;j<3;j++) {
+
+				tw[tidx++]=f.vertex[j];
+				_EdgeKey ek;
+				ek.from=f.vertex[j].snapped(CMP_EPSILON);
+				ek.to=f.vertex[(j+1)%3].snapped(CMP_EPSILON);
+				if (ek.from<ek.to)
+					SWAP(ek.from,ek.to);
+
+				Map<_EdgeKey,bool>::Element *E=edge_map.find(ek);
+
+				if (E) {
+
+					E->get()=false;
+
+				} else {
+
+					edge_map[ek]=true;
+				}
+
+			}
+		}
+	}
+	List<Vector3> lines;
+
+	for(Map<_EdgeKey,bool>::Element *E=edge_map.front();E;E=E->next()) {
+
+		if (E->get()) {
+			lines.push_back(E->key().from);
+			lines.push_back(E->key().to);
+		}
+	}
+
+	DVector<Vector3> varr;
+	varr.resize(lines.size());
+	{
+		DVector<Vector3>::Write w = varr.write();
+		int idx=0;
+		for(List<Vector3>::Element *E=lines.front();E;E=E->next()) {
+			w[idx++]=E->get();
+		}
+	}
+
+	debug_mesh = Ref<Mesh>( memnew( Mesh ) );
+
+	Array arr;
+	arr.resize(Mesh::ARRAY_MAX);
+	arr[Mesh::ARRAY_VERTEX]=varr;
+
+	debug_mesh->add_surface(Mesh::PRIMITIVE_LINES,arr);
+
+	return debug_mesh;
+}
+
 void NavigationMesh::_bind_methods() {
 
 	ObjectTypeDB::bind_method(_MD("set_vertices","vertices"),&NavigationMesh::set_vertices);
@@ -135,6 +226,16 @@ void NavigationMeshInstance::set_enabled(bool p_enabled) {
 
 	}
 
+	if (debug_view) {
+		MeshInstance *dm=debug_view->cast_to<MeshInstance>();
+		if (is_enabled()) {
+			dm->set_material_override( get_tree()->get_debug_navigation_material() );
+		} else {
+			dm->set_material_override( get_tree()->get_debug_navigation_disabled_material() );
+		}
+
+	}
+
 	update_gizmo();
 }
 
@@ -170,6 +271,19 @@ void NavigationMeshInstance::_notification(int p_what) {
 				c=c->get_parent_spatial();
 			}
 
+			if (navmesh.is_valid() && get_tree()->is_debugging_navigation_hint()) {
+
+				MeshInstance *dm = memnew( MeshInstance );
+				dm->set_mesh( navmesh->get_debug_mesh() );
+				if (is_enabled()) {
+					dm->set_material_override( get_tree()->get_debug_navigation_material() );
+				} else {
+					dm->set_material_override( get_tree()->get_debug_navigation_disabled_material() );
+				}
+				add_child(dm);
+				debug_view=dm;
+			}
+
 		} break;
 		case NOTIFICATION_TRANSFORM_CHANGED: {
 
@@ -177,6 +291,8 @@ void NavigationMeshInstance::_notification(int p_what) {
 				navigation->navmesh_set_transform(nav_id,get_relative_transform(navigation));
 			}
 
+
+
 		} break;
 		case NOTIFICATION_EXIT_TREE: {
 
@@ -187,6 +303,11 @@ void NavigationMeshInstance::_notification(int p_what) {
 					nav_id=-1;
 				}
 			}
+
+			if (debug_view) {
+				debug_view->queue_delete();
+				debug_view=NULL;
+			}
 			navigation=NULL;
 		} break;
 	}
@@ -230,6 +351,7 @@ void NavigationMeshInstance::_bind_methods() {
 
 NavigationMeshInstance::NavigationMeshInstance() {
 
+	debug_view=NULL;
 	navigation=NULL;
 	nav_id=-1;
 	enabled=true;
diff --git a/scene/3d/navigation_mesh.h b/scene/3d/navigation_mesh.h
index fccf405f9d..1e53b2127a 100644
--- a/scene/3d/navigation_mesh.h
+++ b/scene/3d/navigation_mesh.h
@@ -4,6 +4,7 @@
 #include "scene/3d/spatial.h"
 #include "scene/resources/mesh.h"
 
+class Mesh;
 
 class NavigationMesh : public Resource  {
 
@@ -14,6 +15,16 @@ class NavigationMesh : public Resource  {
 		Vector<int> indices;
 	};
 	Vector<Polygon> polygons;
+	Ref<Mesh> debug_mesh;
+
+	struct _EdgeKey {
+
+		Vector3 from;
+		Vector3 to;
+
+		bool operator<(const _EdgeKey& p_with) const { return from==p_with.from ? to < p_with.to : from < p_with.from; }
+	};
+
 
 protected:
 
@@ -21,6 +32,7 @@ protected:
 
 	void _set_polygons(const Array& p_array);
 	Array _get_polygons() const;
+
 public:
 
 	void create_from_mesh(const Ref<Mesh>& p_mesh);
@@ -33,6 +45,8 @@ public:
 	Vector<int> get_polygon(int p_idx);
 	void clear_polygons();
 
+	Ref<Mesh> get_debug_mesh();
+
 	NavigationMesh();
 };
 
@@ -47,6 +61,9 @@ class NavigationMeshInstance : public Spatial {
 	int nav_id;
 	Navigation *navigation;
 	Ref<NavigationMesh> navmesh;
+
+	Node *debug_view;
+
 protected:
 
 	void _notification(int p_what);
diff --git a/scene/3d/physics_body.cpp b/scene/3d/physics_body.cpp
index 3d5091f667..d61859a3d0 100644
--- a/scene/3d/physics_body.cpp
+++ b/scene/3d/physics_body.cpp
@@ -133,6 +133,8 @@ real_t StaticBody::get_bounce() const{
 	return bounce;
 }
 
+
+
 void StaticBody::set_constant_linear_velocity(const Vector3& p_vel) {
 
 	constant_linear_velocity=p_vel;
@@ -494,6 +496,42 @@ real_t RigidBody::get_bounce() const{
 	return bounce;
 }
 
+
+void RigidBody::set_gravity_scale(real_t p_gravity_scale){
+
+	gravity_scale=p_gravity_scale;
+	PhysicsServer::get_singleton()->body_set_param(get_rid(),PhysicsServer::BODY_PARAM_GRAVITY_SCALE,gravity_scale);
+
+}
+real_t RigidBody::get_gravity_scale() const{
+
+	return gravity_scale;
+}
+
+void RigidBody::set_linear_damp(real_t p_linear_damp){
+
+	ERR_FAIL_COND(p_linear_damp<-1);
+	linear_damp=p_linear_damp;
+	PhysicsServer::get_singleton()->body_set_param(get_rid(),PhysicsServer::BODY_PARAM_LINEAR_DAMP,linear_damp);
+
+}
+real_t RigidBody::get_linear_damp() const{
+
+	return linear_damp;
+}
+
+void RigidBody::set_angular_damp(real_t p_angular_damp){
+
+	ERR_FAIL_COND(p_angular_damp<-1);
+	angular_damp=p_angular_damp;
+	PhysicsServer::get_singleton()->body_set_param(get_rid(),PhysicsServer::BODY_PARAM_ANGULAR_DAMP,angular_damp);
+
+}
+real_t RigidBody::get_angular_damp() const{
+
+	return angular_damp;
+}
+
 void RigidBody::set_axis_velocity(const Vector3& p_axis) {
 
 	Vector3 v = state? state->get_linear_velocity() : linear_velocity;
@@ -685,6 +723,16 @@ void RigidBody::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("set_angular_velocity","angular_velocity"),&RigidBody::set_angular_velocity);
 	ObjectTypeDB::bind_method(_MD("get_angular_velocity"),&RigidBody::get_angular_velocity);
 
+	ObjectTypeDB::bind_method(_MD("set_gravity_scale","gravity_scale"),&RigidBody::set_gravity_scale);
+	ObjectTypeDB::bind_method(_MD("get_gravity_scale"),&RigidBody::get_gravity_scale);
+
+	ObjectTypeDB::bind_method(_MD("set_linear_damp","linear_damp"),&RigidBody::set_linear_damp);
+	ObjectTypeDB::bind_method(_MD("get_linear_damp"),&RigidBody::get_linear_damp);
+
+	ObjectTypeDB::bind_method(_MD("set_angular_damp","angular_damp"),&RigidBody::set_angular_damp);
+	ObjectTypeDB::bind_method(_MD("get_angular_damp"),&RigidBody::get_angular_damp);
+
+
 	ObjectTypeDB::bind_method(_MD("set_max_contacts_reported","amount"),&RigidBody::set_max_contacts_reported);
 	ObjectTypeDB::bind_method(_MD("get_max_contacts_reported"),&RigidBody::get_max_contacts_reported);
 
@@ -722,6 +770,7 @@ void RigidBody::_bind_methods() {
 	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::REAL,"gravity_scale",PROPERTY_HINT_RANGE,"-128,128,0.01"),_SCS("set_gravity_scale"),_SCS("get_gravity_scale"));
 	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"));
@@ -731,6 +780,8 @@ void RigidBody::_bind_methods() {
 	ADD_PROPERTY( PropertyInfo(Variant::INT,"axis_lock",PROPERTY_HINT_ENUM,"Disabled,Lock X,Lock Y,Lock Z"),_SCS("set_axis_lock"),_SCS("get_axis_lock"));
 	ADD_PROPERTY( PropertyInfo(Variant::VECTOR3,"velocity/linear"),_SCS("set_linear_velocity"),_SCS("get_linear_velocity"));
 	ADD_PROPERTY( PropertyInfo(Variant::VECTOR3,"velocity/angular"),_SCS("set_angular_velocity"),_SCS("get_angular_velocity"));
+	ADD_PROPERTY( PropertyInfo(Variant::REAL,"damp_override/linear",PROPERTY_HINT_RANGE,"-1,128,0.01"),_SCS("set_linear_damp"),_SCS("get_linear_damp"));
+	ADD_PROPERTY( PropertyInfo(Variant::REAL,"damp_override/angular",PROPERTY_HINT_RANGE,"-1,128,0.01"),_SCS("set_angular_damp"),_SCS("get_angular_damp"));
 
 	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")));
@@ -753,6 +804,10 @@ RigidBody::RigidBody() : PhysicsBody(PhysicsServer::BODY_MODE_RIGID) {
 	max_contacts_reported=0;
 	state=NULL;
 
+	gravity_scale=1;
+	linear_damp=-1;
+	angular_damp=-1;
+
 	//angular_velocity=0;
 	sleeping=false;
 	ccd=false;
diff --git a/scene/3d/physics_body.h b/scene/3d/physics_body.h
index 0ff3b360af..66490ba925 100644
--- a/scene/3d/physics_body.h
+++ b/scene/3d/physics_body.h
@@ -129,6 +129,10 @@ private:
 
 	Vector3 linear_velocity;
 	Vector3  angular_velocity;
+	real_t gravity_scale;
+	real_t linear_damp;
+	real_t angular_damp;
+
 	bool sleeping;
 	bool ccd;
 
@@ -217,6 +221,16 @@ public:
 	void set_angular_velocity(const Vector3&p_velocity);
 	Vector3  get_angular_velocity() const;
 
+	void set_gravity_scale(real_t p_gravity_scale);
+	real_t get_gravity_scale() const;
+
+	void set_linear_damp(real_t p_linear_damp);
+	real_t get_linear_damp() const;
+
+	void set_angular_damp(real_t p_angular_damp);
+	real_t get_angular_damp() const;
+
+
 	void set_use_custom_integrator(bool p_enable);
 	bool is_using_custom_integrator();
 
diff --git a/scene/3d/skeleton.cpp b/scene/3d/skeleton.cpp
index ee1b28a8ae..cb81228dff 100644
--- a/scene/3d/skeleton.cpp
+++ b/scene/3d/skeleton.cpp
@@ -41,8 +41,8 @@ bool Skeleton::_set(const StringName& p_path, const Variant& p_value) {
 	if (!path.begins_with("bones/"))
 		return false;
 		
-	int which=path.get_slice("/",1).to_int();
-	String what=path.get_slice("/",2);
+	int which=path.get_slicec('/',1).to_int();
+	String what=path.get_slicec('/',2);
 
 
 	if (which==bones.size() && what=="name") {
@@ -88,8 +88,8 @@ bool Skeleton::_get(const StringName& p_name,Variant &r_ret) const {
 	if (!path.begins_with("bones/"))
 		return false;
 		
-	int which=path.get_slice("/",1).to_int();
-	String what=path.get_slice("/",2);
+	int which=path.get_slicec('/',1).to_int();
+	String what=path.get_slicec('/',2);
 		
 	ERR_FAIL_INDEX_V( which, bones.size(), false );
 	
@@ -187,30 +187,59 @@ void Skeleton::_notification(int p_what) {
 			
 				Bone &b=bonesptr[i];
 		
-				if (b.enabled) {
+				if (b.disable_rest) {
+					if (b.enabled) {
 
-					Transform pose=b.pose;
-					if (b.custom_pose_enable) {
+						Transform pose=b.pose;
+						if (b.custom_pose_enable) {
 
-						pose = b.custom_pose * pose;
-					}
+							pose = b.custom_pose * pose;
+						}
+
+						if (b.parent>=0) {
+
+							b.pose_global=bonesptr[b.parent].pose_global * pose;
+						} else {
 
-					if (b.parent>=0) {
-					
-						b.pose_global=bonesptr[b.parent].pose_global * (b.rest * pose);
+							b.pose_global=pose;
+						}
 					} else {
-					
-						b.pose_global=b.rest * pose;
+
+						if (b.parent>=0) {
+
+							b.pose_global=bonesptr[b.parent].pose_global;
+						} else {
+
+							b.pose_global=Transform();
+						}
 					}
+
 				} else {
-				
-					if (b.parent>=0) {
-					
-						b.pose_global=bonesptr[b.parent].pose_global * b.rest;
+					if (b.enabled) {
+
+						Transform pose=b.pose;
+						if (b.custom_pose_enable) {
+
+							pose = b.custom_pose * pose;
+						}
+
+						if (b.parent>=0) {
+
+							b.pose_global=bonesptr[b.parent].pose_global * (b.rest * pose);
+						} else {
+
+							b.pose_global=b.rest * pose;
+						}
 					} else {
-					
-						b.pose_global=b.rest;				
-					}				
+
+						if (b.parent>=0) {
+
+							b.pose_global=bonesptr[b.parent].pose_global * b.rest;
+						} else {
+
+							b.pose_global=b.rest;
+						}
+					}
 				}
 				
 				vs->skeleton_bone_set_transform( skeleton, i,  b.pose_global * b.rest_global_inverse );
@@ -221,7 +250,7 @@ void Skeleton::_notification(int p_what) {
 					ERR_CONTINUE(!obj);
 					Spatial *sp = obj->cast_to<Spatial>();
 					ERR_CONTINUE(!sp);
-					sp->set_transform(b.pose_global * b.rest_global_inverse);
+					sp->set_transform(b.pose_global);
 				}
 			}
 
@@ -315,6 +344,37 @@ void Skeleton::set_bone_parent(int p_bone, int p_parent) {
 	_make_dirty();
 }
 
+void Skeleton::unparent_bone_and_rest(int p_bone) {
+
+	ERR_FAIL_INDEX( p_bone, bones.size() );
+
+	int parent=bones[p_bone].parent;
+	while(parent>=0) {
+		bones[p_bone].rest = bones[parent].rest * bones[p_bone].rest;
+		parent=bones[parent].parent;
+	}
+
+	bones[p_bone].parent=-1;
+	bones[p_bone].rest_global_inverse=bones[p_bone].rest.affine_inverse(); //same thing
+
+	_make_dirty();
+
+}
+
+void Skeleton::set_bone_disable_rest(int p_bone, bool p_disable) {
+
+	ERR_FAIL_INDEX( p_bone, bones.size() );
+	bones[p_bone].disable_rest=p_disable;
+
+}
+
+bool Skeleton::is_bone_rest_disabled(int p_bone) const {
+
+	ERR_FAIL_INDEX_V( p_bone, bones.size(), false );
+	return bones[p_bone].disable_rest;
+}
+
+
 int Skeleton::get_bone_parent(int p_bone) const {
 
 	ERR_FAIL_INDEX_V( p_bone, bones.size(), -1 );
@@ -522,9 +582,14 @@ void Skeleton::_bind_methods() {
 	
 	ObjectTypeDB::bind_method(_MD("get_bone_count"),&Skeleton::get_bone_count);
 
+	ObjectTypeDB::bind_method(_MD("unparent_bone_and_rest","bone_idx"),&Skeleton::unparent_bone_and_rest);
+
 	ObjectTypeDB::bind_method(_MD("get_bone_rest","bone_idx"),&Skeleton::get_bone_rest);
 	ObjectTypeDB::bind_method(_MD("set_bone_rest","bone_idx","rest"),&Skeleton::set_bone_rest);
 
+	ObjectTypeDB::bind_method(_MD("set_bone_disable_rest","bone_idx","disable"),&Skeleton::set_bone_disable_rest);
+	ObjectTypeDB::bind_method(_MD("is_bone_rest_disabled","bone_idx"),&Skeleton::is_bone_rest_disabled);
+
 	ObjectTypeDB::bind_method(_MD("bind_child_node_to_bone","bone_idx","node:Node"),&Skeleton::bind_child_node_to_bone);
 	ObjectTypeDB::bind_method(_MD("unbind_child_node_from_bone","bone_idx","node:Node"),&Skeleton::unbind_child_node_from_bone);
 	ObjectTypeDB::bind_method(_MD("get_bound_child_nodes_to_bone","bone_idx"),&Skeleton::_get_bound_child_nodes_to_bone);
diff --git a/scene/3d/skeleton.h b/scene/3d/skeleton.h
index b7f84f44c9..6678722d12 100644
--- a/scene/3d/skeleton.h
+++ b/scene/3d/skeleton.h
@@ -46,6 +46,7 @@ class Skeleton : public Spatial {
 		bool enabled;
 		int parent;
 
+		bool disable_rest;
 		Transform rest;
 		Transform rest_global_inverse;
 		 
@@ -57,7 +58,7 @@ class Skeleton : public Spatial {
 		
 		List<uint32_t> nodes_bound;
 		
-		Bone() { parent=-1; enabled=true; custom_pose_enable=false; }
+		Bone() { parent=-1; enabled=true; custom_pose_enable=false; disable_rest=false; }
 	};
 
 	bool rest_global_inverse_dirty;
@@ -111,6 +112,11 @@ public:
 	void set_bone_parent(int p_bone, int p_parent);
 	int get_bone_parent(int p_bone) const;
 
+	void unparent_bone_and_rest(int p_idx);
+
+	void set_bone_disable_rest(int p_bone, bool p_disable);
+	bool is_bone_rest_disabled(int p_bone) const;
+
 	int get_bone_count() const;
 	
 	void set_bone_rest(int p_bone, const Transform& p_rest);
diff --git a/scene/3d/spatial.cpp b/scene/3d/spatial.cpp
index 9c69520a85..a65f68ed2c 100644
--- a/scene/3d/spatial.cpp
+++ b/scene/3d/spatial.cpp
@@ -231,6 +231,11 @@ void Spatial::set_transform(const Transform& p_transform) {
 	_change_notify("transform/rotation");
 	_change_notify("transform/scale");
 	_propagate_transform_changed(this);
+	if (data.notify_local_transform) {
+		notification(NOTIFICATION_LOCAL_TRANSFORM_CHANGED);
+	}
+
+
 
 }
 
@@ -335,6 +340,9 @@ void Spatial::set_translation(const Vector3& p_translation) {
 
 	data.local_transform.origin=p_translation;
 	_propagate_transform_changed(this);
+	if (data.notify_local_transform) {
+		notification(NOTIFICATION_LOCAL_TRANSFORM_CHANGED);
+	}
 
 }
 
@@ -348,6 +356,9 @@ void Spatial::set_rotation(const Vector3& p_euler){
 	data.rotation=p_euler;
 	data.dirty|=DIRTY_LOCAL;
 	_propagate_transform_changed(this);
+	if (data.notify_local_transform) {
+		notification(NOTIFICATION_LOCAL_TRANSFORM_CHANGED);
+	}
 
 }
 void Spatial::set_scale(const Vector3& p_scale){
@@ -360,6 +371,9 @@ void Spatial::set_scale(const Vector3& p_scale){
 	data.scale=p_scale;
 	data.dirty|=DIRTY_LOCAL;
 	_propagate_transform_changed(this);
+	if (data.notify_local_transform) {
+		notification(NOTIFICATION_LOCAL_TRANSFORM_CHANGED);
+	}
 
 }
 
@@ -626,10 +640,11 @@ void Spatial::rotate_z(float p_radians){
 void Spatial::translate(const Vector3& p_offset){
 
 	Transform t =get_transform();
-	t.origin+=p_offset;
+	t.translate(p_offset);
 	set_transform(t);
 
 }
+
 void Spatial::scale(const Vector3& p_ratio){
 
 	Transform t =get_transform();
@@ -684,6 +699,13 @@ void Spatial::look_at_from_pos(const Vector3& p_pos,const Vector3& p_target, con
 
 }
 
+void Spatial::set_notify_local_transform(bool p_enable) {
+	data.notify_local_transform=p_enable;
+}
+
+bool Spatial::is_local_transform_notification_enabled() const {
+	return data.notify_local_transform;
+}
 
 void Spatial::_bind_methods() {
 
@@ -724,6 +746,9 @@ void Spatial::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("_set_visible_"), &Spatial::_set_visible_);
 	ObjectTypeDB::bind_method(_MD("_is_visible_"), &Spatial::_is_visible_);
 
+	ObjectTypeDB::bind_method(_MD("set_notify_local_transform","enable"), &Spatial::set_notify_local_transform);
+	ObjectTypeDB::bind_method(_MD("is_local_transform_notification_enabled"), &Spatial::is_local_transform_notification_enabled);
+
 	void rotate(const Vector3& p_normal,float p_radians);
 	void rotate_x(float p_radians);
 	void rotate_y(float p_radians);
@@ -757,7 +782,7 @@ void Spatial::_bind_methods() {
 	ADD_PROPERTY( PropertyInfo(Variant::VECTOR3,"transform/rotation",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_EDITOR), _SCS("_set_rotation_deg"), _SCS("_get_rotation_deg") );
 	ADD_PROPERTY( PropertyInfo(Variant::VECTOR3,"transform/rotation_rad",PROPERTY_HINT_NONE,"",0), _SCS("set_rotation"), _SCS("get_rotation") );
 	ADD_PROPERTY( PropertyInfo(Variant::VECTOR3,"transform/scale",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_EDITOR), _SCS("set_scale"), _SCS("get_scale") );
-	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"visibility/visible"), _SCS("_set_visible_"), _SCS("_is_visible_") );
+	ADD_PROPERTYNO( PropertyInfo(Variant::BOOL,"visibility/visible"), _SCS("_set_visible_"), _SCS("_is_visible_") );
 	//ADD_PROPERTY( PropertyInfo(Variant::TRANSFORM,"transform/local"), _SCS("set_transform"), _SCS("get_transform") );
 
 	ADD_SIGNAL( MethodInfo("visibility_changed" ) );
@@ -782,6 +807,7 @@ Spatial::Spatial() : xform_change(this)
 	data.gizmo_disabled=false;
 	data.gizmo_dirty=false;
 #endif
+	data.notify_local_transform=false;
 	data.parent=NULL;
 	data.C=NULL;
 
diff --git a/scene/3d/spatial.h b/scene/3d/spatial.h
index 8b40786fb8..7fa6099d7a 100644
--- a/scene/3d/spatial.h
+++ b/scene/3d/spatial.h
@@ -91,6 +91,7 @@ class Spatial : public Node {
 		List<Spatial*>::Element *C;
 		
 		bool ignore_notification;
+		bool notify_local_transform;
 
 		bool visible;
 
@@ -134,6 +135,7 @@ public:
 		NOTIFICATION_ENTER_WORLD=41,
 		NOTIFICATION_EXIT_WORLD=42,
 		NOTIFICATION_VISIBILITY_CHANGED=43,
+		NOTIFICATION_LOCAL_TRANSFORM_CHANGED=44,
 	};
 
 	Spatial *get_parent_spatial() const;
@@ -179,6 +181,9 @@ public:
 	void look_at(const Vector3& p_target, const Vector3& p_up_normal);
 	void look_at_from_pos(const Vector3& p_pos,const Vector3& p_target, const Vector3& p_up_normal);
 
+	void set_notify_local_transform(bool p_enable);
+	bool is_local_transform_notification_enabled() const;
+
 	void orthonormalize();
 	void set_identity();
 
diff --git a/scene/3d/spatial_stream_player.cpp b/scene/3d/spatial_stream_player.cpp
index 84e68bf418..7ed2335fcb 100644
--- a/scene/3d/spatial_stream_player.cpp
+++ b/scene/3d/spatial_stream_player.cpp
@@ -30,21 +30,79 @@
 
 
 
-void SpatialStreamPlayer::_notification(int p_what) {
+int SpatialStreamPlayer::InternalStream::get_channel_count() const {
 
-	switch(p_what) {
+	return player->sp_get_channel_count();
+}
+void SpatialStreamPlayer::InternalStream::set_mix_rate(int p_rate){
 
-		case NOTIFICATION_ENTER_WORLD: {
+	return player->sp_set_mix_rate(p_rate);
+}
+bool SpatialStreamPlayer::InternalStream::mix(int32_t *p_buffer,int p_frames){
+
+	return player->sp_mix(p_buffer,p_frames);
+}
+void SpatialStreamPlayer::InternalStream::update(){
+
+	player->sp_update();
+}
+
+
+int SpatialStreamPlayer::sp_get_channel_count() const {
+
+	return playback->get_channels();
+}
+
+void SpatialStreamPlayer::sp_set_mix_rate(int p_rate){
+
+	server_mix_rate=p_rate;
+}
+
+bool SpatialStreamPlayer::sp_mix(int32_t *p_buffer,int p_frames) {
+
+	if (resampler.is_ready()) {
+		return resampler.mix(p_buffer,p_frames);
+	}
+
+	return false;
+}
+
+void SpatialStreamPlayer::sp_update() {
+
+	_THREAD_SAFE_METHOD_
+	if (!paused && resampler.is_ready() && playback.is_valid()) {
+
+		if (!playback->is_playing()) {
+			//stream depleted data, but there's still audio in the ringbuffer
+			//check that all this audio has been flushed before stopping the stream
+			int to_mix = resampler.get_total() - resampler.get_todo();
+			if (to_mix==0) {
+				stop();
+				return;
+			}
+
+			return;
+		}
+
+		int todo =resampler.get_todo();
+		int wrote = playback->mix(resampler.get_write_buffer(),todo);
+		resampler.write(wrote);
+	}
+}
 
-//			set_idle_process(false); //don't annoy
-		} break;
-		case NOTIFICATION_PROCESS: {
 
-//			if (!stream.is_null())
-//				stream->update();
 
+void SpatialStreamPlayer::_notification(int p_what) {
+
+	switch(p_what) {
+
+		case NOTIFICATION_ENTER_TREE: {
+
+			//set_idle_process(false); //don't annoy
+			if (stream.is_valid() && autoplay && !get_tree()->is_editor_hint())
+				play();
 		} break;
-		case NOTIFICATION_EXIT_WORLD: {
+		case NOTIFICATION_EXIT_TREE: {
 
 			stop(); //wathever it may be doing, stop
 		} break;
@@ -58,12 +116,20 @@ void SpatialStreamPlayer::set_stream(const Ref<AudioStream> &p_stream) {
 	stop();
 
 	stream=p_stream;
-	if (!stream.is_null()) {
 
-		stream->set_loop(loops);
+	if (!stream.is_null()) {
+		playback=stream->instance_playback();
+		playback->set_loop(loops);
+		playback->set_loop_restart_time(loop_point);
+		AudioServer::get_singleton()->lock();
+		resampler.setup(playback->get_channels(),playback->get_mix_rate(),server_mix_rate,buffering_ms,playback->get_minimum_buffer_size());
+		AudioServer::get_singleton()->unlock();
+	} else {
+		AudioServer::get_singleton()->lock();
+		resampler.clear();
+		playback.unref();
+		AudioServer::get_singleton()->unlock();
 	}
-
-
 }
 
 Ref<AudioStream> SpatialStreamPlayer::get_stream() const {
@@ -72,18 +138,25 @@ Ref<AudioStream> SpatialStreamPlayer::get_stream() const {
 }
 
 
-void SpatialStreamPlayer::play() {
+void SpatialStreamPlayer::play(float p_from_offset) {
 
-	if (!is_inside_tree())
+	ERR_FAIL_COND(!is_inside_tree());
+	if (playback.is_null())
 		return;
-	if (stream.is_null())
-		return;
-	if (stream->is_playing())
+	if (playback->is_playing())
 		stop();
-	stream->play();
-	SpatialSoundServer::get_singleton()->source_set_audio_stream(get_source_rid(),stream->get_audio_stream());
-	//if (stream->get_update_mode()!=AudioStream::UPDATE_NONE)
-	//	set_idle_process(true);
+
+	_THREAD_SAFE_METHOD_
+	playback->play(p_from_offset);
+	//feed the ringbuffer as long as no update callback is going on
+	sp_update();
+
+	SpatialSoundServer::get_singleton()->source_set_audio_stream(get_source_rid(),&internal_stream);
+
+//	AudioServer::get_singleton()->stream_set_active(stream_rid,true);
+//	AudioServer::get_singleton()->stream_set_volume_scale(stream_rid,volume);
+//	if (stream->get_update_mode()!=AudioStream::UPDATE_NONE)
+//		set_idle_process(true);
 
 }
 
@@ -91,28 +164,31 @@ void SpatialStreamPlayer::stop() {
 
 	if (!is_inside_tree())
 		return;
-	if (stream.is_null())
+	if (playback.is_null())
 		return;
 
+	_THREAD_SAFE_METHOD_
+	//AudioServer::get_singleton()->stream_set_active(stream_rid,false);
 	SpatialSoundServer::get_singleton()->source_set_audio_stream(get_source_rid(),NULL);
-	stream->stop();
+	playback->stop();
+	resampler.flush();
 	//set_idle_process(false);
 }
 
 bool SpatialStreamPlayer::is_playing() const {
 
-	if (stream.is_null())
+	if (playback.is_null())
 		return false;
 
-	return stream->is_playing();
+	return playback->is_playing();
 }
 
 void SpatialStreamPlayer::set_loop(bool p_enable) {
 
 	loops=p_enable;
-	if (stream.is_null())
+	if (playback.is_null())
 		return;
-	stream->set_loop(loops);
+	playback->set_loop(loops);
 
 }
 bool SpatialStreamPlayer::has_loop() const {
@@ -120,6 +196,46 @@ bool SpatialStreamPlayer::has_loop() const {
 	return loops;
 }
 
+void SpatialStreamPlayer::set_volume(float p_vol) {
+
+	volume=p_vol;
+	if (stream_rid.is_valid())
+		AudioServer::get_singleton()->stream_set_volume_scale(stream_rid,volume);
+}
+
+float SpatialStreamPlayer::get_volume() const {
+
+	return volume;
+}
+
+void SpatialStreamPlayer::set_loop_restart_time(float p_secs) {
+
+	loop_point=p_secs;
+	if (playback.is_valid())
+		playback->set_loop_restart_time(p_secs);
+}
+
+float SpatialStreamPlayer::get_loop_restart_time() const {
+
+	return loop_point;
+}
+
+
+void SpatialStreamPlayer::set_volume_db(float p_db) {
+
+	if (p_db<-79)
+		set_volume(0);
+	else
+		set_volume(Math::db2linear(p_db));
+}
+
+float SpatialStreamPlayer::get_volume_db() const {
+
+	if (volume==0)
+		return -80;
+	else
+		return Math::linear2db(volume);
+}
 
 
 String SpatialStreamPlayer::get_stream_name() const  {
@@ -132,59 +248,156 @@ String SpatialStreamPlayer::get_stream_name() const  {
 
 int SpatialStreamPlayer::get_loop_count() const  {
 
-	if (stream.is_null())
+	if (playback.is_null())
 		return 0;
-	return stream->get_loop_count();
+	return playback->get_loop_count();
 
 }
 
 float SpatialStreamPlayer::get_pos() const  {
 
-	if (stream.is_null())
+	if (playback.is_null())
 		return 0;
-	return stream->get_pos();
+	return playback->get_pos();
+
+}
+
+float SpatialStreamPlayer::get_length() const {
 
+	if (playback.is_null())
+		return 0;
+	return playback->get_length();
 }
 void SpatialStreamPlayer::seek_pos(float p_time) {
 
-	if (stream.is_null())
+	if (playback.is_null())
 		return;
-	return stream->seek_pos(p_time);
+	return playback->seek_pos(p_time);
+
+}
+
+void SpatialStreamPlayer::set_autoplay(bool p_enable) {
+
+	autoplay=p_enable;
+}
+
+bool SpatialStreamPlayer::has_autoplay() const {
+
+	return autoplay;
+}
+
+void SpatialStreamPlayer::set_paused(bool p_paused) {
+
+	paused=p_paused;
+	//if (stream.is_valid())
+	//	stream->set_paused(p_paused);
+}
+
+bool SpatialStreamPlayer::is_paused() const {
 
+	return paused;
 }
 
+void SpatialStreamPlayer::_set_play(bool p_play) {
+
+	_play=p_play;
+	if (is_inside_tree()) {
+		if(_play)
+			play();
+		else
+			stop();
+	}
+
+}
+
+bool SpatialStreamPlayer::_get_play() const{
+
+	return _play;
+}
+
+void SpatialStreamPlayer::set_buffering_msec(int p_msec) {
+
+	buffering_ms=p_msec;
+}
+
+int SpatialStreamPlayer::get_buffering_msec() const{
+
+	return buffering_ms;
+}
+
+
+
 void SpatialStreamPlayer::_bind_methods() {
 
 	ObjectTypeDB::bind_method(_MD("set_stream","stream:Stream"),&SpatialStreamPlayer::set_stream);
 	ObjectTypeDB::bind_method(_MD("get_stream:Stream"),&SpatialStreamPlayer::get_stream);
 
-	ObjectTypeDB::bind_method(_MD("play"),&SpatialStreamPlayer::play);
+	ObjectTypeDB::bind_method(_MD("play"),&SpatialStreamPlayer::play,DEFVAL(0));
 	ObjectTypeDB::bind_method(_MD("stop"),&SpatialStreamPlayer::stop);
 
 	ObjectTypeDB::bind_method(_MD("is_playing"),&SpatialStreamPlayer::is_playing);
 
+	ObjectTypeDB::bind_method(_MD("set_paused","paused"),&SpatialStreamPlayer::set_paused);
+	ObjectTypeDB::bind_method(_MD("is_paused"),&SpatialStreamPlayer::is_paused);
+
 	ObjectTypeDB::bind_method(_MD("set_loop","enabled"),&SpatialStreamPlayer::set_loop);
 	ObjectTypeDB::bind_method(_MD("has_loop"),&SpatialStreamPlayer::has_loop);
 
+	ObjectTypeDB::bind_method(_MD("set_volume","volume"),&SpatialStreamPlayer::set_volume);
+	ObjectTypeDB::bind_method(_MD("get_volume"),&SpatialStreamPlayer::get_volume);
+
+	ObjectTypeDB::bind_method(_MD("set_volume_db","db"),&SpatialStreamPlayer::set_volume_db);
+	ObjectTypeDB::bind_method(_MD("get_volume_db"),&SpatialStreamPlayer::get_volume_db);
+
+	ObjectTypeDB::bind_method(_MD("set_buffering_msec","msec"),&SpatialStreamPlayer::set_buffering_msec);
+	ObjectTypeDB::bind_method(_MD("get_buffering_msec"),&SpatialStreamPlayer::get_buffering_msec);
+
+	ObjectTypeDB::bind_method(_MD("set_loop_restart_time","secs"),&SpatialStreamPlayer::set_loop_restart_time);
+	ObjectTypeDB::bind_method(_MD("get_loop_restart_time"),&SpatialStreamPlayer::get_loop_restart_time);
+
 	ObjectTypeDB::bind_method(_MD("get_stream_name"),&SpatialStreamPlayer::get_stream_name);
 	ObjectTypeDB::bind_method(_MD("get_loop_count"),&SpatialStreamPlayer::get_loop_count);
 
 	ObjectTypeDB::bind_method(_MD("get_pos"),&SpatialStreamPlayer::get_pos);
 	ObjectTypeDB::bind_method(_MD("seek_pos","time"),&SpatialStreamPlayer::seek_pos);
 
-	ADD_PROPERTY( PropertyInfo(Variant::OBJECT, "stream/stream", PROPERTY_HINT_RESOURCE_TYPE,"AudioStream"), _SCS("set_stream"),_SCS("get_stream") );
-	ADD_PROPERTY( PropertyInfo(Variant::BOOL, "stream/loop"), _SCS("set_loop"),_SCS("has_loop") );
+	ObjectTypeDB::bind_method(_MD("set_autoplay","enabled"),&SpatialStreamPlayer::set_autoplay);
+	ObjectTypeDB::bind_method(_MD("has_autoplay"),&SpatialStreamPlayer::has_autoplay);
 
+	ObjectTypeDB::bind_method(_MD("get_length"),&SpatialStreamPlayer::get_length);
+
+	ObjectTypeDB::bind_method(_MD("_set_play","play"),&SpatialStreamPlayer::_set_play);
+	ObjectTypeDB::bind_method(_MD("_get_play"),&SpatialStreamPlayer::_get_play);
+
+	ADD_PROPERTY( PropertyInfo(Variant::OBJECT, "stream/stream", PROPERTY_HINT_RESOURCE_TYPE,"AudioStream"), _SCS("set_stream"), _SCS("get_stream") );
+	ADD_PROPERTY( PropertyInfo(Variant::BOOL, "stream/play"), _SCS("_set_play"), _SCS("_get_play") );
+	ADD_PROPERTY( PropertyInfo(Variant::BOOL, "stream/loop"), _SCS("set_loop"), _SCS("has_loop") );
+	ADD_PROPERTY( PropertyInfo(Variant::REAL, "stream/volume_db", PROPERTY_HINT_RANGE,"-80,24,0.01"), _SCS("set_volume_db"), _SCS("get_volume_db") );
+	ADD_PROPERTY( PropertyInfo(Variant::BOOL, "stream/autoplay"), _SCS("set_autoplay"), _SCS("has_autoplay") );
+	ADD_PROPERTY( PropertyInfo(Variant::BOOL, "stream/paused"), _SCS("set_paused"), _SCS("is_paused") );
+	ADD_PROPERTY( PropertyInfo(Variant::INT, "stream/loop_restart_time"), _SCS("set_loop_restart_time"), _SCS("get_loop_restart_time") );
+	ADD_PROPERTY( PropertyInfo(Variant::INT, "stream/buffering_ms"), _SCS("set_buffering_msec"), _SCS("get_buffering_msec") );
 }
 
 
 SpatialStreamPlayer::SpatialStreamPlayer() {
 
+	volume=1;
 	loops=false;
+	paused=false;
+	autoplay=false;
+	_play=false;
+	server_mix_rate=1;
+	internal_stream.player=this;
+	stream_rid=AudioServer::get_singleton()->audio_stream_create(&internal_stream);
+	buffering_ms=500;
+	loop_point=0;
+
 }
 
 SpatialStreamPlayer::~SpatialStreamPlayer() {
-
-}
+	AudioServer::get_singleton()->free(stream_rid);
+	resampler.clear();
 
 
+}
diff --git a/scene/3d/spatial_stream_player.h b/scene/3d/spatial_stream_player.h
index 7e639a7232..f2775a4982 100644
--- a/scene/3d/spatial_stream_player.h
+++ b/scene/3d/spatial_stream_player.h
@@ -31,16 +31,48 @@
 
 #include "scene/resources/audio_stream.h"
 #include "scene/3d/spatial_player.h"
-
+#include "servers/audio/audio_rb_resampler.h"
 
 class SpatialStreamPlayer : public SpatialPlayer {
 
 	OBJ_TYPE(SpatialStreamPlayer,SpatialPlayer);
 
+	_THREAD_SAFE_CLASS_
+
+	struct InternalStream : public AudioServer::AudioStream {
+		SpatialStreamPlayer *player;
+		virtual int get_channel_count() const;
+		virtual void set_mix_rate(int p_rate); //notify the stream of the mix rate
+		virtual bool mix(int32_t *p_buffer,int p_frames);
+		virtual void update();
+	};
+
+
+	InternalStream internal_stream;
+	Ref<AudioStreamPlayback> playback;
 	Ref<AudioStream> stream;
+
+	int sp_get_channel_count() const;
+	void sp_set_mix_rate(int p_rate); //notify the stream of the mix rate
+	bool sp_mix(int32_t *p_buffer,int p_frames);
+	void sp_update();
+
+	int server_mix_rate;
+
+	RID stream_rid;
+	bool paused;
+	bool autoplay;
 	bool loops;
-protected:
+	float volume;
+	float loop_point;
+	int buffering_ms;
 
+	AudioRBResampler resampler;
+
+	bool _play;
+	void _set_play(bool p_play);
+	bool _get_play() const;
+protected:
 	void _notification(int p_what);
 
 	static void _bind_methods();
@@ -49,21 +81,37 @@ public:
 	void set_stream(const Ref<AudioStream> &p_stream);
 	Ref<AudioStream> get_stream() const;
 
-	void play();
+	void play(float p_from_offset=0);
 	void stop();
 	bool is_playing() const;
 
+	void set_paused(bool p_paused);
+	bool is_paused() const;
+
 	void set_loop(bool p_enable);
 	bool has_loop() const;
 
+	void set_volume(float p_vol);
+	float get_volume() const;
+
+	void set_loop_restart_time(float p_secs);
+	float get_loop_restart_time() const;
+
+	void set_volume_db(float p_db);
+	float get_volume_db() const;
 
 	String get_stream_name() const;
-	int get_loop_count() const;
 
+	int get_loop_count() const;
 
 	float get_pos() const;
 	void seek_pos(float p_time);
+	float get_length() const;
+	void set_autoplay(bool p_vol);
+	bool has_autoplay() const;
 
+	void set_buffering_msec(int p_msec);
+	int get_buffering_msec() const;
 
 	SpatialStreamPlayer();
 	~SpatialStreamPlayer();
diff --git a/scene/3d/sprite_3d.cpp b/scene/3d/sprite_3d.cpp
index 4952f742df..c7d1249a07 100644
--- a/scene/3d/sprite_3d.cpp
+++ b/scene/3d/sprite_3d.cpp
@@ -578,9 +578,9 @@ void Sprite3D::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("get_hframes"),&Sprite3D::get_hframes);
 
 	ADD_PROPERTY( PropertyInfo( Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE,"Texture"), _SCS("set_texture"),_SCS("get_texture"));
-	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::INT, "vframes",PROPERTY_HINT_RANGE,"1,16384,1"), _SCS("set_vframes"),_SCS("get_vframes"));
+	ADD_PROPERTY( PropertyInfo( Variant::INT, "hframes",PROPERTY_HINT_RANGE,"1,16384,1"), _SCS("set_hframes"),_SCS("get_hframes"));
+	ADD_PROPERTY( PropertyInfo( Variant::INT, "frame",PROPERTY_HINT_SPRITE_FRAME), _SCS("set_frame"),_SCS("get_frame"));
 	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"));
 
@@ -727,7 +727,7 @@ void AnimatedSprite3D::_bind_methods(){
 	ObjectTypeDB::bind_method(_MD("get_frame"),&AnimatedSprite3D::get_frame);
 
 	ADD_PROPERTY( PropertyInfo( Variant::OBJECT, "frames", PROPERTY_HINT_RESOURCE_TYPE,"SpriteFrames"), _SCS("set_sprite_frames"),_SCS("get_sprite_frames"));
-	ADD_PROPERTY( PropertyInfo( Variant::INT, "frame"), _SCS("set_frame"),_SCS("get_frame"));
+	ADD_PROPERTY( PropertyInfo( Variant::INT, "frame",PROPERTY_HINT_SPRITE_FRAME), _SCS("set_frame"),_SCS("get_frame"));
 
 	ADD_SIGNAL(MethodInfo("frame_changed"));