Little Bits

-=-=-=-=-=-

-fix duplicate function bug when creating script callback in editor
-fix bug where hiding lights does not work
-fix 2D audio listener bug (romulox_x reported)
-fix exported properties with inheritance bug
-fix timer autostart (make it not work on editor)
-reactivate first camara found if viewport runs out of active camera
-option to hide gizmos in viewport
-changed skeleton gizmo because it sucks
-Make convex shapes using CollisionShape visible (use quickhull class)
-fix up menu when editing a mesh, to export collision, navmesh, convex, etc. from it.
-make a menu option to show SRGB in 3D editor views by default
-make option to edit default light direction in viewport settings
-make option to edit default ambient light in viewport settings
-make software conversion of linear->RGB if hardware support not found

core/math/quick_hull.cpp

@@ -428,6 +428,7 @@ Error QuickHull::build(const Vector<Vector3>& p_points, Geometry::MeshData &r_me
 
 			List<Geometry::MeshData::Face>::Element *O = F->get().left == E ? F->get().right : F->get().left;
 			ERR_CONTINUE(O==E);
+			ERR_CONTINUE(O==NULL);
 
 			if (O->get().plane.is_almost_like(f.plane)) {
 				//merge and delete edge and contiguous face, while repointing edges (uuugh!)

drivers/gles2/rasterizer_gles2.cpp

@@ -403,19 +403,55 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 			if (!image.empty())
 				image.convert(Image::FORMAT_RGBA);
 			r_gl_components=4;
-			r_gl_format=(srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_GL_SRGB_ALPHA_EXT:GL_RGBA;
+
+			if (p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
+
+				if (srgb_supported) {
+					r_gl_format=_GL_SRGB_ALPHA_EXT;
+				} else {
+					r_gl_format=GL_RGBA;
+					if (!image.empty())
+						image.srgb_to_linear();
+				}
+			} else {
+				r_gl_format=GL_RGBA;
+			}
 			r_has_alpha_cache=true;
 
 		} break;
 		case Image::FORMAT_RGB: {
 
 			r_gl_components=3;
-			r_gl_format=(srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_GL_SRGB_EXT:GL_RGB;
+
+			if (p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
+
+				if (srgb_supported) {
+					r_gl_format=_GL_SRGB_EXT;
+				} else {
+					r_gl_format=GL_RGB;
+					if (!image.empty())
+						image.srgb_to_linear();
+				}
+			} else {
+				r_gl_format=GL_RGB;
+			}
 		} break;
 		case Image::FORMAT_RGBA: {
 
 			r_gl_components=4;
-			r_gl_format=(srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_GL_SRGB_ALPHA_EXT:GL_RGBA;
+			if (p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
+
+				if (srgb_supported) {
+					r_gl_format=_GL_SRGB_ALPHA_EXT;
+				} else {
+					r_gl_format=GL_RGBA;
+					if (!image.empty())
+						image.srgb_to_linear();
+				}
+			} else {
+				r_gl_format=GL_RGBA;
+			}
+
 			r_has_alpha_cache=true;
 		} break;
 		case Image::FORMAT_BC1: {
@@ -426,7 +462,18 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 					image.decompress();
 				}
 				r_gl_components=4;
-				r_gl_format=(srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_GL_SRGB_ALPHA_EXT:GL_RGBA;
+				if (p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
+
+					if (srgb_supported) {
+						r_gl_format=_GL_SRGB_ALPHA_EXT;
+					} else {
+						r_gl_format=GL_RGBA;
+						if (!image.empty())
+							image.srgb_to_linear();
+					}
+				} else {
+					r_gl_format=GL_RGBA;
+				}
 				r_has_alpha_cache=true;
 
 			} else {
@@ -445,7 +492,18 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 					image.decompress();
 				}
 				r_gl_components=4;
-				r_gl_format=(srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_GL_SRGB_ALPHA_EXT:GL_RGBA;
+				if (p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
+
+					if (srgb_supported) {
+						r_gl_format=_GL_SRGB_ALPHA_EXT;
+					} else {
+						r_gl_format=GL_RGBA;
+						if (!image.empty())
+							image.srgb_to_linear();
+					}
+				} else {
+					r_gl_format=GL_RGBA;
+				}
 				r_has_alpha_cache=true;
 
 			} else {
@@ -465,7 +523,18 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 					image.decompress();
 				}
 				r_gl_components=4;
-				r_gl_format=(srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_GL_SRGB_ALPHA_EXT:GL_RGBA;
+				if (p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
+
+					if (srgb_supported) {
+						r_gl_format=_GL_SRGB_ALPHA_EXT;
+					} else {
+						r_gl_format=GL_RGBA;
+						if (!image.empty())
+							image.srgb_to_linear();
+					}
+				} else {
+					r_gl_format=GL_RGBA;
+				}
 				r_has_alpha_cache=true;
 
 			} else {
@@ -484,7 +553,18 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 					image.decompress();
 				}
 				r_gl_components=4;
-				r_gl_format=(srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_GL_SRGB_ALPHA_EXT:GL_RGBA;
+				if (p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
+
+					if (srgb_supported) {
+						r_gl_format=_GL_SRGB_ALPHA_EXT;
+					} else {
+						r_gl_format=GL_RGBA;
+						if (!image.empty())
+							image.srgb_to_linear();
+					}
+				} else {
+					r_gl_format=GL_RGBA;
+				}
 				r_has_alpha_cache=true;
 
 			} else {
@@ -503,7 +583,18 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 					image.decompress();
 				}
 				r_gl_components=4;
-				r_gl_format=(srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_GL_SRGB_ALPHA_EXT:GL_RGBA;
+				if (p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
+
+					if (srgb_supported) {
+						r_gl_format=_GL_SRGB_ALPHA_EXT;
+					} else {
+						r_gl_format=GL_RGBA;
+						if (!image.empty())
+							image.srgb_to_linear();
+					}
+				} else {
+					r_gl_format=GL_RGBA;
+				}
 				r_has_alpha_cache=true;
 
 			} else {
@@ -520,7 +611,18 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 					image.decompress();
 				}
 				r_gl_components=4;
-				r_gl_format=(srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_GL_SRGB_ALPHA_EXT:GL_RGBA;
+				if (p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
+
+					if (srgb_supported) {
+						r_gl_format=_GL_SRGB_ALPHA_EXT;
+					} else {
+						r_gl_format=GL_RGBA;
+						if (!image.empty())
+							image.srgb_to_linear();
+					}
+				} else {
+					r_gl_format=GL_RGBA;
+				}
 				r_has_alpha_cache=true;
 
 
@@ -540,7 +642,18 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 				if (!image.empty())
 					image.decompress();
 				r_gl_components=4;
-				r_gl_format=(srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_GL_SRGB_ALPHA_EXT:GL_RGBA;
+				if (p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
+
+					if (srgb_supported) {
+						r_gl_format=_GL_SRGB_ALPHA_EXT;
+					} else {
+						r_gl_format=GL_RGBA;
+						if (!image.empty())
+							image.srgb_to_linear();
+					}
+				} else {
+					r_gl_format=GL_RGBA;
+				}
 				r_has_alpha_cache=true;
 
 
@@ -561,7 +674,18 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 				if (!image.empty())
 					image.decompress();
 				r_gl_components=4;
-				r_gl_format=(srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_GL_SRGB_ALPHA_EXT:GL_RGBA;
+				if (p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
+
+					if (srgb_supported) {
+						r_gl_format=_GL_SRGB_ALPHA_EXT;
+					} else {
+						r_gl_format=GL_RGBA;
+						if (!image.empty())
+							image.srgb_to_linear();
+					}
+				} else {
+					r_gl_format=GL_RGBA;
+				}
 				r_has_alpha_cache=true;
 			} else {
 
@@ -578,7 +702,18 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 				if (!image.empty())
 					image.decompress();
 				r_gl_components=4;
-				r_gl_format=GL_RGBA;
+				if (p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
+
+					if (srgb_supported) {
+						r_gl_format=_GL_SRGB_ALPHA_EXT;
+					} else {
+						r_gl_format=GL_RGBA;
+						if (!image.empty())
+							image.srgb_to_linear();
+					}
+				} else {
+					r_gl_format=GL_RGBA;
+				}
 				r_has_alpha_cache=true;
 
 			} else {
@@ -590,12 +725,24 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 		} break;
 		case Image::FORMAT_ETC: {
 
-			if (!etc_supported) {
+			if (!etc_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
 
 				if (!image.empty()) {
 					image.decompress();
 				}
 				r_gl_components=3;
+				if (p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
+
+					if (srgb_supported) {
+						r_gl_format=_GL_SRGB_EXT;
+					} else {
+						r_gl_format=GL_RGB;
+						if (!image.empty())
+							image.srgb_to_linear();
+					}
+				} else {
+					r_gl_format=GL_RGB;
+				}
 				r_gl_format=GL_RGB;
 
 
@@ -1458,6 +1605,7 @@ void RasterizerGLES2::material_set_flag(RID p_material, VS::MaterialFlag p_flag,
 	Material *material = material_owner.get(p_material);
 	ERR_FAIL_COND(!material);
 	ERR_FAIL_INDEX(p_flag,VS::MATERIAL_FLAG_MAX);
+
 	material->flags[p_flag]=p_enabled;
 
 }
@@ -4715,6 +4863,7 @@ bool RasterizerGLES2::_setup_material(const Geometry *p_geometry,const Material
 	material_shader.set_conditional(MaterialShaderGLES2::USE_SHADOW_PCF_HQ,shadow_filter==SHADOW_FILTER_PCF13);
 	material_shader.set_conditional(MaterialShaderGLES2::USE_SHADOW_ESM,shadow_filter==SHADOW_FILTER_ESM);
 	material_shader.set_conditional(MaterialShaderGLES2::USE_LIGHTMAP_ON_UV2,p_material->flags[VS::MATERIAL_FLAG_LIGHTMAP_ON_UV2]);
+	material_shader.set_conditional(MaterialShaderGLES2::USE_COLOR_ATTRIB_SRGB_TO_LINEAR,p_material->flags[VS::MATERIAL_FLAG_COLOR_ARRAY_SRGB] && current_env && current_env->fx_enabled[VS::ENV_FX_SRGB]);
 
 	if (p_opaque_pass && p_material->depth_draw_mode==VS::MATERIAL_DEPTH_DRAW_OPAQUE_PRE_PASS_ALPHA && p_material->shader_cache && p_material->shader_cache->has_alpha) {
 
@@ -6218,7 +6367,7 @@ void RasterizerGLES2::_render_list_forward(RenderList *p_render_list,const Trans
 			if (!shadow) {
 
 				if (!additive && current_env && current_env->fx_enabled[VS::ENV_FX_AMBIENT_LIGHT]) {
-					Color ambcolor = current_env->fx_param[VS::ENV_FX_PARAM_AMBIENT_LIGHT_COLOR];
+					Color ambcolor = _convert_color(current_env->fx_param[VS::ENV_FX_PARAM_AMBIENT_LIGHT_COLOR]);
 					float ambnrg =  current_env->fx_param[VS::ENV_FX_PARAM_AMBIENT_LIGHT_ENERGY];
 					material_shader.set_uniform(MaterialShaderGLES2::AMBIENT_LIGHT,Vector3(ambcolor.r*ambnrg,ambcolor.g*ambnrg,ambcolor.b*ambnrg));
 				} else {

drivers/gles2/shaders/material.glsl

@@ -292,8 +292,18 @@ void main() {
 	normal_interp = normalize((modelview * vec4(normal_in,0.0)).xyz);
 
 #if defined(ENABLE_COLOR_INTERP)
+#ifdef USE_COLOR_ATTRIB_SRGB_TO_LINEAR
+
+	color_interp = vec4(
+		color_attrib.r<0.04045 ? color_attrib.r * (1.0 / 12.92) : pow((color_attrib.r + 0.055) * (1.0 / (1 + 0.055)), 2.4),
+		color_attrib.g<0.04045 ? color_attrib.g * (1.0 / 12.92) : pow((color_attrib.g + 0.055) * (1.0 / (1 + 0.055)), 2.4),
+		color_attrib.b<0.04045 ? color_attrib.b * (1.0 / 12.92) : pow((color_attrib.b + 0.055) * (1.0 / (1 + 0.055)), 2.4),
+		color_attrib.a
+	);
+#else
 	color_interp = color_attrib;
 #endif
+#endif
 
 #if defined(ENABLE_TANGENT_INTERP)
 	tangent_interp=normalize(tangent_in);

modules/gdscript/gd_editor.cpp

@@ -114,6 +114,7 @@ int GDScriptLanguage::find_function(const String& p_function,const String& p_cod
 		if (tokenizer.get_token()==GDTokenizer::TK_NEWLINE) {
 			indent=tokenizer.get_token_line_indent();
 		}
+		//print_line("TOKEN: "+String(GDTokenizer::get_token_name(tokenizer.get_token())));
 		if (indent==0 && tokenizer.get_token()==GDTokenizer::TK_PR_FUNCTION && tokenizer.get_token(1)==GDTokenizer::TK_IDENTIFIER) {
 
 			String identifier = tokenizer.get_token_identifier(1);
@@ -122,6 +123,8 @@ int GDScriptLanguage::find_function(const String& p_function,const String& p_cod
 			}
 		}
 		tokenizer.advance();
+		//print_line("NEXT: "+String(GDTokenizer::get_token_name(tokenizer.get_token())));
+
 	}
 	return -1;
 }

modules/gdscript/gd_script.cpp

@@ -1626,9 +1626,11 @@ void GDScript::set_source_code(const String& p_code) {
 	source=p_code;
 }
 
-void GDScript::update_exports() {
+
+void GDScript::_update_exports(Set<PlaceHolderScriptInstance*> *p_instances) {
 
 #ifdef TOOLS_ENABLED
+
 	String basedir=path;
 
 	if (basedir=="")
@@ -1645,8 +1647,20 @@ void GDScript::update_exports() {
 	const GDParser::Node* root = parser.get_parse_tree();
 	ERR_FAIL_COND(root->type!=GDParser::Node::TYPE_CLASS);
 
+
+
 	const GDParser::ClassNode *c = static_cast<const GDParser::ClassNode*>(root);
 
+	if (c->extends_used && String(c->extends_file)!="") {
+
+		Ref<GDScript> bf = ResourceLoader::load(c->extends_file);
+		if (bf.is_valid()) {
+
+			bf->_update_exports(p_instances);
+
+		}
+	}
+
 	List<PropertyInfo> plist;
 
 	Map<StringName,Variant> default_values;
@@ -1660,10 +1674,19 @@ void GDScript::update_exports() {
 	}
 
 
-	for (Set<PlaceHolderScriptInstance*>::Element *E=placeholders.front();E;E=E->next()) {
+	for (Set<PlaceHolderScriptInstance*>::Element *E=p_instances->front();E;E=E->next()) {
 
 		E->get()->update(plist,default_values);
 	}
+#endif
+}
+
+void GDScript::update_exports() {
+
+#ifdef TOOLS_ENABLED
+
+	_update_exports(&placeholders);
+
 
 #endif
 }

modules/gdscript/gd_script.h

@@ -263,6 +263,9 @@ friend class GDFunctions;
 #endif
 
 
+
+	void _update_exports(Set<PlaceHolderScriptInstance *> *p_instances);
+
 protected:
 	bool _get(const StringName& p_name,Variant &r_ret) const;
 	bool _set(const StringName& p_name, const Variant& p_value);

scene/3d/camera.cpp

@@ -219,11 +219,14 @@ void Camera::_notification(int p_what) {
 
 			}
 
+			camera_group = "_vp_cameras"+itos(get_viewport()->get_instance_ID());
+			add_to_group(camera_group);
 			if (viewport_ptr)
 				viewport_ptr->cameras.insert(this);
 			if (current)
 				make_current();
 
+
 		} break;			
 		case NOTIFICATION_TRANSFORM_CHANGED: {
 		
@@ -241,6 +244,8 @@ void Camera::_notification(int p_what) {
 			if (viewport_ptr)
 				viewport_ptr->cameras.erase(this);
 			viewport_ptr=NULL;
+			remove_from_group(camera_group);
+
 
 		} break;
 		case NOTIFICATION_BECAME_CURRENT: {
@@ -314,6 +319,20 @@ void Camera::make_current() {
 	//get_scene()->call_group(SceneMainLoop::GROUP_CALL_REALTIME,camera_group,"_camera_make_current",this);
 }
 
+
+void Camera::_camera_make_next_current(Node *p_exclude) {
+
+	if (this==p_exclude)
+		return;
+	if (!is_inside_scene())
+		return;
+	if (get_viewport()->get_camera()!=NULL)
+		return;
+
+	make_current();
+}
+
+
 void Camera::clear_current() {
 
 	current=false;
@@ -321,8 +340,12 @@ void Camera::clear_current() {
 		return;
 
 	if (viewport_ptr) {
-		if (viewport_ptr->get_camera()==this)
+		if (viewport_ptr->get_camera()==this) {
 			viewport_ptr->_set_camera(NULL);
+			//a group is used beause this needs to be in order to be deterministic
+			get_scene()->call_group(SceneMainLoop::GROUP_CALL_REALTIME,camera_group,"_camera_make_next_current",this);
+
+		}
 	}
 
 }
@@ -636,6 +659,7 @@ void Camera::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("get_environment:Environment"),&Camera::get_environment);
 	ObjectTypeDB::bind_method(_MD("set_keep_aspect_mode","mode"),&Camera::set_keep_aspect_mode);
 	ObjectTypeDB::bind_method(_MD("get_keep_aspect_mode"),&Camera::get_keep_aspect_mode);
+	ObjectTypeDB::bind_method(_MD("_camera_make_next_current"),&Camera::_camera_make_next_current);
 	//ObjectTypeDB::bind_method( _MD("_camera_make_current"),&Camera::_camera_make_current );
 
 	BIND_CONSTANT( PROJECTION_PERSPECTIVE );

scene/3d/camera.h

@@ -66,6 +66,8 @@ private:
 	RID camera;
 	RID scenario_id;
 
+	String camera_group;
+
 	uint32_t layers;
 
 	Viewport *viewport_ptr;
@@ -74,6 +76,7 @@ private:
 	virtual bool _can_gizmo_scale() const;
 	virtual RES _get_gizmo_geometry() const;
 
+	void _camera_make_next_current(Node *p_exclude);
 
 
 	//void _camera_make_current(Node *p_camera);

scene/3d/immediate_geometry.cpp

@@ -72,6 +72,53 @@ DVector<Face3> ImmediateGeometry::get_faces(uint32_t p_usage_flags) const {
 	return DVector<Face3>();
 }
 
+
+
+void ImmediateGeometry::add_sphere(int p_lats,int p_lons,float p_radius) {
+
+	for(int i = 1; i <= p_lats; i++) {
+		double lat0 = Math_PI * (-0.5 + (double) (i - 1) / p_lats);
+		double z0  = Math::sin(lat0);
+		double zr0 =  Math::cos(lat0);
+
+		double lat1 = Math_PI * (-0.5 + (double) i / p_lats);
+		double z1 = Math::sin(lat1);
+		double zr1 = Math::cos(lat1);
+
+		for(int j = p_lons; j >= 1; j--) {
+
+			double lng0 = 2 * Math_PI * (double) (j - 1) / p_lons;
+			double x0 = Math::cos(lng0);
+			double y0 = Math::sin(lng0);
+
+			double lng1 = 2 * Math_PI * (double) (j) / p_lons;
+			double x1 = Math::cos(lng1);
+			double y1 = Math::sin(lng1);
+
+
+			Vector3 v[4]={
+				Vector3(x1 * zr0, z0, y1 *zr0),
+				Vector3(x1 * zr1, z1, y1 *zr1),
+				Vector3(x0 * zr1, z1, y0 *zr1),
+				Vector3(x0 * zr0, z0, y0 *zr0)
+			};
+
+#define ADD_POINT(m_idx)\
+	set_normal(v[m_idx]);\
+	add_vertex(v[m_idx]*p_radius);
+
+			ADD_POINT(0);
+			ADD_POINT(1);
+			ADD_POINT(2);
+
+			ADD_POINT(2);
+			ADD_POINT(3);
+			ADD_POINT(0);
+		}
+	}
+
+}
+
 void ImmediateGeometry::_bind_methods() {
 
 	ObjectTypeDB::bind_method(_MD("begin","primitive","texture:Texture"),&ImmediateGeometry::begin);
@@ -81,11 +128,14 @@ void ImmediateGeometry::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("set_uv","uv"),&ImmediateGeometry::set_uv);
 	ObjectTypeDB::bind_method(_MD("set_uv2","uv"),&ImmediateGeometry::set_uv2);
 	ObjectTypeDB::bind_method(_MD("add_vertex","color"),&ImmediateGeometry::add_vertex);
+	ObjectTypeDB::bind_method(_MD("add_sphere","lats","lons","radius"),&ImmediateGeometry::add_sphere);
 	ObjectTypeDB::bind_method(_MD("end"),&ImmediateGeometry::end);
 	ObjectTypeDB::bind_method(_MD("clear"),&ImmediateGeometry::clear);
 
 }
 
+
+
 ImmediateGeometry::ImmediateGeometry() {
 
 	im = VisualServer::get_singleton()->immediate_create();

scene/3d/immediate_geometry.h

@@ -31,6 +31,11 @@ public:
 	void end();
 	void clear();
 
+
+	void add_sphere(int p_lats,int p_lons,float p_radius);
+
+
+
 	virtual AABB get_aabb() const;
 	virtual DVector<Face3> get_faces(uint32_t p_usage_flags) const;
 

scene/3d/light.cpp

@@ -429,10 +429,40 @@ void Light::approximate_opengl_attenuation(float p_constant, float p_linear, flo
 
 }
 
+
+void Light::_update_visibility() {
+
+	if (!is_inside_scene())
+		return;
+
+	bool editor_ok=true;
+	if (editor_only) {
+
+		if (!get_scene()->is_editor_hint()) {
+			editor_ok=false;
+		} else {
+			editor_ok = (get_scene()->get_edited_scene_root() && (this==get_scene()->get_edited_scene_root() || get_owner()==get_scene()->get_edited_scene_root()));
+		}
+	}
+
+
+	VS::get_singleton()->instance_light_set_enabled(get_instance(),is_visible() && enabled && editor_ok);
+	_change_notify("geometry/visible");
+
+}
+
+
+void Light::_notification(int p_what) {
+
+	if (p_what==NOTIFICATION_ENTER_SCENE || p_what==NOTIFICATION_VISIBILITY_CHANGED) {
+		_update_visibility();
+	}
+}
+
 void Light::set_enabled(bool p_enabled) {
 
 	enabled=p_enabled;
-	VS::get_singleton()->instance_light_set_enabled(get_instance(),enabled);
+	_update_visibility();
 }
 
 bool Light::is_enabled() const{
@@ -440,6 +470,17 @@ bool Light::is_enabled() const{
 	return enabled;
 }
 
+void Light::set_editor_only(bool p_editor_only) {
+
+	editor_only=p_editor_only;
+	_update_visibility();
+}
+
+bool Light::is_editor_only() const{
+
+	return editor_only;
+}
+
 
 void Light::_bind_methods() {
 
@@ -457,9 +498,12 @@ void Light::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("get_bake_mode"), &Light::get_bake_mode );
 	ObjectTypeDB::bind_method(_MD("set_enabled","enabled"), &Light::set_enabled );
 	ObjectTypeDB::bind_method(_MD("is_enabled"), &Light::is_enabled );
+	ObjectTypeDB::bind_method(_MD("set_editor_only","editor_only"), &Light::set_editor_only );
+	ObjectTypeDB::bind_method(_MD("is_editor_only"), &Light::is_editor_only );
 
 
 	ADD_PROPERTY( PropertyInfo( Variant::BOOL, "params/enabled"), _SCS("set_enabled"), _SCS("is_enabled"));
+	ADD_PROPERTY( PropertyInfo( Variant::BOOL, "params/editor_only"), _SCS("set_editor_only"), _SCS("is_editor_only"));
 	ADD_PROPERTY( PropertyInfo( Variant::INT, "params/bake_mode",PROPERTY_HINT_ENUM,"Disabled,Indirect,Indirect+Shadows,Full"), _SCS("set_bake_mode"), _SCS("get_bake_mode"));
 	ADD_PROPERTYI( PropertyInfo( Variant::REAL, "params/energy", PROPERTY_HINT_EXP_RANGE, "0,64,0.01"), _SCS("set_parameter"), _SCS("get_parameter"), PARAM_ENERGY );
 	/*
@@ -531,6 +575,7 @@ Light::Light(VisualServer::LightType p_type) {
 	set_project_shadows( false );
 	set_base(light);
 	enabled=true;
+	editor_only=false;
 	bake_mode=BAKE_MODE_DISABLED;
 
 }

scene/3d/light.h

@@ -92,8 +92,10 @@ private:
 	VisualServer::LightType type;
 	bool shadows;
 	bool enabled;
+	bool editor_only;
 	Operator op;
-	
+
+	void _update_visibility();
 // bind helpers
 
 protected:	
@@ -104,6 +106,7 @@ protected:
 	virtual RES _get_gizmo_geometry() const;
 	
 	static void _bind_methods();
+	void _notification(int p_what);
 
 	
 	Light(VisualServer::LightType p_type);	
@@ -132,6 +135,9 @@ public:
 	void set_enabled(bool p_enabled);
 	bool is_enabled() const;
 
+	void set_editor_only(bool p_editor_only);
+	bool is_editor_only() const;
+
 	virtual AABB get_aabb() const;
 	virtual DVector<Face3> get_faces(uint32_t p_usage_flags) const;
 

scene/3d/mesh_instance.cpp

@@ -30,7 +30,7 @@
 
 #include "skeleton.h"
 #include "physics_body.h"
-
+#include "body_shape.h"
 
 
 bool MeshInstance::_set(const StringName& p_name, const Variant& p_value) {
@@ -181,6 +181,11 @@ void MeshInstance::create_trimesh_collision() {
 	add_child(static_body);
 	if (get_owner())
 		static_body->set_owner( get_owner() );
+	CollisionShape *cshape = memnew( CollisionShape );
+	cshape->set_shape(static_body->get_shape(0));
+	static_body->add_child(cshape);
+	if (get_owner())
+		cshape->set_owner( get_owner() );
 
 }
 
@@ -210,6 +215,12 @@ void MeshInstance::create_convex_collision() {
 	add_child(static_body);
 	if (get_owner())
 		static_body->set_owner( get_owner() );
+	CollisionShape *cshape = memnew( CollisionShape );
+	cshape->set_shape(static_body->get_shape(0));
+	static_body->add_child(cshape);
+	if (get_owner())
+		cshape->set_owner( get_owner() );
+
 
 }
 
@@ -229,9 +240,9 @@ void MeshInstance::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("get_skeleton_path:NodePath"),&MeshInstance::get_skeleton_path);
 	ObjectTypeDB::bind_method(_MD("get_aabb"),&MeshInstance::get_aabb);
 	ObjectTypeDB::bind_method(_MD("create_trimesh_collision"),&MeshInstance::create_trimesh_collision);
-	ObjectTypeDB::set_method_flags("MeshInstance","create_trimesh_collision",METHOD_FLAGS_DEFAULT|METHOD_FLAG_EDITOR);
+	ObjectTypeDB::set_method_flags("MeshInstance","create_trimesh_collision",METHOD_FLAGS_DEFAULT);
 	ObjectTypeDB::bind_method(_MD("create_convex_collision"),&MeshInstance::create_convex_collision);
-	ObjectTypeDB::set_method_flags("MeshInstance","create_convex_collision",METHOD_FLAGS_DEFAULT|METHOD_FLAG_EDITOR);
+	ObjectTypeDB::set_method_flags("MeshInstance","create_convex_collision",METHOD_FLAGS_DEFAULT);
 	ADD_PROPERTY( PropertyInfo( Variant::OBJECT, "mesh/mesh", PROPERTY_HINT_RESOURCE_TYPE, "Mesh" ), _SCS("set_mesh"), _SCS("get_mesh"));
 	ADD_PROPERTY( PropertyInfo (Variant::NODE_PATH, "mesh/skeleton"), _SCS("set_skeleton_path"), _SCS("get_skeleton_path"));
 }

scene/main/scene_main_loop.cpp

@@ -968,6 +968,18 @@ void SceneMainLoop::set_screen_stretch(StretchMode p_mode,StretchAspect p_aspect
 }
 
 
+#ifdef TOOLS_ENABLED
+void SceneMainLoop::set_edited_scene_root(Node *p_node) {
+	edited_scene_root=p_node;
+}
+
+Node *SceneMainLoop::get_edited_scene_root() const {
+
+	return edited_scene_root;
+}
+#endif
+
+
 void SceneMainLoop::_bind_methods() {
 
 
@@ -983,6 +995,10 @@ void SceneMainLoop::_bind_methods() {
 
 	ObjectTypeDB::bind_method(_MD("set_editor_hint","enable"),&SceneMainLoop::set_editor_hint);
 	ObjectTypeDB::bind_method(_MD("is_editor_hint"),&SceneMainLoop::is_editor_hint);
+#ifdef TOOLS_ENABLED
+	ObjectTypeDB::bind_method(_MD("set_edited_scene_root","scene"),&SceneMainLoop::set_edited_scene_root);
+	ObjectTypeDB::bind_method(_MD("get_edited_scene_root"),&SceneMainLoop::get_edited_scene_root);
+#endif
 
 	ObjectTypeDB::bind_method(_MD("set_pause","enable"),&SceneMainLoop::set_pause);
 	ObjectTypeDB::bind_method(_MD("is_paused"),&SceneMainLoop::is_paused);
@@ -1069,6 +1085,8 @@ SceneMainLoop::SceneMainLoop() {
 
 	root->set_physics_object_picking(GLOBAL_DEF("physics/enable_object_picking",true));
 
+	edited_scene_root=NULL;
+
 	ADD_SIGNAL( MethodInfo("idle_frame"));
 	ADD_SIGNAL( MethodInfo("fixed_frame"));
 

scene/main/scene_main_loop.h

@@ -102,6 +102,9 @@ private:
 	int64_t current_frame;
 	int node_count;
 
+#ifdef TOOLS_ENABLED
+	Node *edited_scene_root;
+#endif
 	struct UGCall {
 
 		StringName group;
@@ -223,6 +226,10 @@ public:
 
 	void set_screen_stretch(StretchMode p_mode,StretchAspect p_aspect,const Size2 p_minsize);
 
+#ifdef TOOLS_ENABLED
+	void set_edited_scene_root(Node *p_node);
+	Node *get_edited_scene_root() const;
+#endif
 
 	SceneMainLoop();
 	~SceneMainLoop();

scene/main/timer.cpp

@@ -36,8 +36,11 @@ void Timer::_notification(int p_what) {
 
 		case NOTIFICATION_READY: {
 
-			if (autostart)
+			if (autostart) {
+				if (get_scene()->is_editor_hint() && get_scene()->get_edited_scene_root() &&  (get_scene()->get_edited_scene_root()==this || get_scene()->get_edited_scene_root()->is_a_parent_of(this)))
+					break;
 				start();
+			}
 		} break;
 		case NOTIFICATION_PROCESS: {
 

scene/resources/material.cpp

@@ -36,7 +36,8 @@ static const char*_flag_names[Material::FLAG_MAX]={
 	"invert_faces",
 	"unshaded",
 	"on_top",
-	"lightmap_on_uv2"
+	"lightmap_on_uv2",
+	"colarray_is_srgb"
 };
 
 
@@ -46,7 +47,8 @@ static const Material::Flag _flag_indices[Material::FLAG_MAX]={
 	Material::FLAG_INVERT_FACES,
 	Material::FLAG_UNSHADED,
 	Material::FLAG_ONTOP,
-	Material::FLAG_LIGHTMAP_ON_UV2
+	Material::FLAG_LIGHTMAP_ON_UV2,
+	Material::FLAG_COLOR_ARRAY_SRGB,
 };
 
 
@@ -132,6 +134,8 @@ void Material::_bind_methods() {
 	BIND_CONSTANT( FLAG_INVERT_FACES );
 	BIND_CONSTANT( FLAG_UNSHADED );
 	BIND_CONSTANT( FLAG_ONTOP );
+	BIND_CONSTANT( FLAG_LIGHTMAP_ON_UV2 );
+	BIND_CONSTANT( FLAG_COLOR_ARRAY_SRGB );
 	BIND_CONSTANT( FLAG_MAX );
 
 	BIND_CONSTANT( DEPTH_DRAW_ALWAYS );
@@ -156,6 +160,8 @@ Material::Material(const RID& p_material) {
 	flags[FLAG_INVERT_FACES]=false;
 	flags[FLAG_UNSHADED]=false;
 	flags[FLAG_ONTOP]=false;
+	flags[FLAG_LIGHTMAP_ON_UV2]=true;
+	flags[FLAG_COLOR_ARRAY_SRGB]=false;
 
 	depth_draw_mode=DEPTH_DRAW_OPAQUE_ONLY;
 
@@ -427,7 +433,7 @@ FixedMaterial::FixedMaterial() : Material(VS::get_singleton()->fixed_material_cr
 	param[PARAM_SHADE_PARAM]=0.5;
 	param[PARAM_DETAIL]=1.0;
 
-
+	set_flag(FLAG_COLOR_ARRAY_SRGB,true);
 
 	fixed_flags[FLAG_USE_ALPHA]=false;
 	fixed_flags[FLAG_USE_COLOR_ARRAY]=false;
@@ -589,6 +595,8 @@ ParticleSystemMaterial::ParticleSystemMaterial() :Material(VisualServer::get_sin
 	set_depth_draw_mode(DEPTH_DRAW_NEVER);
 	VisualServer::get_singleton()->fixed_material_set_flag(material,VS::FIXED_MATERIAL_FLAG_USE_ALPHA,true);
 	VisualServer::get_singleton()->fixed_material_set_flag(material,VS::FIXED_MATERIAL_FLAG_USE_COLOR_ARRAY,true);
+	set_flag(FLAG_COLOR_ARRAY_SRGB,true);
+
 }
 
 ParticleSystemMaterial::~ParticleSystemMaterial() {
@@ -659,6 +667,8 @@ UnshadedMaterial::UnshadedMaterial() :Material(VisualServer::get_singleton()->fi
 
 	set_flag(FLAG_UNSHADED,true);
 	set_use_alpha(true);
+	set_flag(FLAG_COLOR_ARRAY_SRGB,true);
+
 }
 
 UnshadedMaterial::~UnshadedMaterial() {

scene/resources/material.h

@@ -54,6 +54,7 @@ public:
 		FLAG_UNSHADED = VS::MATERIAL_FLAG_UNSHADED,
 		FLAG_ONTOP = VS::MATERIAL_FLAG_ONTOP,
 		FLAG_LIGHTMAP_ON_UV2 = VS::MATERIAL_FLAG_LIGHTMAP_ON_UV2,
+		FLAG_COLOR_ARRAY_SRGB = VS::MATERIAL_FLAG_COLOR_ARRAY_SRGB,
 		FLAG_MAX = VS::MATERIAL_FLAG_MAX
 	};
 

servers/visual/rasterizer.cpp

@@ -363,12 +363,13 @@ RID Rasterizer::fixed_material_create() {
 	FixedMaterial &fm=*fixed_materials[mat];
 	fm.self=mat;
 	fm.get_key();
+	material_set_flag(mat,VS::MATERIAL_FLAG_COLOR_ARRAY_SRGB,true);
 	for(int i=0;i<VS::FIXED_MATERIAL_PARAM_MAX;i++) {
 
 		material_set_param(mat,_fixed_material_param_names[i],fm.param[i]); //must be there
 	}
 	fixed_material_dirty_list.add(&fm.dirty_list);
-	//print_line("FMC: "+itos(mat.get_id()));
+	//print_line("FMC: "+itos(mat.get_id()));	
 	return mat;
 }
 

servers/visual/visual_server_raster.cpp

@@ -1786,6 +1786,17 @@ void VisualServerRaster::scenario_set_environment(RID p_scenario, RID p_environm
 
 }
 
+void VisualServerRaster::scenario_set_fallback_environment(RID p_scenario, RID p_environment) {
+
+	VS_CHANGED;
+
+	Scenario *scenario = scenario_owner.get(p_scenario);
+	ERR_FAIL_COND(!scenario);
+	scenario->fallback_environment=p_environment;
+
+
+}
+
 RID VisualServerRaster::scenario_get_environment(RID p_scenario, RID p_environment) const{
 
 	const Scenario *scenario = scenario_owner.get(p_scenario);
@@ -5516,8 +5527,10 @@ void VisualServerRaster::_render_camera(Viewport *p_viewport,Camera *p_camera, S
 	RID environment;
 	if (p_camera->env.is_valid()) //camera has more environment priority
 		environment=p_camera->env;
-	else
+	else if (p_scenario->environment.is_valid())
 		environment=p_scenario->environment;
+	else
+		environment=p_scenario->fallback_environment;
 
 	rasterizer->begin_scene(p_viewport->viewport_data,environment,p_scenario->debug);
 	rasterizer->set_viewport(viewport_rect);	

servers/visual/visual_server_raster.h

@@ -320,6 +320,7 @@ class VisualServerRaster : public VisualServer {
 			
 		List<RID> directional_lights;
 		RID environment;
+		RID fallback_environment;
 		
 		Instance *dirty_instances;
 
@@ -1038,6 +1039,8 @@ public:
 	virtual void scenario_set_debug(RID p_scenario,ScenarioDebugMode p_debug_mode);
 	virtual void scenario_set_environment(RID p_scenario, RID p_environment);
 	virtual RID scenario_get_environment(RID p_scenario, RID p_environment) const;
+	virtual void scenario_set_fallback_environment(RID p_scenario, RID p_environment);
+
 
 		
 	/* INSTANCING API */

servers/visual/visual_server_wrap_mt.h

@@ -929,6 +929,7 @@ public:
 	FUNC2(camera_set_environment,RID,RID);
 	FUNC1RC(RID,camera_get_environment,RID);
 
+
 	FUNC2(camera_set_use_vertical_aspect,RID,bool);
 	FUNC2RC(bool,camera_is_using_vertical_aspect,RID,bool);
 
@@ -998,6 +999,7 @@ public:
 	FUNC2(scenario_set_debug,RID,ScenarioDebugMode);
 	FUNC2(scenario_set_environment,RID, RID);
 	FUNC2RC(RID,scenario_get_environment,RID, RID);
+	FUNC2(scenario_set_fallback_environment,RID, RID);
 
 
 	/* INSTANCING API */

servers/visual_server.h

@@ -169,6 +169,7 @@ public:
 		MATERIAL_FLAG_UNSHADED,
 		MATERIAL_FLAG_ONTOP,
 		MATERIAL_FLAG_LIGHTMAP_ON_UV2,
+		MATERIAL_FLAG_COLOR_ARRAY_SRGB,
 		MATERIAL_FLAG_MAX,
 	};
 
@@ -807,7 +808,7 @@ public:
 	virtual void scenario_set_debug(RID p_scenario,ScenarioDebugMode p_debug_mode)=0;
 	virtual void scenario_set_environment(RID p_scenario, RID p_environment)=0;
 	virtual RID scenario_get_environment(RID p_scenario, RID p_environment) const=0;
-
+	virtual void scenario_set_fallback_environment(RID p_scenario, RID p_environment)=0;
 
 
 	/* INSTANCING API */

tools/editor/editor_node.cpp

@@ -69,6 +69,7 @@
 #include "plugins/item_list_editor_plugin.h"
 #include "plugins/stream_editor_plugin.h"
 #include "plugins/multimesh_editor_plugin.h"
+#include "plugins/mesh_editor_plugin.h"
 #include "plugins/theme_editor_plugin.h"
 
 #include "plugins/tile_map_editor_plugin.h"
@@ -2336,6 +2337,8 @@ void EditorNode::set_edited_scene(Node *p_scene) {
 	if (edited_scene && edited_scene->cast_to<Popup>())
 		edited_scene->cast_to<Popup>()->show(); //show popups
 	scene_tree_dock->set_edited_scene(edited_scene);
+	if (get_scene())
+		get_scene()->set_edited_scene_root(edited_scene);
 
 	if (edited_scene) {
 		if (p_scene->get_parent()!=scene_root)
@@ -3974,6 +3977,7 @@ EditorNode::EditorNode() {
 	add_editor_plugin( memnew( SampleLibraryEditorPlugin(this) ) );
 	add_editor_plugin( memnew( ThemeEditorPlugin(this) ) );
 	add_editor_plugin( memnew( MultiMeshEditorPlugin(this) ) );
+	add_editor_plugin( memnew( MeshInstanceEditorPlugin(this) ) );
 	add_editor_plugin( memnew( AnimationTreeEditorPlugin(this) ) );
 	add_editor_plugin( memnew( SamplePlayerEditorPlugin(this) ) );
 	add_editor_plugin( memnew( MeshLibraryEditorPlugin(this) ) );

tools/editor/plugins/mesh_editor_plugin.cpp

@@ -0,0 +1,227 @@
+#include "mesh_editor_plugin.h"
+
+#include "tools/editor/editor_plugin.h"
+#include "tools/editor/editor_node.h"
+#include "scene/3d/mesh_instance.h"
+#include "scene/3d/physics_body.h"
+#include "scene/3d/body_shape.h"
+#include "scene/gui/spin_box.h"
+#include "scene/gui/box_container.h"
+#include "scene/3d/mesh_instance.h"
+#include "scene/3d/navigation_mesh.h"
+#include "spatial_editor_plugin.h"
+
+void MeshInstanceEditor::_node_removed(Node *p_node) {
+
+	if(p_node==node) {
+		node=NULL;
+		options->hide();
+	}
+
+}
+
+
+
+void MeshInstanceEditor::edit(MeshInstance *p_mesh) {
+
+	node=p_mesh;
+
+}
+
+void MeshInstanceEditor::_menu_option(int p_option) {
+
+	Ref<Mesh> mesh = node->get_mesh();
+	if (mesh.is_null()) {
+		err_dialog->set_text("Mesh is empty!");
+		err_dialog->popup_centered(Size2(100,50));
+		return;
+	}
+
+	switch(p_option) {
+		case MENU_OPTION_CREATE_STATIC_TRIMESH_BODY: {
+
+			Ref<Shape> shape = mesh->create_trimesh_shape();
+			if (shape.is_null())
+				return;
+			StaticBody *body = memnew( StaticBody );
+			CollisionShape *cshape = memnew( CollisionShape );
+			cshape->set_shape(shape);
+			body->add_child(cshape);
+			Node *owner = node==get_scene()->get_edited_scene_root() ? node : node->get_owner();
+
+			UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo();
+			ur->create_action("Create Static Trimesh");
+			ur->add_do_method(node,"add_child",body);
+			ur->add_do_method(body,"set_owner",owner);
+			ur->add_do_method(cshape,"set_owner",owner);
+			ur->add_do_reference(body);
+			ur->add_undo_method(node,"remove_child",body);
+			ur->commit_action();
+
+		} break;
+		case MENU_OPTION_CREATE_STATIC_CONVEX_BODY: {
+
+			Ref<Shape> shape = mesh->create_convex_shape();
+			if (shape.is_null())
+				return;
+			StaticBody *body = memnew( StaticBody );
+			CollisionShape *cshape = memnew( CollisionShape );
+			cshape->set_shape(shape);
+			body->add_child(cshape);
+			Node *owner = node==get_scene()->get_edited_scene_root() ? node : node->get_owner();
+
+			UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo();
+			ur->create_action("Create Static Trimesh");
+			ur->add_do_method(node,"add_child",body);
+			ur->add_do_method(body,"set_owner",owner);
+			ur->add_do_method(cshape,"set_owner",owner);
+			ur->add_do_reference(body);
+			ur->add_undo_method(node,"remove_child",body);
+			ur->commit_action();
+
+		} break;
+		case MENU_OPTION_CREATE_TRIMESH_COLLISION_SHAPE: {
+
+
+			if (node==get_scene()->get_edited_scene_root()) {
+				err_dialog->set_text("This doesn't work on scene root!");
+				err_dialog->popup_centered(Size2(100,50));
+				return;
+			}
+			Ref<Shape> shape = mesh->create_trimesh_shape();
+			if (shape.is_null())
+				return;
+			CollisionShape *cshape = memnew( CollisionShape );
+			cshape->set_shape(shape);
+
+			Node *owner =  node->get_owner();
+
+			UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo();
+			ur->create_action("Create Static Trimesh");
+			ur->add_do_method(node->get_parent(),"add_child",cshape);
+			ur->add_do_method(node->get_parent(),"move_child",cshape,node->get_index()+1);
+			ur->add_do_method(cshape,"set_owner",owner);
+			ur->add_do_reference(cshape);
+			ur->add_undo_method(node->get_parent(),"remove_child",cshape);
+			ur->commit_action();
+
+		} break;
+		case MENU_OPTION_CREATE_CONVEX_COLLISION_SHAPE: {
+
+
+			if (node==get_scene()->get_edited_scene_root()) {
+				err_dialog->set_text("This doesn't work on scene root!");
+				err_dialog->popup_centered(Size2(100,50));
+				return;
+			}
+			Ref<Shape> shape = mesh->create_convex_shape();
+			if (shape.is_null())
+				return;
+			CollisionShape *cshape = memnew( CollisionShape );
+			cshape->set_shape(shape);
+
+			Node *owner =  node->get_owner();
+
+			UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo();
+			ur->create_action("Create Static Trimesh");
+			ur->add_do_method(node->get_parent(),"add_child",cshape);
+			ur->add_do_method(node->get_parent(),"move_child",cshape,node->get_index()+1);
+			ur->add_do_method(cshape,"set_owner",owner);
+			ur->add_do_reference(cshape);
+			ur->add_undo_method(node->get_parent(),"remove_child",cshape);
+			ur->commit_action();
+
+		} break;
+		case MENU_OPTION_CREATE_NAVMESH: {
+
+
+
+
+			Ref<NavigationMesh> nmesh = memnew( NavigationMesh );
+
+			if (nmesh.is_null())
+				return;
+
+			nmesh->create_from_mesh(mesh);
+			NavigationMeshInstance *nmi = memnew(  NavigationMeshInstance );
+			nmi->set_navigation_mesh(nmesh);
+
+			Node *owner = node==get_scene()->get_edited_scene_root() ? node : node->get_owner();
+
+			UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo();
+			ur->create_action("Create Navigation Mesh");
+
+			ur->add_do_method(node,"add_child",nmi);
+			ur->add_do_method(nmi,"set_owner",owner);
+
+			ur->add_do_reference(nmi);
+			ur->add_undo_method(node,"remove_child",nmi);
+			ur->commit_action();
+		} break;
+	}
+
+}
+
+void MeshInstanceEditor::_bind_methods() {
+
+	ObjectTypeDB::bind_method("_menu_option",&MeshInstanceEditor::_menu_option);
+}
+
+MeshInstanceEditor::MeshInstanceEditor() {
+
+
+	options = memnew( MenuButton );
+	//add_child(options);
+	SpatialEditor::get_singleton()->add_control_to_menu_panel(options);
+
+	options->set_text("Mesh");
+	options->get_popup()->add_item("Create Trimesh Static Body",MENU_OPTION_CREATE_STATIC_TRIMESH_BODY);
+	options->get_popup()->add_item("Create Convex Static Body",MENU_OPTION_CREATE_STATIC_CONVEX_BODY);
+	options->get_popup()->add_separator();
+	options->get_popup()->add_item("Create Trimesh Collision Sibling",MENU_OPTION_CREATE_TRIMESH_COLLISION_SHAPE);
+	options->get_popup()->add_item("Create Convex Collision Sibling",MENU_OPTION_CREATE_CONVEX_COLLISION_SHAPE);
+	options->get_popup()->add_separator();
+	options->get_popup()->add_item("Create Navigation Mesh",MENU_OPTION_CREATE_NAVMESH);
+
+	options->get_popup()->connect("item_pressed", this,"_menu_option");
+
+}
+
+
+void MeshInstanceEditorPlugin::edit(Object *p_object) {
+
+	mesh_editor->edit(p_object->cast_to<MeshInstance>());
+}
+
+bool MeshInstanceEditorPlugin::handles(Object *p_object) const {
+
+	return p_object->is_type("MeshInstance");
+}
+
+void MeshInstanceEditorPlugin::make_visible(bool p_visible) {
+
+	if (p_visible) {
+		mesh_editor->options->show();
+	} else {
+
+		mesh_editor->options->hide();
+		mesh_editor->edit(NULL);
+	}
+
+}
+
+MeshInstanceEditorPlugin::MeshInstanceEditorPlugin(EditorNode *p_node) {
+
+	editor=p_node;
+	mesh_editor = memnew( MeshInstanceEditor );
+	editor->get_viewport()->add_child(mesh_editor);
+
+	mesh_editor->options->hide();
+}
+
+
+MeshInstanceEditorPlugin::~MeshInstanceEditorPlugin()
+{
+}
+
+

tools/editor/plugins/mesh_editor_plugin.h

@@ -0,0 +1,68 @@
+#ifndef MESH_EDITOR_PLUGIN_H
+#define MESH_EDITOR_PLUGIN_H
+
+
+#include "tools/editor/editor_plugin.h"
+#include "tools/editor/editor_node.h"
+#include "scene/3d/mesh_instance.h"
+#include "scene/gui/spin_box.h"
+
+
+class MeshInstanceEditor : public Node {
+
+	OBJ_TYPE(MeshInstanceEditor, Node );
+
+
+	enum Menu {
+
+		MENU_OPTION_CREATE_STATIC_TRIMESH_BODY,
+		MENU_OPTION_CREATE_STATIC_CONVEX_BODY,
+		MENU_OPTION_CREATE_TRIMESH_COLLISION_SHAPE,
+		MENU_OPTION_CREATE_CONVEX_COLLISION_SHAPE,
+		MENU_OPTION_CREATE_NAVMESH,
+	};
+
+	AcceptDialog *err_dialog;
+
+
+	Panel *panel;
+	MeshInstance *node;
+
+	LineEdit *surface_source;
+	LineEdit *mesh_source;
+
+
+	void _menu_option(int p_option);
+friend class MeshInstanceEditorPlugin;
+	MenuButton * options;
+
+protected:
+	void _node_removed(Node *p_node);
+	static void _bind_methods();
+public:
+
+	void edit(MeshInstance *p_mesh);
+	MeshInstanceEditor();
+};
+
+class MeshInstanceEditorPlugin : public EditorPlugin {
+
+	OBJ_TYPE( MeshInstanceEditorPlugin, EditorPlugin );
+
+	MeshInstanceEditor *mesh_editor;
+	EditorNode *editor;
+
+public:
+
+	virtual String get_name() const { return "MeshInstance"; }
+	bool has_main_screen() const { return false; }
+	virtual void edit(Object *p_node);
+	virtual bool handles(Object *p_node) const;
+	virtual void make_visible(bool p_visible);
+
+	MeshInstanceEditorPlugin(EditorNode *p_node);
+	~MeshInstanceEditorPlugin();
+
+};
+
+#endif // MESH_EDITOR_PLUGIN_H

tools/editor/plugins/script_editor_plugin.cpp

@@ -1286,7 +1286,7 @@ void ScriptEditor::_add_callback(Object *p_obj, const String& p_function, const
 			continue;
 
 		String code = ste->get_text_edit()->get_text();
-		int pos = script->get_language()->find_function(code,p_function);
+		int pos = script->get_language()->find_function(p_function,code);
 		if (pos==-1) {
 			//does not exist
 

tools/editor/plugins/spatial_editor_plugin.cpp

@@ -860,10 +860,19 @@ void SpatialEditorViewport::_sinput(const InputEvent &p_event) {
 						_edit.snap=false;
 						_edit.mode=TRANSFORM_NONE;
 
+
 						//gizmo has priority over everything
 
+						bool can_select_gizmos=true;
+
+						{
+							int idx = view_menu->get_popup()->get_item_index(VIEW_GIZMOS);
+							can_select_gizmos = 	view_menu->get_popup()->is_item_checked( idx );
+						}
+
+
 
-						if (spatial_editor->get_selected()) {
+						if (can_select_gizmos && spatial_editor->get_selected()) {
 
 							Ref<SpatialEditorGizmo> seg = spatial_editor->get_selected()->get_gizmo();
 							if (seg.is_valid()) {
@@ -1934,6 +1943,18 @@ void SpatialEditorViewport::_menu_option(int p_option) {
 			view_menu->get_popup()->set_item_checked( idx, current );
 
 		} break;
+		case VIEW_GIZMOS: {
+
+			int idx = view_menu->get_popup()->get_item_index(VIEW_GIZMOS);
+			bool current = 	view_menu->get_popup()->is_item_checked( idx );
+			current=!current;
+			if (current)
+				camera->set_visible_layers( ((1<<20)-1)|(1<<(GIZMO_BASE_LAYER+index))|(1<<GIZMO_EDIT_LAYER) );
+			else
+				camera->set_visible_layers( ((1<<20)-1)|(1<<(GIZMO_BASE_LAYER+index)) );
+			view_menu->get_popup()->set_item_checked( idx, current );
+
+		} break;
 
 	}
 
@@ -2115,6 +2136,9 @@ void SpatialEditorViewport::reset() {
 	cursor.distance=4;
 	cursor.region_select=false;
 
+
+
+
 }
 
 SpatialEditorViewport::SpatialEditorViewport(SpatialEditor *p_spatial_editor, EditorNode *p_editor, int p_index) {
@@ -2139,7 +2163,7 @@ SpatialEditorViewport::SpatialEditorViewport(SpatialEditor *p_spatial_editor, Ed
 	surface->set_area_as_parent_rect();
 	camera = memnew(Camera);
 	camera->set_disable_gizmo(true);
-	camera->set_visible_layers( ((1<<20)-1)|(1<<(GIZMO_BASE_LAYER+p_index)) );
+	camera->set_visible_layers( ((1<<20)-1)|(1<<(GIZMO_BASE_LAYER+p_index))|(1<<GIZMO_EDIT_LAYER) );
 	//camera->set_environment(SpatialEditor::get_singleton()->get_viewport_environment());
 	viewport->add_child(camera);
 	camera->make_current();
@@ -2166,6 +2190,9 @@ SpatialEditorViewport::SpatialEditorViewport(SpatialEditor *p_spatial_editor, Ed
 	view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(VIEW_ENVIRONMENT),true);
 	view_menu->get_popup()->add_separator();
 	view_menu->get_popup()->add_check_item("Audio Listener",VIEW_AUDIO_LISTENER);
+	view_menu->get_popup()->add_separator();
+	view_menu->get_popup()->add_check_item("Gizmos",VIEW_GIZMOS);
+	view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(VIEW_GIZMOS),true);
 
 	view_menu->get_popup()->add_separator();
 	view_menu->get_popup()->add_item("Selection (F)",VIEW_CENTER_TO_SELECTION);
@@ -2362,11 +2389,16 @@ Dictionary SpatialEditor::get_state() const {
 	d["viewports"]=vpdata;
 
 	d["default_light"]=view_menu->get_popup()->is_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_DEFAULT_LIGHT) );;
+	d["ambient_light_color"]=settings_ambient_color->get_color();
+
+	d["default_srgb"]=view_menu->get_popup()->is_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_DEFAULT_SRGB) );;
 	d["show_grid"]=view_menu->get_popup()->is_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_GRID) );;
 	d["show_origin"]=view_menu->get_popup()->is_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_ORIGIN) );;
 	d["fov"]=get_fov();
 	d["znear"]=get_znear();
 	d["zfar"]=get_zfar();
+	d["deflight_rot_x"]=settings_default_light_rot_x;
+	d["deflight_rot_y"]=settings_default_light_rot_y;
 
 	return d;
 }
@@ -2407,11 +2439,12 @@ void SpatialEditor::set_state(const Dictionary& p_state) {
 
 
 	if (d.has("zfar"))
-		settings_zfar->set_text(d["zfar"]);
+		settings_zfar->set_val(float(d["zfar"]));
 	if (d.has("znear"))
-		settings_znear->set_text(d["znear"]);
+		settings_znear->set_val(float(d["znear"]));
 	if (d.has("fov"))
-		settings_fov->set_text(d["fov"]);
+		settings_fov->set_val(float(d["fov"]));
+
 	if (d.has("default_light")) {
 		bool use = d["default_light"];
 
@@ -2429,7 +2462,17 @@ void SpatialEditor::set_state(const Dictionary& p_state) {
 		}
 
 	}
+	if (d.has("ambient_light_color")) {
+		settings_ambient_color->set_color(d["ambient_light_color"]);
+		viewport_environment->fx_set_param(Environment::FX_PARAM_AMBIENT_LIGHT_COLOR,d["ambient_light_color"]);
+	}
+
+	if (d.has("default_srgb")) {
+		bool use = d["default_light"];
 
+		viewport_environment->set_enable_fx(Environment::FX_SRGB,use);
+		view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_DEFAULT_SRGB), use );
+	}
 	if (d.has("show_grid")) {
 		bool use = d["show_grid"];
 
@@ -2447,6 +2490,12 @@ void SpatialEditor::set_state(const Dictionary& p_state) {
 		}
 	}
 
+	if (d.has("deflight_rot_x"))
+		settings_default_light_rot_x=d["deflight_rot_x"];
+	if (d.has("deflight_rot_y"))
+		settings_default_light_rot_y=d["deflight_rot_y"];
+
+	_update_default_light_angle();
 
 
 }
@@ -2609,10 +2658,28 @@ void SpatialEditor::_menu_item_pressed(int p_option) {
 			} else {
 				light_instance=VisualServer::get_singleton()->instance_create2(light,get_scene()->get_root()->get_world()->get_scenario());
 				VisualServer::get_singleton()->instance_set_transform(light_instance,light_transform);
+
+				_update_default_light_angle();
 			}
 
 			view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(p_option), light_instance.is_valid() );
 
+		} break;
+		case MENU_VIEW_USE_DEFAULT_SRGB: {
+
+			bool is_checked = view_menu->get_popup()->is_item_checked( view_menu->get_popup()->get_item_index(p_option) );
+
+			if (is_checked) {
+				viewport_environment->set_enable_fx(Environment::FX_SRGB,false);
+			} else {
+				viewport_environment->set_enable_fx(Environment::FX_SRGB,true);
+			}
+
+			is_checked = ! is_checked;
+
+			view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(p_option), is_checked );
+
+
 		} break;
 		case MENU_VIEW_USE_1_VIEWPORT: {
 
@@ -2824,7 +2891,7 @@ void SpatialEditor::_menu_item_pressed(int p_option) {
 		} break;
 		case MENU_VIEW_CAMERA_SETTINGS: {
 
-			settings_dialog->popup_centered(Size2(200,160));
+			settings_dialog->popup_centered(settings_vbc->get_combined_minimum_size()+Size2(50,50));
 		} break;
 
 	}
@@ -3233,13 +3300,15 @@ void SpatialEditor::_notification(int p_what) {
 		_menu_item_pressed(MENU_VIEW_USE_1_VIEWPORT);
 
 		get_scene()->connect("node_removed",this,"_node_removed");
+		VS::get_singleton()->scenario_set_fallback_environment(get_viewport()->find_world()->get_scenario(),viewport_environment->get_rid());
+
 	}
 
 	if (p_what==NOTIFICATION_ENTER_SCENE) {
 
 		gizmos = memnew( SpatialEditorGizmos );
 		_init_indicators();
-
+		_update_default_light_angle();
 	}
 
 	if (p_what==NOTIFICATION_EXIT_SCENE) {
@@ -3374,7 +3443,8 @@ void SpatialEditor::_bind_methods() {
 //	ObjectTypeDB::bind_method("_update_selection",&SpatialEditor::_update_selection);
 	ObjectTypeDB::bind_method("_get_editor_data",&SpatialEditor::_get_editor_data);
 	ObjectTypeDB::bind_method("_request_gizmo",&SpatialEditor::_request_gizmo);
-
+	ObjectTypeDB::bind_method("_default_light_angle_input",&SpatialEditor::_default_light_angle_input);
+	ObjectTypeDB::bind_method("_update_ambient_light_color",&SpatialEditor::_update_ambient_light_color);
 	ObjectTypeDB::bind_method("_toggle_maximize_view",&SpatialEditor::_toggle_maximize_view);
 
 	ADD_SIGNAL( MethodInfo("transform_key_request") );
@@ -3384,9 +3454,9 @@ void SpatialEditor::_bind_methods() {
 
 void SpatialEditor::clear() {
 
-	settings_fov->set_text(EDITOR_DEF("3d_editor/default_fov",60.0));
-	settings_znear->set_text(EDITOR_DEF("3d_editor/default_z_near",0.1));
-	settings_zfar->set_text(EDITOR_DEF("3d_editor/default_z_far",1500.0));
+	settings_fov->set_val(EDITOR_DEF("3d_editor/default_fov",60.0));
+	settings_znear->set_val(EDITOR_DEF("3d_editor/default_z_near",0.1));
+	settings_zfar->set_val(EDITOR_DEF("3d_editor/default_z_far",1500.0));
 
 	for(int i=0;i<4;i++) {
 		viewports[i]->reset();
@@ -3410,11 +3480,54 @@ void SpatialEditor::clear() {
 		viewports[i]->view_menu->get_popup()->set_item_checked(view_menu->get_popup()->get_item_index(SpatialEditorViewport::VIEW_AUDIO_LISTENER),i==0);
 		viewports[i]->viewport->set_as_audio_listener(i==0);
 	}
+
 	view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_GRID), true );
 
+	settings_default_light_rot_x=Math_PI*0.3;
+	settings_default_light_rot_y=Math_PI*0.2;
+
+	viewport_environment->fx_set_param(Environment::FX_PARAM_AMBIENT_LIGHT_COLOR,Color(0.15,0.15,0.15));
+	settings_ambient_color->set_color(Color(0.15,0.15,0.15));
+	if (!light_instance.is_valid())
+		_menu_item_pressed(MENU_VIEW_USE_DEFAULT_LIGHT);
+
+	_update_default_light_angle();
+
+
+}
+
+
+void SpatialEditor::_update_ambient_light_color(const Color& p_color) {
+
+	viewport_environment->fx_set_param(Environment::FX_PARAM_AMBIENT_LIGHT_COLOR,settings_ambient_color->get_color());
+
+}
+
+void SpatialEditor::_update_default_light_angle() {
+
+	Transform t;
+	t.basis.rotate(Vector3(1,0,0),settings_default_light_rot_x);
+	t.basis.rotate(Vector3(0,1,0),settings_default_light_rot_y);
+	settings_dlight->set_transform(t);
+	if (light_instance.is_valid()) {
+		VS::get_singleton()->instance_set_transform(light_instance,t);
+	}
+
+}
+
+void SpatialEditor::_default_light_angle_input(const InputEvent& p_event) {
+
+
+	if (p_event.type==InputEvent::MOUSE_MOTION && p_event.mouse_motion.button_mask&(0x1|0x2|0x4)) {
+
+		settings_default_light_rot_y = Math::fposmod(settings_default_light_rot_y - p_event.mouse_motion.relative_x*0.01,Math_PI*2.0);
+		settings_default_light_rot_x = Math::fposmod(settings_default_light_rot_x - p_event.mouse_motion.relative_y*0.01,Math_PI*2.0);
+		_update_default_light_angle();
+	}
 
 }
 
+
 SpatialEditor::SpatialEditor(EditorNode *p_editor) {
 
 
@@ -3510,6 +3623,7 @@ SpatialEditor::SpatialEditor(EditorNode *p_editor) {
 	p = view_menu->get_popup();
 
 	p->add_check_item("Use Default Light",MENU_VIEW_USE_DEFAULT_LIGHT);
+	p->add_check_item("Use Default sRGB",MENU_VIEW_USE_DEFAULT_SRGB);
 	p->add_separator();
 
 	p->add_check_item("1 Viewport",MENU_VIEW_USE_1_VIEWPORT,KEY_MASK_ALT+KEY_1);
@@ -3612,42 +3726,68 @@ SpatialEditor::SpatialEditor(EditorNode *p_editor) {
 	settings_dialog = memnew( ConfirmationDialog );
 	settings_dialog->set_title("Viewport Settings");
 	add_child(settings_dialog);
-	l = memnew(Label);
-	l->set_text("Perspective FOV (deg.):");
-	l->set_pos(Point2(5,5));
-	settings_dialog->add_child(l);
-
-	settings_fov = memnew( LineEdit );
-	settings_fov->set_anchor( MARGIN_RIGHT, ANCHOR_END );
-	settings_fov->set_begin( Point2(15,22) );
-	settings_fov->set_end( Point2(15,35) );
-	settings_fov->set_text(EDITOR_DEF("3d_editor/default_fov",60.0));
-	settings_dialog->add_child(settings_fov);
-
-	l = memnew(Label);
-	l->set_text("View Z-Near");
-	l->set_pos(Point2(5,45));
-	settings_dialog->add_child(l);
-
-	settings_znear = memnew( LineEdit );
-	settings_znear->set_anchor( MARGIN_RIGHT, ANCHOR_END );
-	settings_znear->set_begin( Point2(15,62) );
-	settings_znear->set_end( Point2(15,75) );
-	settings_znear->set_text(EDITOR_DEF("3d_editor/default_z_near",0.1));
-	settings_dialog->add_child(settings_znear);
-
-
-	l = memnew(Label);
-	l->set_text("View Z-Far");
-	l->set_pos(Point2(5,85));
-	settings_dialog->add_child(l);
-
-	settings_zfar = memnew( LineEdit );
-	settings_zfar->set_anchor( MARGIN_RIGHT, ANCHOR_END );
-	settings_zfar->set_begin( Point2(15,102) );
-	settings_zfar->set_end( Point2(15,115) );
-	settings_zfar->set_text(EDITOR_DEF("3d_editor/default_z_far",1500.0));
-	settings_dialog->add_child(settings_zfar);
+	settings_vbc = memnew( VBoxContainer );
+	settings_vbc->set_custom_minimum_size(Size2(200,0));
+	settings_dialog->add_child(settings_vbc);
+	settings_dialog->set_child_rect(settings_vbc);
+
+
+
+	settings_light_base = memnew( Control );
+	settings_light_base->set_custom_minimum_size(Size2(128,128));
+	settings_light_base->connect("input_event",this,"_default_light_angle_input");
+	settings_vbc->add_margin_child("Default Light Normal:",settings_light_base);
+	settings_light_vp = memnew( Viewport );
+	settings_light_vp->set_use_own_world(true);
+	settings_light_base->add_child(settings_light_vp);
+
+	settings_dlight = memnew( DirectionalLight );
+	settings_light_vp->add_child(settings_dlight);
+	settings_sphere = memnew( ImmediateGeometry );
+	settings_sphere->begin(Mesh::PRIMITIVE_TRIANGLES,Ref<Texture>());
+	settings_sphere->set_color(Color(1,1,1));
+	settings_sphere->add_sphere(32,16,1);
+	settings_sphere->end();
+	settings_light_vp->add_child(settings_sphere);
+	settings_camera = memnew( Camera );
+	settings_light_vp->add_child(settings_camera);
+	settings_camera->set_translation(Vector3(0,0,2));
+	settings_camera->set_orthogonal(2.1,0.1,5);
+
+	settings_default_light_rot_x=Math_PI*0.3;
+	settings_default_light_rot_y=Math_PI*0.2;
+
+
+
+	settings_ambient_color = memnew( ColorPickerButton );
+	settings_vbc->add_margin_child("Ambient Light Color:",settings_ambient_color);
+	settings_ambient_color->connect("color_changed",this,"_update_ambient_light_color");
+
+	viewport_environment->set_enable_fx(Environment::FX_AMBIENT_LIGHT,true);
+	viewport_environment->fx_set_param(Environment::FX_PARAM_AMBIENT_LIGHT_COLOR,Color(0.15,0.15,0.15));
+	settings_ambient_color->set_color(Color(0.15,0.15,0.15));
+
+
+	settings_fov = memnew( SpinBox );
+	settings_fov->set_max(179);
+	settings_fov->set_min(1);
+	settings_fov->set_step(0.01);
+	settings_fov->set_val(EDITOR_DEF("3d_editor/default_fov",60.0));
+	settings_vbc->add_margin_child("Perspective FOV (deg.):",settings_fov);
+
+	settings_znear = memnew( SpinBox );
+	settings_znear->set_max(10000);
+	settings_znear->set_min(0.1);
+	settings_znear->set_step(0.01);
+	settings_znear->set_val(EDITOR_DEF("3d_editor/default_z_near",0.1));
+	settings_vbc->add_margin_child("View Z-Near:",settings_znear);
+
+	settings_zfar = memnew( SpinBox );
+	settings_zfar->set_max(10000);
+	settings_zfar->set_min(0.1);
+	settings_zfar->set_step(0.01);
+	settings_zfar->set_val(EDITOR_DEF("3d_editor/default_z_far",1500));
+	settings_vbc->add_margin_child("View Z-Far:",settings_zfar);
 
 	//settings_dialog->get_cancel()->hide();
 	/* XFORM DIALOG */

tools/editor/plugins/spatial_editor_plugin.h

@@ -32,6 +32,8 @@
 #include "tools/editor/editor_plugin.h"
 #include "tools/editor/editor_node.h"
 #include "scene/3d/visual_instance.h"
+#include "scene/3d/immediate_geometry.h"
+#include "scene/3d/light.h"
 #include "scene/gui/panel_container.h"
 /**
 	@author Juan Linietsky <[email protected]>
@@ -80,11 +82,14 @@ friend class SpatialEditor;
 		VIEW_ENVIRONMENT,
 		VIEW_ORTHOGONAL,
 		VIEW_AUDIO_LISTENER,
+		VIEW_GIZMOS,
 	};
+public:
 	enum {
-		GIZMO_BASE_LAYER=25
+		GIZMO_BASE_LAYER=27,
+		GIZMO_EDIT_LAYER=26
 	};
-
+private:
 	int index;
 	void _menu_option(int p_option);
 	Size2 prev_size;
@@ -349,6 +354,7 @@ private:
 		MENU_VIEW_USE_3_VIEWPORTS_ALT,
 		MENU_VIEW_USE_4_VIEWPORTS,
 		MENU_VIEW_USE_DEFAULT_LIGHT,
+		MENU_VIEW_USE_DEFAULT_SRGB,
 		MENU_VIEW_DISPLAY_NORMAL,
 		MENU_VIEW_DISPLAY_WIREFRAME,
 		MENU_VIEW_DISPLAY_OVERDRAW,
@@ -382,15 +388,28 @@ private:
 	LineEdit *xform_scale[3];
 	OptionButton *xform_type;
 
-	LineEdit *settings_fov;
-	LineEdit *settings_znear;
-	LineEdit *settings_zfar;
+	VBoxContainer *settings_vbc;
+	SpinBox *settings_fov;
+	SpinBox *settings_znear;
+	SpinBox *settings_zfar;
+	DirectionalLight *settings_dlight;
+	ImmediateGeometry *settings_sphere;
+	Camera *settings_camera;
+	float settings_default_light_rot_x;
+	float settings_default_light_rot_y;
+
+	Control *settings_light_base;
+	Viewport *settings_light_vp;
+	ColorPickerButton *settings_ambient_color;
+	Image settings_light_dir_image;
+
 
 	void _xform_dialog_action();
 	void _menu_item_pressed(int p_option);
 
 	HBoxContainer *hbc_menu;
 
+
 //
 //
 	void _generate_selection_box();
@@ -420,6 +439,10 @@ private:
 	SpatialEditorGizmos *gizmos;
 	SpatialEditor();
 
+	void _update_ambient_light_color(const Color& p_color);
+	void _update_default_light_angle();
+	void _default_light_angle_input(const InputEvent& p_event);
+
 protected:	
 
 
@@ -436,9 +459,9 @@ public:
 	static SpatialEditor *get_singleton() { return singleton; }
 	void snap_cursor_to_plane(const Plane& p_plane);
 
-	float get_znear() const { return settings_znear->get_text().to_double(); }
-	float get_zfar() const { return settings_zfar->get_text().to_double(); }
-	float get_fov() const { return settings_fov->get_text().to_double(); }
+	float get_znear() const { return settings_znear->get_val(); }
+	float get_zfar() const { return settings_zfar->get_val(); }
+	float get_fov() const { return settings_fov->get_val(); }
 
 	Transform get_gizmo_transform() const { return gizmo.transform; }
 	bool is_gizmo_visible() const { return gizmo.visible; }

tools/editor/spatial_editor_gizmos.cpp

@@ -36,7 +36,7 @@
 #include "scene/resources/ray_shape.h"
 #include "scene/resources/convex_polygon_shape.h"
 #include "scene/resources/plane_shape.h"
-
+#include "quick_hull.h"
 
 // Keep small children away from this file.
 // It's so ugly it will eat them alive
@@ -75,6 +75,7 @@ void SpatialGizmoTool::Instance::create_instance(Spatial *p_base) {
 		VS::get_singleton()->instance_set_extra_visibility_margin(instance,1);
 	VS::get_singleton()->instance_geometry_set_flag(instance,VS::INSTANCE_FLAG_CAST_SHADOW,false);
 	VS::get_singleton()->instance_geometry_set_flag(instance,VS::INSTANCE_FLAG_RECEIVE_SHADOWS,false);
+	VS::get_singleton()->instance_set_layer_mask(instance,1<<SpatialEditorViewport::GIZMO_EDIT_LAYER); //gizmos are 26
 }
 
 
@@ -1237,6 +1238,10 @@ void SkeletonSpatialGizmo::redraw() {
 	weights[0]=1;
 
 
+	AABB aabb;
+
+	Color bonecolor = Color(1.0,0.4,0.4,0.3);
+	Color rootcolor = Color(0.4,1.0,0.4,0.1);
 
 	for (int i=0;i<skel->get_bone_count();i++) {
 
@@ -1247,8 +1252,96 @@ void SkeletonSpatialGizmo::redraw() {
 
 			Vector3 v0 = grests[parent].origin;
 			Vector3 v1 = grests[i].origin;
+			Vector3 d = (v1-v0).normalized();
+			float dist = v0.distance_to(v1);
+
+			//find closest axis
+			int closest=-1;
+			float closest_d;
+			for(int j=0;j<3;j++) {
+				float dp = Math::abs(grests[parent].basis[j].normalized().dot(d));
+				if (j==0 || dp>closest_d)
+					closest=j;
+			}
+
+			//find closest other
+			Vector3 first;
+			Vector3 points[4];
+			int pointidx=0;
+			for(int j=0;j<3;j++) {
+
+				bones[0]=parent;
+				surface_tool->add_bones(bones);
+				surface_tool->add_weights(weights);
+				surface_tool->add_color(rootcolor);
+				surface_tool->add_vertex(v0-grests[parent].basis[j].normalized()*dist*0.05);
+				surface_tool->add_bones(bones);
+				surface_tool->add_weights(weights);
+				surface_tool->add_color(rootcolor);
+				surface_tool->add_vertex(v0+grests[parent].basis[j].normalized()*dist*0.05);
+
+				if (j==closest)
+					continue;
+
+				Vector3 axis;
+				if (first==Vector3()) {
+					axis = d.cross(d.cross(grests[parent].basis[j])).normalized();
+					first=axis;
+				} else {
+					axis = d.cross(first).normalized();
+				}
+
+				for(int k=0;k<2;k++) {
+
+					if (k==1)
+						axis=-axis;
+					Vector3 point = v0+d*dist*0.2;
+					point+=axis*dist*0.1;
+
+
+					bones[0]=parent;
+					surface_tool->add_bones(bones);
+					surface_tool->add_weights(weights);
+					surface_tool->add_color(bonecolor);
+					surface_tool->add_vertex(v0);
+					surface_tool->add_bones(bones);
+					surface_tool->add_weights(weights);
+					surface_tool->add_color(bonecolor);
+					surface_tool->add_vertex(point);
+
+					bones[0]=parent;
+					surface_tool->add_bones(bones);
+					surface_tool->add_weights(weights);
+					surface_tool->add_color(bonecolor);
+					surface_tool->add_vertex(point);
+					bones[0]=i;
+					surface_tool->add_bones(bones);
+					surface_tool->add_weights(weights);
+					surface_tool->add_color(bonecolor);
+					surface_tool->add_vertex(v1);
+					points[pointidx++]=point;
+
+				}
+
+			}
+
+			SWAP( points[1],points[2] );
+			for(int j=0;j<4;j++) {
+
+
+				bones[0]=parent;
+				surface_tool->add_bones(bones);
+				surface_tool->add_weights(weights);
+				surface_tool->add_color(bonecolor);
+				surface_tool->add_vertex(points[j]);
+				surface_tool->add_bones(bones);
+				surface_tool->add_weights(weights);
+				surface_tool->add_color(bonecolor);
+				surface_tool->add_vertex(points[(j+1)%4]);
+			}
 
 
+/*
 			bones[0]=parent;
 			surface_tool->add_bones(bones);
 			surface_tool->add_weights(weights);
@@ -1259,13 +1352,13 @@ void SkeletonSpatialGizmo::redraw() {
 			surface_tool->add_weights(weights);
 			surface_tool->add_color(Color(0.4,1,0.4,0.4));
 			surface_tool->add_vertex(v1);
-
+*/
 		} else {
 
 			grests[i]=skel->get_bone_rest(i);
 			bones[0]=i;
 		}
-
+/*
 		Transform  t = grests[i];
 		t.orthonormalize();
 
@@ -1302,6 +1395,7 @@ void SkeletonSpatialGizmo::redraw() {
 			}
 
 		}
+		*/
 	}
 
 	Ref<Mesh> m = surface_tool->commit();
@@ -1978,6 +2072,34 @@ void CollisionShapeSpatialGizmo::redraw(){
 	}
 
 
+	if (s->cast_to<ConvexPolygonShape>()) {
+
+		DVector<Vector3> points = s->cast_to<ConvexPolygonShape>()->get_points();
+
+		if (points.size()>3) {
+
+			QuickHull qh;
+			Vector<Vector3> varr = Variant(points);
+			Geometry::MeshData md;
+			Error err = qh.build(varr,md);
+			if (err==OK) {
+				Vector<Vector3> points;
+				points.resize(md.edges.size()*2);
+				for(int i=0;i<md.edges.size();i++) {
+					points[i*2+0]=md.vertices[md.edges[i].a];
+					points[i*2+1]=md.vertices[md.edges[i].b];
+				}
+
+
+				add_lines(points,SpatialEditorGizmos::singleton->shape_material);
+				add_collision_segments(points);
+
+			}
+		}
+
+	}
+
+
 	if (s->cast_to<RayShape>()) {
 
 		Ref<RayShape> rs=s;
@@ -2210,7 +2332,8 @@ void NavigationMeshSpatialGizmo::redraw() {
 	Ref<TriangleMesh> tmesh = memnew( TriangleMesh);
 	tmesh->create(tmeshfaces);
 
-	add_lines(lines,navmesh->is_enabled()?SpatialEditorGizmos::singleton->navmesh_edge_material:SpatialEditorGizmos::singleton->navmesh_edge_material_disabled);
+	if (lines.size())
+		add_lines(lines,navmesh->is_enabled()?SpatialEditorGizmos::singleton->navmesh_edge_material:SpatialEditorGizmos::singleton->navmesh_edge_material_disabled);
 	add_collision_triangles(tmesh);
 	Ref<Mesh> m = memnew( Mesh );
 	Array a;