diff options
Diffstat (limited to 'editor')
24 files changed, 1630 insertions, 407 deletions
diff --git a/editor/editor_file_system.cpp b/editor/editor_file_system.cpp index b188a5760b..032e200775 100644 --- a/editor/editor_file_system.cpp +++ b/editor/editor_file_system.cpp @@ -789,7 +789,7 @@ void EditorFileSystem::_scan_fs_changes(EditorFileSystemDirectory *p_dir, const } else { uint64_t import_mt = FileAccess::get_modified_time(path + ".import"); - print_line(itos(import_mt) + " vs " + itos(p_dir->files[i]->import_modified_time)); + //print_line(itos(import_mt) + " vs " + itos(p_dir->files[i]->import_modified_time)); if (import_mt != p_dir->files[i]->import_modified_time) { print_line("REIMPORT: import modified changed, reimport"); reimport = true; diff --git a/editor/editor_node.cpp b/editor/editor_node.cpp index 03a241855b..72f26a5230 100644 --- a/editor/editor_node.cpp +++ b/editor/editor_node.cpp @@ -73,7 +73,9 @@ #include "plugins/collision_shape_2d_editor_plugin.h" #include "plugins/color_ramp_editor_plugin.h" #include "plugins/cube_grid_theme_editor_plugin.h" +#include "plugins/curve_editor_plugin.h" #include "plugins/gi_probe_editor_plugin.h" +#include "plugins/gradient_texture_editor_plugin.h" #include "plugins/item_list_editor_plugin.h" #include "plugins/light_occluder_2d_editor_plugin.h" #include "plugins/line_2d_editor_plugin.h" @@ -5909,7 +5911,7 @@ EditorNode::EditorNode() { //add_editor_plugin( memnew( MeshLibraryEditorPlugin(this) ) ); //add_editor_plugin( memnew( StreamEditorPlugin(this) ) ); add_editor_plugin(memnew(StyleBoxEditorPlugin(this))); - //add_editor_plugin( memnew( ParticlesEditorPlugin(this) ) ); + add_editor_plugin(memnew(ParticlesEditorPlugin(this))); add_editor_plugin(memnew(ResourcePreloaderEditorPlugin(this))); add_editor_plugin(memnew(ItemListEditorPlugin(this))); //add_editor_plugin( memnew( RichTextEditorPlugin(this) ) ); @@ -5929,7 +5931,9 @@ EditorNode::EditorNode() { add_editor_plugin(memnew(LightOccluder2DEditorPlugin(this))); add_editor_plugin(memnew(NavigationPolygonEditorPlugin(this))); add_editor_plugin(memnew(ColorRampEditorPlugin(this))); + add_editor_plugin(memnew(GradientTextureEditorPlugin(this))); add_editor_plugin(memnew(CollisionShape2DEditorPlugin(this))); + add_editor_plugin(memnew(CurveTextureEditorPlugin(this))); add_editor_plugin(memnew(TextureEditorPlugin(this))); add_editor_plugin(memnew(AudioBusesEditorPlugin(audio_bus_editor))); //add_editor_plugin( memnew( MaterialEditorPlugin(this) ) ); diff --git a/editor/import/editor_import_collada.cpp b/editor/import/editor_import_collada.cpp index 93614fb511..95baacb9e7 100644 --- a/editor/import/editor_import_collada.cpp +++ b/editor/import/editor_import_collada.cpp @@ -364,7 +364,7 @@ Error ColladaImport::_create_material(const String &p_target) { ERR_FAIL_COND_V(!collada.state.effect_map.has(src_mat.instance_effect), ERR_INVALID_PARAMETER); Collada::Effect &effect = collada.state.effect_map[src_mat.instance_effect]; - Ref<FixedSpatialMaterial> material = memnew(FixedSpatialMaterial); + Ref<SpatialMaterial> material = memnew(SpatialMaterial); if (src_mat.name != "") material->set_name(src_mat.name); @@ -381,15 +381,15 @@ Error ColladaImport::_create_material(const String &p_target) { Ref<Texture> texture = ResourceLoader::load(texfile, "Texture"); if (texture.is_valid()) { - material->set_texture(FixedSpatialMaterial::TEXTURE_ALBEDO, texture); + material->set_texture(SpatialMaterial::TEXTURE_ALBEDO, texture); material->set_albedo(Color(1, 1, 1, 1)); - //material->set_parameter(FixedSpatialMaterial::PARAM_DIFFUSE,Color(1,1,1,1)); + //material->set_parameter(SpatialMaterial::PARAM_DIFFUSE,Color(1,1,1,1)); } else { missing_textures.push_back(texfile.get_file()); } } } else { - //material->set_parameter(FixedSpatialMaterial::PARAM_DIFFUSE,effect.diffuse.color); + //material->set_parameter(SpatialMaterial::PARAM_DIFFUSE,effect.diffuse.color); } // SPECULAR @@ -401,11 +401,11 @@ Error ColladaImport::_create_material(const String &p_target) { Ref<Texture> texture = ResourceLoader::load(texfile, "Texture"); if (texture.is_valid()) { - material->set_texture(FixedSpatialMaterial::TEXTURE_SPECULAR, texture); + material->set_texture(SpatialMaterial::TEXTURE_SPECULAR, texture); material->set_specular(Color(1, 1, 1, 1)); - //material->set_texture(FixedSpatialMaterial::PARAM_SPECULAR,texture); - //material->set_parameter(FixedSpatialMaterial::PARAM_SPECULAR,Color(1,1,1,1)); + //material->set_texture(SpatialMaterial::PARAM_SPECULAR,texture); + //material->set_parameter(SpatialMaterial::PARAM_SPECULAR,Color(1,1,1,1)); } else { missing_textures.push_back(texfile.get_file()); } @@ -424,18 +424,18 @@ 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_feature(SpatialMaterial::FEATURE_EMISSION, true); + material->set_texture(SpatialMaterial::TEXTURE_EMISSION, texture); material->set_emission(Color(1, 1, 1, 1)); - //material->set_parameter(FixedSpatialMaterial::PARAM_EMISSION,Color(1,1,1,1)); + //material->set_parameter(SpatialMaterial::PARAM_EMISSION,Color(1,1,1,1)); } else { missing_textures.push_back(texfile.get_file()); } } } else { if (effect.emission.color != Color()) { - material->set_feature(FixedSpatialMaterial::FEATURE_EMISSION, true); + material->set_feature(SpatialMaterial::FEATURE_EMISSION, true); material->set_emission(effect.emission.color); } } @@ -449,11 +449,11 @@ 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_feature(SpatialMaterial::FEATURE_NORMAL_MAPPING, true); + material->set_texture(SpatialMaterial::TEXTURE_NORMAL, texture); //material->set_emission(Color(1,1,1,1)); - //material->set_texture(FixedSpatialMaterial::PARAM_NORMAL,texture); + //material->set_texture(SpatialMaterial::PARAM_NORMAL,texture); } else { //missing_textures.push_back(texfile.get_file()); } @@ -464,9 +464,9 @@ Error ColladaImport::_create_material(const String &p_target) { material->set_roughness(roughness); if (effect.double_sided) { - material->set_cull_mode(FixedSpatialMaterial::CULL_DISABLED); + material->set_cull_mode(SpatialMaterial::CULL_DISABLED); } - material->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, effect.unshaded); + material->set_flag(SpatialMaterial::FLAG_UNSHADED, effect.unshaded); material_cache[p_target] = material; return OK; @@ -1000,7 +1000,7 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize, Ref<Mesh> &p_mesh, c { - Ref<FixedSpatialMaterial> material; + Ref<SpatialMaterial> material; //find material Mesh::PrimitiveType primitive = Mesh::PRIMITIVE_TRIANGLES; diff --git a/editor/import/resource_importer_scene.cpp b/editor/import/resource_importer_scene.cpp index 8a78376f13..3aa412bd5c 100644 --- a/editor/import/resource_importer_scene.cpp +++ b/editor/import/resource_importer_scene.cpp @@ -157,7 +157,7 @@ Node *ResourceImporterScene::_fix_node(Node *p_node, Node *p_root, Map<Ref<Mesh> memdelete(p_node); return NULL; } - +#if 0 if (p_node->cast_to<MeshInstance>()) { MeshInstance *mi = p_node->cast_to<MeshInstance>(); @@ -177,18 +177,18 @@ Node *ResourceImporterScene::_fix_node(Node *p_node, Node *p_root, Map<Ref<Mesh> Ref<Mesh> m = mi->get_mesh(); for (int i = 0; i < m->get_surface_count(); i++) { - Ref<FixedSpatialMaterial> fm = m->surface_get_material(i); + Ref<SpatialMaterial> fm = m->surface_get_material(i); if (fm.is_valid()) { //fm->set_flag(Material::FLAG_UNSHADED,true); //fm->set_flag(Material::FLAG_DOUBLE_SIDED,true); //fm->set_depth_draw_mode(Material::DEPTH_DRAW_NEVER); - //fm->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_ALPHA,true); + //fm->set_fixed_flag(SpatialMaterial::FLAG_USE_ALPHA,true); } } } } } - +#endif if (p_node->cast_to<MeshInstance>()) { MeshInstance *mi = p_node->cast_to<MeshInstance>(); @@ -199,19 +199,19 @@ Node *ResourceImporterScene::_fix_node(Node *p_node, Node *p_root, Map<Ref<Mesh> for (int i = 0; i < m->get_surface_count(); i++) { - Ref<FixedSpatialMaterial> mat = m->surface_get_material(i); + Ref<SpatialMaterial> mat = m->surface_get_material(i); if (!mat.is_valid()) continue; if (_teststr(mat->get_name(), "alpha")) { - mat->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT, true); + mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); mat->set_name(_fixstr(mat->get_name(), "alpha")); } if (_teststr(mat->get_name(), "vcol")) { - mat->set_flag(FixedSpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true); - mat->set_flag(FixedSpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true); + mat->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true); + mat->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true); mat->set_name(_fixstr(mat->get_name(), "vcol")); } } @@ -242,7 +242,7 @@ Node *ResourceImporterScene::_fix_node(Node *p_node, Node *p_root, Map<Ref<Mesh> } } } - +#if 0 if (p_node->cast_to<MeshInstance>()) { MeshInstance *mi = p_node->cast_to<MeshInstance>(); @@ -277,12 +277,12 @@ Node *ResourceImporterScene::_fix_node(Node *p_node, Node *p_root, Map<Ref<Mesh> Ref<Mesh> m = mi->get_mesh(); for (int i = 0; i < m->get_surface_count(); i++) { - Ref<FixedSpatialMaterial> fm = m->surface_get_material(i); + Ref<SpatialMaterial> fm = m->surface_get_material(i); if (fm.is_valid()) { //fm->set_flag(Material::FLAG_UNSHADED,true); //fm->set_flag(Material::FLAG_DOUBLE_SIDED,true); //fm->set_depth_draw_mode(Material::DEPTH_DRAW_NEVER); - //fm->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_ALPHA,true); + //fm->set_fixed_flag(SpatialMaterial::FLAG_USE_ALPHA,true); } } } @@ -290,6 +290,8 @@ Node *ResourceImporterScene::_fix_node(Node *p_node, Node *p_root, Map<Ref<Mesh> } } } + +#endif #if 0 if (p_flags&SCENE_FLAG_CREATE_LODS && p_node->cast_to<MeshInstance>()) { @@ -325,12 +327,12 @@ Node *ResourceImporterScene::_fix_node(Node *p_node, Node *p_root, Map<Ref<Mesh> Ref<Mesh> m = mi->get_mesh(); for(int i=0;i<m->get_surface_count();i++) { - Ref<FixedSpatialMaterial> fm = m->surface_get_material(i); + Ref<SpatialMaterial> fm = m->surface_get_material(i); if (fm.is_valid()) { fm->set_flag(Material::FLAG_UNSHADED,true); fm->set_flag(Material::FLAG_DOUBLE_SIDED,true); fm->set_hint(Material::HINT_NO_DEPTH_DRAW,true); - fm->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_ALPHA,true); + fm->set_fixed_flag(SpatialMaterial::FLAG_USE_ALPHA,true); } } }*/ @@ -687,16 +689,16 @@ Node *ResourceImporterScene::_fix_node(Node *p_node, Node *p_root, Map<Ref<Mesh> for (int i = 0; i < mesh->get_surface_count(); i++) { - Ref<FixedSpatialMaterial> fm = mesh->surface_get_material(i); + Ref<SpatialMaterial> fm = mesh->surface_get_material(i); if (fm.is_valid()) { String name = fm->get_name(); /* if (_teststr(name,"alpha")) { - fm->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_ALPHA,true); + fm->set_fixed_flag(SpatialMaterial::FLAG_USE_ALPHA,true); name=_fixstr(name,"alpha"); } if (_teststr(name,"vcol")) { - fm->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_COLOR_ARRAY,true); + fm->set_fixed_flag(SpatialMaterial::FLAG_USE_COLOR_ARRAY,true); name=_fixstr(name,"vcol"); }*/ fm->set_name(name); diff --git a/editor/io_plugins/editor_scene_import_plugin.cpp b/editor/io_plugins/editor_scene_import_plugin.cpp index 52a554f6d1..1fd7078135 100644 --- a/editor/io_plugins/editor_scene_import_plugin.cpp +++ b/editor/io_plugins/editor_scene_import_plugin.cpp @@ -1408,7 +1408,7 @@ void EditorSceneImportPlugin::_find_resources(const Variant& p_var, Map<Ref<Imag for(List<PropertyInfo>::Element *E=pl.front();E;E=E->next()) { if (E->get().type==Variant::OBJECT || E->get().type==Variant::ARRAY || E->get().type==Variant::DICTIONARY) { - if (E->get().type==Variant::OBJECT && res->cast_to<FixedSpatialMaterial>() && (E->get().name=="textures/diffuse" || E->get().name=="textures/detail" || E->get().name=="textures/emission")) { + if (E->get().type==Variant::OBJECT && res->cast_to<SpatialMaterial>() && (E->get().name=="textures/diffuse" || E->get().name=="textures/detail" || E->get().name=="textures/emission")) { Ref<ImageTexture> tex =res->get(E->get().name); if (tex.is_valid()) { @@ -1416,7 +1416,7 @@ void EditorSceneImportPlugin::_find_resources(const Variant& p_var, Map<Ref<Imag image_map.insert(tex,TEXTURE_ROLE_DIFFUSE); } - } else if (E->get().type==Variant::OBJECT && res->cast_to<FixedSpatialMaterial>() && (E->get().name=="textures/normal")) { + } else if (E->get().type==Variant::OBJECT && res->cast_to<SpatialMaterial>() && (E->get().name=="textures/normal")) { Ref<ImageTexture> tex =res->get(E->get().name); if (tex.is_valid()) { @@ -1424,7 +1424,7 @@ void EditorSceneImportPlugin::_find_resources(const Variant& p_var, Map<Ref<Imag image_map.insert(tex,TEXTURE_ROLE_NORMALMAP); /* if (p_flags&SCENE_FLAG_CONVERT_NORMALMAPS_TO_XY) - res->cast_to<FixedSpatialMaterial>()->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_XY_NORMALMAP,true); + res->cast_to<SpatialMaterial>()->set_fixed_flag(SpatialMaterial::FLAG_USE_XY_NORMALMAP,true); */ } @@ -1532,12 +1532,12 @@ Node* EditorSceneImportPlugin::_fix_node(Node *p_node,Node *p_root,Map<Ref<Mesh> Ref<Mesh> m = mi->get_mesh(); for(int i=0;i<m->get_surface_count();i++) { - Ref<FixedSpatialMaterial> fm = m->surface_get_material(i); + Ref<SpatialMaterial> fm = m->surface_get_material(i); if (fm.is_valid()) { //fm->set_flag(Material::FLAG_UNSHADED,true); //fm->set_flag(Material::FLAG_DOUBLE_SIDED,true); //fm->set_depth_draw_mode(Material::DEPTH_DRAW_NEVER); - //fm->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_ALPHA,true); + //fm->set_fixed_flag(SpatialMaterial::FLAG_USE_ALPHA,true); } } } @@ -1555,18 +1555,18 @@ Node* EditorSceneImportPlugin::_fix_node(Node *p_node,Node *p_root,Map<Ref<Mesh> for(int i=0;i<m->get_surface_count();i++) { - Ref<FixedSpatialMaterial> mat = m->surface_get_material(i); + Ref<SpatialMaterial> mat = m->surface_get_material(i); if (!mat.is_valid()) continue; if (p_flags&SCENE_FLAG_DETECT_ALPHA && _teststr(mat->get_name(),"alpha")) { - //mat->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_ALPHA,true); + //mat->set_fixed_flag(SpatialMaterial::FLAG_USE_ALPHA,true); //mat->set_name(_fixstr(mat->get_name(),"alpha")); } if (p_flags&SCENE_FLAG_DETECT_VCOLOR && _teststr(mat->get_name(),"vcol")) { - //mat->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_COLOR_ARRAY,true); + //mat->set_fixed_flag(SpatialMaterial::FLAG_USE_COLOR_ARRAY,true); //mat->set_name(_fixstr(mat->get_name(),"vcol")); } @@ -1641,12 +1641,12 @@ Node* EditorSceneImportPlugin::_fix_node(Node *p_node,Node *p_root,Map<Ref<Mesh> Ref<Mesh> m = mi->get_mesh(); for(int i=0;i<m->get_surface_count();i++) { - Ref<FixedSpatialMaterial> fm = m->surface_get_material(i); + Ref<SpatialMaterial> fm = m->surface_get_material(i); if (fm.is_valid()) { //fm->set_flag(Material::FLAG_UNSHADED,true); //fm->set_flag(Material::FLAG_DOUBLE_SIDED,true); //fm->set_depth_draw_mode(Material::DEPTH_DRAW_NEVER); - //fm->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_ALPHA,true); + //fm->set_fixed_flag(SpatialMaterial::FLAG_USE_ALPHA,true); } } } @@ -1689,12 +1689,12 @@ Node* EditorSceneImportPlugin::_fix_node(Node *p_node,Node *p_root,Map<Ref<Mesh> Ref<Mesh> m = mi->get_mesh(); for(int i=0;i<m->get_surface_count();i++) { - Ref<FixedSpatialMaterial> fm = m->surface_get_material(i); + Ref<SpatialMaterial> fm = m->surface_get_material(i); if (fm.is_valid()) { fm->set_flag(Material::FLAG_UNSHADED,true); fm->set_flag(Material::FLAG_DOUBLE_SIDED,true); fm->set_hint(Material::HINT_NO_DEPTH_DRAW,true); - fm->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_ALPHA,true); + fm->set_fixed_flag(SpatialMaterial::FLAG_USE_ALPHA,true); } } }*/ @@ -2062,16 +2062,16 @@ Node* EditorSceneImportPlugin::_fix_node(Node *p_node,Node *p_root,Map<Ref<Mesh> for(int i=0;i<mesh->get_surface_count();i++) { - Ref<FixedSpatialMaterial> fm = mesh->surface_get_material(i); + Ref<SpatialMaterial> fm = mesh->surface_get_material(i); if (fm.is_valid()) { String name = fm->get_name(); /* if (_teststr(name,"alpha")) { - fm->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_ALPHA,true); + fm->set_fixed_flag(SpatialMaterial::FLAG_USE_ALPHA,true); name=_fixstr(name,"alpha"); } if (_teststr(name,"vcol")) { - fm->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_COLOR_ARRAY,true); + fm->set_fixed_flag(SpatialMaterial::FLAG_USE_COLOR_ARRAY,true); name=_fixstr(name,"vcol"); }*/ fm->set_name(name); diff --git a/editor/io_plugins/editor_scene_importer_fbxconv.cpp b/editor/io_plugins/editor_scene_importer_fbxconv.cpp index a2fe4a649b..12a88c3eb6 100644 --- a/editor/io_plugins/editor_scene_importer_fbxconv.cpp +++ b/editor/io_plugins/editor_scene_importer_fbxconv.cpp @@ -483,29 +483,29 @@ void EditorSceneImporterFBXConv::_parse_materials(State& state) { ERR_CONTINUE(!material.has("id")); String id = _id(material["id"]); - Ref<FixedSpatialMaterial> mat = memnew( FixedSpatialMaterial ); + Ref<SpatialMaterial> mat = memnew( SpatialMaterial ); if (material.has("diffuse")) { - mat->set_parameter(FixedSpatialMaterial::PARAM_DIFFUSE,_get_color(material["diffuse"])); + mat->set_parameter(SpatialMaterial::PARAM_DIFFUSE,_get_color(material["diffuse"])); } if (material.has("specular")) { - mat->set_parameter(FixedSpatialMaterial::PARAM_SPECULAR,_get_color(material["specular"])); + mat->set_parameter(SpatialMaterial::PARAM_SPECULAR,_get_color(material["specular"])); } if (material.has("emissive")) { - mat->set_parameter(FixedSpatialMaterial::PARAM_EMISSION,_get_color(material["emissive"])); + mat->set_parameter(SpatialMaterial::PARAM_EMISSION,_get_color(material["emissive"])); } if (material.has("shininess")) { float exp = material["shininess"]; - mat->set_parameter(FixedSpatialMaterial::PARAM_SPECULAR_EXP,exp); + mat->set_parameter(SpatialMaterial::PARAM_SPECULAR_EXP,exp); } if (material.has("opacity")) { - Color c = mat->get_parameter(FixedSpatialMaterial::PARAM_DIFFUSE); + Color c = mat->get_parameter(SpatialMaterial::PARAM_DIFFUSE); c.a=material["opacity"]; - mat->set_parameter(FixedSpatialMaterial::PARAM_DIFFUSE,c); + mat->set_parameter(SpatialMaterial::PARAM_DIFFUSE,c); } @@ -537,15 +537,15 @@ void EditorSceneImporterFBXConv::_parse_materials(State& state) { String type=texture["type"]; if (type=="DIFFUSE") - mat->set_texture(FixedSpatialMaterial::PARAM_DIFFUSE,tex); + mat->set_texture(SpatialMaterial::PARAM_DIFFUSE,tex); else if (type=="SPECULAR") - mat->set_texture(FixedSpatialMaterial::PARAM_SPECULAR,tex); + mat->set_texture(SpatialMaterial::PARAM_SPECULAR,tex); else if (type=="SHININESS") - mat->set_texture(FixedSpatialMaterial::PARAM_SPECULAR_EXP,tex); + mat->set_texture(SpatialMaterial::PARAM_SPECULAR_EXP,tex); else if (type=="NORMAL") - mat->set_texture(FixedSpatialMaterial::PARAM_NORMAL,tex); + mat->set_texture(SpatialMaterial::PARAM_NORMAL,tex); else if (type=="EMISSIVE") - mat->set_texture(FixedSpatialMaterial::PARAM_EMISSION,tex); + mat->set_texture(SpatialMaterial::PARAM_EMISSION,tex); } } diff --git a/editor/plugins/baked_light_baker.cpp b/editor/plugins/baked_light_baker.cpp index de2b78b8dd..3db54978e1 100644 --- a/editor/plugins/baked_light_baker.cpp +++ b/editor/plugins/baked_light_baker.cpp @@ -144,18 +144,18 @@ void BakedLightBaker::_add_mesh(const Ref<Mesh>& p_mesh,const Ref<Material>& p_m MeshMaterial mm; - Ref<FixedSpatialMaterial> fm = mat; + Ref<SpatialMaterial> fm = mat; if (fm.is_valid()) { //fixed route - mm.diffuse.color=fm->get_parameter(FixedSpatialMaterial::PARAM_DIFFUSE); + mm.diffuse.color=fm->get_parameter(SpatialMaterial::PARAM_DIFFUSE); if (linear_color) mm.diffuse.color=mm.diffuse.color.to_linear(); - mm.diffuse.tex=_get_mat_tex(fm->get_texture(FixedSpatialMaterial::PARAM_DIFFUSE)); - mm.specular.color=fm->get_parameter(FixedSpatialMaterial::PARAM_SPECULAR); + mm.diffuse.tex=_get_mat_tex(fm->get_texture(SpatialMaterial::PARAM_DIFFUSE)); + mm.specular.color=fm->get_parameter(SpatialMaterial::PARAM_SPECULAR); if (linear_color) mm.specular.color=mm.specular.color.to_linear(); - mm.specular.tex=_get_mat_tex(fm->get_texture(FixedSpatialMaterial::PARAM_SPECULAR)); + mm.specular.tex=_get_mat_tex(fm->get_texture(SpatialMaterial::PARAM_SPECULAR)); } else { mm.diffuse.color=Color(1,1,1,1); diff --git a/editor/plugins/collision_polygon_editor_plugin.cpp b/editor/plugins/collision_polygon_editor_plugin.cpp index 62426a7699..c0599bf26e 100644 --- a/editor/plugins/collision_polygon_editor_plugin.cpp +++ b/editor/plugins/collision_polygon_editor_plugin.cpp @@ -571,25 +571,25 @@ CollisionPolygonEditor::CollisionPolygonEditor(EditorNode *p_editor) { imgeom->set_transform(Transform(Matrix3(),Vector3(0,0,0.00001))); - line_material = Ref<FixedSpatialMaterial>( memnew( FixedSpatialMaterial )); + line_material = Ref<SpatialMaterial>( memnew( SpatialMaterial )); line_material->set_flag(Material::FLAG_UNSHADED, true); line_material->set_line_width(3.0); - line_material->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_ALPHA, true); - line_material->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_COLOR_ARRAY, true); - line_material->set_parameter(FixedSpatialMaterial::PARAM_DIFFUSE,Color(1,1,1)); + line_material->set_fixed_flag(SpatialMaterial::FLAG_USE_ALPHA, true); + line_material->set_fixed_flag(SpatialMaterial::FLAG_USE_COLOR_ARRAY, true); + line_material->set_parameter(SpatialMaterial::PARAM_DIFFUSE,Color(1,1,1)); - handle_material = Ref<FixedSpatialMaterial>( memnew( FixedSpatialMaterial )); + handle_material = Ref<SpatialMaterial>( memnew( SpatialMaterial )); handle_material->set_flag(Material::FLAG_UNSHADED, true); - handle_material->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_POINT_SIZE, true); - handle_material->set_parameter(FixedSpatialMaterial::PARAM_DIFFUSE,Color(1,1,1)); - handle_material->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_ALPHA, true); - handle_material->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_COLOR_ARRAY, false); + handle_material->set_fixed_flag(SpatialMaterial::FLAG_USE_POINT_SIZE, true); + handle_material->set_parameter(SpatialMaterial::PARAM_DIFFUSE,Color(1,1,1)); + handle_material->set_fixed_flag(SpatialMaterial::FLAG_USE_ALPHA, true); + handle_material->set_fixed_flag(SpatialMaterial::FLAG_USE_COLOR_ARRAY, false); Ref<Texture> handle=editor->get_gui_base()->get_icon("Editor3DHandle","EditorIcons"); handle_material->set_point_size(handle->get_width()); - handle_material->set_texture(FixedSpatialMaterial::PARAM_DIFFUSE,handle); + handle_material->set_texture(SpatialMaterial::PARAM_DIFFUSE,handle); pointsm = memnew( MeshInstance ); imgeom->add_child(pointsm); diff --git a/editor/plugins/collision_polygon_editor_plugin.h b/editor/plugins/collision_polygon_editor_plugin.h index ace8c3429f..d033fbf2ed 100644 --- a/editor/plugins/collision_polygon_editor_plugin.h +++ b/editor/plugins/collision_polygon_editor_plugin.h @@ -62,8 +62,8 @@ class CollisionPolygonEditor : public HBoxContainer { ToolButton *button_edit; - Ref<FixedSpatialMaterial> line_material; - Ref<FixedSpatialMaterial> handle_material; + Ref<SpatialMaterial> line_material; + Ref<SpatialMaterial> handle_material; EditorNode *editor; Panel *panel; diff --git a/editor/plugins/curve_editor_plugin.cpp b/editor/plugins/curve_editor_plugin.cpp new file mode 100644 index 0000000000..52edc75bc0 --- /dev/null +++ b/editor/plugins/curve_editor_plugin.cpp @@ -0,0 +1,519 @@ +#include "curve_editor_plugin.h" + +#include "canvas_item_editor_plugin.h" +#include "os/keyboard.h" +#include "spatial_editor_plugin.h" +void CurveTextureEdit::_gui_input(const InputEvent &p_event) { + + if (p_event.type == InputEvent::KEY && p_event.key.pressed && p_event.key.scancode == KEY_DELETE && grabbed != -1) { + + points.remove(grabbed); + grabbed = -1; + update(); + emit_signal("curve_changed"); + accept_event(); + } + + if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1 && p_event.mouse_button.pressed) { + + update(); + Ref<Font> font = get_font("font", "Label"); + + int font_h = font->get_height(); + + Vector2 size = get_size(); + size.y -= font_h; + + Point2 p = Vector2(p_event.mouse_button.x, p_event.mouse_button.y) / size; + p.y = CLAMP(1.0 - p.y, 0, 1) * (max - min) + min; + grabbed = -1; + grabbing = true; + + for (int i = 0; i < points.size(); i++) { + + Vector2 ps = p * get_size(); + Vector2 pt = Vector2(points[i].offset, points[i].height) * get_size(); + if (ps.distance_to(pt) < 4) { + grabbed = i; + } + } + + //grab or select + if (grabbed != -1) { + return; + } + //insert + + Point np; + np.offset = p.x; + np.height = p.y; + + points.push_back(np); + points.sort(); + for (int i = 0; i < points.size(); i++) { + if (points[i].offset == p.x && points[i].height == p.y) { + grabbed = i; + break; + } + } + + emit_signal("curve_changed"); + } + + if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1 && !p_event.mouse_button.pressed) { + + if (grabbing) { + grabbing = false; + emit_signal("curve_changed"); + } + update(); + } + + if (p_event.type == InputEvent::MOUSE_MOTION && grabbing && grabbed != -1) { + + Ref<Font> font = get_font("font", "Label"); + int font_h = font->get_height(); + Vector2 size = get_size(); + size.y -= font_h; + + Point2 p = Vector2(p_event.mouse_motion.x, p_event.mouse_motion.y) / size; + p.y = CLAMP(1.0 - p.y, 0, 1) * (max - min) + min; + p.x = CLAMP(p.x, 0.0, 1.0); + + bool valid = true; + + for (int i = 0; i < points.size(); i++) { + + if (points[i].offset == p.x && points[i].height == p.y && i != grabbed) { + valid = false; + } + } + + if (!valid) + return; + + points[grabbed].offset = p.x; + points[grabbed].height = p.y; + + points.sort(); + for (int i = 0; i < points.size(); i++) { + if (points[i].offset == p.x && points[i].height == p.y) { + grabbed = i; + break; + } + } + + emit_signal("curve_changed"); + + update(); + } +} + +void CurveTextureEdit::_plot_curve(const Vector2 &p_a, const Vector2 &p_b, const Vector2 &p_c, const Vector2 &p_d) { + + Ref<Font> font = get_font("font", "Label"); + + int font_h = font->get_height(); + + float geometry[4][4]; + float tmp1[4][4]; + float tmp2[4][4]; + float deltas[4][4]; + double x, dx, dx2, dx3; + double y, dy, dy2, dy3; + double d, d2, d3; + int lastx, lasty; + int newx, newy; + int ntimes; + int i, j; + + int xmax = get_size().x; + int ymax = get_size().y - font_h; + + int vsplits = 4; + + int zero_ofs = (1.0 - (0.0 - min) / (max - min)) * ymax; + + draw_line(Vector2(0, zero_ofs), Vector2(xmax, zero_ofs), Color(0.8, 0.8, 0.8, 0.15), 2.0); + + for (int i = 0; i <= vsplits; i++) { + float fofs = float(i) / vsplits; + int yofs = fofs * ymax; + draw_line(Vector2(xmax, yofs), Vector2(xmax - 4, yofs), Color(0.8, 0.8, 0.8, 0.8), 2.0); + + String text = rtos((1.0 - fofs) * (max - min) + min); + int ppos = text.find("."); + if (ppos != -1) { + if (text.length() > ppos + 2) + text = text.substr(0, ppos + 2); + } + + int size = font->get_string_size(text).x; + int xofs = xmax - size - 4; + yofs -= font_h / 2; + + if (yofs < 2) { + yofs = 2; + } else if (yofs + font_h > ymax - 2) { + yofs = ymax - font_h - 2; + } + + draw_string(font, Vector2(xofs, yofs + font->get_ascent()), text, Color(0.8, 0.8, 0.8, 1)); + } + + /* construct the geometry matrix from the segment */ + for (i = 0; i < 4; i++) { + geometry[i][2] = 0; + geometry[i][3] = 0; + } + + geometry[0][0] = (p_a[0] * xmax); + geometry[1][0] = (p_b[0] * xmax); + geometry[2][0] = (p_c[0] * xmax); + geometry[3][0] = (p_d[0] * xmax); + + geometry[0][1] = ((p_a[1] - min) / (max - min) * ymax); + geometry[1][1] = ((p_b[1] - min) / (max - min) * ymax); + geometry[2][1] = ((p_c[1] - min) / (max - min) * ymax); + geometry[3][1] = ((p_d[1] - min) / (max - min) * ymax); + + /* subdivide the curve ntimes (1000) times */ + ntimes = 4 * xmax; + /* ntimes can be adjusted to give a finer or coarser curve */ + d = 1.0 / ntimes; + d2 = d * d; + d3 = d * d * d; + + /* construct a temporary matrix for determining the forward differencing deltas */ + tmp2[0][0] = 0; + tmp2[0][1] = 0; + tmp2[0][2] = 0; + tmp2[0][3] = 1; + tmp2[1][0] = d3; + tmp2[1][1] = d2; + tmp2[1][2] = d; + tmp2[1][3] = 0; + tmp2[2][0] = 6 * d3; + tmp2[2][1] = 2 * d2; + tmp2[2][2] = 0; + tmp2[2][3] = 0; + tmp2[3][0] = 6 * d3; + tmp2[3][1] = 0; + tmp2[3][2] = 0; + tmp2[3][3] = 0; + + /* compose the basis and geometry matrices */ + + static const float CR_basis[4][4] = { + { -0.5, 1.5, -1.5, 0.5 }, + { 1.0, -2.5, 2.0, -0.5 }, + { -0.5, 0.0, 0.5, 0.0 }, + { 0.0, 1.0, 0.0, 0.0 }, + }; + + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + tmp1[i][j] = (CR_basis[i][0] * geometry[0][j] + + CR_basis[i][1] * geometry[1][j] + + CR_basis[i][2] * geometry[2][j] + + CR_basis[i][3] * geometry[3][j]); + } + } + /* compose the above results to get the deltas matrix */ + + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + deltas[i][j] = (tmp2[i][0] * tmp1[0][j] + + tmp2[i][1] * tmp1[1][j] + + tmp2[i][2] * tmp1[2][j] + + tmp2[i][3] * tmp1[3][j]); + } + } + + /* extract the x deltas */ + x = deltas[0][0]; + dx = deltas[1][0]; + dx2 = deltas[2][0]; + dx3 = deltas[3][0]; + + /* extract the y deltas */ + y = deltas[0][1]; + dy = deltas[1][1]; + dy2 = deltas[2][1]; + dy3 = deltas[3][1]; + + lastx = CLAMP(x, 0, xmax); + lasty = CLAMP(y, 0, ymax); + + /* if (fix255) + { + cd->curve[cd->outline][lastx] = lasty; + } + else + { + cd->curve_ptr[cd->outline][lastx] = lasty; + if(gb_debug) printf("bender_plot_curve xmax:%d ymax:%d\n", (int)xmax, (int)ymax); + } +*/ + /* loop over the curve */ + for (i = 0; i < ntimes; i++) { + /* increment the x values */ + x += dx; + dx += dx2; + dx2 += dx3; + + /* increment the y values */ + y += dy; + dy += dy2; + dy2 += dy3; + + newx = CLAMP((Math::round(x)), 0, xmax); + newy = CLAMP((Math::round(y)), 0, ymax); + + /* if this point is different than the last one...then draw it */ + if ((lastx != newx) || (lasty != newy)) { +#if 0 + if(fix255) + { + /* use fixed array size (for the curve graph) */ + cd->curve[cd->outline][newx] = newy; + } + else + { + /* use dynamic allocated curve_ptr (for the real curve) */ + cd->curve_ptr[cd->outline][newx] = newy; + + if(gb_debug) printf("outline: %d cX: %d cY: %d\n", (int)cd->outline, (int)newx, (int)newy); + } +#endif + draw_line(Vector2(lastx, ymax - lasty), Vector2(newx, ymax - newy), Color(0.8, 0.8, 0.8, 0.8), 2.0); + } + + lastx = newx; + lasty = newy; + } + + int splits = 8; + + draw_line(Vector2(0, ymax - 1), Vector2(xmax, ymax - 1), Color(0.8, 0.8, 0.8, 0.3), 2.0); + + for (int i = 0; i <= splits; i++) { + float fofs = float(i) / splits; + draw_line(Vector2(fofs * xmax, ymax), Vector2(fofs * xmax, ymax - 2), Color(0.8, 0.8, 0.8, 0.8), 2.0); + + String text = rtos(fofs); + int size = font->get_string_size(text).x; + int ofs = fofs * xmax - size * 0.5; + if (ofs < 2) { + ofs = 2; + } else if (ofs + size > xmax - 2) { + ofs = xmax - size - 2; + } + + draw_string(font, Vector2(ofs, ymax + font->get_ascent()), text, Color(0.8, 0.8, 0.8, 1)); + } +} + +void CurveTextureEdit::_notification(int p_what) { + + if (p_what == NOTIFICATION_DRAW) { + + Ref<Font> font = get_font("font", "Label"); + + int font_h = font->get_height(); + + draw_style_box(get_stylebox("bg", "Tree"), Rect2(Point2(), get_size())); + + int w = get_size().x; + int h = get_size().y; + + Vector2 prev = Vector2(0, 0); + Vector2 prev2 = Vector2(0, 0); + + for (int i = -1; i < points.size(); i++) { + + Vector2 next; + Vector2 next2; + if (i + 1 >= points.size()) { + next = Vector2(1, 0); + } else { + next = Vector2(points[i + 1].offset, points[i + 1].height); + } + + if (i + 2 >= points.size()) { + next2 = Vector2(1, 0); + } else { + next2 = Vector2(points[i + 2].offset, points[i + 2].height); + } + + /*if (i==-1 && prev.offset==next.offset) { + prev=next; + continue; + }*/ + + _plot_curve(prev2, prev, next, next2); + + prev2 = prev; + prev = next; + } + + Vector2 size = get_size(); + size.y -= font_h; + for (int i = 0; i < points.size(); i++) { + + Color col = i == grabbed ? Color(1, 0.0, 0.0, 0.9) : Color(1, 1, 1, 0.8); + + float h = (points[i].height - min) / (max - min); + draw_rect(Rect2(Vector2(points[i].offset, 1.0 - h) * size - Vector2(2, 2), Vector2(5, 5)), col); + } + + /* if (grabbed!=-1) { + + draw_rect(Rect2(total_w+3,0,h,h),points[grabbed].color); + } +*/ + if (has_focus()) { + + draw_line(Vector2(-1, -1), Vector2(w + 1, -1), Color(1, 1, 1, 0.6)); + draw_line(Vector2(w + 1, -1), Vector2(w + 1, h + 1), Color(1, 1, 1, 0.6)); + draw_line(Vector2(w + 1, h + 1), Vector2(-1, h + 1), Color(1, 1, 1, 0.6)); + draw_line(Vector2(-1, -1), Vector2(-1, h + 1), Color(1, 1, 1, 0.6)); + } + } +} + +Size2 CurveTextureEdit::get_minimum_size() const { + + return Vector2(64, 64); +} + +void CurveTextureEdit::set_range(float p_min, float p_max) { + max = p_max; + min = p_min; + update(); +} + +void CurveTextureEdit::set_points(const Vector<Vector2> &p_points) { + + points.clear(); + for (int i = 0; i < p_points.size(); i++) { + Point p; + p.offset = p_points[i].x; + p.height = p_points[i].y; + points.push_back(p); + } + + points.sort(); + update(); +} + +Vector<Vector2> CurveTextureEdit::get_points() const { + Vector<Vector2> ret; + for (int i = 0; i < points.size(); i++) + ret.push_back(Vector2(points[i].offset, points[i].height)); + return ret; +} + +void CurveTextureEdit::_bind_methods() { + + ClassDB::bind_method(D_METHOD("_gui_input"), &CurveTextureEdit::_gui_input); + + ADD_SIGNAL(MethodInfo("curve_changed")); +} + +CurveTextureEdit::CurveTextureEdit() { + + grabbed = -1; + grabbing = false; + max = 1; + min = 0; + set_focus_mode(FOCUS_ALL); +} + +void CurveTextureEditorPlugin::_curve_settings_changed() { + + if (!curve_texture_ref.is_valid()) + return; + curve_editor->set_points(Variant(curve_texture_ref->get_points())); + curve_editor->set_range(curve_texture_ref->get_min(), curve_texture_ref->get_max()); +} + +CurveTextureEditorPlugin::CurveTextureEditorPlugin(EditorNode *p_node) { + + editor = p_node; + curve_editor = memnew(CurveTextureEdit); + + curve_button = editor->add_bottom_panel_item("CurveTexture", curve_editor); + + curve_button->hide(); + curve_editor->set_custom_minimum_size(Size2(100, 128 * EDSCALE)); + curve_editor->hide(); + curve_editor->connect("curve_changed", this, "curve_changed"); +} + +void CurveTextureEditorPlugin::edit(Object *p_object) { + + if (curve_texture_ref.is_valid()) { + curve_texture_ref->disconnect("changed", this, "_curve_settings_changed"); + } + CurveTexture *curve_texture = p_object->cast_to<CurveTexture>(); + if (!curve_texture) + return; + curve_texture_ref = Ref<CurveTexture>(curve_texture); + curve_editor->set_points(Variant(curve_texture_ref->get_points())); + curve_editor->set_range(curve_texture_ref->get_min(), curve_texture_ref->get_max()); + if (!curve_texture_ref->is_connected("changed", this, "_curve_settings_changed")) { + curve_texture_ref->connect("changed", this, "_curve_settings_changed"); + } +} + +bool CurveTextureEditorPlugin::handles(Object *p_object) const { + + return p_object->is_class("CurveTexture"); +} + +void CurveTextureEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + curve_button->show(); + editor->make_bottom_panel_item_visible(curve_editor); + + } else { + + curve_button->hide(); + if (curve_editor->is_visible_in_tree()) + editor->hide_bottom_panel(); + } +} + +void CurveTextureEditorPlugin::_curve_changed() { + + if (curve_texture_ref.is_valid()) { + + UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo(); + + Vector<Vector2> points = curve_editor->get_points(); + PoolVector<Vector2> ppoints = Variant(points); + + ur->create_action(TTR("Modify Curve"), UndoRedo::MERGE_ENDS); + ur->add_do_method(this, "undo_redo_curve_texture", ppoints); + ur->add_undo_method(this, "undo_redo_curve_texture", curve_texture_ref->get_points()); + ur->commit_action(); + } +} + +void CurveTextureEditorPlugin::_undo_redo_curve_texture(const PoolVector<Vector2> &points) { + + curve_texture_ref->set_points(points); + curve_editor->set_points(Variant(curve_texture_ref->get_points())); + curve_editor->update(); +} + +CurveTextureEditorPlugin::~CurveTextureEditorPlugin() { +} + +void CurveTextureEditorPlugin::_bind_methods() { + ClassDB::bind_method(D_METHOD("curve_changed"), &CurveTextureEditorPlugin::_curve_changed); + ClassDB::bind_method(D_METHOD("_curve_settings_changed"), &CurveTextureEditorPlugin::_curve_settings_changed); + ClassDB::bind_method(D_METHOD("undo_redo_curve_texture", "points"), &CurveTextureEditorPlugin::_undo_redo_curve_texture); +} diff --git a/editor/plugins/curve_editor_plugin.h b/editor/plugins/curve_editor_plugin.h new file mode 100644 index 0000000000..e98cec2727 --- /dev/null +++ b/editor/plugins/curve_editor_plugin.h @@ -0,0 +1,66 @@ +#ifndef CURVE_EDITOR_PLUGIN_H +#define CURVE_EDITOR_PLUGIN_H + +#include "editor/editor_node.h" +#include "editor/editor_plugin.h" + +class CurveTextureEdit : public Control { + + GDCLASS(CurveTextureEdit, Control); + + struct Point { + + float offset; + float height; + bool operator<(const Point &p_ponit) const { + return offset < p_ponit.offset; + } + }; + + bool grabbing; + int grabbed; + Vector<Point> points; + float max, min; + + void _plot_curve(const Vector2 &p_a, const Vector2 &p_b, const Vector2 &p_c, const Vector2 &p_d); + +protected: + void _gui_input(const InputEvent &p_event); + void _notification(int p_what); + static void _bind_methods(); + +public: + void set_range(float p_min, float p_max); + void set_points(const Vector<Vector2> &p_points); + Vector<Vector2> get_points() const; + virtual Size2 get_minimum_size() const; + CurveTextureEdit(); +}; + +class CurveTextureEditorPlugin : public EditorPlugin { + + GDCLASS(CurveTextureEditorPlugin, EditorPlugin); + + CurveTextureEdit *curve_editor; + Ref<CurveTexture> curve_texture_ref; + EditorNode *editor; + ToolButton *curve_button; + +protected: + static void _bind_methods(); + void _curve_changed(); + void _undo_redo_curve_texture(const PoolVector<Vector2> &points); + void _curve_settings_changed(); + +public: + virtual String get_name() const { return "CurveTexture"; } + 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); + + CurveTextureEditorPlugin(EditorNode *p_node); + ~CurveTextureEditorPlugin(); +}; + +#endif // CURVE_EDITOR_PLUGIN_H diff --git a/editor/plugins/gradient_texture_editor_plugin.cpp b/editor/plugins/gradient_texture_editor_plugin.cpp new file mode 100644 index 0000000000..1e82a1105a --- /dev/null +++ b/editor/plugins/gradient_texture_editor_plugin.cpp @@ -0,0 +1,504 @@ +#include "gradient_texture_editor_plugin.h" + +#include "canvas_item_editor_plugin.h" +#include "spatial_editor_plugin.h" + +#include "os/keyboard.h" +#include "scene/resources/default_theme/theme_data.h" +#define POINT_WIDTH 8 + +GradientTextureEdit::GradientTextureEdit() { + grabbed = -1; + grabbing = false; + set_focus_mode(FOCUS_ALL); + + popup = memnew(PopupPanel); + picker = memnew(ColorPicker); + popup->add_child(picker); + + add_child(popup); + + checker = Ref<ImageTexture>(memnew(ImageTexture)); + checker->create_from_image(Image(checker_bg_png), ImageTexture::FLAG_REPEAT); +} + +int GradientTextureEdit::_get_point_from_pos(int x) { + int result = -1; + int total_w = get_size().width - get_size().height - 3; + for (int i = 0; i < points.size(); i++) { + //Check if we clicked at point + if (ABS(x - points[i].offset * total_w + 1) < (POINT_WIDTH / 2 + 1)) { + result = i; + } + } + return result; +} + +void GradientTextureEdit::_show_color_picker() { + if (grabbed == -1) + return; + Size2 ms = Size2(350, picker->get_combined_minimum_size().height + 10); + picker->set_pick_color(points[grabbed].color); + popup->set_pos(get_global_pos() - Vector2(ms.width - get_size().width, ms.height)); + popup->set_size(ms); + popup->popup(); +} + +GradientTextureEdit::~GradientTextureEdit() { +} + +void GradientTextureEdit::_gui_input(const InputEvent &p_event) { + + if (p_event.type == InputEvent::KEY && p_event.key.pressed && p_event.key.scancode == KEY_DELETE && grabbed != -1) { + + points.remove(grabbed); + grabbed = -1; + grabbing = false; + update(); + emit_signal("ramp_changed"); + accept_event(); + } + + //Show color picker on double click. + if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1 && p_event.mouse_button.doubleclick && p_event.mouse_button.pressed) { + grabbed = _get_point_from_pos(p_event.mouse_button.x); + _show_color_picker(); + accept_event(); + } + + //Delete point on right click + if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 2 && p_event.mouse_button.pressed) { + grabbed = _get_point_from_pos(p_event.mouse_button.x); + if (grabbed != -1) { + points.remove(grabbed); + grabbed = -1; + grabbing = false; + update(); + emit_signal("ramp_changed"); + accept_event(); + } + } + + //Hold alt key to duplicate selected color + if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1 && p_event.mouse_button.pressed && p_event.key.mod.alt) { + + int x = p_event.mouse_button.x; + grabbed = _get_point_from_pos(x); + + if (grabbed != -1) { + int total_w = get_size().width - get_size().height - 3; + GradientTexture::Point newPoint = points[grabbed]; + newPoint.offset = CLAMP(x / float(total_w), 0, 1); + + points.push_back(newPoint); + points.sort(); + for (int i = 0; i < points.size(); ++i) { + if (points[i].offset == newPoint.offset) { + grabbed = i; + break; + } + } + + emit_signal("ramp_changed"); + update(); + } + } + + if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1 && p_event.mouse_button.pressed) { + + update(); + int x = p_event.mouse_button.x; + int total_w = get_size().width - get_size().height - 3; + + //Check if color selector was clicked. + if (x > total_w + 3) { + _show_color_picker(); + return; + } + + grabbing = true; + + grabbed = _get_point_from_pos(x); + //grab or select + if (grabbed != -1) { + return; + } + + //insert + GradientTexture::Point newPoint; + newPoint.offset = CLAMP(x / float(total_w), 0, 1); + + GradientTexture::Point prev; + GradientTexture::Point next; + + int pos = -1; + for (int i = 0; i < points.size(); i++) { + if (points[i].offset < newPoint.offset) + pos = i; + } + + if (pos == -1) { + + prev.color = Color(0, 0, 0); + prev.offset = 0; + if (points.size()) { + next = points[0]; + } else { + next.color = Color(1, 1, 1); + next.offset = 1.0; + } + } else { + + if (pos == points.size() - 1) { + next.color = Color(1, 1, 1); + next.offset = 1.0; + } else { + next = points[pos + 1]; + } + prev = points[pos]; + } + + newPoint.color = prev.color.linear_interpolate(next.color, (newPoint.offset - prev.offset) / (next.offset - prev.offset)); + + points.push_back(newPoint); + points.sort(); + for (int i = 0; i < points.size(); i++) { + if (points[i].offset == newPoint.offset) { + grabbed = i; + break; + } + } + + emit_signal("ramp_changed"); + } + + if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1 && !p_event.mouse_button.pressed) { + + if (grabbing) { + grabbing = false; + emit_signal("ramp_changed"); + } + update(); + } + + if (p_event.type == InputEvent::MOUSE_MOTION && grabbing) { + + int total_w = get_size().width - get_size().height - 3; + + int x = p_event.mouse_motion.x; + float newofs = CLAMP(x / float(total_w), 0, 1); + + //Snap to nearest point if holding shift + if (p_event.key.mod.shift) { + float snap_treshhold = 0.03; + float smallest_ofs = snap_treshhold; + bool founded = false; + int nearest_point; + for (int i = 0; i < points.size(); ++i) { + if (i != grabbed) { + float temp_ofs = ABS(points[i].offset - newofs); + if (temp_ofs < smallest_ofs) { + smallest_ofs = temp_ofs; + nearest_point = i; + if (founded) + break; + founded = true; + } + } + } + if (founded) { + if (points[nearest_point].offset < newofs) + newofs = points[nearest_point].offset + 0.00001; + else + newofs = points[nearest_point].offset - 0.00001; + newofs = CLAMP(newofs, 0, 1); + } + } + + bool valid = true; + for (int i = 0; i < points.size(); i++) { + + if (points[i].offset == newofs && i != grabbed) { + valid = false; + } + } + + if (!valid) + return; + + points[grabbed].offset = newofs; + + points.sort(); + for (int i = 0; i < points.size(); i++) { + if (points[i].offset == newofs) { + grabbed = i; + break; + } + } + + emit_signal("ramp_changed"); + + update(); + } +} + +void GradientTextureEdit::_notification(int p_what) { + + if (p_what == NOTIFICATION_ENTER_TREE) { + if (!picker->is_connected("color_changed", this, "_color_changed")) { + picker->connect("color_changed", this, "_color_changed"); + } + } + if (p_what == NOTIFICATION_DRAW) { + + int w = get_size().x; + int h = get_size().y; + + if (w == 0 || h == 0) + return; //Safety check. We have division by 'h'. And in any case there is nothing to draw with such size + + int total_w = get_size().width - get_size().height - 3; + + //Draw checker pattern for ramp + _draw_checker(0, 0, total_w, h); + + //Draw color ramp + GradientTexture::Point prev; + prev.offset = 0; + if (points.size() == 0) + prev.color = Color(0, 0, 0); //Draw black rectangle if we have no points + else + prev.color = points[0].color; //Extend color of first point to the beginning. + + for (int i = -1; i < points.size(); i++) { + + GradientTexture::Point next; + //If there is no next point + if (i + 1 == points.size()) { + if (points.size() == 0) + next.color = Color(0, 0, 0); //Draw black rectangle if we have no points + else + next.color = points[i].color; //Extend color of last point to the end. + next.offset = 1; + } else { + next = points[i + 1]; + } + + if (prev.offset == next.offset) { + prev = next; + continue; + } + + Vector<Vector2> points; + Vector<Color> colors; + points.push_back(Vector2(prev.offset * total_w, h)); + points.push_back(Vector2(prev.offset * total_w, 0)); + points.push_back(Vector2(next.offset * total_w, 0)); + points.push_back(Vector2(next.offset * total_w, h)); + colors.push_back(prev.color); + colors.push_back(prev.color); + colors.push_back(next.color); + colors.push_back(next.color); + draw_primitive(points, colors, Vector<Point2>()); + prev = next; + } + + //Draw point markers + for (int i = 0; i < points.size(); i++) { + + Color col = i == grabbed ? Color(1, 0.0, 0.0, 0.9) : points[i].color.contrasted(); + col.a = 0.9; + + draw_line(Vector2(points[i].offset * total_w, 0), Vector2(points[i].offset * total_w, h / 2), col); + draw_rect(Rect2(points[i].offset * total_w - POINT_WIDTH / 2, h / 2, POINT_WIDTH, h / 2), Color(0.6, 0.6, 0.6, i == grabbed ? 0.9 : 0.4)); + draw_line(Vector2(points[i].offset * total_w - POINT_WIDTH / 2, h / 2), Vector2(points[i].offset * total_w - POINT_WIDTH / 2, h - 1), col); + draw_line(Vector2(points[i].offset * total_w + POINT_WIDTH / 2, h / 2), Vector2(points[i].offset * total_w + POINT_WIDTH / 2, h - 1), col); + draw_line(Vector2(points[i].offset * total_w - POINT_WIDTH / 2, h / 2), Vector2(points[i].offset * total_w + POINT_WIDTH / 2, h / 2), col); + draw_line(Vector2(points[i].offset * total_w - POINT_WIDTH / 2, h - 1), Vector2(points[i].offset * total_w + POINT_WIDTH / 2, h - 1), col); + } + + //Draw "button" for color selector + _draw_checker(total_w + 3, 0, h, h); + if (grabbed != -1) { + //Draw with selection color + draw_rect(Rect2(total_w + 3, 0, h, h), points[grabbed].color); + } else { + //if no color selected draw grey color with 'X' on top. + draw_rect(Rect2(total_w + 3, 0, h, h), Color(0.5, 0.5, 0.5, 1)); + draw_line(Vector2(total_w + 3, 0), Vector2(total_w + 3 + h, h), Color(1, 1, 1, 0.6)); + draw_line(Vector2(total_w + 3, h), Vector2(total_w + 3 + h, 0), Color(1, 1, 1, 0.6)); + } + + //Draw borders around color ramp if in focus + if (has_focus()) { + + draw_line(Vector2(-1, -1), Vector2(total_w + 1, -1), Color(1, 1, 1, 0.6)); + draw_line(Vector2(total_w + 1, -1), Vector2(total_w + 1, h + 1), Color(1, 1, 1, 0.6)); + draw_line(Vector2(total_w + 1, h + 1), Vector2(-1, h + 1), Color(1, 1, 1, 0.6)); + draw_line(Vector2(-1, -1), Vector2(-1, h + 1), Color(1, 1, 1, 0.6)); + } + } +} + +void GradientTextureEdit::_draw_checker(int x, int y, int w, int h) { + //Draw it with polygon to insert UVs for scale + Vector<Vector2> backPoints; + backPoints.push_back(Vector2(x, y)); + backPoints.push_back(Vector2(x, y + h)); + backPoints.push_back(Vector2(x + w, y + h)); + backPoints.push_back(Vector2(x + w, y)); + Vector<Color> colorPoints; + colorPoints.push_back(Color(1, 1, 1, 1)); + colorPoints.push_back(Color(1, 1, 1, 1)); + colorPoints.push_back(Color(1, 1, 1, 1)); + colorPoints.push_back(Color(1, 1, 1, 1)); + Vector<Vector2> uvPoints; + //Draw checker pattern pixel-perfect and scale it by 2. + uvPoints.push_back(Vector2(x, y)); + uvPoints.push_back(Vector2(x, y + h * .5f / checker->get_height())); + uvPoints.push_back(Vector2(x + w * .5f / checker->get_width(), y + h * .5f / checker->get_height())); + uvPoints.push_back(Vector2(x + w * .5f / checker->get_width(), y)); + draw_polygon(backPoints, colorPoints, uvPoints, checker); +} + +Size2 GradientTextureEdit::get_minimum_size() const { + + return Vector2(0, 16); +} + +void GradientTextureEdit::_color_changed(const Color &p_color) { + + if (grabbed == -1) + return; + points[grabbed].color = p_color; + update(); + emit_signal("ramp_changed"); +} + +void GradientTextureEdit::set_ramp(const Vector<float> &p_offsets, const Vector<Color> &p_colors) { + + ERR_FAIL_COND(p_offsets.size() != p_colors.size()); + points.clear(); + for (int i = 0; i < p_offsets.size(); i++) { + GradientTexture::Point p; + p.offset = p_offsets[i]; + p.color = p_colors[i]; + points.push_back(p); + } + + points.sort(); + update(); +} + +Vector<float> GradientTextureEdit::get_offsets() const { + Vector<float> ret; + for (int i = 0; i < points.size(); i++) + ret.push_back(points[i].offset); + return ret; +} + +Vector<Color> GradientTextureEdit::get_colors() const { + Vector<Color> ret; + for (int i = 0; i < points.size(); i++) + ret.push_back(points[i].color); + return ret; +} + +void GradientTextureEdit::set_points(Vector<GradientTexture::Point> &p_points) { + if (points.size() != p_points.size()) + grabbed = -1; + points.clear(); + points = p_points; +} + +Vector<GradientTexture::Point> &GradientTextureEdit::get_points() { + return points; +} + +void GradientTextureEdit::_bind_methods() { + ClassDB::bind_method(D_METHOD("_gui_input"), &GradientTextureEdit::_gui_input); + ClassDB::bind_method(D_METHOD("_color_changed"), &GradientTextureEdit::_color_changed); + ADD_SIGNAL(MethodInfo("ramp_changed")); +} + +GradientTextureEditorPlugin::GradientTextureEditorPlugin(EditorNode *p_node) { + + editor = p_node; + ramp_editor = memnew(GradientTextureEdit); + + gradient_button = editor->add_bottom_panel_item("GradientTexture", ramp_editor); + + gradient_button->hide(); + ramp_editor->set_custom_minimum_size(Size2(100, 100 * EDSCALE)); + ramp_editor->hide(); + ramp_editor->connect("ramp_changed", this, "ramp_changed"); +} + +void GradientTextureEditorPlugin::edit(Object *p_object) { + + GradientTexture *gradient_texture = p_object->cast_to<GradientTexture>(); + if (!gradient_texture) + return; + gradient_texture_ref = Ref<GradientTexture>(gradient_texture); + ramp_editor->set_points(gradient_texture_ref->get_points()); +} + +bool GradientTextureEditorPlugin::handles(Object *p_object) const { + + return p_object->is_class("GradientTexture"); +} + +void GradientTextureEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + gradient_button->show(); + editor->make_bottom_panel_item_visible(ramp_editor); + + } else { + + gradient_button->hide(); + if (ramp_editor->is_visible_in_tree()) + editor->hide_bottom_panel(); + } +} + +void GradientTextureEditorPlugin::_ramp_changed() { + + if (gradient_texture_ref.is_valid()) { + + UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo(); + + //Not sure if I should convert this data to PoolVector + Vector<float> new_offsets = ramp_editor->get_offsets(); + Vector<Color> new_colors = ramp_editor->get_colors(); + Vector<float> old_offsets = gradient_texture_ref->get_offsets(); + Vector<Color> old_colors = gradient_texture_ref->get_colors(); + + if (old_offsets.size() != new_offsets.size()) + ur->create_action(TTR("Add/Remove Color Ramp Point")); + else + ur->create_action(TTR("Modify Color Ramp"), UndoRedo::MERGE_ENDS); + ur->add_do_method(this, "undo_redo_gradient_texture", new_offsets, new_colors); + ur->add_undo_method(this, "undo_redo_gradient_texture", old_offsets, old_colors); + ur->commit_action(); + + //gradient_texture_ref->set_points(ramp_editor->get_points()); + } +} + +void GradientTextureEditorPlugin::_undo_redo_gradient_texture(const Vector<float> &offsets, + const Vector<Color> &colors) { + + gradient_texture_ref->set_offsets(offsets); + gradient_texture_ref->set_colors(colors); + ramp_editor->set_points(gradient_texture_ref->get_points()); + ramp_editor->update(); +} + +GradientTextureEditorPlugin::~GradientTextureEditorPlugin() { +} + +void GradientTextureEditorPlugin::_bind_methods() { + ClassDB::bind_method(D_METHOD("ramp_changed"), &GradientTextureEditorPlugin::_ramp_changed); + ClassDB::bind_method(D_METHOD("undo_redo_gradient_texture", "offsets", "colors"), &GradientTextureEditorPlugin::_undo_redo_gradient_texture); +} diff --git a/editor/plugins/gradient_texture_editor_plugin.h b/editor/plugins/gradient_texture_editor_plugin.h new file mode 100644 index 0000000000..5af828f17c --- /dev/null +++ b/editor/plugins/gradient_texture_editor_plugin.h @@ -0,0 +1,69 @@ +#ifndef GRADIENT_TEXTURE_EDITOR_PLUGIN_H +#define GRADIENT_TEXTURE_EDITOR_PLUGIN_H + +#include "editor/editor_node.h" +#include "editor/editor_plugin.h" +#include "scene/resources/texture.h" + +class GradientTextureEdit : public Control { + + GDCLASS(GradientTextureEdit, Control); + + PopupPanel *popup; + ColorPicker *picker; + + Ref<ImageTexture> checker; + + bool grabbing; + int grabbed; + Vector<GradientTexture::Point> points; + + void _draw_checker(int x, int y, int w, int h); + void _color_changed(const Color &p_color); + int _get_point_from_pos(int x); + void _show_color_picker(); + +protected: + void _gui_input(const InputEvent &p_event); + void _notification(int p_what); + static void _bind_methods(); + +public: + void set_ramp(const Vector<float> &p_offsets, const Vector<Color> &p_colors); + Vector<float> get_offsets() const; + Vector<Color> get_colors() const; + void set_points(Vector<GradientTexture::Point> &p_points); + Vector<GradientTexture::Point> &get_points(); + virtual Size2 get_minimum_size() const; + + GradientTextureEdit(); + virtual ~GradientTextureEdit(); +}; + +class GradientTextureEditorPlugin : public EditorPlugin { + + GDCLASS(GradientTextureEditorPlugin, EditorPlugin); + + bool _2d; + Ref<GradientTexture> gradient_texture_ref; + GradientTextureEdit *ramp_editor; + EditorNode *editor; + ToolButton *gradient_button; + +protected: + static void _bind_methods(); + void _ramp_changed(); + void _undo_redo_gradient_texture(const Vector<float> &offsets, const Vector<Color> &colors); + +public: + virtual String get_name() const { return "GradientTexture"; } + 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); + + GradientTextureEditorPlugin(EditorNode *p_node); + ~GradientTextureEditorPlugin(); +}; + +#endif // GRADIENT_TEXTURE_EDITOR_PLUGIN_H diff --git a/editor/plugins/particles_editor_plugin.cpp b/editor/plugins/particles_editor_plugin.cpp index fd26674a0e..9624030246 100644 --- a/editor/plugins/particles_editor_plugin.cpp +++ b/editor/plugins/particles_editor_plugin.cpp @@ -27,30 +27,24 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ -#if 0 #include "particles_editor_plugin.h" #include "editor/plugins/spatial_editor_plugin.h" #include "io/resource_loader.h" -#include "servers/visual/particle_system_sw.h" - void ParticlesEditor::_node_removed(Node *p_node) { - if(p_node==node) { - node=NULL; + if (p_node == node) { + node = NULL; hide(); } - } - -void ParticlesEditor::_resource_seleted(const String& p_res) { +void ParticlesEditor::_resource_seleted(const String &p_res) { //print_line("selected resource path: "+p_res); } -void ParticlesEditor::_node_selected(const NodePath& p_path){ - +void ParticlesEditor::_node_selected(const NodePath &p_path) { Node *sel = get_node(p_path); if (!sel) @@ -66,12 +60,11 @@ void ParticlesEditor::_node_selected(const NodePath& p_path){ geometry = vi->get_faces(VisualInstance::FACES_SOLID); - if (geometry.size()==0) { + if (geometry.size() == 0) { err_dialog->set_text(TTR("Node does not contain geometry (faces).")); err_dialog->popup_centered_minsize(); return; - } Transform geom_xform = node->get_global_transform().affine_inverse() * vi->get_global_transform(); @@ -79,20 +72,17 @@ void ParticlesEditor::_node_selected(const NodePath& p_path){ int gc = geometry.size(); PoolVector<Face3>::Write w = geometry.write(); - - for(int i=0;i<gc;i++) { - for(int j=0;j<3;j++) { - w[i].vertex[j] = geom_xform.xform( w[i].vertex[j] ); + for (int i = 0; i < gc; i++) { + for (int j = 0; j < 3; j++) { + w[i].vertex[j] = geom_xform.xform(w[i].vertex[j]); } } - w = PoolVector<Face3>::Write(); - emission_dialog->popup_centered(Size2(300,130)); + emission_dialog->popup_centered(Size2(300, 130)); } - /* void ParticlesEditor::_populate() { @@ -112,74 +102,77 @@ void ParticlesEditor::_populate() { void ParticlesEditor::_notification(int p_notification) { - if (p_notification==NOTIFICATION_ENTER_TREE) { - options->set_icon(options->get_popup()->get_icon("Particles","EditorIcons")); - + if (p_notification == NOTIFICATION_ENTER_TREE) { + options->set_icon(options->get_popup()->get_icon("Particles", "EditorIcons")); } } - void ParticlesEditor::_menu_option(int p_option) { - - switch(p_option) { + switch (p_option) { case MENU_OPTION_GENERATE_AABB: { - +#if 0 Transform globalizer = node->get_global_transform(); ParticleSystemSW pssw; - for(int i=0;i<VS::PARTICLE_VAR_MAX;i++) { + for (int i = 0; i < VS::PARTICLE_VAR_MAX; i++) { - pssw.particle_vars[i]=node->get_variable((Particles::Variable)i); - pssw.particle_randomness[i]=node->get_randomness((Particles::Variable)i); + pssw.particle_vars[i] = node->get_variable((Particles::Variable)i); + pssw.particle_randomness[i] = node->get_randomness((Particles::Variable)i); } - pssw.emission_half_extents=node->get_emission_half_extents(); - pssw.emission_points=node->get_emission_points(); - pssw.emission_base_velocity=node->get_emission_base_velocity(); - pssw.amount=node->get_amount(); - pssw.gravity_normal=node->get_gravity_normal(); - pssw.emitting=true; - pssw.height_from_velocity=node->has_height_from_velocity(); - pssw.color_phase_count=1; - + pssw.emission_half_extents = node->get_emission_half_extents(); + pssw.emission_points = node->get_emission_points(); + pssw.emission_base_velocity = node->get_emission_base_velocity(); + pssw.amount = node->get_amount(); + pssw.gravity_normal = node->get_gravity_normal(); + pssw.emitting = true; + pssw.height_from_velocity = node->has_height_from_velocity(); + pssw.color_phase_count = 1; ParticleSystemProcessSW pp; - float delta=0.01; - float lifetime=pssw.particle_vars[VS::PARTICLE_LIFETIME]; - + float delta = 0.01; + float lifetime = pssw.particle_vars[VS::PARTICLE_LIFETIME]; Transform localizer = globalizer.affine_inverse(); AABB aabb; - for(float t=0;t<lifetime;t+=delta) { + for (float t = 0; t < lifetime; t += delta) { - pp.process(&pssw,globalizer,delta); - for(int i=0;i<pp.particle_data.size();i++) { + pp.process(&pssw, globalizer, delta); + for (int i = 0; i < pp.particle_data.size(); i++) { Vector3 p = localizer.xform(pp.particle_data[i].pos); - if (t==0 && i==0) - aabb.pos=p; + if (t == 0 && i == 0) + aabb.pos = p; else aabb.expand_to(p); } } - aabb.grow_by( aabb.get_longest_axis_size()*0.2); + aabb.grow_by(aabb.get_longest_axis_size() * 0.2); node->set_visibility_aabb(aabb); - - +#endif } break; case MENU_OPTION_CREATE_EMISSION_VOLUME_FROM_MESH: { - + Ref<ParticlesMaterial> material = node->get_process_material(); + if (material.is_null()) { + EditorNode::get_singleton()->show_warning(TTR("A processor material of type 'ParticlesMaterial' is required.")); + return; + } emission_file_dialog->popup_centered_ratio(); } break; case MENU_OPTION_CREATE_EMISSION_VOLUME_FROM_NODE: { -/* + Ref<ParticlesMaterial> material = node->get_process_material(); + if (material.is_null()) { + EditorNode::get_singleton()->show_warning(TTR("A processor material of type 'ParticlesMaterial' is required.")); + return; + } + /* Node *root = get_scene()->get_root_node(); ERR_FAIL_COND(!root); EditorNode *en = root->cast_to<EditorNode>(); @@ -192,50 +185,50 @@ void ParticlesEditor::_menu_option(int p_option) { } } - void ParticlesEditor::edit(Particles *p_particles) { - node=p_particles; - + node = p_particles; } void ParticlesEditor::_generate_emission_points() { /// hacer codigo aca - PoolVector<Vector3> points; + PoolVector<float> points; + bool use_normals = emission_fill->get_selected() == 1; + PoolVector<float> normals; - if (emission_fill->get_selected()==0) { + if (emission_fill->get_selected() < 2) { - float area_accum=0; - Map<float,int> triangle_area_map; - print_line("geometry size: "+itos(geometry.size())); + float area_accum = 0; + Map<float, int> triangle_area_map; + print_line("geometry size: " + itos(geometry.size())); - for(int i=0;i<geometry.size();i++) { + for (int i = 0; i < geometry.size(); i++) { float area = geometry[i].get_area(); - if (area<CMP_EPSILON) + if (area < CMP_EPSILON) continue; - triangle_area_map[area_accum]=i; - area_accum+=area; + triangle_area_map[area_accum] = i; + area_accum += area; } - if (!triangle_area_map.size() || area_accum==0) { + if (!triangle_area_map.size() || area_accum == 0) { err_dialog->set_text(TTR("Faces contain no area!")); err_dialog->popup_centered_minsize(); return; } - int emissor_count=emission_amount->get_val(); + int emissor_count = emission_amount->get_value(); - for(int i=0;i<emissor_count;i++) { + for (int i = 0; i < emissor_count; i++) { - float areapos = Math::random(0,area_accum); + float areapos = Math::random(0.0f, area_accum); - Map<float,int>::Element *E = triangle_area_map.find_closest(areapos); + Map<float, int>::Element *E = triangle_area_map.find_closest(areapos); ERR_FAIL_COND(!E) int index = E->get(); - ERR_FAIL_INDEX(index,geometry.size()); + ERR_FAIL_INDEX(index, geometry.size()); // ok FINALLY get face Face3 face = geometry[index]; @@ -243,13 +236,22 @@ void ParticlesEditor::_generate_emission_points() { Vector3 pos = face.get_random_point_inside(); - points.push_back(pos); + points.push_back(pos.x); + points.push_back(pos.y); + points.push_back(pos.z); + + if (use_normals) { + Vector3 normal = face.get_plane().normal; + normals.push_back(normal.x); + normals.push_back(normal.y); + normals.push_back(normal.z); + } } } else { int gcount = geometry.size(); - if (gcount==0) { + if (gcount == 0) { err_dialog->set_text(TTR("No faces!")); err_dialog->popup_centered_minsize(); @@ -258,32 +260,32 @@ void ParticlesEditor::_generate_emission_points() { PoolVector<Face3>::Read r = geometry.read(); - AABB aabb; + Rect3 aabb; - for(int i=0;i<gcount;i++) { + for (int i = 0; i < gcount; i++) { - for(int j=0;j<3;j++) { + for (int j = 0; j < 3; j++) { - if (i==0 && j==0) - aabb.pos=r[i].vertex[j]; + if (i == 0 && j == 0) + aabb.pos = r[i].vertex[j]; else aabb.expand_to(r[i].vertex[j]); } } - int emissor_count=emission_amount->get_val(); + int emissor_count = emission_amount->get_value(); - for(int i=0;i<emissor_count;i++) { + for (int i = 0; i < emissor_count; i++) { - int attempts=5; + int attempts = 5; - for(int j=0;j<attempts;j++) { + for (int j = 0; j < attempts; j++) { Vector3 dir; - dir[Math::rand()%3]=1.0; - Vector3 ofs = Vector3(1,1,1)-dir; - ofs=(Vector3(1,1,1)-dir)*Vector3(Math::randf(),Math::randf(),Math::randf())*aabb.size; - ofs+=aabb.pos; + dir[Math::rand() % 3] = 1.0; + Vector3 ofs = Vector3(1, 1, 1) - dir; + ofs = (Vector3(1, 1, 1) - dir) * Vector3(Math::randf(), Math::randf(), Math::randf()) * aabb.size; + ofs += aabb.pos; Vector3 ofsv = ofs + aabb.size * dir; @@ -291,135 +293,172 @@ void ParticlesEditor::_generate_emission_points() { ofs -= dir; ofsv += dir; - float max=-1e7,min=1e7; + float max = -1e7, min = 1e7; - for(int k=0;k<gcount;k++) { + for (int k = 0; k < gcount; k++) { - const Face3& f3 = r[k]; + const Face3 &f3 = r[k]; Vector3 res; - if (f3.intersects_segment(ofs,ofsv,&res)) { + if (f3.intersects_segment(ofs, ofsv, &res)) { - res-=ofs; + res -= ofs; float d = dir.dot(res); - if (d<min) - min=d; - if (d>max) - max=d; - + if (d < min) + min = d; + if (d > max) + max = d; } } - - if (max<min) + if (max < min) continue; //lost attempt - float val = min + (max-min)*Math::randf(); + float val = min + (max - min) * Math::randf(); Vector3 point = ofs + dir * val; - points.push_back(point); + points.push_back(point.x); + points.push_back(point.y); + points.push_back(point.z); break; } } } - //print_line("point count: "+itos(points.size())); - node->set_emission_points(points); + int point_count = points.size() / 3; + + int w = 2048; + int h = (point_count / 2048) + 1; + PoolVector<uint8_t> point_img; + point_img.resize(w * h * 3 * sizeof(float)); + + { + PoolVector<uint8_t>::Write iw = point_img.write(); + zeromem(iw.ptr(), w * h * 3 * sizeof(float)); + PoolVector<float>::Read r = points.read(); + copymem(iw.ptr(), r.ptr(), point_count * sizeof(float) * 3); + } + + Image image(w, h, false, Image::FORMAT_RGBF, point_img); + + Ref<ImageTexture> tex; + tex.instance(); + tex->create_from_image(image, Texture::FLAG_FILTER); + + Ref<ParticlesMaterial> material = node->get_process_material(); + ERR_FAIL_COND(material.is_null()); + + if (use_normals) { + + material->set_emission_shape(ParticlesMaterial::EMISSION_SHAPE_DIRECTED_POINTS); + material->set_emission_point_count(point_count); + material->set_emission_point_texture(tex); + + PoolVector<uint8_t> point_img2; + point_img2.resize(w * h * 3 * sizeof(float)); + + { + PoolVector<uint8_t>::Write iw = point_img2.write(); + zeromem(iw.ptr(), w * h * 3 * sizeof(float)); + PoolVector<float>::Read r = normals.read(); + copymem(iw.ptr(), r.ptr(), point_count * sizeof(float) * 3); + } + + Image image2(w, h, false, Image::FORMAT_RGBF, point_img2); + + Ref<ImageTexture> tex2; + tex2.instance(); + tex2->create_from_image(image2, Texture::FLAG_FILTER); + + material->set_emission_normal_texture(tex2); + } else { + + material->set_emission_shape(ParticlesMaterial::EMISSION_SHAPE_POINTS); + material->set_emission_point_count(point_count); + material->set_emission_point_texture(tex); + } + + //print_line("point count: "+itos(points.size())); + //node->set_emission_points(points); } void ParticlesEditor::_bind_methods() { - ClassDB::bind_method("_menu_option",&ParticlesEditor::_menu_option); - ClassDB::bind_method("_resource_seleted",&ParticlesEditor::_resource_seleted); - ClassDB::bind_method("_node_selected",&ParticlesEditor::_node_selected); - ClassDB::bind_method("_generate_emission_points",&ParticlesEditor::_generate_emission_points); + ClassDB::bind_method("_menu_option", &ParticlesEditor::_menu_option); + ClassDB::bind_method("_resource_seleted", &ParticlesEditor::_resource_seleted); + ClassDB::bind_method("_node_selected", &ParticlesEditor::_node_selected); + ClassDB::bind_method("_generate_emission_points", &ParticlesEditor::_generate_emission_points); //ClassDB::bind_method("_populate",&ParticlesEditor::_populate); - } ParticlesEditor::ParticlesEditor() { - particles_editor_hb = memnew ( HBoxContainer ); + particles_editor_hb = memnew(HBoxContainer); SpatialEditor::get_singleton()->add_control_to_menu_panel(particles_editor_hb); - options = memnew( MenuButton ); + options = memnew(MenuButton); particles_editor_hb->add_child(options); particles_editor_hb->hide(); options->set_text("Particles"); - options->get_popup()->add_item(TTR("Generate AABB"),MENU_OPTION_GENERATE_AABB); + options->get_popup()->add_item(TTR("Generate AABB"), MENU_OPTION_GENERATE_AABB); options->get_popup()->add_separator(); - options->get_popup()->add_item(TTR("Create Emitter From Mesh"),MENU_OPTION_CREATE_EMISSION_VOLUME_FROM_MESH); - options->get_popup()->add_item(TTR("Create Emitter From Node"),MENU_OPTION_CREATE_EMISSION_VOLUME_FROM_NODE); - options->get_popup()->add_item(TTR("Clear Emitter"),MENU_OPTION_CLEAR_EMISSION_VOLUME); + options->get_popup()->add_item(TTR("Create Emission Points From Mesh"), MENU_OPTION_CREATE_EMISSION_VOLUME_FROM_MESH); + options->get_popup()->add_item(TTR("Create Emission Points From Node"), MENU_OPTION_CREATE_EMISSION_VOLUME_FROM_NODE); + // options->get_popup()->add_item(TTR("Clear Emitter"), MENU_OPTION_CLEAR_EMISSION_VOLUME); - options->get_popup()->connect("id_pressed", this,"_menu_option"); + options->get_popup()->connect("id_pressed", this, "_menu_option"); - emission_dialog = memnew( ConfirmationDialog ); + emission_dialog = memnew(ConfirmationDialog); emission_dialog->set_title(TTR("Create Emitter")); add_child(emission_dialog); - Label *l = memnew(Label); - l->set_pos(Point2(5,5)); - l->set_text(TTR("Emission Positions:")); - emission_dialog->add_child(l); - + VBoxContainer *emd_vb = memnew(VBoxContainer); + emission_dialog->add_child(emd_vb); - emission_amount = memnew( SpinBox ); - emission_amount->set_anchor(MARGIN_RIGHT,ANCHOR_END); - emission_amount->set_begin( Point2(20,23)); - emission_amount->set_end( Point2(5,25)); + emission_amount = memnew(SpinBox); emission_amount->set_min(1); - emission_amount->set_max(65536); - emission_amount->set_val(512); - emission_dialog->add_child(emission_amount); - emission_dialog->get_ok()->set_text(TTR("Create")); - emission_dialog->connect("confirmed",this,"_generate_emission_points"); - - l = memnew(Label); - l->set_pos(Point2(5,50)); - l->set_text(TTR("Emission Fill:")); - emission_dialog->add_child(l); - - emission_fill = memnew( OptionButton ); - emission_fill->set_anchor(MARGIN_RIGHT,ANCHOR_END); - emission_fill->set_begin( Point2(20,70)); - emission_fill->set_end( Point2(5,75)); - emission_fill->add_item(TTR("Surface")); + emission_amount->set_max(100000); + emission_amount->set_value(512); + emd_vb->add_margin_child(TTR("Emission Points:"), emission_amount); + + emission_fill = memnew(OptionButton); + emission_fill->add_item(TTR("Surface Points")); + emission_fill->add_item(TTR("Surface Points+Normal (Directed)")); emission_fill->add_item(TTR("Volume")); - emission_dialog->add_child(emission_fill); + emd_vb->add_margin_child(TTR("Emission Source: "), emission_fill); + + emission_dialog->get_ok()->set_text(TTR("Create")); + emission_dialog->connect("confirmed", this, "_generate_emission_points"); - err_dialog = memnew( ConfirmationDialog ); + err_dialog = memnew(ConfirmationDialog); //err_dialog->get_cancel()->hide(); add_child(err_dialog); - - emission_file_dialog = memnew( EditorFileDialog ); + emission_file_dialog = memnew(EditorFileDialog); add_child(emission_file_dialog); - emission_file_dialog->connect("file_selected",this,"_resource_seleted"); - emission_tree_dialog = memnew( SceneTreeDialog ); + emission_file_dialog->connect("file_selected", this, "_resource_seleted"); + emission_tree_dialog = memnew(SceneTreeDialog); add_child(emission_tree_dialog); - emission_tree_dialog->connect("selected",this,"_node_selected"); + emission_tree_dialog->connect("selected", this, "_node_selected"); List<String> extensions; - ResourceLoader::get_recognized_extensions_for_type("Mesh",&extensions); + ResourceLoader::get_recognized_extensions_for_type("Mesh", &extensions); emission_file_dialog->clear_filters(); - for(int i=0;i<extensions.size();i++) { + for (int i = 0; i < extensions.size(); i++) { - emission_file_dialog->add_filter("*."+extensions[i]+" ; "+extensions[i].to_upper()); + emission_file_dialog->add_filter("*." + extensions[i] + " ; " + extensions[i].to_upper()); } emission_file_dialog->set_mode(EditorFileDialog::MODE_OPEN_FILE); //options->set_anchor(MARGIN_LEFT,Control::ANCHOR_END); //options->set_anchor(MARGIN_RIGHT,Control::ANCHOR_END); - } - void ParticlesEditorPlugin::edit(Object *p_object) { particles_editor->edit(p_object->cast_to<Particles>()); @@ -427,7 +466,7 @@ void ParticlesEditorPlugin::edit(Object *p_object) { bool ParticlesEditorPlugin::handles(Object *p_object) const { - return p_object->is_type("Particles"); + return p_object->is_class("Particles"); } void ParticlesEditorPlugin::make_visible(bool p_visible) { @@ -440,21 +479,16 @@ void ParticlesEditorPlugin::make_visible(bool p_visible) { particles_editor->hide(); particles_editor->edit(NULL); } - } ParticlesEditorPlugin::ParticlesEditorPlugin(EditorNode *p_node) { - editor=p_node; - particles_editor = memnew( ParticlesEditor ); + editor = p_node; + particles_editor = memnew(ParticlesEditor); editor->get_viewport()->add_child(particles_editor); particles_editor->hide(); } - -ParticlesEditorPlugin::~ParticlesEditorPlugin() -{ +ParticlesEditorPlugin::~ParticlesEditorPlugin() { } - -#endif diff --git a/editor/plugins/particles_editor_plugin.h b/editor/plugins/particles_editor_plugin.h index 420e20d641..b3394d879e 100644 --- a/editor/plugins/particles_editor_plugin.h +++ b/editor/plugins/particles_editor_plugin.h @@ -37,17 +37,16 @@ /** @author Juan Linietsky <reduzio@gmail.com> */ -#if 0 + class ParticlesEditor : public Control { - GDCLASS(ParticlesEditor, Control ); + GDCLASS(ParticlesEditor, Control); Panel *panel; MenuButton *options; HBoxContainer *particles_editor_hb; Particles *node; - EditorFileDialog *emission_file_dialog; SceneTreeDialog *emission_tree_dialog; @@ -57,9 +56,6 @@ class ParticlesEditor : public Control { SpinBox *emission_amount; OptionButton *emission_fill; - - - enum Menu { MENU_OPTION_GENERATE_AABB, @@ -72,35 +68,33 @@ class ParticlesEditor : public Control { PoolVector<Face3> geometry; void _generate_emission_points(); - void _resource_seleted(const String& p_res); - void _node_selected(const NodePath& p_path); + void _resource_seleted(const String &p_res); + void _node_selected(const NodePath &p_path); void _menu_option(int); void _populate(); -friend class ParticlesEditorPlugin; + friend class ParticlesEditorPlugin; protected: - void _notification(int p_notification); void _node_removed(Node *p_node); static void _bind_methods(); -public: +public: void edit(Particles *p_particles); ParticlesEditor(); }; class ParticlesEditorPlugin : public EditorPlugin { - GDCLASS( ParticlesEditorPlugin, EditorPlugin ); + GDCLASS(ParticlesEditorPlugin, EditorPlugin); ParticlesEditor *particles_editor; EditorNode *editor; public: - virtual String get_name() const { return "Particles"; } bool has_main_screen() const { return false; } virtual void edit(Object *p_node); @@ -109,8 +103,6 @@ public: ParticlesEditorPlugin(EditorNode *p_node); ~ParticlesEditorPlugin(); - }; #endif // PARTICLES_EDITOR_PLUGIN_H -#endif diff --git a/editor/plugins/path_editor_plugin.cpp b/editor/plugins/path_editor_plugin.cpp index 0b3587bc5e..6fcda001ee 100644 --- a/editor/plugins/path_editor_plugin.cpp +++ b/editor/plugins/path_editor_plugin.cpp @@ -530,16 +530,16 @@ PathEditorPlugin::PathEditorPlugin(EditorNode *p_node) { editor=p_node; singleton=this; - path_material = Ref<FixedSpatialMaterial>( memnew( FixedSpatialMaterial )); - path_material->set_parameter( FixedSpatialMaterial::PARAM_DIFFUSE,Color(0.5,0.5,1.0,0.8) ); - path_material->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_ALPHA, true); + path_material = Ref<SpatialMaterial>( memnew( SpatialMaterial )); + path_material->set_parameter( SpatialMaterial::PARAM_DIFFUSE,Color(0.5,0.5,1.0,0.8) ); + path_material->set_fixed_flag(SpatialMaterial::FLAG_USE_ALPHA, true); path_material->set_line_width(3); path_material->set_flag(Material::FLAG_DOUBLE_SIDED,true); path_material->set_flag(Material::FLAG_UNSHADED,true); - path_thin_material = Ref<FixedSpatialMaterial>( memnew( FixedSpatialMaterial )); - path_thin_material->set_parameter( FixedSpatialMaterial::PARAM_DIFFUSE,Color(0.5,0.5,1.0,0.4) ); - path_thin_material->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_ALPHA, true); + path_thin_material = Ref<SpatialMaterial>( memnew( SpatialMaterial )); + path_thin_material->set_parameter( SpatialMaterial::PARAM_DIFFUSE,Color(0.5,0.5,1.0,0.4) ); + path_thin_material->set_fixed_flag(SpatialMaterial::FLAG_USE_ALPHA, true); path_thin_material->set_line_width(1); path_thin_material->set_flag(Material::FLAG_DOUBLE_SIDED,true); path_thin_material->set_flag(Material::FLAG_UNSHADED,true); diff --git a/editor/plugins/path_editor_plugin.h b/editor/plugins/path_editor_plugin.h index 9d0f6eb9f2..131cf11ef8 100644 --- a/editor/plugins/path_editor_plugin.h +++ b/editor/plugins/path_editor_plugin.h @@ -78,8 +78,8 @@ public: Path *get_edited_path() { return path; } static PathEditorPlugin* singleton; - Ref<FixedSpatialMaterial> path_material; - Ref<FixedSpatialMaterial> path_thin_material; + Ref<SpatialMaterial> path_material; + Ref<SpatialMaterial> path_thin_material; virtual bool forward_spatial_gui_input(Camera* p_camera,const InputEvent& p_event); //virtual bool forward_gui_input(const InputEvent& p_event) { return collision_polygon_editor->forward_gui_input(p_event); } diff --git a/editor/plugins/shader_editor_plugin.cpp b/editor/plugins/shader_editor_plugin.cpp index 11dfb7b910..37782ed173 100644 --- a/editor/plugins/shader_editor_plugin.cpp +++ b/editor/plugins/shader_editor_plugin.cpp @@ -137,14 +137,35 @@ void ShaderTextEditor::_load_theme_settings() { }*/ } +void ShaderTextEditor::_check_shader_mode() { + + String type = ShaderLanguage::get_shader_type(get_text_edit()->get_text()); + + print_line("type is: " + type); + Shader::Mode mode; + + if (type == "canvas_item") { + mode = Shader::MODE_CANVAS_ITEM; + } else if (type == "particles") { + mode = Shader::MODE_PARTICLES; + } else { + mode = Shader::MODE_SPATIAL; + } + + if (shader->get_mode() != mode) { + shader->set_code(get_text_edit()->get_text()); + _load_theme_settings(); + } +} + void ShaderTextEditor::_code_complete_script(const String &p_code, List<String> *r_options) { - print_line("code complete"); + _check_shader_mode(); ShaderLanguage sl; String calltip; - Error err = sl.complete(p_code, ShaderTypes::get_singleton()->get_functions(VisualServer::ShaderMode(shader->get_mode())), ShaderTypes::get_singleton()->get_modes(VisualServer::ShaderMode(shader->get_mode())), r_options, calltip); + Error err = sl.complete(p_code, ShaderTypes::get_singleton()->get_functions(VisualServer::ShaderMode(shader->get_mode())), ShaderTypes::get_singleton()->get_modes(VisualServer::ShaderMode(shader->get_mode())), ShaderTypes::get_singleton()->get_types(), r_options, calltip); if (calltip != "") { get_text_edit()->set_code_hint(calltip); @@ -153,13 +174,15 @@ void ShaderTextEditor::_code_complete_script(const String &p_code, List<String> void ShaderTextEditor::_validate_script() { + _check_shader_mode(); + String code = get_text_edit()->get_text(); //List<StringName> params; //shader->get_param_list(¶ms); ShaderLanguage sl; - Error err = sl.compile(code, ShaderTypes::get_singleton()->get_functions(VisualServer::ShaderMode(shader->get_mode())), ShaderTypes::get_singleton()->get_modes(VisualServer::ShaderMode(shader->get_mode()))); + Error err = sl.compile(code, ShaderTypes::get_singleton()->get_functions(VisualServer::ShaderMode(shader->get_mode())), ShaderTypes::get_singleton()->get_modes(VisualServer::ShaderMode(shader->get_mode())), ShaderTypes::get_singleton()->get_types()); if (err != OK) { String error_text = "error(" + itos(sl.get_error_line()) + "): " + sl.get_error_text(); diff --git a/editor/plugins/shader_editor_plugin.h b/editor/plugins/shader_editor_plugin.h index 4a56c14ecb..14caf4ab49 100644 --- a/editor/plugins/shader_editor_plugin.h +++ b/editor/plugins/shader_editor_plugin.h @@ -44,6 +44,8 @@ class ShaderTextEditor : public CodeTextEditor { Ref<Shader> shader; + void _check_shader_mode(); + protected: static void _bind_methods(); virtual void _load_theme_settings(); diff --git a/editor/plugins/spatial_editor_plugin.cpp b/editor/plugins/spatial_editor_plugin.cpp index d642a3c468..5e0901f9be 100644 --- a/editor/plugins/spatial_editor_plugin.cpp +++ b/editor/plugins/spatial_editor_plugin.cpp @@ -2329,12 +2329,12 @@ void SpatialEditor::_generate_selection_box() { st->add_vertex(b); } - Ref<FixedSpatialMaterial> mat = memnew(FixedSpatialMaterial); - mat->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true); + Ref<SpatialMaterial> mat = memnew(SpatialMaterial); + mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true); mat->set_albedo(Color(1, 1, 1)); - mat->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT, true); - mat->set_flag(FixedSpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true); - mat->set_flag(FixedSpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true); + mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); + mat->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true); + mat->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true); st->set_material(mat); selection_box = st->commit(); } @@ -2888,12 +2888,12 @@ 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_ALBEDO_FROM_VERTEX_COLOR, true); - indicator_mat->set_flag(FixedSpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true); + indicator_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true); + //indicator_mat->set_flag(SpatialMaterial::FLAG_ONTOP,true); + indicator_mat->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true); + indicator_mat->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true); - indicator_mat->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT, true); + indicator_mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); PoolVector<Color> grid_colors[3]; PoolVector<Vector3> grid_points[3]; @@ -2980,7 +2980,7 @@ void SpatialEditor::_init_indicators() { cursor_points.push_back(Vector3(0, 0, -cs)); cursor_material.instance(); cursor_material->set_albedo(Color(0, 1, 1)); - cursor_material->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true); + cursor_material->set_flag(SpatialMaterial::FLAG_UNSHADED, true); Array d; d.resize(VS::ARRAY_MAX); @@ -3000,10 +3000,10 @@ void SpatialEditor::_init_indicators() { float gizmo_alph = EditorSettings::get_singleton()->get("editors/3d/manipulator_gizmo_opacity"); - gizmo_hl = Ref<FixedSpatialMaterial>(memnew(FixedSpatialMaterial)); - gizmo_hl->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true); - gizmo_hl->set_flag(FixedSpatialMaterial::FLAG_ONTOP, true); - gizmo_hl->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT, true); + gizmo_hl = Ref<SpatialMaterial>(memnew(SpatialMaterial)); + gizmo_hl->set_flag(SpatialMaterial::FLAG_UNSHADED, true); + gizmo_hl->set_flag(SpatialMaterial::FLAG_ONTOP, true); + gizmo_hl->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); gizmo_hl->set_albedo(Color(1, 1, 1, gizmo_alph + 0.2f)); for (int i = 0; i < 3; i++) { @@ -3011,10 +3011,10 @@ void SpatialEditor::_init_indicators() { move_gizmo[i] = Ref<Mesh>(memnew(Mesh)); rotate_gizmo[i] = Ref<Mesh>(memnew(Mesh)); - Ref<FixedSpatialMaterial> mat = memnew(FixedSpatialMaterial); - mat->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true); - mat->set_flag(FixedSpatialMaterial::FLAG_ONTOP, true); - mat->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT, true); + Ref<SpatialMaterial> mat = memnew(SpatialMaterial); + mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true); + mat->set_flag(SpatialMaterial::FLAG_ONTOP, true); + mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); Color col; col[i] = 1.0; col.a = gizmo_alph; diff --git a/editor/plugins/spatial_editor_plugin.h b/editor/plugins/spatial_editor_plugin.h index 734057dc90..0dedd6ce6d 100644 --- a/editor/plugins/spatial_editor_plugin.h +++ b/editor/plugins/spatial_editor_plugin.h @@ -323,8 +323,8 @@ private: bool grid_enabled; Ref<Mesh> move_gizmo[3], rotate_gizmo[3]; - Ref<FixedSpatialMaterial> gizmo_color[3]; - Ref<FixedSpatialMaterial> gizmo_hl; + Ref<SpatialMaterial> gizmo_color[3]; + Ref<SpatialMaterial> gizmo_hl; int over_gizmo_handle; @@ -333,8 +333,8 @@ private: RID indicators_instance; RID cursor_mesh; RID cursor_instance; - Ref<FixedSpatialMaterial> indicator_mat; - Ref<FixedSpatialMaterial> cursor_material; + Ref<SpatialMaterial> indicator_mat; + Ref<SpatialMaterial> cursor_material; /* struct Selected { diff --git a/editor/plugins/tile_set_editor_plugin.cpp b/editor/plugins/tile_set_editor_plugin.cpp index 6dee151d99..2ae6f6a3d7 100644 --- a/editor/plugins/tile_set_editor_plugin.cpp +++ b/editor/plugins/tile_set_editor_plugin.cpp @@ -58,7 +58,7 @@ void TileSetEditor::_import_scene(Node *scene, Ref<TileSet> p_library, bool p_me Sprite *mi = child->cast_to<Sprite>(); Ref<Texture> texture = mi->get_texture(); - Ref<CanvasItemMaterial> material = mi->get_material(); + Ref<ShaderMaterial> material = mi->get_material(); if (texture.is_null()) continue; diff --git a/editor/spatial_editor_gizmos.cpp b/editor/spatial_editor_gizmos.cpp index 8a24ed2b2f..385de3fa18 100644 --- a/editor/spatial_editor_gizmos.cpp +++ b/editor/spatial_editor_gizmos.cpp @@ -70,10 +70,6 @@ void EditorSpatialGizmo::Instance::create_instance(Spatial *p_base) { instance = VS::get_singleton()->instance_create2(mesh->get_rid(), p_base->get_world()->get_scenario()); VS::get_singleton()->instance_attach_object_instance_ID(instance, p_base->get_instance_ID()); - if (billboard) - VS::get_singleton()->instance_geometry_set_flag(instance, VS::INSTANCE_FLAG_BILLBOARD, true); - if (unscaled) - VS::get_singleton()->instance_geometry_set_flag(instance, VS::INSTANCE_FLAG_DEPH_SCALE, true); if (skeleton.is_valid()) VS::get_singleton()->instance_attach_skeleton(instance, skeleton); if (extra_margin) @@ -228,7 +224,6 @@ void EditorSpatialGizmo::add_handles(const Vector<Vector3> &p_handles, bool p_bi Array a; a.resize(VS::ARRAY_MAX); a[VS::ARRAY_VERTEX] = p_handles; - print_line("handles?: " + itos(p_handles.size())); PoolVector<Color> colors; { colors.resize(p_handles.size()); @@ -243,7 +238,10 @@ void EditorSpatialGizmo::add_handles(const Vector<Vector3> &p_handles, bool p_bi } a[VS::ARRAY_COLOR] = colors; mesh->add_surface_from_arrays(Mesh::PRIMITIVE_POINTS, a); - mesh->surface_set_material(0, SpatialEditorGizmos::singleton->handle2_material); + if (p_billboard) + mesh->surface_set_material(0, SpatialEditorGizmos::singleton->handle2_material_billboard); + else + mesh->surface_set_material(0, SpatialEditorGizmos::singleton->handle2_material); if (p_billboard) { float md = 0; @@ -390,7 +388,7 @@ bool EditorSpatialGizmo::intersect_ray(const Camera *p_camera, const Point2 &p_p Transform t = spatial_node->get_global_transform(); t.orthonormalize(); if (billboard_handle) { - t.set_look_at(t.origin, t.origin + p_camera->get_transform().basis.get_axis(2), p_camera->get_transform().basis.get_axis(1)); + t.set_look_at(t.origin, t.origin - p_camera->get_transform().basis.get_axis(2), p_camera->get_transform().basis.get_axis(1)); } float min_d = 1e20; @@ -452,7 +450,7 @@ bool EditorSpatialGizmo::intersect_ray(const Camera *p_camera, const Point2 &p_p const Vector3 *vptr = collision_segments.ptr(); Transform t = spatial_node->get_global_transform(); if (billboard_handle) { - t.set_look_at(t.origin, t.origin + p_camera->get_transform().basis.get_axis(2), p_camera->get_transform().basis.get_axis(1)); + t.set_look_at(t.origin, t.origin - p_camera->get_transform().basis.get_axis(2), p_camera->get_transform().basis.get_axis(1)); } Vector3 cp; @@ -504,7 +502,7 @@ bool EditorSpatialGizmo::intersect_ray(const Camera *p_camera, const Point2 &p_p Transform gt = spatial_node->get_global_transform(); if (billboard_handle) { - gt.set_look_at(gt.origin, gt.origin + p_camera->get_transform().basis.get_axis(2), p_camera->get_transform().basis.get_axis(1)); + gt.set_look_at(gt.origin, gt.origin - p_camera->get_transform().basis.get_axis(2), p_camera->get_transform().basis.get_axis(1)); } Transform ai = gt.affine_inverse(); @@ -777,7 +775,7 @@ void LightSpatialGizmo::redraw() { points.push_back(Vector3(b.x, b.y, 0)); } - add_lines(points, SpatialEditorGizmos::singleton->light_material, true); + add_lines(points, SpatialEditorGizmos::singleton->light_material_omni, true); add_collision_segments(points); add_unscaled_billboard(SpatialEditorGizmos::singleton->light_material_omni_icon, 0.05); @@ -2994,24 +2992,24 @@ Ref<SpatialEditorGizmo> SpatialEditorGizmos::get_gizmo(Spatial *p_spatial) { return Ref<SpatialEditorGizmo>(); } -Ref<FixedSpatialMaterial> SpatialEditorGizmos::create_line_material(const Color &p_base_color) { +Ref<SpatialMaterial> SpatialEditorGizmos::create_line_material(const Color &p_base_color) { - Ref<FixedSpatialMaterial> line_material = Ref<FixedSpatialMaterial>(memnew(FixedSpatialMaterial)); - line_material->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true); + Ref<SpatialMaterial> line_material = Ref<SpatialMaterial>(memnew(SpatialMaterial)); + line_material->set_flag(SpatialMaterial::FLAG_UNSHADED, true); line_material->set_line_width(3.0); - line_material->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT, true); - //line_material->set_flag(FixedSpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true); - //->set_flag(FixedSpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true); + line_material->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); + //line_material->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true); + //->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true); line_material->set_albedo(p_base_color); return line_material; } -Ref<FixedSpatialMaterial> SpatialEditorGizmos::create_solid_material(const Color &p_base_color) { +Ref<SpatialMaterial> SpatialEditorGizmos::create_solid_material(const Color &p_base_color) { - Ref<FixedSpatialMaterial> line_material = Ref<FixedSpatialMaterial>(memnew(FixedSpatialMaterial)); - line_material->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true); - line_material->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT, true); + Ref<SpatialMaterial> line_material = Ref<SpatialMaterial>(memnew(SpatialMaterial)); + line_material->set_flag(SpatialMaterial::FLAG_UNSHADED, true); + line_material->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); line_material->set_albedo(p_base_color); return line_material; @@ -3021,58 +3019,65 @@ SpatialEditorGizmos::SpatialEditorGizmos() { singleton = this; - handle_material = Ref<FixedSpatialMaterial>(memnew(FixedSpatialMaterial)); - handle_material->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true); + handle_material = Ref<SpatialMaterial>(memnew(SpatialMaterial)); + handle_material->set_flag(SpatialMaterial::FLAG_UNSHADED, true); handle_material->set_albedo(Color(0.8, 0.8, 0.8)); + handle_material_billboard = handle_material->duplicate(); + handle_material_billboard->set_billboard_mode(SpatialMaterial::BILLBOARD_ENABLED); - handle2_material = Ref<FixedSpatialMaterial>(memnew(FixedSpatialMaterial)); - handle2_material->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true); - handle2_material->set_flag(FixedSpatialMaterial::FLAG_USE_POINT_SIZE, true); + handle2_material = Ref<SpatialMaterial>(memnew(SpatialMaterial)); + handle2_material->set_flag(SpatialMaterial::FLAG_UNSHADED, true); + handle2_material->set_flag(SpatialMaterial::FLAG_USE_POINT_SIZE, true); handle_t = SpatialEditor::get_singleton()->get_icon("Editor3DHandle", "EditorIcons"); handle2_material->set_point_size(handle_t->get_width()); - handle2_material->set_texture(FixedSpatialMaterial::TEXTURE_ALBEDO, handle_t); + handle2_material->set_texture(SpatialMaterial::TEXTURE_ALBEDO, handle_t); handle2_material->set_albedo(Color(1, 1, 1)); - handle2_material->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT, true); - handle2_material->set_flag(FixedSpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true); - handle2_material->set_flag(FixedSpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true); + handle2_material->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); + handle2_material->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true); + handle2_material->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true); + handle2_material_billboard = handle2_material->duplicate(); + handle2_material_billboard->set_billboard_mode(SpatialMaterial::BILLBOARD_ENABLED); light_material = create_line_material(Color(1, 1, 0.2)); - - light_material_omni_icon = Ref<FixedSpatialMaterial>(memnew(FixedSpatialMaterial)); - light_material_omni_icon->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true); - light_material_omni_icon->set_cull_mode(FixedSpatialMaterial::CULL_DISABLED); - light_material_omni_icon->set_depth_draw_mode(FixedSpatialMaterial::DEPTH_DRAW_DISABLED); - light_material_omni_icon->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT, true); + light_material_omni = create_line_material(Color(1, 1, 0.2)); + light_material_omni->set_billboard_mode(SpatialMaterial::BILLBOARD_ENABLED); + + light_material_omni_icon = Ref<SpatialMaterial>(memnew(SpatialMaterial)); + light_material_omni_icon->set_flag(SpatialMaterial::FLAG_UNSHADED, true); + light_material_omni_icon->set_cull_mode(SpatialMaterial::CULL_DISABLED); + light_material_omni_icon->set_depth_draw_mode(SpatialMaterial::DEPTH_DRAW_DISABLED); + light_material_omni_icon->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); light_material_omni_icon->set_albedo(Color(1, 1, 1, 0.9)); - light_material_omni_icon->set_texture(FixedSpatialMaterial::TEXTURE_ALBEDO, SpatialEditor::get_singleton()->get_icon("GizmoLight", "EditorIcons")); - - light_material_directional_icon = Ref<FixedSpatialMaterial>(memnew(FixedSpatialMaterial)); - light_material_directional_icon->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true); - light_material_directional_icon->set_cull_mode(FixedSpatialMaterial::CULL_DISABLED); - light_material_directional_icon->set_depth_draw_mode(FixedSpatialMaterial::DEPTH_DRAW_DISABLED); - light_material_directional_icon->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT, true); + light_material_omni_icon->set_texture(SpatialMaterial::TEXTURE_ALBEDO, SpatialEditor::get_singleton()->get_icon("GizmoLight", "EditorIcons")); + light_material_omni_icon->set_flag(SpatialMaterial::FLAG_FIXED_SIZE, true); + + light_material_directional_icon = Ref<SpatialMaterial>(memnew(SpatialMaterial)); + light_material_directional_icon->set_flag(SpatialMaterial::FLAG_UNSHADED, true); + light_material_directional_icon->set_cull_mode(SpatialMaterial::CULL_DISABLED); + light_material_directional_icon->set_depth_draw_mode(SpatialMaterial::DEPTH_DRAW_DISABLED); + light_material_directional_icon->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); light_material_directional_icon->set_albedo(Color(1, 1, 1, 0.9)); - light_material_directional_icon->set_texture(FixedSpatialMaterial::TEXTURE_ALBEDO, SpatialEditor::get_singleton()->get_icon("GizmoDirectionalLight", "EditorIcons")); + light_material_directional_icon->set_texture(SpatialMaterial::TEXTURE_ALBEDO, SpatialEditor::get_singleton()->get_icon("GizmoDirectionalLight", "EditorIcons")); camera_material = create_line_material(Color(1.0, 0.5, 1.0)); navmesh_edge_material = create_line_material(Color(0.1, 0.8, 1.0)); navmesh_solid_material = create_solid_material(Color(0.1, 0.8, 1.0, 0.4)); - navmesh_edge_material->set_flag(FixedSpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, false); - navmesh_edge_material->set_flag(FixedSpatialMaterial::FLAG_SRGB_VERTEX_COLOR, false); - navmesh_solid_material->set_cull_mode(FixedSpatialMaterial::CULL_DISABLED); + navmesh_edge_material->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, false); + navmesh_edge_material->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, false); + navmesh_solid_material->set_cull_mode(SpatialMaterial::CULL_DISABLED); navmesh_edge_material_disabled = create_line_material(Color(1.0, 0.8, 0.1)); navmesh_solid_material_disabled = create_solid_material(Color(1.0, 0.8, 0.1, 0.4)); - navmesh_edge_material_disabled->set_flag(FixedSpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, false); - navmesh_edge_material_disabled->set_flag(FixedSpatialMaterial::FLAG_SRGB_VERTEX_COLOR, false); - navmesh_solid_material_disabled->set_cull_mode(FixedSpatialMaterial::CULL_DISABLED); + navmesh_edge_material_disabled->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, false); + navmesh_edge_material_disabled->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, false); + navmesh_solid_material_disabled->set_cull_mode(SpatialMaterial::CULL_DISABLED); skeleton_material = create_line_material(Color(0.6, 1.0, 0.3)); - skeleton_material->set_cull_mode(FixedSpatialMaterial::CULL_DISABLED); - skeleton_material->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true); - skeleton_material->set_flag(FixedSpatialMaterial::FLAG_ONTOP, true); - skeleton_material->set_depth_draw_mode(FixedSpatialMaterial::DEPTH_DRAW_DISABLED); + skeleton_material->set_cull_mode(SpatialMaterial::CULL_DISABLED); + skeleton_material->set_flag(SpatialMaterial::FLAG_UNSHADED, true); + skeleton_material->set_flag(SpatialMaterial::FLAG_ONTOP, true); + skeleton_material->set_depth_draw_mode(SpatialMaterial::DEPTH_DRAW_DISABLED); //position 3D Shared mesh @@ -3095,11 +3100,11 @@ SpatialEditorGizmos::SpatialEditorGizmos() { cursor_colors.push_back(Color(0.5, 0.5, 1, 0.7)); cursor_colors.push_back(Color(0.5, 0.5, 1, 0.7)); - Ref<FixedSpatialMaterial> mat = memnew(FixedSpatialMaterial); - mat->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true); - mat->set_flag(FixedSpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true); - mat->set_flag(FixedSpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true); - mat->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT, true); + Ref<SpatialMaterial> mat = memnew(SpatialMaterial); + mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true); + mat->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true); + mat->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true); + mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); mat->set_line_width(3); Array d; d.resize(VS::ARRAY_MAX); @@ -3119,11 +3124,11 @@ SpatialEditorGizmos::SpatialEditorGizmos() { cursor_colors.push_back(Color(0.5, 0.5, 0.5, 0.7)); cursor_colors.push_back(Color(0.5, 0.5, 0.5, 0.7)); - Ref<FixedSpatialMaterial> mat = memnew(FixedSpatialMaterial); - mat->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true); - mat->set_flag(FixedSpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true); - mat->set_flag(FixedSpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true); - mat->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT, true); + Ref<SpatialMaterial> mat = memnew(SpatialMaterial); + mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true); + mat->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true); + mat->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true); + mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); mat->set_line_width(3); Array d; d.resize(VS::ARRAY_MAX); @@ -3133,13 +3138,13 @@ SpatialEditorGizmos::SpatialEditorGizmos() { listener_line_mesh->surface_set_material(0, mat); } - sample_player_icon = Ref<FixedSpatialMaterial>(memnew(FixedSpatialMaterial)); - sample_player_icon->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true); - sample_player_icon->set_cull_mode(FixedSpatialMaterial::CULL_DISABLED); - sample_player_icon->set_depth_draw_mode(FixedSpatialMaterial::DEPTH_DRAW_DISABLED); - sample_player_icon->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT, true); + sample_player_icon = Ref<SpatialMaterial>(memnew(SpatialMaterial)); + sample_player_icon->set_flag(SpatialMaterial::FLAG_UNSHADED, true); + sample_player_icon->set_cull_mode(SpatialMaterial::CULL_DISABLED); + sample_player_icon->set_depth_draw_mode(SpatialMaterial::DEPTH_DRAW_DISABLED); + sample_player_icon->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); sample_player_icon->set_albedo(Color(1, 1, 1, 0.9)); - sample_player_icon->set_texture(FixedSpatialMaterial::TEXTURE_ALBEDO, SpatialEditor::get_singleton()->get_icon("GizmoSpatialSamplePlayer", "EditorIcons")); + sample_player_icon->set_texture(SpatialMaterial::TEXTURE_ALBEDO, SpatialEditor::get_singleton()->get_icon("GizmoSpatialSamplePlayer", "EditorIcons")); room_material = create_line_material(Color(1.0, 0.6, 0.9)); portal_material = create_line_material(Color(1.0, 0.8, 0.6)); @@ -3152,29 +3157,29 @@ SpatialEditorGizmos::SpatialEditorGizmos() { 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)); - stream_player_icon->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true); - stream_player_icon->set_cull_mode(FixedSpatialMaterial::CULL_DISABLED); - stream_player_icon->set_depth_draw_mode(FixedSpatialMaterial::DEPTH_DRAW_DISABLED); - stream_player_icon->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT, true); + stream_player_icon = Ref<SpatialMaterial>(memnew(SpatialMaterial)); + stream_player_icon->set_flag(SpatialMaterial::FLAG_UNSHADED, true); + stream_player_icon->set_cull_mode(SpatialMaterial::CULL_DISABLED); + stream_player_icon->set_depth_draw_mode(SpatialMaterial::DEPTH_DRAW_DISABLED); + stream_player_icon->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); stream_player_icon->set_albedo(Color(1, 1, 1, 0.9)); - stream_player_icon->set_texture(FixedSpatialMaterial::TEXTURE_ALBEDO, SpatialEditor::get_singleton()->get_icon("GizmoSpatialStreamPlayer", "EditorIcons")); + stream_player_icon->set_texture(SpatialMaterial::TEXTURE_ALBEDO, SpatialEditor::get_singleton()->get_icon("GizmoSpatialStreamPlayer", "EditorIcons")); - visibility_notifier_icon = Ref<FixedSpatialMaterial>(memnew(FixedSpatialMaterial)); - visibility_notifier_icon->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true); - visibility_notifier_icon->set_cull_mode(FixedSpatialMaterial::CULL_DISABLED); - visibility_notifier_icon->set_depth_draw_mode(FixedSpatialMaterial::DEPTH_DRAW_DISABLED); - visibility_notifier_icon->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT, true); + visibility_notifier_icon = Ref<SpatialMaterial>(memnew(SpatialMaterial)); + visibility_notifier_icon->set_flag(SpatialMaterial::FLAG_UNSHADED, true); + visibility_notifier_icon->set_cull_mode(SpatialMaterial::CULL_DISABLED); + visibility_notifier_icon->set_depth_draw_mode(SpatialMaterial::DEPTH_DRAW_DISABLED); + visibility_notifier_icon->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); visibility_notifier_icon->set_albedo(Color(1, 1, 1, 0.9)); - visibility_notifier_icon->set_texture(FixedSpatialMaterial::TEXTURE_ALBEDO, SpatialEditor::get_singleton()->get_icon("Visible", "EditorIcons")); + visibility_notifier_icon->set_texture(SpatialMaterial::TEXTURE_ALBEDO, SpatialEditor::get_singleton()->get_icon("Visible", "EditorIcons")); - listener_icon = Ref<FixedSpatialMaterial>(memnew(FixedSpatialMaterial)); - listener_icon->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true); - listener_icon->set_cull_mode(FixedSpatialMaterial::CULL_DISABLED); - listener_icon->set_depth_draw_mode(FixedSpatialMaterial::DEPTH_DRAW_DISABLED); - listener_icon->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT, true); + listener_icon = Ref<SpatialMaterial>(memnew(SpatialMaterial)); + listener_icon->set_flag(SpatialMaterial::FLAG_UNSHADED, true); + listener_icon->set_cull_mode(SpatialMaterial::CULL_DISABLED); + listener_icon->set_depth_draw_mode(SpatialMaterial::DEPTH_DRAW_DISABLED); + listener_icon->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); listener_icon->set_albedo(Color(1, 1, 1, 0.9)); - listener_icon->set_texture(FixedSpatialMaterial::TEXTURE_ALBEDO, SpatialEditor::get_singleton()->get_icon("GizmoListener", "EditorIcons")); + listener_icon->set_texture(SpatialMaterial::TEXTURE_ALBEDO, SpatialEditor::get_singleton()->get_icon("GizmoListener", "EditorIcons")); { diff --git a/editor/spatial_editor_gizmos.h b/editor/spatial_editor_gizmos.h index 76564c5a99..a47a134975 100644 --- a/editor/spatial_editor_gizmos.h +++ b/editor/spatial_editor_gizmos.h @@ -399,38 +399,41 @@ public: class SpatialEditorGizmos { public: - Ref<FixedSpatialMaterial> create_line_material(const Color &p_base_color); - Ref<FixedSpatialMaterial> create_solid_material(const Color &p_base_color); - Ref<FixedSpatialMaterial> handle2_material; - Ref<FixedSpatialMaterial> handle_material; - Ref<FixedSpatialMaterial> light_material; - Ref<FixedSpatialMaterial> light_material_omni_icon; - Ref<FixedSpatialMaterial> light_material_directional_icon; - Ref<FixedSpatialMaterial> camera_material; - Ref<FixedSpatialMaterial> skeleton_material; - Ref<FixedSpatialMaterial> reflection_probe_material; - Ref<FixedSpatialMaterial> reflection_probe_material_internal; - Ref<FixedSpatialMaterial> gi_probe_material; - Ref<FixedSpatialMaterial> gi_probe_material_internal; - Ref<FixedSpatialMaterial> room_material; - Ref<FixedSpatialMaterial> portal_material; - Ref<FixedSpatialMaterial> raycast_material; - Ref<FixedSpatialMaterial> visibility_notifier_material; - Ref<FixedSpatialMaterial> car_wheel_material; - Ref<FixedSpatialMaterial> joint_material; - - Ref<FixedSpatialMaterial> navmesh_edge_material; - Ref<FixedSpatialMaterial> navmesh_solid_material; - Ref<FixedSpatialMaterial> navmesh_edge_material_disabled; - Ref<FixedSpatialMaterial> navmesh_solid_material_disabled; - - Ref<FixedSpatialMaterial> listener_icon; - - Ref<FixedSpatialMaterial> sample_player_icon; - Ref<FixedSpatialMaterial> stream_player_icon; - Ref<FixedSpatialMaterial> visibility_notifier_icon; - - Ref<FixedSpatialMaterial> shape_material; + Ref<SpatialMaterial> create_line_material(const Color &p_base_color); + Ref<SpatialMaterial> create_solid_material(const Color &p_base_color); + Ref<SpatialMaterial> handle2_material; + Ref<SpatialMaterial> handle2_material_billboard; + Ref<SpatialMaterial> handle_material; + Ref<SpatialMaterial> handle_material_billboard; + Ref<SpatialMaterial> light_material; + Ref<SpatialMaterial> light_material_omni; + Ref<SpatialMaterial> light_material_omni_icon; + Ref<SpatialMaterial> light_material_directional_icon; + Ref<SpatialMaterial> camera_material; + Ref<SpatialMaterial> skeleton_material; + Ref<SpatialMaterial> reflection_probe_material; + Ref<SpatialMaterial> reflection_probe_material_internal; + Ref<SpatialMaterial> gi_probe_material; + Ref<SpatialMaterial> gi_probe_material_internal; + Ref<SpatialMaterial> room_material; + Ref<SpatialMaterial> portal_material; + Ref<SpatialMaterial> raycast_material; + Ref<SpatialMaterial> visibility_notifier_material; + Ref<SpatialMaterial> car_wheel_material; + Ref<SpatialMaterial> joint_material; + + Ref<SpatialMaterial> navmesh_edge_material; + Ref<SpatialMaterial> navmesh_solid_material; + Ref<SpatialMaterial> navmesh_edge_material_disabled; + Ref<SpatialMaterial> navmesh_solid_material_disabled; + + Ref<SpatialMaterial> listener_icon; + + Ref<SpatialMaterial> sample_player_icon; + Ref<SpatialMaterial> stream_player_icon; + Ref<SpatialMaterial> visibility_notifier_icon; + + Ref<SpatialMaterial> shape_material; Ref<Texture> handle_t; Ref<Mesh> pos3d_mesh; |