-Much improvement to baked light baker

-Fixed many bugs in stretch mode
-Fixes to camera project and unproject as consequence of the above
-added setget to script (documented in script doc)
-more fixes to collada exporter for blender

15 files changed, 322 insertions, 13 deletions

diff --git a/scene/3d/baked_light_instance.cpp b/scene/3d/baked_light_instance.cpp
index c1cc1f6b68..b55093a779 100644
--- a/scene/3d/baked_light_instance.cpp
+++ b/scene/3d/baked_light_instance.cpp
@@ -63,3 +63,81 @@ BakedLightInstance::BakedLightInstance() {
 
 
 }
+/////////////////////////
+
+
+void BakedLightSampler::set_param(Param p_param,float p_value) {
+	ERR_FAIL_INDEX(p_param,PARAM_MAX);
+	params[p_param]=p_value;
+	VS::get_singleton()->baked_light_sampler_set_param(base,VS::BakedLightSamplerParam(p_param),p_value);
+}
+
+float BakedLightSampler::get_param(Param p_param) const{
+
+	ERR_FAIL_INDEX_V(p_param,PARAM_MAX,0);
+	return params[p_param];
+
+}
+
+void BakedLightSampler::set_resolution(int p_resolution){
+
+	ERR_FAIL_COND(p_resolution<4 && p_resolution>32);
+	resolution=p_resolution;
+	VS::get_singleton()->baked_light_sampler_set_resolution(base,resolution);
+}
+int BakedLightSampler::get_resolution() const {
+
+	return resolution;
+}
+
+AABB BakedLightSampler::get_aabb() const {
+
+	float r = get_param(PARAM_RADIUS);
+	return AABB( Vector3(-r,-r,-r),Vector3(r*2,r*2,r*2));
+}
+DVector<Face3> BakedLightSampler::get_faces(uint32_t p_usage_flags) const {
+	return DVector<Face3>();
+}
+
+void BakedLightSampler::_bind_methods() {
+
+	ObjectTypeDB::bind_method(_MD("set_param","param","value"),&BakedLightSampler::set_param);
+	ObjectTypeDB::bind_method(_MD("get_param","param"),&BakedLightSampler::get_param);
+
+	ObjectTypeDB::bind_method(_MD("set_resolution","resolution"),&BakedLightSampler::set_resolution);
+	ObjectTypeDB::bind_method(_MD("get_resolution"),&BakedLightSampler::get_resolution);
+
+
+	BIND_CONSTANT( PARAM_RADIUS );
+	BIND_CONSTANT( PARAM_STRENGTH );
+	BIND_CONSTANT( PARAM_ATTENUATION );
+	BIND_CONSTANT( PARAM_DETAIL_RATIO );
+	BIND_CONSTANT( PARAM_MAX );
+
+	ADD_PROPERTYI( PropertyInfo(Variant::REAL,"params/radius",PROPERTY_HINT_RANGE,"0.01,1024,0.01"),_SCS("set_param"),_SCS("get_param"),PARAM_RADIUS);
+	ADD_PROPERTYI( PropertyInfo(Variant::REAL,"params/strength",PROPERTY_HINT_RANGE,"0.01,16,0.01"),_SCS("set_param"),_SCS("get_param"),PARAM_STRENGTH);
+	ADD_PROPERTYI( PropertyInfo(Variant::REAL,"params/attenuation",PROPERTY_HINT_EXP_EASING),_SCS("set_param"),_SCS("get_param"),PARAM_ATTENUATION);
+	ADD_PROPERTYI( PropertyInfo(Variant::REAL,"params/detail_ratio",PROPERTY_HINT_RANGE,"0.01,1.0,0.01"),_SCS("set_param"),_SCS("get_param"),PARAM_DETAIL_RATIO);
+//	ADD_PROPERTYI( PropertyInfo(Variant::REAL,"params/detail_ratio",PROPERTY_HINT_RANGE,"0,20,1"),_SCS("set_param"),_SCS("get_param"),PARAM_DETAIL_RATIO);
+	ADD_PROPERTY( PropertyInfo(Variant::REAL,"params/resolution",PROPERTY_HINT_RANGE,"4,32,1"),_SCS("set_resolution"),_SCS("get_resolution"));
+
+}
+
+BakedLightSampler::BakedLightSampler() {
+
+	base = VS::get_singleton()->baked_light_sampler_create();
+	set_base(base);
+
+	params[PARAM_RADIUS]=1.0;
+	params[PARAM_STRENGTH]=1.0;
+	params[PARAM_ATTENUATION]=1.0;
+	params[PARAM_DETAIL_RATIO]=0.1;
+	resolution=16;
+
+
+}
+
+BakedLightSampler::~BakedLightSampler(){
+
+	VS::get_singleton()->free(base);
+}
diff --git a/scene/3d/baked_light_instance.h b/scene/3d/baked_light_instance.h
index b904ced9a7..0694c813ce 100644
--- a/scene/3d/baked_light_instance.h
+++ b/scene/3d/baked_light_instance.h
@@ -30,4 +30,46 @@ public:
 	BakedLightInstance();
 };
 
+
+
+class BakedLightSampler : public VisualInstance {
+	OBJ_TYPE(BakedLightSampler,VisualInstance);
+
+
+public:
+
+	enum Param {
+		PARAM_RADIUS=VS::BAKED_LIGHT_SAMPLER_RADIUS,
+		PARAM_STRENGTH=VS::BAKED_LIGHT_SAMPLER_STRENGTH,
+		PARAM_ATTENUATION=VS::BAKED_LIGHT_SAMPLER_ATTENUATION,
+		PARAM_DETAIL_RATIO=VS::BAKED_LIGHT_SAMPLER_DETAIL_RATIO,
+		PARAM_MAX=VS::BAKED_LIGHT_SAMPLER_MAX
+	};
+
+
+
+protected:
+
+	RID base;
+	float params[PARAM_MAX];
+	int resolution;
+	static void _bind_methods();
+public:
+
+	virtual AABB get_aabb() const;
+	virtual DVector<Face3> get_faces(uint32_t p_usage_flags) const;
+
+	void set_param(Param p_param,float p_value);
+	float get_param(Param p_param) const;
+
+	void set_resolution(int p_resolution);
+	int get_resolution() const;
+
+	BakedLightSampler();
+	~BakedLightSampler();
+};
+
+VARIANT_ENUM_CAST( BakedLightSampler::Param );
+
+
 #endif // BAKED_LIGHT_H
diff --git a/scene/3d/camera.cpp b/scene/3d/camera.cpp
index 93a27f7ac1..ab28c0c8d4 100644
--- a/scene/3d/camera.cpp
+++ b/scene/3d/camera.cpp
@@ -467,7 +467,15 @@ Vector3 Camera::project_local_ray_normal(const Point2& p_pos) const {
 		ERR_FAIL_COND_V(!is_inside_scene(),Vector3());
 	}
 
+
+#if 0
 	Size2 viewport_size = viewport_ptr->get_visible_rect().size;
+	Vector2 cpos = p_pos;
+#else
+
+	Size2 viewport_size = viewport_ptr->get_camera_rect_size();
+	Vector2 cpos = viewport_ptr->get_camera_coords(p_pos);
+#endif
 
 	Vector3 ray;
 
@@ -479,10 +487,9 @@ Vector3 Camera::project_local_ray_normal(const Point2& p_pos) const {
 		cm.set_perspective(fov,viewport_size.get_aspect(),near,far,keep_aspect==KEEP_WIDTH);
 		float screen_w,screen_h;
 		cm.get_viewport_size(screen_w,screen_h);
-		ray=Vector3( ((p_pos.x/viewport_size.width)*2.0-1.0)*screen_w, ((1.0-(p_pos.y/viewport_size.height))*2.0-1.0)*screen_h,-near).normalized();
+		ray=Vector3( ((cpos.x/viewport_size.width)*2.0-1.0)*screen_w, ((1.0-(cpos.y/viewport_size.height))*2.0-1.0)*screen_h,-near).normalized();
 	}
 
-
 	return ray;
 };
 
@@ -494,8 +501,14 @@ Vector3 Camera::project_ray_origin(const Point2& p_pos) const {
 		ERR_FAIL_COND_V(!is_inside_scene(),Vector3());
 	}
 
+#if 0
 	Size2 viewport_size = viewport_ptr->get_visible_rect().size;
+	Vector2 cpos = p_pos;
+#else
 
+	Size2 viewport_size = viewport_ptr->get_camera_rect_size();
+	Vector2 cpos = viewport_ptr->get_camera_coords(p_pos);
+#endif
 
 	ERR_FAIL_COND_V( viewport_size.y == 0, Vector3() );
 //	float aspect = viewport_size.x / viewport_size.y;
@@ -505,7 +518,7 @@ Vector3 Camera::project_ray_origin(const Point2& p_pos) const {
 		return get_camera_transform().origin;
 	} else {
 
-		Vector2 pos = p_pos / viewport_size;
+		Vector2 pos = cpos / viewport_size;
 		float vsize,hsize;
 		if (keep_aspect==KEEP_WIDTH) {
 			vsize = size/viewport_size.get_aspect();
diff --git a/scene/3d/skeleton.cpp b/scene/3d/skeleton.cpp
index 858ee4e4ad..737f7d2dce 100644
--- a/scene/3d/skeleton.cpp
+++ b/scene/3d/skeleton.cpp
@@ -237,6 +237,21 @@ Transform Skeleton::get_bone_transform(int p_bone) const {
 	return bones[p_bone].pose_global * bones[p_bone].rest_global_inverse;
 }
 
+
+void Skeleton::set_bone_global_pose(int p_bone,const Transform& p_pose) {
+
+	ERR_FAIL_INDEX(p_bone,bones.size());
+	if (bones[p_bone].parent==-1) {
+
+		set_bone_pose(p_bone,bones[p_bone].rest.inverse() * p_pose);
+	} else {
+
+		set_bone_pose(p_bone, bones[p_bone].rest.inverse() * (get_bone_global_pose(bones[p_bone].parent).affine_inverse() * p_pose));
+
+	}
+
+}
+
 Transform Skeleton::get_bone_global_pose(int p_bone) const {
 
 	ERR_FAIL_INDEX_V(p_bone,bones.size(),Transform());
@@ -519,6 +534,7 @@ void Skeleton::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("get_bone_pose","bone_idx"),&Skeleton::get_bone_pose);
 	ObjectTypeDB::bind_method(_MD("set_bone_pose","bone_idx","pose"),&Skeleton::set_bone_pose);
 
+	ObjectTypeDB::bind_method(_MD("set_bone_global_pose","bone_idx","pose"),&Skeleton::set_bone_global_pose);
 	ObjectTypeDB::bind_method(_MD("get_bone_global_pose","bone_idx"),&Skeleton::get_bone_global_pose);
 
 	ObjectTypeDB::bind_method(_MD("get_bone_custom_pose","bone_idx"),&Skeleton::get_bone_custom_pose);
diff --git a/scene/3d/skeleton.h b/scene/3d/skeleton.h
index 3e0ab0afd7..c61946a4c7 100644
--- a/scene/3d/skeleton.h
+++ b/scene/3d/skeleton.h
@@ -118,6 +118,8 @@ public:
 	Transform get_bone_transform(int p_bone) const;
 	Transform get_bone_global_pose(int p_bone) const;
 
+	void set_bone_global_pose(int p_bone,const Transform& p_pose);
+
 	void set_bone_enabled(int p_bone, bool p_enabled);
 	bool is_bone_enabled(int p_bone) const;
 	
diff --git a/scene/3d/visual_instance.cpp b/scene/3d/visual_instance.cpp
index af535e139f..398fbdea82 100644
--- a/scene/3d/visual_instance.cpp
+++ b/scene/3d/visual_instance.cpp
@@ -50,17 +50,24 @@ void VisualInstance::_notification(int p_what) {
 			// CHECK ROOM
 			Spatial * parent = get_parent_spatial();
 			Room *room=NULL;
+			bool is_geom = cast_to<GeometryInstance>();
 
 			while(parent) {
 
 				room = parent->cast_to<Room>();
 				if (room)
 					break;
-				else
-					parent=parent->get_parent_spatial();
+
+				if (is_geom && parent->cast_to<BakedLightSampler>()) {
+					VS::get_singleton()->instance_geometry_set_baked_light_sampler(get_instance(),parent->cast_to<BakedLightSampler>()->get_instance());
+					break;
+				}
+
+				parent=parent->get_parent_spatial();
 			}
 
 
+
 			if (room) {
 
 				VisualServer::get_singleton()->instance_set_room(instance,room->get_instance());
@@ -85,6 +92,7 @@ void VisualInstance::_notification(int p_what) {
 			VisualServer::get_singleton()->instance_set_scenario( instance, RID() );
 			VisualServer::get_singleton()->instance_set_room(instance,RID());
 			VisualServer::get_singleton()->instance_attach_skeleton( instance, RID() );
+			VS::get_singleton()->instance_geometry_set_baked_light_sampler(instance, RID() );
 
 
 		} break;
diff --git a/scene/3d/visual_instance.h b/scene/3d/visual_instance.h
index bbb49a2e78..e9fefe1ba0 100644
--- a/scene/3d/visual_instance.h
+++ b/scene/3d/visual_instance.h
@@ -47,6 +47,7 @@ class VisualInstance : public Spatial {
 
 	RID _get_visual_instance_rid() const;
 
+
 protected:
 
 
diff --git a/scene/animation/animation_player.cpp b/scene/animation/animation_player.cpp
index 88fabb3489..9a3c7e71ec 100644
--- a/scene/animation/animation_player.cpp
+++ b/scene/animation/animation_player.cpp
@@ -927,7 +927,7 @@ void AnimationPlayer::play(const StringName& p_name, float p_custom_blend, float
 
 
 	StringName next=animation_get_next(p_name);
-	if (next!=StringName()) {
+	if (next!=StringName() && animation_set.has(next)) {
 		queue(next);
 	}
 }
diff --git a/scene/main/scene_main_loop.h b/scene/main/scene_main_loop.h
index 63a6468a73..bfa755ff7c 100644
--- a/scene/main/scene_main_loop.h
+++ b/scene/main/scene_main_loop.h
@@ -226,6 +226,9 @@ public:
 
 	void set_screen_stretch(StretchMode p_mode,StretchAspect p_aspect,const Size2 p_minsize);
 
+	//void change_scene(const String& p_path);
+	//Node *get_loaded_scene();
+
 #ifdef TOOLS_ENABLED
 	void set_edited_scene_root(Node *p_node);
 	Node *get_edited_scene_root() const;
diff --git a/scene/main/viewport.cpp b/scene/main/viewport.cpp
index 7e953e44c7..6b7ed66463 100644
--- a/scene/main/viewport.cpp
+++ b/scene/main/viewport.cpp
@@ -95,8 +95,8 @@ void Viewport::_update_stretch_transform() {
 
 	if (size_override_stretch && size_override) {
 
-		print_line("sive override size "+size_override_size);
-		print_line("rect size "+rect.size);
+		//print_line("sive override size "+size_override_size);
+		//print_line("rect size "+rect.size);
 		stretch_transform=Matrix32();
 		Size2 scale = rect.size/(size_override_size+size_override_margin*2);
 		stretch_transform.scale(scale);
@@ -135,7 +135,9 @@ void Viewport::_update_rect() {
 	}
 	vr.width=rect.size.width;
 	vr.height=rect.size.height;
+
 	VisualServer::get_singleton()->viewport_set_rect(viewport,vr);
+	last_vp_rect=rect;
 
 	if (canvas_item.is_valid()) {
 		VisualServer::get_singleton()->canvas_item_set_custom_rect(canvas_item,true,rect);
@@ -513,6 +515,7 @@ void Viewport::set_rect(const Rect2& p_rect) {
 	if (rect==p_rect)
 		return;
 	rect=p_rect;
+
 	_update_rect();
 	_update_stretch_transform();
 
@@ -1029,13 +1032,16 @@ void Viewport::_make_input_local(InputEvent& ev) {
 			Matrix32 ai = get_final_transform().affine_inverse() * _get_input_pre_xform();
 			Vector2 g = ai.xform(Vector2(ev.mouse_motion.global_x,ev.mouse_motion.global_y));
 			Vector2 l = ai.xform(Vector2(ev.mouse_motion.x,ev.mouse_motion.y));
-			Vector2 r = ai.xform(Vector2(ev.mouse_motion.relative_x,ev.mouse_motion.relative_y));
+			Vector2 r = ai.basis_xform(Vector2(ev.mouse_motion.relative_x,ev.mouse_motion.relative_y));
+			Vector2 s = ai.basis_xform(Vector2(ev.mouse_motion.speed_x,ev.mouse_motion.speed_y));
 			ev.mouse_motion.x=l.x;
 			ev.mouse_motion.y=l.y;
 			ev.mouse_motion.global_x=g.x;
 			ev.mouse_motion.global_y=g.y;
 			ev.mouse_motion.relative_x=r.x;
 			ev.mouse_motion.relative_y=r.y;
+			ev.mouse_motion.speed_x=s.x;
+			ev.mouse_motion.speed_y=s.y;
 
 		} break;
 		case InputEvent::SCREEN_TOUCH: {
@@ -1050,8 +1056,8 @@ void Viewport::_make_input_local(InputEvent& ev) {
 
 			Matrix32 ai = get_final_transform().affine_inverse() * _get_input_pre_xform();
 			Vector2 t = ai.xform(Vector2(ev.screen_drag.x,ev.screen_drag.y));
-			Vector2 r = ai.xform(Vector2(ev.screen_drag.relative_x,ev.screen_drag.relative_y));
-			Vector2 s = ai.xform(Vector2(ev.screen_drag.speed_x,ev.screen_drag.speed_y));
+			Vector2 r = ai.basis_xform(Vector2(ev.screen_drag.relative_x,ev.screen_drag.relative_y));
+			Vector2 s = ai.basis_xform(Vector2(ev.screen_drag.speed_x,ev.screen_drag.speed_y));
 			ev.screen_drag.x=t.x;
 			ev.screen_drag.y=t.y;
 			ev.screen_drag.relative_x=r.x;
@@ -1185,6 +1191,21 @@ void Viewport::set_physics_object_picking(bool p_enable) {
 
 }
 
+
+Vector2 Viewport::get_camera_coords(const Vector2 &p_viewport_coords) const {
+
+	Matrix32 xf = get_final_transform();
+	return xf.xform(p_viewport_coords);
+
+
+}
+
+Vector2 Viewport::get_camera_rect_size() const {
+
+	return last_vp_rect.size;
+}
+
+
 bool Viewport::get_physics_object_picking() {
 
 
diff --git a/scene/main/viewport.h b/scene/main/viewport.h
index 5d68438f0d..37f1b357c6 100644
--- a/scene/main/viewport.h
+++ b/scene/main/viewport.h
@@ -110,6 +110,7 @@ friend class RenderTargetTexture;
 	Size2 size_override_size;
 	Size2 size_override_margin;
 
+	Rect2 last_vp_rect;
 
 	bool transparent_bg;
 	bool render_target_vflip;
@@ -229,6 +230,10 @@ public:
 	RenderTargetUpdateMode get_render_target_update_mode() const;
 	Ref<RenderTargetTexture> get_render_target_texture() const;
 
+
+	Vector2 get_camera_coords(const Vector2& p_viewport_coords) const;
+	Vector2 get_camera_rect_size() const;
+
 	void queue_screen_capture();
 	Image get_screen_capture() const;
 
diff --git a/scene/register_scene_types.cpp b/scene/register_scene_types.cpp
index afa127caef..f3b13f30bf 100644
--- a/scene/register_scene_types.cpp
+++ b/scene/register_scene_types.cpp
@@ -394,6 +394,7 @@ void register_scene_types() {
 	ObjectTypeDB::register_type<VisibilityNotifier>();
 	ObjectTypeDB::register_type<VisibilityEnabler>();
 	ObjectTypeDB::register_type<BakedLightInstance>();
+	ObjectTypeDB::register_type<BakedLightSampler>();
 	ObjectTypeDB::register_type<WorldEnvironment>();
 
 	//scenariofx	
diff --git a/scene/resources/baked_light.cpp b/scene/resources/baked_light.cpp
index 647c8df5d4..226edec9ae 100644
--- a/scene/resources/baked_light.cpp
+++ b/scene/resources/baked_light.cpp
@@ -23,6 +23,27 @@ DVector<uint8_t> BakedLight::get_octree() const {
 	return VS::get_singleton()->baked_light_get_octree(baked_light);
 }
 
+void BakedLight::set_light(const DVector<uint8_t>& p_light) {
+
+	VS::get_singleton()->baked_light_set_light(baked_light,p_light);
+}
+
+DVector<uint8_t> BakedLight::get_light() const {
+
+	return VS::get_singleton()->baked_light_get_light(baked_light);
+}
+
+
+void BakedLight::set_sampler_octree(const DVector<int>& p_sampler_octree) {
+
+	VS::get_singleton()->baked_light_set_sampler_octree(baked_light,p_sampler_octree);
+}
+
+DVector<int> BakedLight::get_sampler_octree() const {
+
+	return VS::get_singleton()->baked_light_get_sampler_octree(baked_light);
+}
+
 
 
 
@@ -199,6 +220,43 @@ float BakedLight::get_normal_damp() const {
 	return normal_damp;
 }
 
+void BakedLight::set_tint(float p_margin) {
+	tint=p_margin;
+}
+
+float BakedLight::get_tint() const {
+
+	return tint;
+}
+
+void BakedLight::set_saturation(float p_margin) {
+	saturation=p_margin;
+}
+
+float BakedLight::get_saturation() const {
+
+	return saturation;
+}
+
+void BakedLight::set_ao_radius(float p_ao_radius) {
+	ao_radius=p_ao_radius;
+}
+
+float BakedLight::get_ao_radius() const {
+	return ao_radius;
+}
+
+void BakedLight::set_ao_strength(float p_ao_strength) {
+
+	ao_strength=p_ao_strength;
+}
+
+float BakedLight::get_ao_strength() const {
+
+	return ao_strength;
+}
+
+
 void BakedLight::set_energy_multiplier(float p_multiplier){
 
 	energy_multiply=p_multiplier;
@@ -329,6 +387,13 @@ void BakedLight::_bind_methods(){
 	ObjectTypeDB::bind_method(_MD("set_octree","octree"),&BakedLight::set_octree);
 	ObjectTypeDB::bind_method(_MD("get_octree"),&BakedLight::get_octree);
 
+	ObjectTypeDB::bind_method(_MD("set_light","light"),&BakedLight::set_light);
+	ObjectTypeDB::bind_method(_MD("get_light"),&BakedLight::get_light);
+
+	ObjectTypeDB::bind_method(_MD("set_sampler_octree","sampler_octree"),&BakedLight::set_sampler_octree);
+	ObjectTypeDB::bind_method(_MD("get_sampler_octree"),&BakedLight::get_sampler_octree);
+
+
 	ObjectTypeDB::bind_method(_MD("add_lightmap","texture:Texture","gen_size"),&BakedLight::add_lightmap);
 	ObjectTypeDB::bind_method(_MD("erase_lightmap","id"),&BakedLight::erase_lightmap);
 	ObjectTypeDB::bind_method(_MD("clear_lightmaps"),&BakedLight::clear_lightmaps);
@@ -357,6 +422,18 @@ void BakedLight::_bind_methods(){
 	ObjectTypeDB::bind_method(_MD("set_normal_damp","normal_damp"),&BakedLight::set_normal_damp);
 	ObjectTypeDB::bind_method(_MD("get_normal_damp"),&BakedLight::get_normal_damp);
 
+	ObjectTypeDB::bind_method(_MD("set_tint","tint"),&BakedLight::set_tint);
+	ObjectTypeDB::bind_method(_MD("get_tint"),&BakedLight::get_tint);
+
+	ObjectTypeDB::bind_method(_MD("set_saturation","saturation"),&BakedLight::set_saturation);
+	ObjectTypeDB::bind_method(_MD("get_saturation"),&BakedLight::get_saturation);
+
+	ObjectTypeDB::bind_method(_MD("set_ao_radius","ao_radius"),&BakedLight::set_ao_radius);
+	ObjectTypeDB::bind_method(_MD("get_ao_radius"),&BakedLight::get_ao_radius);
+
+	ObjectTypeDB::bind_method(_MD("set_ao_strength","ao_strength"),&BakedLight::set_ao_strength);
+	ObjectTypeDB::bind_method(_MD("get_ao_strength"),&BakedLight::get_ao_strength);
+
 	ObjectTypeDB::bind_method(_MD("set_format","format"),&BakedLight::set_format);
 	ObjectTypeDB::bind_method(_MD("get_format"),&BakedLight::get_format);
 
@@ -384,17 +461,24 @@ void BakedLight::_bind_methods(){
 	ADD_PROPERTY( PropertyInfo(Variant::REAL,"baking/plot_size",PROPERTY_HINT_RANGE,"1.0,16.0,0.01"),_SCS("set_plot_size"),_SCS("get_plot_size"));
 	ADD_PROPERTY( PropertyInfo(Variant::REAL,"baking/energy_mult",PROPERTY_HINT_RANGE,"0.01,4096.0,0.01"),_SCS("set_energy_multiplier"),_SCS("get_energy_multiplier"));
 	ADD_PROPERTY( PropertyInfo(Variant::REAL,"baking/gamma_adjust",PROPERTY_HINT_EXP_EASING),_SCS("set_gamma_adjust"),_SCS("get_gamma_adjust"));
+	ADD_PROPERTY( PropertyInfo(Variant::REAL,"baking/saturation",PROPERTY_HINT_RANGE,"0,8,0.01"),_SCS("set_saturation"),_SCS("get_saturation"));
 	ADD_PROPERTYI( PropertyInfo(Variant::BOOL,"baking_flags/diffuse"),_SCS("set_bake_flag"),_SCS("get_bake_flag"),BAKE_DIFFUSE);
 	ADD_PROPERTYI( PropertyInfo(Variant::BOOL,"baking_flags/specular"),_SCS("set_bake_flag"),_SCS("get_bake_flag"),BAKE_SPECULAR);
 	ADD_PROPERTYI( PropertyInfo(Variant::BOOL,"baking_flags/translucent"),_SCS("set_bake_flag"),_SCS("get_bake_flag"),BAKE_TRANSLUCENT);
 	ADD_PROPERTYI( PropertyInfo(Variant::BOOL,"baking_flags/conserve_energy"),_SCS("set_bake_flag"),_SCS("get_bake_flag"),BAKE_CONSERVE_ENERGY);
+	ADD_PROPERTYI( PropertyInfo(Variant::BOOL,"baking_flags/linear_color"),_SCS("set_bake_flag"),_SCS("get_bake_flag"),BAKE_LINEAR_COLOR);
 	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"lightmap/use_only_uv2"),_SCS("set_transfer_lightmaps_only_to_uv2"),_SCS("get_transfer_lightmaps_only_to_uv2"));
 
 	ADD_PROPERTY( PropertyInfo(Variant::RAW_ARRAY,"octree",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),_SCS("set_octree"),_SCS("get_octree"));
+	ADD_PROPERTY( PropertyInfo(Variant::RAW_ARRAY,"light",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),_SCS("set_light"),_SCS("get_light"));
+	ADD_PROPERTY( PropertyInfo(Variant::INT_ARRAY,"sampler_octree",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),_SCS("set_sampler_octree"),_SCS("get_sampler_octree"));
 	ADD_PROPERTY( PropertyInfo(Variant::ARRAY,"lightmaps",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),_SCS("_set_lightmap_data"),_SCS("_get_lightmap_data"));
 	ADD_PROPERTY( PropertyInfo(Variant::REAL,"advanced/cell_margin",PROPERTY_HINT_RANGE,"0.01,0.8,0.01"),_SCS("set_cell_extra_margin"),_SCS("get_cell_extra_margin"));
 	ADD_PROPERTY( PropertyInfo(Variant::REAL,"advanced/edge_damp",PROPERTY_HINT_RANGE,"0.0,8.0,0.1"),_SCS("set_edge_damp"),_SCS("get_edge_damp"));
 	ADD_PROPERTY( PropertyInfo(Variant::REAL,"advanced/normal_damp",PROPERTY_HINT_RANGE,"0.0,1.0,0.01"),_SCS("set_normal_damp"),_SCS("get_normal_damp"));
+	ADD_PROPERTY( PropertyInfo(Variant::REAL,"advanced/light_tint",PROPERTY_HINT_RANGE,"0.0,1.0,0.01"),_SCS("set_tint"),_SCS("get_tint"));
+	ADD_PROPERTY( PropertyInfo(Variant::REAL,"advanced/ao_radius",PROPERTY_HINT_RANGE,"0.0,16.0,0.01"),_SCS("set_ao_radius"),_SCS("get_ao_radius"));
+	ADD_PROPERTY( PropertyInfo(Variant::REAL,"advanced/ao_strength",PROPERTY_HINT_RANGE,"0.0,1.0,0.01"),_SCS("set_ao_strength"),_SCS("get_ao_strength"));
 
 	BIND_CONSTANT(  MODE_OCTREE );
 	BIND_CONSTANT(  MODE_LIGHTMAPS );
@@ -415,18 +499,24 @@ BakedLight::BakedLight() {
 	lattice_subdiv=4;
 	plot_size=2.5;
 	bounces=1;
-	energy_multiply=1.0;
-	gamma_adjust=1.0;
+	energy_multiply=2.0;
+	gamma_adjust=0.7;
 	cell_extra_margin=0.05;
 	edge_damp=0.0;
 	normal_damp=0.0;
+	saturation=1;
+	tint=0.0;
+	ao_radius=2.5;
+	ao_strength=0.7;
 	format=FORMAT_RGB;
 	transfer_only_uv2=false;
 
+
 	flags[BAKE_DIFFUSE]=true;
 	flags[BAKE_SPECULAR]=false;
 	flags[BAKE_TRANSLUCENT]=true;
 	flags[BAKE_CONSERVE_ENERGY]=false;
+	flags[BAKE_LINEAR_COLOR]=false;
 
 	mode=MODE_OCTREE;
 	baked_light=VS::get_singleton()->baked_light_create();
diff --git a/scene/resources/baked_light.h b/scene/resources/baked_light.h
index 57ed7d7aee..41e1e5f9e0 100644
--- a/scene/resources/baked_light.h
+++ b/scene/resources/baked_light.h
@@ -26,6 +26,7 @@ public:
 		BAKE_SPECULAR,
 		BAKE_TRANSLUCENT,
 		BAKE_CONSERVE_ENERGY,
+		BAKE_LINEAR_COLOR,
 		BAKE_MAX
 	};
 
@@ -50,6 +51,10 @@ private:
 	float cell_extra_margin;
 	float edge_damp;
 	float normal_damp;
+	float tint;
+	float ao_radius;
+	float ao_strength;
+	float saturation;
 	int bounces;
 	bool transfer_only_uv2;
 	Format format;
@@ -99,6 +104,18 @@ public:
 	void set_normal_damp(float p_margin);
 	float get_normal_damp() const;
 
+	void set_tint(float p_margin);
+	float get_tint() const;
+
+	void set_saturation(float p_saturation);
+	float get_saturation() const;
+
+	void set_ao_radius(float p_ao_radius);
+	float get_ao_radius() const;
+
+	void set_ao_strength(float p_ao_strength);
+	float get_ao_strength() const;
+
 	void set_bake_flag(BakeFlags p_flags,bool p_enable);
 	bool get_bake_flag(BakeFlags p_flags) const;
 
@@ -114,6 +131,14 @@ public:
 	void set_octree(const DVector<uint8_t>& p_octree);
 	DVector<uint8_t> get_octree() const;
 
+	void set_light(const DVector<uint8_t>& p_light);
+	DVector<uint8_t> get_light() const;
+
+	void set_sampler_octree(const DVector<int>& p_sampler_octree);
+	DVector<int> get_sampler_octree() const;
+
+
+
 	void add_lightmap(const Ref<Texture> &p_texture,Size2 p_gen_size=Size2(256,256));
 	void set_lightmap_gen_size(int p_idx,const Size2& p_size);
 	Size2 get_lightmap_gen_size(int p_idx) const;
diff --git a/scene/resources/material.cpp b/scene/resources/material.cpp
index 351d65654d..2c278f4fed 100644
--- a/scene/resources/material.cpp
+++ b/scene/resources/material.cpp
@@ -550,6 +550,10 @@ void ShaderMaterial::_bind_methods() {
 
 	ObjectTypeDB::bind_method(_MD("set_shader","shader:Shader"), &ShaderMaterial::set_shader );
 	ObjectTypeDB::bind_method(_MD("get_shader:Shader"), &ShaderMaterial::get_shader );
+
+	ObjectTypeDB::bind_method(_MD("set_shader_param","param","value:var"), &ShaderMaterial::set_shader_param);
+	ObjectTypeDB::bind_method(_MD("get_shader_param:var","param"), &ShaderMaterial::get_shader_param);
+
 	ObjectTypeDB::bind_method(_MD("_shader_changed"), &ShaderMaterial::_shader_changed );
 }