Several bugfixes, improving the import workflow

8 files changed, 222 insertions, 93 deletions

diff --git a/tools/editor/editor_file_system.cpp b/tools/editor/editor_file_system.cpp
index 077910de3..c7b50a3c0 100644
--- a/tools/editor/editor_file_system.cpp
+++ b/tools/editor/editor_file_system.cpp
@@ -1028,7 +1028,7 @@ void EditorFileSystem::_notification(int p_what) {
 
 bool EditorFileSystem::is_scanning() const {
 
-	return scanning;
+	return scanning || scanning_changes;
 }
 float EditorFileSystem::get_scanning_progress() const {
 
@@ -1393,6 +1393,7 @@ void EditorFileSystem::_reimport_file(const String& p_file) {
 		f->store_line("type=\""+importer->get_resource_type()+"\"");
 	}
 
+
 	if (importer->get_save_extension()=="") {
 		//no path
 	} else if (import_variants.size()) {
@@ -1400,7 +1401,10 @@ void EditorFileSystem::_reimport_file(const String& p_file) {
 		for(List<String>::Element *E=import_variants.front();E;E=E->next()) {
 
 
-			f->store_line("path."+E->get()+"=\""+base_path.c_escape()+"."+E->get()+"."+importer->get_save_extension()+"\"");
+			String path = base_path.c_escape()+"."+E->get()+"."+importer->get_save_extension();
+
+			f->store_line("path."+E->get()+"=\""+path+"\"");
+
 		}
 	} else {
 
@@ -1426,6 +1430,8 @@ void EditorFileSystem::_reimport_file(const String& p_file) {
 	f->store_line("");
 
 	//store options in provided order, to avoid file changing
+
+
 	for (List<ResourceImporter::ImportOption>::Element *E=opts.front();E;E=E->next()) {
 
 		String base = E->get().option.name;
@@ -1442,11 +1448,25 @@ void EditorFileSystem::_reimport_file(const String& p_file) {
 	//update modified times, to avoid reimport
 	fs->files[cpos]->modified_time = FileAccess::get_modified_time(p_file);
 	fs->files[cpos]->import_modified_time = FileAccess::get_modified_time(p_file+".import");
+
+	//if file is currently up, maybe the source it was loaded from changed, so import math must be updated for it
+	//to reload properly
+	if (ResourceCache::has(p_file)) {
+
+		Resource *r = ResourceCache::get(p_file);
+
+		if (r->get_import_path()!=String()) {
+
+			String dst_path = ResourceFormatImporter::get_singleton()->get_internal_resource_path(p_file);
+			r->set_import_path(dst_path);
+			r->set_import_last_modified_time(0);
+		}
+	}
 }
 
 void EditorFileSystem::reimport_files(const Vector<String>& p_files) {
 
-
+	importing=true;
 	EditorProgress pr("reimport",TTR("(Re)Importing Assets"),p_files.size());
 	for(int i=0;i<p_files.size();i++) {
 		pr.step(p_files[i].get_file(),i);
@@ -1455,6 +1475,10 @@ void EditorFileSystem::reimport_files(const Vector<String>& p_files) {
 	}
 
 	_save_filesystem_cache();
+	importing=false;
+	if (!is_scanning()) {
+		emit_signal("filesystem_changed");
+	}
 }
 
 void EditorFileSystem::_bind_methods() {
@@ -1503,6 +1527,7 @@ EditorFileSystem::EditorFileSystem() {
 
 	thread = NULL;
 	scanning=false;
+	importing=false;
 	use_threads=true;
 	thread_sources=NULL;
 	new_filesystem=NULL;
diff --git a/tools/editor/editor_file_system.h b/tools/editor/editor_file_system.h
index 92169907a..10d9b919f 100644
--- a/tools/editor/editor_file_system.h
+++ b/tools/editor/editor_file_system.h
@@ -133,6 +133,7 @@ class EditorFileSystem : public Node {
 
 	bool abort_scan;
 	bool scanning;
+	bool importing;
 	float scan_total;
 
 
@@ -210,6 +211,7 @@ public:
 
 	EditorFileSystemDirectory *get_filesystem();
 	bool is_scanning() const;
+	bool is_importing() const { return importing; }
 	float get_scanning_progress() const;
 	void scan();
 	void scan_changes();
diff --git a/tools/editor/editor_node.cpp b/tools/editor/editor_node.cpp
index f8540e3c6..352b0818b 100644
--- a/tools/editor/editor_node.cpp
+++ b/tools/editor/editor_node.cpp
@@ -308,6 +308,8 @@ void EditorNode::_notification(int p_what) {
 
 		}
 
+		ResourceImporterTexture::get_singleton()->update_imports();
+
 	}
 	if (p_what==NOTIFICATION_ENTER_TREE) {
 
@@ -411,8 +413,10 @@ void EditorNode::_fs_changed() {
 			if (E->get()->get_import_path()!=String()) {
 				//imported resource
 				uint64_t mt = FileAccess::get_modified_time(E->get()->get_import_path());
+				print_line("testing modified: "+E->get()->get_import_path()+" "+itos(mt)+" vs "+itos(E->get()->get_import_last_modified_time()));
 
 				if (mt!=E->get()->get_import_last_modified_time()) {
+					print_line("success");
 					changed.push_back(E->get());
 				}
 
diff --git a/tools/editor/import/editor_import_collada.cpp b/tools/editor/import/editor_import_collada.cpp
index 19608b4e9..4d99389f9 100644
--- a/tools/editor/import/editor_import_collada.cpp
+++ b/tools/editor/import/editor_import_collada.cpp
@@ -430,9 +430,10 @@ Error ColladaImport::_create_material(const String& p_target) {
 
 		}
 	} else {
-		//material->set_parameter(FixedSpatialMaterial::PARAM_SPECULAR,effect.specular.color);
+		material->set_metalness(effect.specular.color.get_v());
 	}
 
+
 	// EMISSION
 
 	if (effect.emission.texture!="") {
@@ -443,17 +444,21 @@ Error ColladaImport::_create_material(const String& p_target) {
 			Ref<Texture> texture = ResourceLoader::load(texfile,"Texture");
 			if (texture.is_valid()) {
 
+				material->set_feature(FixedSpatialMaterial::FEATURE_EMISSION,true);
 				material->set_texture(FixedSpatialMaterial::TEXTURE_EMISSION,texture);
 				material->set_emission(Color(1,1,1,1));
 
 				//material->set_parameter(FixedSpatialMaterial::PARAM_EMISSION,Color(1,1,1,1));
 			}else {
-				//missing_textures.push_back(texfile.get_file());
+				missing_textures.push_back(texfile.get_file());
 			}
 
 		}
 	} else {
-		//material->set_parameter(FixedSpatialMaterial::PARAM_EMISSION,effect.emission.color);
+		if (effect.emission.color!=Color()) {
+			material->set_feature(FixedSpatialMaterial::FEATURE_EMISSION,true);
+			material->set_emission(effect.emission.color);
+		}
 	}
 
 	// NORMAL
@@ -465,6 +470,7 @@ Error ColladaImport::_create_material(const String& p_target) {
 
 			Ref<Texture> texture = ResourceLoader::load(texfile,"Texture");
 			if (texture.is_valid()) {
+				material->set_feature(FixedSpatialMaterial::FEATURE_NORMAL_MAPPING,true);
 				material->set_texture(FixedSpatialMaterial::TEXTURE_NORMAL,texture);
 				//material->set_emission(Color(1,1,1,1));
 
@@ -477,7 +483,9 @@ Error ColladaImport::_create_material(const String& p_target) {
 	}
 
 
-	//material->set_parameter(FixedSpatialMaterial::PARAM_SPECULAR_EXP,effect.shininess);
+	float roughness = Math::sqrt(1.0-((Math::log(effect.shininess)/Math::log(2.0))/8.0)); //not very right..
+	material->set_roughness(roughness);
+
 	if (effect.double_sided) {
 		material->set_cull_mode(FixedSpatialMaterial::CULL_DISABLED);
 	}
diff --git a/tools/editor/import/resource_importer_texture.cpp b/tools/editor/import/resource_importer_texture.cpp
index 3cbe034e4..21e434fa1 100644
--- a/tools/editor/import/resource_importer_texture.cpp
+++ b/tools/editor/import/resource_importer_texture.cpp
@@ -1,6 +1,106 @@
 #include "resource_importer_texture.h"
 #include "io/image_loader.h"
 #include "scene/resources/texture.h"
+#include "tools/editor/editor_file_system.h"
+#include "io/config_file.h"
+
+
+void ResourceImporterTexture::_texture_reimport_srgb(const Ref<StreamTexture>& p_tex) {
+
+	singleton->mutex->lock();
+	StringName path = p_tex->get_path();
+
+	if (!singleton->make_flags.has(path)) {
+		singleton->make_flags[path]=0;
+	}
+
+	singleton->make_flags[path]|=MAKE_SRGB_FLAG;
+
+	print_line("requesting srgb for "+String(path));
+
+	singleton->mutex->unlock();
+
+}
+
+
+
+void ResourceImporterTexture::_texture_reimport_3d(const Ref<StreamTexture>& p_tex) {
+
+
+	singleton->mutex->lock();
+	StringName path = p_tex->get_path();
+
+	if (!singleton->make_flags.has(path)) {
+		singleton->make_flags[path]=0;
+	}
+
+	singleton->make_flags[path]|=MAKE_3D_FLAG;
+
+	print_line("requesting 3d for "+String(path));
+
+	singleton->mutex->unlock();
+
+
+}
+
+void ResourceImporterTexture::update_imports() {
+
+	if (EditorFileSystem::get_singleton()->is_scanning() || EditorFileSystem::get_singleton()->is_importing()) {
+		return; // do nothing for noe
+	}
+	mutex->lock();
+
+	if (make_flags.empty()) {
+		mutex->unlock();
+		return;
+	}
+
+	Vector<String> to_reimport;
+	for (Map<StringName,int>::Element *E=make_flags.front();E;E=E->next()) {
+
+		print_line("checking for reimport "+String(E->key()));
+
+
+		Ref<ConfigFile> cf;
+		cf.instance();
+		String src_path = String(E->key())+".import";
+
+		Error err = cf->load(src_path);
+		ERR_CONTINUE(err!=OK);
+
+		bool changed=false;
+		if (E->get()&MAKE_SRGB_FLAG && int(cf->get_value("params","flags/srgb"))==2) {
+			cf->set_value("params","flags/srgb",1);
+			changed=true;
+		}
+
+		if (E->get()&MAKE_3D_FLAG && bool(cf->get_value("params","detect_3d"))) {
+			cf->set_value("params","detect_3d",false);
+			cf->set_value("params","compress/mode",2);
+			cf->set_value("params","flags/repeat",true);
+			cf->set_value("params","flags/filter",true);
+			cf->set_value("params","flags/mipmaps",true);
+			changed=true;
+		}
+
+		if (changed) {
+			cf->save(src_path);
+			to_reimport.push_back(E->key());
+		}
+
+	}
+
+	make_flags.clear();
+
+	mutex->unlock();
+
+	if (to_reimport.size()) {
+		EditorFileSystem::get_singleton()->reimport_files(to_reimport);
+	}
+
+}
+
+
 
 String ResourceImporterTexture::get_importer_name() const {
 
@@ -57,7 +157,7 @@ void ResourceImporterTexture::get_import_options(List<ImportOption> *r_options,i
 	r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL,"flags/filter"),p_preset==PRESET_2D_PIXEL?false:true));
 	r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL,"flags/mipmaps"),p_preset==PRESET_3D?true:false));
 	r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL,"flags/anisotropic"),false));
-	r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL,"flags/srgb",PROPERTY_HINT_ENUM,"Disable,Enable,Detect"),2));
+	r_options->push_back(ImportOption(PropertyInfo(Variant::INT,"flags/srgb",PROPERTY_HINT_ENUM,"Disable,Enable,Detect"),2));
 	r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL,"process/fix_alpha_border"),p_preset!=PRESET_3D?true:false));
 	r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL,"process/premult_alpha"),true));
 	r_options->push_back(ImportOption(PropertyInfo(Variant::INT,"stream"),false));
@@ -67,7 +167,7 @@ void ResourceImporterTexture::get_import_options(List<ImportOption> *r_options,i
 }
 
 
-void ResourceImporterTexture::_save_stex(const Image& p_image,const String& p_to_path,int p_compress_mode,float p_lossy_quality,Image::CompressMode p_vram_compression,bool p_mipmaps,int p_texture_flags,bool p_streamable) {
+void ResourceImporterTexture::_save_stex(const Image& p_image, const String& p_to_path, int p_compress_mode, float p_lossy_quality, Image::CompressMode p_vram_compression, bool p_mipmaps, int p_texture_flags, bool p_streamable, bool p_detect_3d, bool p_detect_srgb) {
 
 
 	FileAccess *f = FileAccess::open(p_to_path,FileAccess::WRITE);
@@ -86,6 +186,11 @@ void ResourceImporterTexture::_save_stex(const Image& p_image,const String& p_to
 		format|=StreamTexture::FORMAT_BIT_STREAM;
 	if (p_mipmaps || p_compress_mode==COMPRESS_VIDEO_RAM) //VRAM always uses mipmaps
 		format|=StreamTexture::FORMAT_BIT_HAS_MIPMAPS; //mipmaps bit
+	if (p_detect_3d)
+		format|=StreamTexture::FORMAT_BIT_DETECT_3D;
+	if (p_detect_srgb)
+		format|=StreamTexture::FORMAT_BIT_DETECT_SRGB;
+
 
 	switch (p_compress_mode) {
 		case COMPRESS_LOSSLESS: {
@@ -99,7 +204,7 @@ void ResourceImporterTexture::_save_stex(const Image& p_image,const String& p_to
 
 			int mmc = image.get_mipmap_count() + 1;
 
-			format=StreamTexture::FORMAT_BIT_LOSSLESS;
+			format|=StreamTexture::FORMAT_BIT_LOSSLESS;
 			f->store_32(format);
 			f->store_32(mmc);
 
@@ -130,7 +235,7 @@ void ResourceImporterTexture::_save_stex(const Image& p_image,const String& p_to
 
 			int mmc = image.get_mipmap_count() + 1;
 
-			format=StreamTexture::FORMAT_BIT_LOSSY;
+			format|=StreamTexture::FORMAT_BIT_LOSSY;
 			f->store_32(format);
 			f->store_32(mmc);
 
@@ -162,7 +267,6 @@ void ResourceImporterTexture::_save_stex(const Image& p_image,const String& p_to
 			PoolVector<uint8_t> data=image.get_data();
 			int dl = data.size();
 			PoolVector<uint8_t>::Read r = data.read();
-
 			f->store_buffer(r.ptr(),dl);
 
 		} break;
@@ -198,7 +302,7 @@ Error ResourceImporterTexture::import(const String& p_source_file, const String&
 	bool filter= p_options["flags/filter"];
 	bool mipmaps= p_options["flags/mipmaps"];
 	bool anisotropic= p_options["flags/anisotropic"];
-	bool srgb= p_options["flags/srgb"];
+	int srgb= p_options["flags/srgb"];
 	bool fix_alpha_border= p_options["process/fix_alpha_border"];
 	bool premult_alpha= p_options["process/premult_alpha"];
 	bool stream = p_options["stream"];
@@ -222,7 +326,7 @@ Error ResourceImporterTexture::import(const String& p_source_file, const String&
 		tex_flags|=Texture::FLAG_MIPMAPS;
 	if (anisotropic)
 		tex_flags|=Texture::FLAG_ANISOTROPIC_FILTER;
-	if (srgb)
+	if (srgb==1)
 		tex_flags|=Texture::FLAG_CONVERT_TO_LINEAR;
 
 	if (size_limit >0 && (image.get_width()>size_limit || image.get_height()>size_limit )) {
@@ -249,26 +353,41 @@ Error ResourceImporterTexture::import(const String& p_source_file, const String&
 		image.premultiply_alpha();
 	}
 
+	bool detect_3d = p_options["detect_3d"];
+	bool detect_srgb = srgb==2;
 
 	if (compress_mode==COMPRESS_VIDEO_RAM) {
 		//must import in all formats
 		//Android, GLES 2.x
-		_save_stex(image,p_save_path+".etc.stex",compress_mode,lossy,Image::COMPRESS_ETC,mipmaps,tex_flags,stream);
+		_save_stex(image,p_save_path+".etc.stex",compress_mode,lossy,Image::COMPRESS_ETC,mipmaps,tex_flags,stream,detect_3d,detect_srgb);
 		r_platform_variants->push_back("etc");
 		//_save_stex(image,p_save_path+".etc2.stex",compress_mode,lossy,Image::COMPRESS_ETC2,mipmaps,tex_flags,stream);
 		//r_platform_variants->push_back("etc2");
-		_save_stex(image,p_save_path+".s3tc.stex",compress_mode,lossy,Image::COMPRESS_S3TC,mipmaps,tex_flags,stream);
+		_save_stex(image,p_save_path+".s3tc.stex",compress_mode,lossy,Image::COMPRESS_S3TC,mipmaps,tex_flags,stream,detect_3d,detect_srgb);
 		r_platform_variants->push_back("s3tc");
 
 	} else {
 		//import normally
-		_save_stex(image,p_save_path+".stex",compress_mode,lossy,Image::COMPRESS_16BIT /*this is ignored */,mipmaps,tex_flags,stream);
+		_save_stex(image,p_save_path+".stex",compress_mode,lossy,Image::COMPRESS_16BIT /*this is ignored */,mipmaps,tex_flags,stream,detect_3d,detect_srgb);
 	}
 
 	return OK;
 }
 
+ResourceImporterTexture *ResourceImporterTexture::singleton=NULL;
+
 ResourceImporterTexture::ResourceImporterTexture()
 {
 
+	singleton=this;
+	StreamTexture::request_3d_callback=_texture_reimport_3d;
+	StreamTexture::request_srgb_callback=_texture_reimport_srgb;
+	mutex = Mutex::create();
 }
+
+ResourceImporterTexture::~ResourceImporterTexture()
+{
+
+	memdelete(mutex);
+}
+
diff --git a/tools/editor/import/resource_importer_texture.h b/tools/editor/import/resource_importer_texture.h
index 84f7b7783..4c795e132 100644
--- a/tools/editor/import/resource_importer_texture.h
+++ b/tools/editor/import/resource_importer_texture.h
@@ -2,10 +2,33 @@
 #define RESOURCEIMPORTTEXTURE_H
 
 #include "io/resource_import.h"
+class StreamTexture;
 
 class ResourceImporterTexture : public ResourceImporter {
 	GDCLASS(ResourceImporterTexture,ResourceImporter)
+
+
+
+protected:
+
+	enum {
+		MAKE_3D_FLAG=1,
+		MAKE_SRGB_FLAG=2
+	};
+
+	Mutex *mutex;
+	Map<StringName,int> make_flags;
+
+	static void _texture_reimport_srgb(const Ref<StreamTexture>& p_tex);
+	static void _texture_reimport_3d(const Ref<StreamTexture>& p_tex);
+
+
+
+
+	static ResourceImporterTexture *singleton;
 public:
+
+	static ResourceImporterTexture *get_singleton() { return singleton; }
 	virtual String get_importer_name() const;
 	virtual String get_visible_name() const;
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
@@ -33,11 +56,15 @@ public:
 	virtual void get_import_options(List<ImportOption> *r_options,int p_preset=0) const;
 	virtual bool get_option_visibility(const String& p_option,const Map<StringName,Variant>& p_options) const;
 
-	void _save_stex(const Image& p_image, const String& p_to_path, int p_compress_mode, float p_lossy_quality, Image::CompressMode p_vram_compression, bool p_mipmaps, int p_texture_flags, bool p_streamable);
+	void _save_stex(const Image& p_image, const String& p_to_path, int p_compress_mode, float p_lossy_quality, Image::CompressMode p_vram_compression, bool p_mipmaps, int p_texture_flags, bool p_streamable,bool p_detect_3d,bool p_detect_srgb);
 
 	virtual Error import(const String& p_source_file,const String& p_save_path,const Map<StringName,Variant>& p_options,List<String>* r_platform_variants,List<String>* r_gen_files=NULL);
 
+
+	void update_imports();
+
 	ResourceImporterTexture();
+	~ResourceImporterTexture();
 };
 
 #endif // RESOURCEIMPORTTEXTURE_H
diff --git a/tools/editor/plugins/spatial_editor_plugin.cpp b/tools/editor/plugins/spatial_editor_plugin.cpp
index 9f8367ff1..3ba1a2cbd 100644
--- a/tools/editor/plugins/spatial_editor_plugin.cpp
+++ b/tools/editor/plugins/spatial_editor_plugin.cpp
@@ -277,12 +277,10 @@ ObjectID SpatialEditorViewport::_select_ray(const Point2& p_pos, bool p_append,b
 	Vector<ObjectID> instances=VisualServer::get_singleton()->instances_cull_ray(pos,ray,get_tree()->get_root()->get_world()->get_scenario() );
 	Set<Ref<SpatialEditorGizmo> > found_gizmos;
 
-	//uint32_t closest=0;
-	//float closest_dist=0;
-
-	r_includes_current=false;
-
-	List<_RayResult> results;
+	ObjectID closest=0;
+	Spatial *item=NULL;
+	float closest_dist=1e20;
+	int selected_handle=-1;
 
 	for (int i=0;i<instances.size();i++) {
 
@@ -318,84 +316,30 @@ ObjectID SpatialEditorViewport::_select_ray(const Point2& p_pos, bool p_append,b
 		if (dist<0)
 			continue;
 
+		if (dist < closest_dist) {
+			closest=instances[i];
+			closest_dist=dist;
+			selected_handle=handle;
+			item=spat;
+		}
 
+	//	if (editor_selection->is_selected(spat))
+	//		r_includes_current=true;
 
-		if (editor_selection->is_selected(spat))
-			r_includes_current=true;
-
-		_RayResult res;
-		res.item=spat;
-		res.depth=dist;
-		res.handle=handle;
-		results.push_back(res);
 	}
 
 
-	if (results.empty())
+	if (!item)
 		return 0;
 
-	results.sort();
-	Spatial *s=NULL;
-
+	if (!editor_selection->is_selected(item) || (r_gizmo_handle && selected_handle>=0)) {
 
-	if (!r_includes_current || results.size()==1 || (r_gizmo_handle && results.front()->get().handle>=0)) {
-
-		//return the nearest one
-		s = results.front()->get().item;
 		if (r_gizmo_handle)
-			*r_gizmo_handle=results.front()->get().handle;
-
-	} else {
-
-		//returns the next one from a curent selection
-		List<_RayResult>::Element *E=results.front();
-		List<_RayResult>::Element *S=NULL;
-
+			*r_gizmo_handle=selected_handle;
 
-		while(true) {
-
-			//very strange loop algorithm that complies with object selection standards (tm).
-
-			if (S==E) {
-				//went all around and anothing was found
-				//since can't rotate the selection
-				//just return the first one
-
-				s=results.front()->get().item;
-				break;
-
-			}
-
-			if (!S && editor_selection->is_selected(E->get().item)) {
-				//found an item currently in the selection,
-				//so start from this one
-				S=E;
-			}
-
-			if (S && !editor_selection->is_selected(E->get().item)) {
-				// free item after a selected item, this one is desired.
-				s=E->get().item;
-				break;
-			}
-
-			E=E->next();
-			if (!E) {
-
-				if (!S) {
-					//did a loop but nothing was selected, select first
-					s=results.front()->get().item;
-					break;
-
-				}
-				E=results.front();
-			}
-		}
 	}
 
-	if (!s)
-		return 0;
-
-	return s->get_instance_ID();
+	return closest;
 
 }
 
@@ -3143,7 +3087,7 @@ void SpatialEditor::_init_indicators() {
 
 		indicator_mat.instance();
 		indicator_mat->set_flag(FixedSpatialMaterial::FLAG_UNSHADED,true);
-		indicator_mat->set_flag(FixedSpatialMaterial::FLAG_ONTOP,true);
+		//indicator_mat->set_flag(FixedSpatialMaterial::FLAG_ONTOP,true);
 		indicator_mat->set_flag(FixedSpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR,true);
 		indicator_mat->set_flag(FixedSpatialMaterial::FLAG_SRGB_VERTEX_COLOR,true);
 
diff --git a/tools/editor/spatial_editor_gizmos.cpp b/tools/editor/spatial_editor_gizmos.cpp
index c67024528..3ed101cdd 100644
--- a/tools/editor/spatial_editor_gizmos.cpp
+++ b/tools/editor/spatial_editor_gizmos.cpp
@@ -2484,7 +2484,7 @@ void GIProbeGizmo::redraw(){
 
 	}
 
-	add_lines(lines,SpatialEditorGizmos::singleton->reflection_probe_material_internal);
+	add_lines(lines,SpatialEditorGizmos::singleton->gi_probe_material_internal);
 
 	Vector<Vector3> handles;
 
@@ -3406,7 +3406,7 @@ SpatialEditorGizmos::SpatialEditorGizmos() {
 	reflection_probe_material = create_line_material(Color(0.5,1.0,0.7));
 	reflection_probe_material_internal = create_line_material(Color(0.3,0.8,0.5,0.15));
 	gi_probe_material = create_line_material(Color(0.7,1.0,0.5));
-	gi_probe_material_internal = create_line_material(Color(0.5,0.8,0.3,0.4));
+	gi_probe_material_internal = create_line_material(Color(0.5,0.8,0.3,0.1));
 	joint_material = create_line_material(Color(0.6,0.8,1.0));
 
 	stream_player_icon = Ref<FixedSpatialMaterial>( memnew( FixedSpatialMaterial ));