566 lines
16 KiB
C++
566 lines
16 KiB
C++
/*************************************************************************/
|
|
/* editor_mesh_import_plugin.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
#include "editor_mesh_import_plugin.h"
|
|
|
|
#include "editor/editor_dir_dialog.h"
|
|
#include "editor/editor_file_dialog.h"
|
|
#include "editor/editor_node.h"
|
|
#include "editor/property_editor.h"
|
|
#include "io/marshalls.h"
|
|
#include "io/resource_saver.h"
|
|
#include "os/file_access.h"
|
|
#include "scene/resources/sample.h"
|
|
#include "scene/resources/surface_tool.h"
|
|
|
|
class _EditorMeshImportOptions : public Object {
|
|
|
|
OBJ_TYPE(_EditorMeshImportOptions, Object);
|
|
|
|
public:
|
|
bool generate_tangents;
|
|
bool generate_normals;
|
|
bool flip_faces;
|
|
bool smooth_shading;
|
|
bool weld_vertices;
|
|
bool import_material;
|
|
bool import_textures;
|
|
float weld_tolerance;
|
|
|
|
bool _set(const StringName &p_name, const Variant &p_value) {
|
|
|
|
String n = p_name;
|
|
if (n == "generate/tangents")
|
|
generate_tangents = p_value;
|
|
else if (n == "generate/normals")
|
|
generate_normals = p_value;
|
|
else if (n == "import/materials")
|
|
import_material = p_value;
|
|
else if (n == "import/textures")
|
|
import_textures = p_value;
|
|
else if (n == "force/flip_faces")
|
|
flip_faces = p_value;
|
|
else if (n == "force/smooth_shading")
|
|
smooth_shading = p_value;
|
|
else if (n == "force/weld_vertices")
|
|
weld_vertices = p_value;
|
|
else if (n == "force/weld_tolerance")
|
|
weld_tolerance = p_value;
|
|
else
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool _get(const StringName &p_name, Variant &r_ret) const {
|
|
|
|
String n = p_name;
|
|
if (n == "generate/tangents")
|
|
r_ret = generate_tangents;
|
|
else if (n == "generate/normals")
|
|
r_ret = generate_normals;
|
|
else if (n == "import/materials")
|
|
r_ret = import_material;
|
|
else if (n == "import/textures")
|
|
r_ret = import_textures;
|
|
else if (n == "force/flip_faces")
|
|
r_ret = flip_faces;
|
|
else if (n == "force/smooth_shading")
|
|
r_ret = smooth_shading;
|
|
else if (n == "force/weld_vertices")
|
|
r_ret = weld_vertices;
|
|
else if (n == "force/weld_tolerance")
|
|
r_ret = weld_tolerance;
|
|
else
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
void _get_property_list(List<PropertyInfo> *p_list) const {
|
|
|
|
p_list->push_back(PropertyInfo(Variant::BOOL, "generate/tangents"));
|
|
p_list->push_back(PropertyInfo(Variant::BOOL, "generate/normals"));
|
|
//not for nowp
|
|
//p_list->push_back(PropertyInfo(Variant::BOOL,"import/materials"));
|
|
//p_list->push_back(PropertyInfo(Variant::BOOL,"import/textures"));
|
|
p_list->push_back(PropertyInfo(Variant::BOOL, "force/flip_faces"));
|
|
p_list->push_back(PropertyInfo(Variant::BOOL, "force/smooth_shading"));
|
|
p_list->push_back(PropertyInfo(Variant::BOOL, "force/weld_vertices"));
|
|
p_list->push_back(PropertyInfo(Variant::REAL, "force/weld_tolerance", PROPERTY_HINT_RANGE, "0.00001,16,0.00001"));
|
|
//p_list->push_back(PropertyInfo(Variant::BOOL,"compress/enable"));
|
|
//p_list->push_back(PropertyInfo(Variant::INT,"compress/bitrate",PROPERTY_HINT_ENUM,"64,96,128,192"));
|
|
}
|
|
|
|
static void _bind_methods() {
|
|
|
|
ADD_SIGNAL(MethodInfo("changed"));
|
|
}
|
|
|
|
_EditorMeshImportOptions() {
|
|
|
|
generate_tangents = true;
|
|
generate_normals = false;
|
|
flip_faces = false;
|
|
smooth_shading = false;
|
|
weld_vertices = true;
|
|
weld_tolerance = 0.0001;
|
|
import_material = false;
|
|
import_textures = false;
|
|
}
|
|
};
|
|
|
|
class EditorMeshImportDialog : public ConfirmationDialog {
|
|
|
|
OBJ_TYPE(EditorMeshImportDialog, ConfirmationDialog);
|
|
|
|
EditorMeshImportPlugin *plugin;
|
|
|
|
LineEdit *import_path;
|
|
LineEdit *save_path;
|
|
EditorFileDialog *file_select;
|
|
EditorDirDialog *save_select;
|
|
AcceptDialog *error_dialog;
|
|
PropertyEditor *option_editor;
|
|
|
|
_EditorMeshImportOptions *options;
|
|
|
|
public:
|
|
void _choose_files(const Vector<String> &p_path) {
|
|
|
|
String files;
|
|
for (int i = 0; i < p_path.size(); i++) {
|
|
|
|
if (i > 0)
|
|
files += ",";
|
|
files += p_path[i];
|
|
}
|
|
/*
|
|
if (p_path.size()) {
|
|
String srctex=p_path[0];
|
|
String ipath = EditorImportDB::get_singleton()->find_source_path(srctex);
|
|
|
|
if (ipath!="")
|
|
save_path->set_text(ipath.get_base_dir());
|
|
}*/
|
|
import_path->set_text(files);
|
|
}
|
|
void _choose_save_dir(const String &p_path) {
|
|
|
|
save_path->set_text(p_path);
|
|
}
|
|
|
|
void _browse() {
|
|
|
|
file_select->popup_centered_ratio();
|
|
}
|
|
|
|
void _browse_target() {
|
|
|
|
save_select->popup_centered_ratio();
|
|
}
|
|
|
|
void popup_import(const String &p_path) {
|
|
|
|
popup_centered(Size2(400, 400) * EDSCALE);
|
|
|
|
if (p_path != "") {
|
|
|
|
Ref<ResourceImportMetadata> rimd = ResourceLoader::load_import_metadata(p_path);
|
|
ERR_FAIL_COND(!rimd.is_valid());
|
|
|
|
save_path->set_text(p_path.get_base_dir());
|
|
List<String> opts;
|
|
rimd->get_options(&opts);
|
|
for (List<String>::Element *E = opts.front(); E; E = E->next()) {
|
|
|
|
options->_set(E->get(), rimd->get_option(E->get()));
|
|
}
|
|
|
|
String src = "";
|
|
for (int i = 0; i < rimd->get_source_count(); i++) {
|
|
if (i > 0)
|
|
src += ",";
|
|
src += EditorImportPlugin::expand_source_path(rimd->get_source_path(i));
|
|
}
|
|
import_path->set_text(src);
|
|
}
|
|
}
|
|
|
|
void _import() {
|
|
|
|
Vector<String> meshes = import_path->get_text().split(",");
|
|
if (meshes.size() == 0) {
|
|
error_dialog->set_text(TTR("No meshes to import!"));
|
|
error_dialog->popup_centered_minsize();
|
|
return;
|
|
}
|
|
|
|
String dst = save_path->get_text();
|
|
if (dst == "") {
|
|
error_dialog->set_text(TTR("Save path is empty!"));
|
|
error_dialog->popup_centered_minsize();
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < meshes.size(); i++) {
|
|
|
|
Ref<ResourceImportMetadata> imd = memnew(ResourceImportMetadata);
|
|
|
|
List<PropertyInfo> pl;
|
|
options->_get_property_list(&pl);
|
|
for (List<PropertyInfo>::Element *E = pl.front(); E; E = E->next()) {
|
|
|
|
Variant v;
|
|
String opt = E->get().name;
|
|
options->_get(opt, v);
|
|
imd->set_option(opt, v);
|
|
}
|
|
|
|
imd->add_source(EditorImportPlugin::validate_source_path(meshes[i]));
|
|
|
|
String file_path = dst.plus_file(meshes[i].get_file().basename() + ".msh");
|
|
|
|
plugin->import(file_path, imd);
|
|
}
|
|
|
|
hide();
|
|
}
|
|
|
|
void _notification(int p_what) {
|
|
|
|
if (p_what == NOTIFICATION_ENTER_TREE) {
|
|
|
|
option_editor->edit(options);
|
|
}
|
|
}
|
|
|
|
static void _bind_methods() {
|
|
|
|
ObjectTypeDB::bind_method("_choose_files", &EditorMeshImportDialog::_choose_files);
|
|
ObjectTypeDB::bind_method("_choose_save_dir", &EditorMeshImportDialog::_choose_save_dir);
|
|
ObjectTypeDB::bind_method("_import", &EditorMeshImportDialog::_import);
|
|
ObjectTypeDB::bind_method("_browse", &EditorMeshImportDialog::_browse);
|
|
ObjectTypeDB::bind_method("_browse_target", &EditorMeshImportDialog::_browse_target);
|
|
}
|
|
|
|
EditorMeshImportDialog(EditorMeshImportPlugin *p_plugin) {
|
|
|
|
plugin = p_plugin;
|
|
|
|
set_title(TTR("Single Mesh Import"));
|
|
set_hide_on_ok(false);
|
|
|
|
VBoxContainer *vbc = memnew(VBoxContainer);
|
|
add_child(vbc);
|
|
set_child_rect(vbc);
|
|
|
|
HBoxContainer *hbc = memnew(HBoxContainer);
|
|
vbc->add_margin_child(TTR("Source Mesh(es):"), hbc);
|
|
|
|
import_path = memnew(LineEdit);
|
|
import_path->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
hbc->add_child(import_path);
|
|
|
|
Button *import_choose = memnew(Button);
|
|
import_choose->set_text(" .. ");
|
|
hbc->add_child(import_choose);
|
|
|
|
import_choose->connect("pressed", this, "_browse");
|
|
|
|
hbc = memnew(HBoxContainer);
|
|
vbc->add_margin_child(TTR("Target Path:"), hbc);
|
|
|
|
save_path = memnew(LineEdit);
|
|
save_path->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
hbc->add_child(save_path);
|
|
|
|
Button *save_choose = memnew(Button);
|
|
save_choose->set_text(" .. ");
|
|
hbc->add_child(save_choose);
|
|
|
|
save_choose->connect("pressed", this, "_browse_target");
|
|
|
|
file_select = memnew(EditorFileDialog);
|
|
file_select->set_access(EditorFileDialog::ACCESS_FILESYSTEM);
|
|
file_select->set_mode(EditorFileDialog::MODE_OPEN_FILES);
|
|
file_select->add_filter("*.obj ; Wavefront OBJ");
|
|
add_child(file_select);
|
|
file_select->connect("files_selected", this, "_choose_files");
|
|
|
|
save_select = memnew(EditorDirDialog);
|
|
add_child(save_select);
|
|
save_select->connect("dir_selected", this, "_choose_save_dir");
|
|
|
|
get_ok()->connect("pressed", this, "_import");
|
|
get_ok()->set_text(TTR("Import"));
|
|
|
|
error_dialog = memnew(AcceptDialog);
|
|
add_child(error_dialog);
|
|
|
|
options = memnew(_EditorMeshImportOptions);
|
|
|
|
option_editor = memnew(PropertyEditor);
|
|
option_editor->hide_top_label();
|
|
vbc->add_margin_child(TTR("Options:"), option_editor, true);
|
|
}
|
|
|
|
~EditorMeshImportDialog() {
|
|
memdelete(options);
|
|
}
|
|
};
|
|
|
|
String EditorMeshImportPlugin::get_name() const {
|
|
|
|
return "mesh";
|
|
}
|
|
String EditorMeshImportPlugin::get_visible_name() const {
|
|
|
|
return TTR("Mesh");
|
|
}
|
|
void EditorMeshImportPlugin::import_dialog(const String &p_from) {
|
|
|
|
dialog->popup_import(p_from);
|
|
}
|
|
Error EditorMeshImportPlugin::import(const String &p_path, const Ref<ResourceImportMetadata> &p_from) {
|
|
|
|
ERR_FAIL_COND_V(p_from->get_source_count() != 1, ERR_INVALID_PARAMETER);
|
|
|
|
Ref<ResourceImportMetadata> from = p_from;
|
|
|
|
String src_path = EditorImportPlugin::expand_source_path(from->get_source_path(0));
|
|
FileAccessRef f = FileAccess::open(src_path, FileAccess::READ);
|
|
ERR_FAIL_COND_V(!f, ERR_CANT_OPEN);
|
|
|
|
Ref<Mesh> mesh;
|
|
Map<String, Ref<Material> > name_map;
|
|
|
|
if (FileAccess::exists(p_path)) {
|
|
mesh = ResourceLoader::load(p_path, "Mesh");
|
|
if (mesh.is_valid()) {
|
|
for (int i = 0; i < mesh->get_surface_count(); i++) {
|
|
|
|
if (!mesh->surface_get_material(i).is_valid())
|
|
continue;
|
|
String name;
|
|
if (mesh->surface_get_name(i) != "")
|
|
name = mesh->surface_get_name(i);
|
|
else
|
|
name = vformat(TTR("Surface %d"), i + 1);
|
|
|
|
name_map[name] = mesh->surface_get_material(i);
|
|
}
|
|
|
|
while (mesh->get_surface_count()) {
|
|
mesh->surface_remove(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!mesh.is_valid())
|
|
mesh = Ref<Mesh>(memnew(Mesh));
|
|
|
|
bool generate_normals = from->get_option("generate/normals");
|
|
bool generate_tangents = from->get_option("generate/tangents");
|
|
bool flip_faces = from->get_option("force/flip_faces");
|
|
bool force_smooth = from->get_option("force/smooth_shading");
|
|
bool weld_vertices = from->get_option("force/weld_vertices");
|
|
float weld_tolerance = from->get_option("force/weld_tolerance");
|
|
Vector<Vector3> vertices;
|
|
Vector<Vector3> normals;
|
|
Vector<Vector2> uvs;
|
|
String name;
|
|
|
|
Ref<SurfaceTool> surf_tool = memnew(SurfaceTool);
|
|
surf_tool->begin(Mesh::PRIMITIVE_TRIANGLES);
|
|
if (force_smooth)
|
|
surf_tool->add_smooth_group(true);
|
|
int has_index_data = false;
|
|
|
|
while (true) {
|
|
|
|
String l = f->get_line().strip_edges();
|
|
|
|
if (l.begins_with("v ")) {
|
|
//vertex
|
|
Vector<String> v = l.split(" ", false);
|
|
ERR_FAIL_COND_V(v.size() < 4, ERR_INVALID_DATA);
|
|
Vector3 vtx;
|
|
vtx.x = v[1].to_float();
|
|
vtx.y = v[2].to_float();
|
|
vtx.z = v[3].to_float();
|
|
vertices.push_back(vtx);
|
|
} else if (l.begins_with("vt ")) {
|
|
//uv
|
|
Vector<String> v = l.split(" ", false);
|
|
ERR_FAIL_COND_V(v.size() < 3, ERR_INVALID_DATA);
|
|
Vector2 uv;
|
|
uv.x = v[1].to_float();
|
|
uv.y = 1.0 - v[2].to_float();
|
|
uvs.push_back(uv);
|
|
|
|
} else if (l.begins_with("vn ")) {
|
|
//normal
|
|
Vector<String> v = l.split(" ", false);
|
|
ERR_FAIL_COND_V(v.size() < 4, ERR_INVALID_DATA);
|
|
Vector3 nrm;
|
|
nrm.x = v[1].to_float();
|
|
nrm.y = v[2].to_float();
|
|
nrm.z = v[3].to_float();
|
|
normals.push_back(nrm);
|
|
}
|
|
if (l.begins_with("f ")) {
|
|
//vertex
|
|
|
|
has_index_data = true;
|
|
Vector<String> v = l.split(" ", false);
|
|
ERR_FAIL_COND_V(v.size() < 4, ERR_INVALID_DATA);
|
|
|
|
//not very fast, could be sped up
|
|
|
|
Vector<String> face[3];
|
|
face[0] = v[1].split("/");
|
|
face[1] = v[2].split("/");
|
|
ERR_FAIL_COND_V(face[0].size() == 0, ERR_PARSE_ERROR);
|
|
ERR_FAIL_COND_V(face[0].size() != face[1].size(), ERR_PARSE_ERROR);
|
|
for (int i = 2; i < v.size() - 1; i++) {
|
|
|
|
face[2] = v[i + 1].split("/");
|
|
ERR_FAIL_COND_V(face[0].size() != face[2].size(), ERR_PARSE_ERROR);
|
|
for (int j = 0; j < 3; j++) {
|
|
|
|
int idx = j;
|
|
|
|
if (!flip_faces && idx < 2) {
|
|
idx = 1 ^ idx;
|
|
}
|
|
|
|
if (face[idx].size() == 3) {
|
|
int norm = face[idx][2].to_int() - 1;
|
|
ERR_FAIL_INDEX_V(norm, normals.size(), ERR_PARSE_ERROR);
|
|
surf_tool->add_normal(normals[norm]);
|
|
}
|
|
|
|
if (face[idx].size() >= 2 && face[idx][1] != String()) {
|
|
|
|
int uv = face[idx][1].to_int() - 1;
|
|
ERR_FAIL_INDEX_V(uv, uvs.size(), ERR_PARSE_ERROR);
|
|
surf_tool->add_uv(uvs[uv]);
|
|
}
|
|
|
|
int vtx = face[idx][0].to_int() - 1;
|
|
ERR_FAIL_INDEX_V(vtx, vertices.size(), ERR_PARSE_ERROR);
|
|
|
|
Vector3 vertex = vertices[vtx];
|
|
if (weld_vertices)
|
|
vertex = vertex.snapped(weld_tolerance);
|
|
surf_tool->add_vertex(vertex);
|
|
}
|
|
|
|
face[1] = face[2];
|
|
}
|
|
} else if (l.begins_with("s ") && !force_smooth) { //smoothing
|
|
String what = l.substr(2, l.length()).strip_edges();
|
|
if (what == "off")
|
|
surf_tool->add_smooth_group(false);
|
|
else
|
|
surf_tool->add_smooth_group(true);
|
|
|
|
} else if (l.begins_with("o ") || f->eof_reached()) { //new surface or done
|
|
|
|
if (has_index_data) {
|
|
//new object/surface
|
|
if (generate_normals || force_smooth)
|
|
surf_tool->generate_normals();
|
|
if (uvs.size() && (normals.size() || generate_normals) && generate_tangents)
|
|
surf_tool->generate_tangents();
|
|
|
|
surf_tool->index();
|
|
mesh = surf_tool->commit(mesh);
|
|
if (name == "")
|
|
name = vformat(TTR("Surface %d"), mesh->get_surface_count() - 1);
|
|
mesh->surface_set_name(mesh->get_surface_count() - 1, name);
|
|
name = "";
|
|
surf_tool->clear();
|
|
surf_tool->begin(Mesh::PRIMITIVE_TRIANGLES);
|
|
if (force_smooth)
|
|
surf_tool->add_smooth_group(true);
|
|
|
|
has_index_data = false;
|
|
}
|
|
|
|
if (l.begins_with("o ")) //name
|
|
name = l.substr(2, l.length()).strip_edges();
|
|
|
|
if (f->eof_reached())
|
|
break;
|
|
}
|
|
}
|
|
|
|
from->set_source_md5(0, FileAccess::get_md5(src_path));
|
|
from->set_editor(get_name());
|
|
mesh->set_import_metadata(from);
|
|
|
|
//re-apply materials if exist
|
|
for (int i = 0; i < mesh->get_surface_count(); i++) {
|
|
|
|
String n = mesh->surface_get_name(i);
|
|
if (name_map.has(n))
|
|
mesh->surface_set_material(i, name_map[n]);
|
|
}
|
|
|
|
Error err = ResourceSaver::save(p_path, mesh);
|
|
|
|
return err;
|
|
}
|
|
|
|
void EditorMeshImportPlugin::import_from_drop(const Vector<String> &p_drop, const String &p_dest_path) {
|
|
|
|
Vector<String> files;
|
|
for (int i = 0; i < p_drop.size(); i++) {
|
|
String ext = p_drop[i].extension().to_lower();
|
|
String file = p_drop[i].get_file();
|
|
if (ext == "obj") {
|
|
|
|
files.push_back(p_drop[i]);
|
|
}
|
|
}
|
|
|
|
if (files.size()) {
|
|
import_dialog();
|
|
dialog->_choose_files(files);
|
|
dialog->_choose_save_dir(p_dest_path);
|
|
}
|
|
}
|
|
|
|
EditorMeshImportPlugin::EditorMeshImportPlugin(EditorNode *p_editor) {
|
|
|
|
dialog = memnew(EditorMeshImportDialog(this));
|
|
p_editor->get_gui_base()->add_child(dialog);
|
|
}
|