0be6d925dc
Which means that reduz' beloved style which we all became used to will now be changed automatically to remove the first empty line. This makes us lean closer to 1TBS (the one true brace style) instead of hybridating it with some Allman-inspired spacing. There's still the case of braces around single-statement blocks that needs to be addressed (but clang-format can't help with that, but clang-tidy may if we agree about it). Part of #33027.
3012 lines
90 KiB
C++
3012 lines
90 KiB
C++
/*************************************************************************/
|
|
/* editor_scene_importer_gltf.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2020 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_scene_importer_gltf.h"
|
|
|
|
#include "core/crypto/crypto_core.h"
|
|
#include "core/io/json.h"
|
|
#include "core/math/disjoint_set.h"
|
|
#include "core/math/math_defs.h"
|
|
#include "core/os/file_access.h"
|
|
#include "core/os/os.h"
|
|
#include "modules/regex/regex.h"
|
|
#include "scene/3d/bone_attachment_3d.h"
|
|
#include "scene/3d/camera_3d.h"
|
|
#include "scene/3d/mesh_instance_3d.h"
|
|
#include "scene/animation/animation_player.h"
|
|
#include "scene/resources/surface_tool.h"
|
|
|
|
uint32_t EditorSceneImporterGLTF::get_import_flags() const {
|
|
return IMPORT_SCENE | IMPORT_ANIMATION;
|
|
}
|
|
void EditorSceneImporterGLTF::get_extensions(List<String> *r_extensions) const {
|
|
r_extensions->push_back("gltf");
|
|
r_extensions->push_back("glb");
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_parse_json(const String &p_path, GLTFState &state) {
|
|
Error err;
|
|
FileAccessRef f = FileAccess::open(p_path, FileAccess::READ, &err);
|
|
if (!f) {
|
|
return err;
|
|
}
|
|
|
|
Vector<uint8_t> array;
|
|
array.resize(f->get_len());
|
|
f->get_buffer(array.ptrw(), array.size());
|
|
String text;
|
|
text.parse_utf8((const char *)array.ptr(), array.size());
|
|
|
|
String err_txt;
|
|
int err_line;
|
|
Variant v;
|
|
err = JSON::parse(text, v, err_txt, err_line);
|
|
if (err != OK) {
|
|
_err_print_error("", p_path.utf8().get_data(), err_line, err_txt.utf8().get_data(), ERR_HANDLER_SCRIPT);
|
|
return err;
|
|
}
|
|
state.json = v;
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_parse_glb(const String &p_path, GLTFState &state) {
|
|
Error err;
|
|
FileAccessRef f = FileAccess::open(p_path, FileAccess::READ, &err);
|
|
if (!f) {
|
|
return err;
|
|
}
|
|
|
|
uint32_t magic = f->get_32();
|
|
ERR_FAIL_COND_V(magic != 0x46546C67, ERR_FILE_UNRECOGNIZED); //glTF
|
|
f->get_32(); // version
|
|
f->get_32(); // length
|
|
|
|
uint32_t chunk_length = f->get_32();
|
|
uint32_t chunk_type = f->get_32();
|
|
|
|
ERR_FAIL_COND_V(chunk_type != 0x4E4F534A, ERR_PARSE_ERROR); //JSON
|
|
Vector<uint8_t> json_data;
|
|
json_data.resize(chunk_length);
|
|
uint32_t len = f->get_buffer(json_data.ptrw(), chunk_length);
|
|
ERR_FAIL_COND_V(len != chunk_length, ERR_FILE_CORRUPT);
|
|
|
|
String text;
|
|
text.parse_utf8((const char *)json_data.ptr(), json_data.size());
|
|
|
|
String err_txt;
|
|
int err_line;
|
|
Variant v;
|
|
err = JSON::parse(text, v, err_txt, err_line);
|
|
if (err != OK) {
|
|
_err_print_error("", p_path.utf8().get_data(), err_line, err_txt.utf8().get_data(), ERR_HANDLER_SCRIPT);
|
|
return err;
|
|
}
|
|
|
|
state.json = v;
|
|
|
|
//data?
|
|
|
|
chunk_length = f->get_32();
|
|
chunk_type = f->get_32();
|
|
|
|
if (f->eof_reached()) {
|
|
return OK; //all good
|
|
}
|
|
|
|
ERR_FAIL_COND_V(chunk_type != 0x004E4942, ERR_PARSE_ERROR); //BIN
|
|
|
|
state.glb_data.resize(chunk_length);
|
|
len = f->get_buffer(state.glb_data.ptrw(), chunk_length);
|
|
ERR_FAIL_COND_V(len != chunk_length, ERR_FILE_CORRUPT);
|
|
|
|
return OK;
|
|
}
|
|
|
|
static Vector3 _arr_to_vec3(const Array &p_array) {
|
|
ERR_FAIL_COND_V(p_array.size() != 3, Vector3());
|
|
return Vector3(p_array[0], p_array[1], p_array[2]);
|
|
}
|
|
|
|
static Quat _arr_to_quat(const Array &p_array) {
|
|
ERR_FAIL_COND_V(p_array.size() != 4, Quat());
|
|
return Quat(p_array[0], p_array[1], p_array[2], p_array[3]);
|
|
}
|
|
|
|
static Transform _arr_to_xform(const Array &p_array) {
|
|
ERR_FAIL_COND_V(p_array.size() != 16, Transform());
|
|
|
|
Transform xform;
|
|
xform.basis.set_axis(Vector3::AXIS_X, Vector3(p_array[0], p_array[1], p_array[2]));
|
|
xform.basis.set_axis(Vector3::AXIS_Y, Vector3(p_array[4], p_array[5], p_array[6]));
|
|
xform.basis.set_axis(Vector3::AXIS_Z, Vector3(p_array[8], p_array[9], p_array[10]));
|
|
xform.set_origin(Vector3(p_array[12], p_array[13], p_array[14]));
|
|
|
|
return xform;
|
|
}
|
|
|
|
String EditorSceneImporterGLTF::_sanitize_scene_name(const String &name) {
|
|
RegEx regex("([^a-zA-Z0-9_ -]+)");
|
|
String p_name = regex.sub(name, "", true);
|
|
return p_name;
|
|
}
|
|
|
|
String EditorSceneImporterGLTF::_gen_unique_name(GLTFState &state, const String &p_name) {
|
|
const String s_name = _sanitize_scene_name(p_name);
|
|
|
|
String name;
|
|
int index = 1;
|
|
while (true) {
|
|
name = s_name;
|
|
|
|
if (index > 1) {
|
|
name += " " + itos(index);
|
|
}
|
|
if (!state.unique_names.has(name)) {
|
|
break;
|
|
}
|
|
index++;
|
|
}
|
|
|
|
state.unique_names.insert(name);
|
|
|
|
return name;
|
|
}
|
|
|
|
String EditorSceneImporterGLTF::_sanitize_bone_name(const String &name) {
|
|
String p_name = name.camelcase_to_underscore(true);
|
|
|
|
RegEx pattern_del("([^a-zA-Z0-9_ ])+");
|
|
p_name = pattern_del.sub(p_name, "", true);
|
|
|
|
RegEx pattern_nospace(" +");
|
|
p_name = pattern_nospace.sub(p_name, "_", true);
|
|
|
|
RegEx pattern_multiple("_+");
|
|
p_name = pattern_multiple.sub(p_name, "_", true);
|
|
|
|
RegEx pattern_padded("0+(\\d+)");
|
|
p_name = pattern_padded.sub(p_name, "$1", true);
|
|
|
|
return p_name;
|
|
}
|
|
|
|
String EditorSceneImporterGLTF::_gen_unique_bone_name(GLTFState &state, const GLTFSkeletonIndex skel_i, const String &p_name) {
|
|
const String s_name = _sanitize_bone_name(p_name);
|
|
|
|
String name;
|
|
int index = 1;
|
|
while (true) {
|
|
name = s_name;
|
|
|
|
if (index > 1) {
|
|
name += "_" + itos(index);
|
|
}
|
|
if (!state.skeletons[skel_i].unique_names.has(name)) {
|
|
break;
|
|
}
|
|
index++;
|
|
}
|
|
|
|
state.skeletons.write[skel_i].unique_names.insert(name);
|
|
|
|
return name;
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_parse_scenes(GLTFState &state) {
|
|
ERR_FAIL_COND_V(!state.json.has("scenes"), ERR_FILE_CORRUPT);
|
|
const Array &scenes = state.json["scenes"];
|
|
int loaded_scene = 0;
|
|
if (state.json.has("scene")) {
|
|
loaded_scene = state.json["scene"];
|
|
} else {
|
|
WARN_PRINT("The load-time scene is not defined in the glTF2 file. Picking the first scene.");
|
|
}
|
|
|
|
if (scenes.size()) {
|
|
ERR_FAIL_COND_V(loaded_scene >= scenes.size(), ERR_FILE_CORRUPT);
|
|
const Dictionary &s = scenes[loaded_scene];
|
|
ERR_FAIL_COND_V(!s.has("nodes"), ERR_UNAVAILABLE);
|
|
const Array &nodes = s["nodes"];
|
|
for (int j = 0; j < nodes.size(); j++) {
|
|
state.root_nodes.push_back(nodes[j]);
|
|
}
|
|
|
|
if (s.has("name") && s["name"] != "") {
|
|
state.scene_name = _gen_unique_name(state, s["name"]);
|
|
} else {
|
|
state.scene_name = _gen_unique_name(state, "Scene");
|
|
}
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_parse_nodes(GLTFState &state) {
|
|
ERR_FAIL_COND_V(!state.json.has("nodes"), ERR_FILE_CORRUPT);
|
|
const Array &nodes = state.json["nodes"];
|
|
for (int i = 0; i < nodes.size(); i++) {
|
|
GLTFNode *node = memnew(GLTFNode);
|
|
const Dictionary &n = nodes[i];
|
|
|
|
if (n.has("name")) {
|
|
node->name = n["name"];
|
|
}
|
|
if (n.has("camera")) {
|
|
node->camera = n["camera"];
|
|
}
|
|
if (n.has("mesh")) {
|
|
node->mesh = n["mesh"];
|
|
}
|
|
if (n.has("skin")) {
|
|
node->skin = n["skin"];
|
|
}
|
|
if (n.has("matrix")) {
|
|
node->xform = _arr_to_xform(n["matrix"]);
|
|
|
|
} else {
|
|
if (n.has("translation")) {
|
|
node->translation = _arr_to_vec3(n["translation"]);
|
|
}
|
|
if (n.has("rotation")) {
|
|
node->rotation = _arr_to_quat(n["rotation"]);
|
|
}
|
|
if (n.has("scale")) {
|
|
node->scale = _arr_to_vec3(n["scale"]);
|
|
}
|
|
|
|
node->xform.basis.set_quat_scale(node->rotation, node->scale);
|
|
node->xform.origin = node->translation;
|
|
}
|
|
|
|
if (n.has("children")) {
|
|
const Array &children = n["children"];
|
|
for (int j = 0; j < children.size(); j++) {
|
|
node->children.push_back(children[j]);
|
|
}
|
|
}
|
|
|
|
state.nodes.push_back(node);
|
|
}
|
|
|
|
// build the hierarchy
|
|
for (GLTFNodeIndex node_i = 0; node_i < state.nodes.size(); node_i++) {
|
|
for (int j = 0; j < state.nodes[node_i]->children.size(); j++) {
|
|
GLTFNodeIndex child_i = state.nodes[node_i]->children[j];
|
|
|
|
ERR_FAIL_INDEX_V(child_i, state.nodes.size(), ERR_FILE_CORRUPT);
|
|
ERR_CONTINUE(state.nodes[child_i]->parent != -1); //node already has a parent, wtf.
|
|
|
|
state.nodes[child_i]->parent = node_i;
|
|
}
|
|
}
|
|
|
|
_compute_node_heights(state);
|
|
|
|
return OK;
|
|
}
|
|
|
|
void EditorSceneImporterGLTF::_compute_node_heights(GLTFState &state) {
|
|
state.root_nodes.clear();
|
|
for (GLTFNodeIndex node_i = 0; node_i < state.nodes.size(); ++node_i) {
|
|
GLTFNode *node = state.nodes[node_i];
|
|
node->height = 0;
|
|
|
|
GLTFNodeIndex current_i = node_i;
|
|
while (current_i >= 0) {
|
|
const GLTFNodeIndex parent_i = state.nodes[current_i]->parent;
|
|
if (parent_i >= 0) {
|
|
++node->height;
|
|
}
|
|
current_i = parent_i;
|
|
}
|
|
|
|
if (node->height == 0) {
|
|
state.root_nodes.push_back(node_i);
|
|
}
|
|
}
|
|
}
|
|
|
|
static Vector<uint8_t> _parse_base64_uri(const String &uri) {
|
|
int start = uri.find(",");
|
|
ERR_FAIL_COND_V(start == -1, Vector<uint8_t>());
|
|
|
|
CharString substr = uri.right(start + 1).ascii();
|
|
|
|
int strlen = substr.length();
|
|
|
|
Vector<uint8_t> buf;
|
|
buf.resize(strlen / 4 * 3 + 1 + 1);
|
|
|
|
size_t len = 0;
|
|
ERR_FAIL_COND_V(CryptoCore::b64_decode(buf.ptrw(), buf.size(), &len, (unsigned char *)substr.get_data(), strlen) != OK, Vector<uint8_t>());
|
|
|
|
buf.resize(len);
|
|
|
|
return buf;
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_parse_buffers(GLTFState &state, const String &p_base_path) {
|
|
if (!state.json.has("buffers"))
|
|
return OK;
|
|
|
|
const Array &buffers = state.json["buffers"];
|
|
for (GLTFBufferIndex i = 0; i < buffers.size(); i++) {
|
|
if (i == 0 && state.glb_data.size()) {
|
|
state.buffers.push_back(state.glb_data);
|
|
|
|
} else {
|
|
const Dictionary &buffer = buffers[i];
|
|
if (buffer.has("uri")) {
|
|
Vector<uint8_t> buffer_data;
|
|
String uri = buffer["uri"];
|
|
|
|
if (uri.findn("data:application/octet-stream;base64") == 0) {
|
|
//embedded data
|
|
buffer_data = _parse_base64_uri(uri);
|
|
} else {
|
|
uri = p_base_path.plus_file(uri).replace("\\", "/"); //fix for windows
|
|
buffer_data = FileAccess::get_file_as_array(uri);
|
|
ERR_FAIL_COND_V(buffer.size() == 0, ERR_PARSE_ERROR);
|
|
}
|
|
|
|
ERR_FAIL_COND_V(!buffer.has("byteLength"), ERR_PARSE_ERROR);
|
|
int byteLength = buffer["byteLength"];
|
|
ERR_FAIL_COND_V(byteLength < buffer_data.size(), ERR_PARSE_ERROR);
|
|
state.buffers.push_back(buffer_data);
|
|
}
|
|
}
|
|
}
|
|
|
|
print_verbose("glTF: Total buffers: " + itos(state.buffers.size()));
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_parse_buffer_views(GLTFState &state) {
|
|
ERR_FAIL_COND_V(!state.json.has("bufferViews"), ERR_FILE_CORRUPT);
|
|
const Array &buffers = state.json["bufferViews"];
|
|
for (GLTFBufferViewIndex i = 0; i < buffers.size(); i++) {
|
|
const Dictionary &d = buffers[i];
|
|
|
|
GLTFBufferView buffer_view;
|
|
|
|
ERR_FAIL_COND_V(!d.has("buffer"), ERR_PARSE_ERROR);
|
|
buffer_view.buffer = d["buffer"];
|
|
ERR_FAIL_COND_V(!d.has("byteLength"), ERR_PARSE_ERROR);
|
|
buffer_view.byte_length = d["byteLength"];
|
|
|
|
if (d.has("byteOffset")) {
|
|
buffer_view.byte_offset = d["byteOffset"];
|
|
}
|
|
|
|
if (d.has("byteStride")) {
|
|
buffer_view.byte_stride = d["byteStride"];
|
|
}
|
|
|
|
if (d.has("target")) {
|
|
const int target = d["target"];
|
|
buffer_view.indices = target == ELEMENT_ARRAY_BUFFER;
|
|
}
|
|
|
|
state.buffer_views.push_back(buffer_view);
|
|
}
|
|
|
|
print_verbose("glTF: Total buffer views: " + itos(state.buffer_views.size()));
|
|
|
|
return OK;
|
|
}
|
|
|
|
EditorSceneImporterGLTF::GLTFType EditorSceneImporterGLTF::_get_type_from_str(const String &p_string) {
|
|
if (p_string == "SCALAR")
|
|
return TYPE_SCALAR;
|
|
|
|
if (p_string == "VEC2")
|
|
return TYPE_VEC2;
|
|
if (p_string == "VEC3")
|
|
return TYPE_VEC3;
|
|
if (p_string == "VEC4")
|
|
return TYPE_VEC4;
|
|
|
|
if (p_string == "MAT2")
|
|
return TYPE_MAT2;
|
|
if (p_string == "MAT3")
|
|
return TYPE_MAT3;
|
|
if (p_string == "MAT4")
|
|
return TYPE_MAT4;
|
|
|
|
ERR_FAIL_V(TYPE_SCALAR);
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_parse_accessors(GLTFState &state) {
|
|
ERR_FAIL_COND_V(!state.json.has("accessors"), ERR_FILE_CORRUPT);
|
|
const Array &accessors = state.json["accessors"];
|
|
for (GLTFAccessorIndex i = 0; i < accessors.size(); i++) {
|
|
const Dictionary &d = accessors[i];
|
|
|
|
GLTFAccessor accessor;
|
|
|
|
ERR_FAIL_COND_V(!d.has("componentType"), ERR_PARSE_ERROR);
|
|
accessor.component_type = d["componentType"];
|
|
ERR_FAIL_COND_V(!d.has("count"), ERR_PARSE_ERROR);
|
|
accessor.count = d["count"];
|
|
ERR_FAIL_COND_V(!d.has("type"), ERR_PARSE_ERROR);
|
|
accessor.type = _get_type_from_str(d["type"]);
|
|
|
|
if (d.has("bufferView")) {
|
|
accessor.buffer_view = d["bufferView"]; //optional because it may be sparse...
|
|
}
|
|
|
|
if (d.has("byteOffset")) {
|
|
accessor.byte_offset = d["byteOffset"];
|
|
}
|
|
|
|
if (d.has("max")) {
|
|
accessor.max = d["max"];
|
|
}
|
|
|
|
if (d.has("min")) {
|
|
accessor.min = d["min"];
|
|
}
|
|
|
|
if (d.has("sparse")) {
|
|
//eeh..
|
|
|
|
const Dictionary &s = d["sparse"];
|
|
|
|
ERR_FAIL_COND_V(!s.has("count"), ERR_PARSE_ERROR);
|
|
accessor.sparse_count = s["count"];
|
|
ERR_FAIL_COND_V(!s.has("indices"), ERR_PARSE_ERROR);
|
|
const Dictionary &si = s["indices"];
|
|
|
|
ERR_FAIL_COND_V(!si.has("bufferView"), ERR_PARSE_ERROR);
|
|
accessor.sparse_indices_buffer_view = si["bufferView"];
|
|
ERR_FAIL_COND_V(!si.has("componentType"), ERR_PARSE_ERROR);
|
|
accessor.sparse_indices_component_type = si["componentType"];
|
|
|
|
if (si.has("byteOffset")) {
|
|
accessor.sparse_indices_byte_offset = si["byteOffset"];
|
|
}
|
|
|
|
ERR_FAIL_COND_V(!s.has("values"), ERR_PARSE_ERROR);
|
|
const Dictionary &sv = s["values"];
|
|
|
|
ERR_FAIL_COND_V(!sv.has("bufferView"), ERR_PARSE_ERROR);
|
|
accessor.sparse_values_buffer_view = sv["bufferView"];
|
|
if (sv.has("byteOffset")) {
|
|
accessor.sparse_values_byte_offset = sv["byteOffset"];
|
|
}
|
|
}
|
|
|
|
state.accessors.push_back(accessor);
|
|
}
|
|
|
|
print_verbose("glTF: Total accessors: " + itos(state.accessors.size()));
|
|
|
|
return OK;
|
|
}
|
|
|
|
String EditorSceneImporterGLTF::_get_component_type_name(const uint32_t p_component) {
|
|
switch (p_component) {
|
|
case COMPONENT_TYPE_BYTE:
|
|
return "Byte";
|
|
case COMPONENT_TYPE_UNSIGNED_BYTE:
|
|
return "UByte";
|
|
case COMPONENT_TYPE_SHORT:
|
|
return "Short";
|
|
case COMPONENT_TYPE_UNSIGNED_SHORT:
|
|
return "UShort";
|
|
case COMPONENT_TYPE_INT:
|
|
return "Int";
|
|
case COMPONENT_TYPE_FLOAT:
|
|
return "Float";
|
|
}
|
|
|
|
return "<Error>";
|
|
}
|
|
|
|
String EditorSceneImporterGLTF::_get_type_name(const GLTFType p_component) {
|
|
static const char *names[] = {
|
|
"float",
|
|
"vec2",
|
|
"vec3",
|
|
"vec4",
|
|
"mat2",
|
|
"mat3",
|
|
"mat4"
|
|
};
|
|
|
|
return names[p_component];
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_decode_buffer_view(GLTFState &state, double *dst, const GLTFBufferViewIndex p_buffer_view, const int skip_every, const int skip_bytes, const int element_size, const int count, const GLTFType type, const int component_count, const int component_type, const int component_size, const bool normalized, const int byte_offset, const bool for_vertex) {
|
|
const GLTFBufferView &bv = state.buffer_views[p_buffer_view];
|
|
|
|
int stride = bv.byte_stride ? bv.byte_stride : element_size;
|
|
if (for_vertex && stride % 4) {
|
|
stride += 4 - (stride % 4); //according to spec must be multiple of 4
|
|
}
|
|
|
|
ERR_FAIL_INDEX_V(bv.buffer, state.buffers.size(), ERR_PARSE_ERROR);
|
|
|
|
const uint32_t offset = bv.byte_offset + byte_offset;
|
|
Vector<uint8_t> buffer = state.buffers[bv.buffer]; //copy on write, so no performance hit
|
|
const uint8_t *bufptr = buffer.ptr();
|
|
|
|
//use to debug
|
|
print_verbose("glTF: type " + _get_type_name(type) + " component type: " + _get_component_type_name(component_type) + " stride: " + itos(stride) + " amount " + itos(count));
|
|
print_verbose("glTF: accessor offset" + itos(byte_offset) + " view offset: " + itos(bv.byte_offset) + " total buffer len: " + itos(buffer.size()) + " view len " + itos(bv.byte_length));
|
|
|
|
const int buffer_end = (stride * (count - 1)) + element_size;
|
|
ERR_FAIL_COND_V(buffer_end > bv.byte_length, ERR_PARSE_ERROR);
|
|
|
|
ERR_FAIL_COND_V((int)(offset + buffer_end) > buffer.size(), ERR_PARSE_ERROR);
|
|
|
|
//fill everything as doubles
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
const uint8_t *src = &bufptr[offset + i * stride];
|
|
|
|
for (int j = 0; j < component_count; j++) {
|
|
if (skip_every && j > 0 && (j % skip_every) == 0) {
|
|
src += skip_bytes;
|
|
}
|
|
|
|
double d = 0;
|
|
|
|
switch (component_type) {
|
|
case COMPONENT_TYPE_BYTE: {
|
|
int8_t b = int8_t(*src);
|
|
if (normalized) {
|
|
d = (double(b) / 128.0);
|
|
} else {
|
|
d = double(b);
|
|
}
|
|
} break;
|
|
case COMPONENT_TYPE_UNSIGNED_BYTE: {
|
|
uint8_t b = *src;
|
|
if (normalized) {
|
|
d = (double(b) / 255.0);
|
|
} else {
|
|
d = double(b);
|
|
}
|
|
} break;
|
|
case COMPONENT_TYPE_SHORT: {
|
|
int16_t s = *(int16_t *)src;
|
|
if (normalized) {
|
|
d = (double(s) / 32768.0);
|
|
} else {
|
|
d = double(s);
|
|
}
|
|
} break;
|
|
case COMPONENT_TYPE_UNSIGNED_SHORT: {
|
|
uint16_t s = *(uint16_t *)src;
|
|
if (normalized) {
|
|
d = (double(s) / 65535.0);
|
|
} else {
|
|
d = double(s);
|
|
}
|
|
|
|
} break;
|
|
case COMPONENT_TYPE_INT: {
|
|
d = *(int *)src;
|
|
} break;
|
|
case COMPONENT_TYPE_FLOAT: {
|
|
d = *(float *)src;
|
|
} break;
|
|
}
|
|
|
|
*dst++ = d;
|
|
src += component_size;
|
|
}
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
int EditorSceneImporterGLTF::_get_component_type_size(const int component_type) {
|
|
switch (component_type) {
|
|
case COMPONENT_TYPE_BYTE:
|
|
return 1;
|
|
break;
|
|
case COMPONENT_TYPE_UNSIGNED_BYTE:
|
|
return 1;
|
|
break;
|
|
case COMPONENT_TYPE_SHORT:
|
|
return 2;
|
|
break;
|
|
case COMPONENT_TYPE_UNSIGNED_SHORT:
|
|
return 2;
|
|
break;
|
|
case COMPONENT_TYPE_INT:
|
|
return 4;
|
|
break;
|
|
case COMPONENT_TYPE_FLOAT:
|
|
return 4;
|
|
break;
|
|
default: {
|
|
ERR_FAIL_V(0);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
Vector<double> EditorSceneImporterGLTF::_decode_accessor(GLTFState &state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {
|
|
//spec, for reference:
|
|
//https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#data-alignment
|
|
|
|
ERR_FAIL_INDEX_V(p_accessor, state.accessors.size(), Vector<double>());
|
|
|
|
const GLTFAccessor &a = state.accessors[p_accessor];
|
|
|
|
const int component_count_for_type[7] = {
|
|
1, 2, 3, 4, 4, 9, 16
|
|
};
|
|
|
|
const int component_count = component_count_for_type[a.type];
|
|
const int component_size = _get_component_type_size(a.component_type);
|
|
ERR_FAIL_COND_V(component_size == 0, Vector<double>());
|
|
int element_size = component_count * component_size;
|
|
|
|
int skip_every = 0;
|
|
int skip_bytes = 0;
|
|
//special case of alignments, as described in spec
|
|
switch (a.component_type) {
|
|
case COMPONENT_TYPE_BYTE:
|
|
case COMPONENT_TYPE_UNSIGNED_BYTE: {
|
|
if (a.type == TYPE_MAT2) {
|
|
skip_every = 2;
|
|
skip_bytes = 2;
|
|
element_size = 8; //override for this case
|
|
}
|
|
if (a.type == TYPE_MAT3) {
|
|
skip_every = 3;
|
|
skip_bytes = 1;
|
|
element_size = 12; //override for this case
|
|
}
|
|
|
|
} break;
|
|
case COMPONENT_TYPE_SHORT:
|
|
case COMPONENT_TYPE_UNSIGNED_SHORT: {
|
|
if (a.type == TYPE_MAT3) {
|
|
skip_every = 6;
|
|
skip_bytes = 4;
|
|
element_size = 16; //override for this case
|
|
}
|
|
} break;
|
|
default: {
|
|
}
|
|
}
|
|
|
|
Vector<double> dst_buffer;
|
|
dst_buffer.resize(component_count * a.count);
|
|
double *dst = dst_buffer.ptrw();
|
|
|
|
if (a.buffer_view >= 0) {
|
|
ERR_FAIL_INDEX_V(a.buffer_view, state.buffer_views.size(), Vector<double>());
|
|
|
|
const Error err = _decode_buffer_view(state, dst, a.buffer_view, skip_every, skip_bytes, element_size, a.count, a.type, component_count, a.component_type, component_size, a.normalized, a.byte_offset, p_for_vertex);
|
|
if (err != OK)
|
|
return Vector<double>();
|
|
|
|
} else {
|
|
//fill with zeros, as bufferview is not defined.
|
|
for (int i = 0; i < (a.count * component_count); i++) {
|
|
dst_buffer.write[i] = 0;
|
|
}
|
|
}
|
|
|
|
if (a.sparse_count > 0) {
|
|
// I could not find any file using this, so this code is so far untested
|
|
Vector<double> indices;
|
|
indices.resize(a.sparse_count);
|
|
const int indices_component_size = _get_component_type_size(a.sparse_indices_component_type);
|
|
|
|
Error err = _decode_buffer_view(state, indices.ptrw(), a.sparse_indices_buffer_view, 0, 0, indices_component_size, a.sparse_count, TYPE_SCALAR, 1, a.sparse_indices_component_type, indices_component_size, false, a.sparse_indices_byte_offset, false);
|
|
if (err != OK)
|
|
return Vector<double>();
|
|
|
|
Vector<double> data;
|
|
data.resize(component_count * a.sparse_count);
|
|
err = _decode_buffer_view(state, data.ptrw(), a.sparse_values_buffer_view, skip_every, skip_bytes, element_size, a.sparse_count, a.type, component_count, a.component_type, component_size, a.normalized, a.sparse_values_byte_offset, p_for_vertex);
|
|
if (err != OK)
|
|
return Vector<double>();
|
|
|
|
for (int i = 0; i < indices.size(); i++) {
|
|
const int write_offset = int(indices[i]) * component_count;
|
|
|
|
for (int j = 0; j < component_count; j++) {
|
|
dst[write_offset + j] = data[i * component_count + j];
|
|
}
|
|
}
|
|
}
|
|
|
|
return dst_buffer;
|
|
}
|
|
|
|
Vector<int> EditorSceneImporterGLTF::_decode_accessor_as_ints(GLTFState &state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {
|
|
const Vector<double> attribs = _decode_accessor(state, p_accessor, p_for_vertex);
|
|
Vector<int> ret;
|
|
|
|
if (attribs.size() == 0)
|
|
return ret;
|
|
|
|
const double *attribs_ptr = attribs.ptr();
|
|
const int ret_size = attribs.size();
|
|
ret.resize(ret_size);
|
|
{
|
|
int *w = ret.ptrw();
|
|
for (int i = 0; i < ret_size; i++) {
|
|
w[i] = int(attribs_ptr[i]);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
Vector<float> EditorSceneImporterGLTF::_decode_accessor_as_floats(GLTFState &state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {
|
|
const Vector<double> attribs = _decode_accessor(state, p_accessor, p_for_vertex);
|
|
Vector<float> ret;
|
|
|
|
if (attribs.size() == 0)
|
|
return ret;
|
|
|
|
const double *attribs_ptr = attribs.ptr();
|
|
const int ret_size = attribs.size();
|
|
ret.resize(ret_size);
|
|
{
|
|
float *w = ret.ptrw();
|
|
for (int i = 0; i < ret_size; i++) {
|
|
w[i] = float(attribs_ptr[i]);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
Vector<Vector2> EditorSceneImporterGLTF::_decode_accessor_as_vec2(GLTFState &state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {
|
|
const Vector<double> attribs = _decode_accessor(state, p_accessor, p_for_vertex);
|
|
Vector<Vector2> ret;
|
|
|
|
if (attribs.size() == 0)
|
|
return ret;
|
|
|
|
ERR_FAIL_COND_V(attribs.size() % 2 != 0, ret);
|
|
const double *attribs_ptr = attribs.ptr();
|
|
const int ret_size = attribs.size() / 2;
|
|
ret.resize(ret_size);
|
|
{
|
|
Vector2 *w = ret.ptrw();
|
|
for (int i = 0; i < ret_size; i++) {
|
|
w[i] = Vector2(attribs_ptr[i * 2 + 0], attribs_ptr[i * 2 + 1]);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
Vector<Vector3> EditorSceneImporterGLTF::_decode_accessor_as_vec3(GLTFState &state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {
|
|
const Vector<double> attribs = _decode_accessor(state, p_accessor, p_for_vertex);
|
|
Vector<Vector3> ret;
|
|
|
|
if (attribs.size() == 0)
|
|
return ret;
|
|
|
|
ERR_FAIL_COND_V(attribs.size() % 3 != 0, ret);
|
|
const double *attribs_ptr = attribs.ptr();
|
|
const int ret_size = attribs.size() / 3;
|
|
ret.resize(ret_size);
|
|
{
|
|
Vector3 *w = ret.ptrw();
|
|
for (int i = 0; i < ret_size; i++) {
|
|
w[i] = Vector3(attribs_ptr[i * 3 + 0], attribs_ptr[i * 3 + 1], attribs_ptr[i * 3 + 2]);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
Vector<Color> EditorSceneImporterGLTF::_decode_accessor_as_color(GLTFState &state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {
|
|
const Vector<double> attribs = _decode_accessor(state, p_accessor, p_for_vertex);
|
|
Vector<Color> ret;
|
|
|
|
if (attribs.size() == 0)
|
|
return ret;
|
|
|
|
const int type = state.accessors[p_accessor].type;
|
|
ERR_FAIL_COND_V(!(type == TYPE_VEC3 || type == TYPE_VEC4), ret);
|
|
int vec_len = 3;
|
|
if (type == TYPE_VEC4) {
|
|
vec_len = 4;
|
|
}
|
|
|
|
ERR_FAIL_COND_V(attribs.size() % vec_len != 0, ret);
|
|
const double *attribs_ptr = attribs.ptr();
|
|
const int ret_size = attribs.size() / vec_len;
|
|
ret.resize(ret_size);
|
|
{
|
|
Color *w = ret.ptrw();
|
|
for (int i = 0; i < ret_size; i++) {
|
|
w[i] = Color(attribs_ptr[i * vec_len + 0], attribs_ptr[i * vec_len + 1], attribs_ptr[i * vec_len + 2], vec_len == 4 ? attribs_ptr[i * 4 + 3] : 1.0);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
Vector<Quat> EditorSceneImporterGLTF::_decode_accessor_as_quat(GLTFState &state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {
|
|
const Vector<double> attribs = _decode_accessor(state, p_accessor, p_for_vertex);
|
|
Vector<Quat> ret;
|
|
|
|
if (attribs.size() == 0)
|
|
return ret;
|
|
|
|
ERR_FAIL_COND_V(attribs.size() % 4 != 0, ret);
|
|
const double *attribs_ptr = attribs.ptr();
|
|
const int ret_size = attribs.size() / 4;
|
|
ret.resize(ret_size);
|
|
{
|
|
for (int i = 0; i < ret_size; i++) {
|
|
ret.write[i] = Quat(attribs_ptr[i * 4 + 0], attribs_ptr[i * 4 + 1], attribs_ptr[i * 4 + 2], attribs_ptr[i * 4 + 3]).normalized();
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
Vector<Transform2D> EditorSceneImporterGLTF::_decode_accessor_as_xform2d(GLTFState &state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {
|
|
const Vector<double> attribs = _decode_accessor(state, p_accessor, p_for_vertex);
|
|
Vector<Transform2D> ret;
|
|
|
|
if (attribs.size() == 0)
|
|
return ret;
|
|
|
|
ERR_FAIL_COND_V(attribs.size() % 4 != 0, ret);
|
|
ret.resize(attribs.size() / 4);
|
|
for (int i = 0; i < ret.size(); i++) {
|
|
ret.write[i][0] = Vector2(attribs[i * 4 + 0], attribs[i * 4 + 1]);
|
|
ret.write[i][1] = Vector2(attribs[i * 4 + 2], attribs[i * 4 + 3]);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
Vector<Basis> EditorSceneImporterGLTF::_decode_accessor_as_basis(GLTFState &state, const GLTFAccessorIndex p_accessor, bool p_for_vertex) {
|
|
const Vector<double> attribs = _decode_accessor(state, p_accessor, p_for_vertex);
|
|
Vector<Basis> ret;
|
|
|
|
if (attribs.size() == 0)
|
|
return ret;
|
|
|
|
ERR_FAIL_COND_V(attribs.size() % 9 != 0, ret);
|
|
ret.resize(attribs.size() / 9);
|
|
for (int i = 0; i < ret.size(); i++) {
|
|
ret.write[i].set_axis(0, Vector3(attribs[i * 9 + 0], attribs[i * 9 + 1], attribs[i * 9 + 2]));
|
|
ret.write[i].set_axis(1, Vector3(attribs[i * 9 + 3], attribs[i * 9 + 4], attribs[i * 9 + 5]));
|
|
ret.write[i].set_axis(2, Vector3(attribs[i * 9 + 6], attribs[i * 9 + 7], attribs[i * 9 + 8]));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
Vector<Transform> EditorSceneImporterGLTF::_decode_accessor_as_xform(GLTFState &state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {
|
|
const Vector<double> attribs = _decode_accessor(state, p_accessor, p_for_vertex);
|
|
Vector<Transform> ret;
|
|
|
|
if (attribs.size() == 0)
|
|
return ret;
|
|
|
|
ERR_FAIL_COND_V(attribs.size() % 16 != 0, ret);
|
|
ret.resize(attribs.size() / 16);
|
|
for (int i = 0; i < ret.size(); i++) {
|
|
ret.write[i].basis.set_axis(0, Vector3(attribs[i * 16 + 0], attribs[i * 16 + 1], attribs[i * 16 + 2]));
|
|
ret.write[i].basis.set_axis(1, Vector3(attribs[i * 16 + 4], attribs[i * 16 + 5], attribs[i * 16 + 6]));
|
|
ret.write[i].basis.set_axis(2, Vector3(attribs[i * 16 + 8], attribs[i * 16 + 9], attribs[i * 16 + 10]));
|
|
ret.write[i].set_origin(Vector3(attribs[i * 16 + 12], attribs[i * 16 + 13], attribs[i * 16 + 14]));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_parse_meshes(GLTFState &state) {
|
|
if (!state.json.has("meshes"))
|
|
return OK;
|
|
|
|
Array meshes = state.json["meshes"];
|
|
for (GLTFMeshIndex i = 0; i < meshes.size(); i++) {
|
|
print_verbose("glTF: Parsing mesh: " + itos(i));
|
|
Dictionary d = meshes[i];
|
|
|
|
GLTFMesh mesh;
|
|
mesh.mesh.instance();
|
|
|
|
ERR_FAIL_COND_V(!d.has("primitives"), ERR_PARSE_ERROR);
|
|
|
|
Array primitives = d["primitives"];
|
|
const Dictionary &extras = d.has("extras") ? (Dictionary)d["extras"] : Dictionary();
|
|
|
|
for (int j = 0; j < primitives.size(); j++) {
|
|
Dictionary p = primitives[j];
|
|
|
|
Array array;
|
|
array.resize(Mesh::ARRAY_MAX);
|
|
|
|
ERR_FAIL_COND_V(!p.has("attributes"), ERR_PARSE_ERROR);
|
|
|
|
Dictionary a = p["attributes"];
|
|
|
|
Mesh::PrimitiveType primitive = Mesh::PRIMITIVE_TRIANGLES;
|
|
if (p.has("mode")) {
|
|
const int mode = p["mode"];
|
|
ERR_FAIL_INDEX_V(mode, 7, ERR_FILE_CORRUPT);
|
|
static const Mesh::PrimitiveType primitives2[7] = {
|
|
Mesh::PRIMITIVE_POINTS,
|
|
Mesh::PRIMITIVE_LINES,
|
|
Mesh::PRIMITIVE_LINES, //loop not supported, should ce converted
|
|
Mesh::PRIMITIVE_LINES,
|
|
Mesh::PRIMITIVE_TRIANGLES,
|
|
Mesh::PRIMITIVE_TRIANGLE_STRIP,
|
|
Mesh::PRIMITIVE_TRIANGLES, //fan not supported, should be converted
|
|
#ifndef _MSC_VER
|
|
#warning line loop and triangle fan are not supported and need to be converted to lines and triangles
|
|
#endif
|
|
|
|
};
|
|
|
|
primitive = primitives2[mode];
|
|
}
|
|
|
|
ERR_FAIL_COND_V(!a.has("POSITION"), ERR_PARSE_ERROR);
|
|
if (a.has("POSITION")) {
|
|
array[Mesh::ARRAY_VERTEX] = _decode_accessor_as_vec3(state, a["POSITION"], true);
|
|
}
|
|
if (a.has("NORMAL")) {
|
|
array[Mesh::ARRAY_NORMAL] = _decode_accessor_as_vec3(state, a["NORMAL"], true);
|
|
}
|
|
if (a.has("TANGENT")) {
|
|
array[Mesh::ARRAY_TANGENT] = _decode_accessor_as_floats(state, a["TANGENT"], true);
|
|
}
|
|
if (a.has("TEXCOORD_0")) {
|
|
array[Mesh::ARRAY_TEX_UV] = _decode_accessor_as_vec2(state, a["TEXCOORD_0"], true);
|
|
}
|
|
if (a.has("TEXCOORD_1")) {
|
|
array[Mesh::ARRAY_TEX_UV2] = _decode_accessor_as_vec2(state, a["TEXCOORD_1"], true);
|
|
}
|
|
if (a.has("COLOR_0")) {
|
|
array[Mesh::ARRAY_COLOR] = _decode_accessor_as_color(state, a["COLOR_0"], true);
|
|
}
|
|
if (a.has("JOINTS_0")) {
|
|
array[Mesh::ARRAY_BONES] = _decode_accessor_as_ints(state, a["JOINTS_0"], true);
|
|
}
|
|
if (a.has("WEIGHTS_0")) {
|
|
Vector<float> weights = _decode_accessor_as_floats(state, a["WEIGHTS_0"], true);
|
|
{ //gltf does not seem to normalize the weights for some reason..
|
|
int wc = weights.size();
|
|
float *w = weights.ptrw();
|
|
|
|
for (int k = 0; k < wc; k += 4) {
|
|
float total = 0.0;
|
|
total += w[k + 0];
|
|
total += w[k + 1];
|
|
total += w[k + 2];
|
|
total += w[k + 3];
|
|
if (total > 0.0) {
|
|
w[k + 0] /= total;
|
|
w[k + 1] /= total;
|
|
w[k + 2] /= total;
|
|
w[k + 3] /= total;
|
|
}
|
|
}
|
|
}
|
|
array[Mesh::ARRAY_WEIGHTS] = weights;
|
|
}
|
|
|
|
if (p.has("indices")) {
|
|
Vector<int> indices = _decode_accessor_as_ints(state, p["indices"], false);
|
|
|
|
if (primitive == Mesh::PRIMITIVE_TRIANGLES) {
|
|
//swap around indices, convert ccw to cw for front face
|
|
|
|
const int is = indices.size();
|
|
int *w = indices.ptrw();
|
|
for (int k = 0; k < is; k += 3) {
|
|
SWAP(w[k + 1], w[k + 2]);
|
|
}
|
|
}
|
|
array[Mesh::ARRAY_INDEX] = indices;
|
|
|
|
} else if (primitive == Mesh::PRIMITIVE_TRIANGLES) {
|
|
//generate indices because they need to be swapped for CW/CCW
|
|
const Vector<Vector3> &vertices = array[Mesh::ARRAY_VERTEX];
|
|
ERR_FAIL_COND_V(vertices.size() == 0, ERR_PARSE_ERROR);
|
|
Vector<int> indices;
|
|
const int vs = vertices.size();
|
|
indices.resize(vs);
|
|
{
|
|
int *w = indices.ptrw();
|
|
for (int k = 0; k < vs; k += 3) {
|
|
w[k] = k;
|
|
w[k + 1] = k + 2;
|
|
w[k + 2] = k + 1;
|
|
}
|
|
}
|
|
array[Mesh::ARRAY_INDEX] = indices;
|
|
}
|
|
|
|
bool generate_tangents = (primitive == Mesh::PRIMITIVE_TRIANGLES && !a.has("TANGENT") && a.has("TEXCOORD_0") && a.has("NORMAL"));
|
|
|
|
if (generate_tangents) {
|
|
//must generate mikktspace tangents.. ergh..
|
|
Ref<SurfaceTool> st;
|
|
st.instance();
|
|
st->create_from_triangle_arrays(array);
|
|
st->generate_tangents();
|
|
array = st->commit_to_arrays();
|
|
}
|
|
|
|
Array morphs;
|
|
//blend shapes
|
|
if (p.has("targets")) {
|
|
print_verbose("glTF: Mesh has targets");
|
|
const Array &targets = p["targets"];
|
|
|
|
//ideally BLEND_SHAPE_MODE_RELATIVE since gltf2 stores in displacement
|
|
//but it could require a larger refactor?
|
|
mesh.mesh->set_blend_shape_mode(Mesh::BLEND_SHAPE_MODE_NORMALIZED);
|
|
|
|
if (j == 0) {
|
|
const Array &target_names = extras.has("targetNames") ? (Array)extras["targetNames"] : Array();
|
|
for (int k = 0; k < targets.size(); k++) {
|
|
const String name = k < target_names.size() ? (String)target_names[k] : String("morph_") + itos(k);
|
|
mesh.mesh->add_blend_shape(name);
|
|
}
|
|
}
|
|
|
|
for (int k = 0; k < targets.size(); k++) {
|
|
const Dictionary &t = targets[k];
|
|
|
|
Array array_copy;
|
|
array_copy.resize(Mesh::ARRAY_MAX);
|
|
|
|
for (int l = 0; l < Mesh::ARRAY_MAX; l++) {
|
|
array_copy[l] = array[l];
|
|
}
|
|
|
|
array_copy[Mesh::ARRAY_INDEX] = Variant();
|
|
|
|
if (t.has("POSITION")) {
|
|
Vector<Vector3> varr = _decode_accessor_as_vec3(state, t["POSITION"], true);
|
|
const Vector<Vector3> src_varr = array[Mesh::ARRAY_VERTEX];
|
|
const int size = src_varr.size();
|
|
ERR_FAIL_COND_V(size == 0, ERR_PARSE_ERROR);
|
|
{
|
|
const int max_idx = varr.size();
|
|
varr.resize(size);
|
|
|
|
Vector3 *w_varr = varr.ptrw();
|
|
const Vector3 *r_varr = varr.ptr();
|
|
const Vector3 *r_src_varr = src_varr.ptr();
|
|
for (int l = 0; l < size; l++) {
|
|
if (l < max_idx) {
|
|
w_varr[l] = r_varr[l] + r_src_varr[l];
|
|
} else {
|
|
w_varr[l] = r_src_varr[l];
|
|
}
|
|
}
|
|
}
|
|
array_copy[Mesh::ARRAY_VERTEX] = varr;
|
|
}
|
|
if (t.has("NORMAL")) {
|
|
Vector<Vector3> narr = _decode_accessor_as_vec3(state, t["NORMAL"], true);
|
|
const Vector<Vector3> src_narr = array[Mesh::ARRAY_NORMAL];
|
|
int size = src_narr.size();
|
|
ERR_FAIL_COND_V(size == 0, ERR_PARSE_ERROR);
|
|
{
|
|
int max_idx = narr.size();
|
|
narr.resize(size);
|
|
|
|
Vector3 *w_narr = narr.ptrw();
|
|
const Vector3 *r_narr = narr.ptr();
|
|
const Vector3 *r_src_narr = src_narr.ptr();
|
|
for (int l = 0; l < size; l++) {
|
|
if (l < max_idx) {
|
|
w_narr[l] = r_narr[l] + r_src_narr[l];
|
|
} else {
|
|
w_narr[l] = r_src_narr[l];
|
|
}
|
|
}
|
|
}
|
|
array_copy[Mesh::ARRAY_NORMAL] = narr;
|
|
}
|
|
if (t.has("TANGENT")) {
|
|
const Vector<Vector3> tangents_v3 = _decode_accessor_as_vec3(state, t["TANGENT"], true);
|
|
const Vector<float> src_tangents = array[Mesh::ARRAY_TANGENT];
|
|
ERR_FAIL_COND_V(src_tangents.size() == 0, ERR_PARSE_ERROR);
|
|
|
|
Vector<float> tangents_v4;
|
|
|
|
{
|
|
int max_idx = tangents_v3.size();
|
|
|
|
int size4 = src_tangents.size();
|
|
tangents_v4.resize(size4);
|
|
float *w4 = tangents_v4.ptrw();
|
|
|
|
const Vector3 *r3 = tangents_v3.ptr();
|
|
const float *r4 = src_tangents.ptr();
|
|
|
|
for (int l = 0; l < size4 / 4; l++) {
|
|
if (l < max_idx) {
|
|
w4[l * 4 + 0] = r3[l].x + r4[l * 4 + 0];
|
|
w4[l * 4 + 1] = r3[l].y + r4[l * 4 + 1];
|
|
w4[l * 4 + 2] = r3[l].z + r4[l * 4 + 2];
|
|
} else {
|
|
w4[l * 4 + 0] = r4[l * 4 + 0];
|
|
w4[l * 4 + 1] = r4[l * 4 + 1];
|
|
w4[l * 4 + 2] = r4[l * 4 + 2];
|
|
}
|
|
w4[l * 4 + 3] = r4[l * 4 + 3]; //copy flip value
|
|
}
|
|
}
|
|
|
|
array_copy[Mesh::ARRAY_TANGENT] = tangents_v4;
|
|
}
|
|
|
|
if (generate_tangents) {
|
|
Ref<SurfaceTool> st;
|
|
st.instance();
|
|
st->create_from_triangle_arrays(array_copy);
|
|
st->deindex();
|
|
st->generate_tangents();
|
|
array_copy = st->commit_to_arrays();
|
|
}
|
|
|
|
morphs.push_back(array_copy);
|
|
}
|
|
}
|
|
|
|
//just add it
|
|
mesh.mesh->add_surface_from_arrays(primitive, array, morphs);
|
|
|
|
if (p.has("material")) {
|
|
const int material = p["material"];
|
|
ERR_FAIL_INDEX_V(material, state.materials.size(), ERR_FILE_CORRUPT);
|
|
const Ref<Material> &mat = state.materials[material];
|
|
|
|
mesh.mesh->surface_set_material(mesh.mesh->get_surface_count() - 1, mat);
|
|
}
|
|
}
|
|
|
|
if (d.has("weights")) {
|
|
const Array &weights = d["weights"];
|
|
ERR_FAIL_COND_V(mesh.mesh->get_blend_shape_count() != weights.size(), ERR_PARSE_ERROR);
|
|
mesh.blend_weights.resize(weights.size());
|
|
for (int j = 0; j < weights.size(); j++) {
|
|
mesh.blend_weights.write[j] = weights[j];
|
|
}
|
|
}
|
|
|
|
state.meshes.push_back(mesh);
|
|
}
|
|
|
|
print_verbose("glTF: Total meshes: " + itos(state.meshes.size()));
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_parse_images(GLTFState &state, const String &p_base_path) {
|
|
if (!state.json.has("images"))
|
|
return OK;
|
|
|
|
const Array &images = state.json["images"];
|
|
for (int i = 0; i < images.size(); i++) {
|
|
const Dictionary &d = images[i];
|
|
|
|
String mimetype;
|
|
if (d.has("mimeType")) {
|
|
mimetype = d["mimeType"];
|
|
}
|
|
|
|
Vector<uint8_t> data;
|
|
const uint8_t *data_ptr = nullptr;
|
|
int data_size = 0;
|
|
|
|
if (d.has("uri")) {
|
|
String uri = d["uri"];
|
|
|
|
if (uri.findn("data:application/octet-stream;base64") == 0 ||
|
|
uri.findn("data:" + mimetype + ";base64") == 0) {
|
|
//embedded data
|
|
data = _parse_base64_uri(uri);
|
|
data_ptr = data.ptr();
|
|
data_size = data.size();
|
|
} else {
|
|
uri = p_base_path.plus_file(uri).replace("\\", "/"); //fix for windows
|
|
Ref<Texture2D> texture = ResourceLoader::load(uri);
|
|
state.images.push_back(texture);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (d.has("bufferView")) {
|
|
const GLTFBufferViewIndex bvi = d["bufferView"];
|
|
|
|
ERR_FAIL_INDEX_V(bvi, state.buffer_views.size(), ERR_PARAMETER_RANGE_ERROR);
|
|
|
|
const GLTFBufferView &bv = state.buffer_views[bvi];
|
|
|
|
const GLTFBufferIndex bi = bv.buffer;
|
|
ERR_FAIL_INDEX_V(bi, state.buffers.size(), ERR_PARAMETER_RANGE_ERROR);
|
|
|
|
ERR_FAIL_COND_V(bv.byte_offset + bv.byte_length > state.buffers[bi].size(), ERR_FILE_CORRUPT);
|
|
|
|
data_ptr = &state.buffers[bi][bv.byte_offset];
|
|
data_size = bv.byte_length;
|
|
}
|
|
|
|
ERR_FAIL_COND_V(mimetype == "", ERR_FILE_CORRUPT);
|
|
|
|
if (mimetype.findn("png") != -1) {
|
|
//is a png
|
|
ERR_FAIL_COND_V(Image::_png_mem_loader_func == nullptr, ERR_UNAVAILABLE);
|
|
|
|
const Ref<Image> img = Image::_png_mem_loader_func(data_ptr, data_size);
|
|
|
|
ERR_FAIL_COND_V(img.is_null(), ERR_FILE_CORRUPT);
|
|
|
|
Ref<ImageTexture> t;
|
|
t.instance();
|
|
t->create_from_image(img);
|
|
|
|
state.images.push_back(t);
|
|
continue;
|
|
}
|
|
|
|
if (mimetype.findn("jpeg") != -1) {
|
|
//is a jpg
|
|
ERR_FAIL_COND_V(Image::_jpg_mem_loader_func == nullptr, ERR_UNAVAILABLE);
|
|
|
|
const Ref<Image> img = Image::_jpg_mem_loader_func(data_ptr, data_size);
|
|
|
|
ERR_FAIL_COND_V(img.is_null(), ERR_FILE_CORRUPT);
|
|
|
|
Ref<ImageTexture> t;
|
|
t.instance();
|
|
t->create_from_image(img);
|
|
|
|
state.images.push_back(t);
|
|
|
|
continue;
|
|
}
|
|
|
|
ERR_FAIL_V(ERR_FILE_CORRUPT);
|
|
}
|
|
|
|
print_verbose("Total images: " + itos(state.images.size()));
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_parse_textures(GLTFState &state) {
|
|
if (!state.json.has("textures"))
|
|
return OK;
|
|
|
|
const Array &textures = state.json["textures"];
|
|
for (GLTFTextureIndex i = 0; i < textures.size(); i++) {
|
|
const Dictionary &d = textures[i];
|
|
|
|
ERR_FAIL_COND_V(!d.has("source"), ERR_PARSE_ERROR);
|
|
|
|
GLTFTexture t;
|
|
t.src_image = d["source"];
|
|
state.textures.push_back(t);
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
Ref<Texture2D> EditorSceneImporterGLTF::_get_texture(GLTFState &state, const GLTFTextureIndex p_texture) {
|
|
ERR_FAIL_INDEX_V(p_texture, state.textures.size(), Ref<Texture2D>());
|
|
const GLTFImageIndex image = state.textures[p_texture].src_image;
|
|
|
|
ERR_FAIL_INDEX_V(image, state.images.size(), Ref<Texture2D>());
|
|
|
|
return state.images[image];
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_parse_materials(GLTFState &state) {
|
|
if (!state.json.has("materials"))
|
|
return OK;
|
|
|
|
const Array &materials = state.json["materials"];
|
|
for (GLTFMaterialIndex i = 0; i < materials.size(); i++) {
|
|
const Dictionary &d = materials[i];
|
|
|
|
Ref<StandardMaterial3D> material;
|
|
material.instance();
|
|
if (d.has("name")) {
|
|
material->set_name(d["name"]);
|
|
}
|
|
|
|
if (d.has("pbrMetallicRoughness")) {
|
|
const Dictionary &mr = d["pbrMetallicRoughness"];
|
|
if (mr.has("baseColorFactor")) {
|
|
const Array &arr = mr["baseColorFactor"];
|
|
ERR_FAIL_COND_V(arr.size() != 4, ERR_PARSE_ERROR);
|
|
const Color c = Color(arr[0], arr[1], arr[2], arr[3]).to_srgb();
|
|
|
|
material->set_albedo(c);
|
|
}
|
|
|
|
if (mr.has("baseColorTexture")) {
|
|
const Dictionary &bct = mr["baseColorTexture"];
|
|
if (bct.has("index")) {
|
|
material->set_texture(StandardMaterial3D::TEXTURE_ALBEDO, _get_texture(state, bct["index"]));
|
|
}
|
|
if (!mr.has("baseColorFactor")) {
|
|
material->set_albedo(Color(1, 1, 1));
|
|
}
|
|
}
|
|
|
|
if (mr.has("metallicFactor")) {
|
|
material->set_metallic(mr["metallicFactor"]);
|
|
} else {
|
|
material->set_metallic(1.0);
|
|
}
|
|
|
|
if (mr.has("roughnessFactor")) {
|
|
material->set_roughness(mr["roughnessFactor"]);
|
|
} else {
|
|
material->set_roughness(1.0);
|
|
}
|
|
|
|
if (mr.has("metallicRoughnessTexture")) {
|
|
const Dictionary &bct = mr["metallicRoughnessTexture"];
|
|
if (bct.has("index")) {
|
|
const Ref<Texture2D> t = _get_texture(state, bct["index"]);
|
|
material->set_texture(StandardMaterial3D::TEXTURE_METALLIC, t);
|
|
material->set_metallic_texture_channel(StandardMaterial3D::TEXTURE_CHANNEL_BLUE);
|
|
material->set_texture(StandardMaterial3D::TEXTURE_ROUGHNESS, t);
|
|
material->set_roughness_texture_channel(StandardMaterial3D::TEXTURE_CHANNEL_GREEN);
|
|
if (!mr.has("metallicFactor")) {
|
|
material->set_metallic(1);
|
|
}
|
|
if (!mr.has("roughnessFactor")) {
|
|
material->set_roughness(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (d.has("normalTexture")) {
|
|
const Dictionary &bct = d["normalTexture"];
|
|
if (bct.has("index")) {
|
|
material->set_texture(StandardMaterial3D::TEXTURE_NORMAL, _get_texture(state, bct["index"]));
|
|
material->set_feature(StandardMaterial3D::FEATURE_NORMAL_MAPPING, true);
|
|
}
|
|
if (bct.has("scale")) {
|
|
material->set_normal_scale(bct["scale"]);
|
|
}
|
|
}
|
|
if (d.has("occlusionTexture")) {
|
|
const Dictionary &bct = d["occlusionTexture"];
|
|
if (bct.has("index")) {
|
|
material->set_texture(StandardMaterial3D::TEXTURE_AMBIENT_OCCLUSION, _get_texture(state, bct["index"]));
|
|
material->set_ao_texture_channel(StandardMaterial3D::TEXTURE_CHANNEL_RED);
|
|
material->set_feature(StandardMaterial3D::FEATURE_AMBIENT_OCCLUSION, true);
|
|
}
|
|
}
|
|
|
|
if (d.has("emissiveFactor")) {
|
|
const Array &arr = d["emissiveFactor"];
|
|
ERR_FAIL_COND_V(arr.size() != 3, ERR_PARSE_ERROR);
|
|
const Color c = Color(arr[0], arr[1], arr[2]).to_srgb();
|
|
material->set_feature(StandardMaterial3D::FEATURE_EMISSION, true);
|
|
|
|
material->set_emission(c);
|
|
}
|
|
|
|
if (d.has("emissiveTexture")) {
|
|
const Dictionary &bct = d["emissiveTexture"];
|
|
if (bct.has("index")) {
|
|
material->set_texture(StandardMaterial3D::TEXTURE_EMISSION, _get_texture(state, bct["index"]));
|
|
material->set_feature(StandardMaterial3D::FEATURE_EMISSION, true);
|
|
material->set_emission(Color(0, 0, 0));
|
|
}
|
|
}
|
|
|
|
if (d.has("doubleSided")) {
|
|
const bool ds = d["doubleSided"];
|
|
if (ds) {
|
|
material->set_cull_mode(StandardMaterial3D::CULL_DISABLED);
|
|
}
|
|
}
|
|
|
|
if (d.has("alphaMode")) {
|
|
const String &am = d["alphaMode"];
|
|
if (am == "BLEND") {
|
|
material->set_transparency(StandardMaterial3D::TRANSPARENCY_ALPHA_DEPTH_PRE_PASS);
|
|
} else if (am == "MASK") {
|
|
material->set_transparency(StandardMaterial3D::TRANSPARENCY_ALPHA_SCISSOR);
|
|
if (d.has("alphaCutoff")) {
|
|
material->set_alpha_scissor_threshold(d["alphaCutoff"]);
|
|
} else {
|
|
material->set_alpha_scissor_threshold(0.5f);
|
|
}
|
|
}
|
|
}
|
|
|
|
state.materials.push_back(material);
|
|
}
|
|
|
|
print_verbose("Total materials: " + itos(state.materials.size()));
|
|
|
|
return OK;
|
|
}
|
|
|
|
EditorSceneImporterGLTF::GLTFNodeIndex EditorSceneImporterGLTF::_find_highest_node(GLTFState &state, const Vector<GLTFNodeIndex> &subset) {
|
|
int highest = -1;
|
|
GLTFNodeIndex best_node = -1;
|
|
|
|
for (int i = 0; i < subset.size(); ++i) {
|
|
const GLTFNodeIndex node_i = subset[i];
|
|
const GLTFNode *node = state.nodes[node_i];
|
|
|
|
if (highest == -1 || node->height < highest) {
|
|
highest = node->height;
|
|
best_node = node_i;
|
|
}
|
|
}
|
|
|
|
return best_node;
|
|
}
|
|
|
|
bool EditorSceneImporterGLTF::_capture_nodes_in_skin(GLTFState &state, GLTFSkin &skin, const GLTFNodeIndex node_index) {
|
|
bool found_joint = false;
|
|
|
|
for (int i = 0; i < state.nodes[node_index]->children.size(); ++i) {
|
|
found_joint |= _capture_nodes_in_skin(state, skin, state.nodes[node_index]->children[i]);
|
|
}
|
|
|
|
if (found_joint) {
|
|
// Mark it if we happen to find another skins joint...
|
|
if (state.nodes[node_index]->joint && skin.joints.find(node_index) < 0) {
|
|
skin.joints.push_back(node_index);
|
|
} else if (skin.non_joints.find(node_index) < 0) {
|
|
skin.non_joints.push_back(node_index);
|
|
}
|
|
}
|
|
|
|
if (skin.joints.find(node_index) > 0) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void EditorSceneImporterGLTF::_capture_nodes_for_multirooted_skin(GLTFState &state, GLTFSkin &skin) {
|
|
DisjointSet<GLTFNodeIndex> disjoint_set;
|
|
|
|
for (int i = 0; i < skin.joints.size(); ++i) {
|
|
const GLTFNodeIndex node_index = skin.joints[i];
|
|
const GLTFNodeIndex parent = state.nodes[node_index]->parent;
|
|
disjoint_set.insert(node_index);
|
|
|
|
if (skin.joints.find(parent) >= 0) {
|
|
disjoint_set.create_union(parent, node_index);
|
|
}
|
|
}
|
|
|
|
Vector<GLTFNodeIndex> roots;
|
|
disjoint_set.get_representatives(roots);
|
|
|
|
if (roots.size() <= 1) {
|
|
return;
|
|
}
|
|
|
|
int maxHeight = -1;
|
|
|
|
// Determine the max height rooted tree
|
|
for (int i = 0; i < roots.size(); ++i) {
|
|
const GLTFNodeIndex root = roots[i];
|
|
|
|
if (maxHeight == -1 || state.nodes[root]->height < maxHeight) {
|
|
maxHeight = state.nodes[root]->height;
|
|
}
|
|
}
|
|
|
|
// Go up the tree till all of the multiple roots of the skin are at the same hierarchy level.
|
|
// This sucks, but 99% of all game engines (not just Godot) would have this same issue.
|
|
for (int i = 0; i < roots.size(); ++i) {
|
|
GLTFNodeIndex current_node = roots[i];
|
|
while (state.nodes[current_node]->height > maxHeight) {
|
|
GLTFNodeIndex parent = state.nodes[current_node]->parent;
|
|
|
|
if (state.nodes[parent]->joint && skin.joints.find(parent) < 0) {
|
|
skin.joints.push_back(parent);
|
|
} else if (skin.non_joints.find(parent) < 0) {
|
|
skin.non_joints.push_back(parent);
|
|
}
|
|
|
|
current_node = parent;
|
|
}
|
|
|
|
// replace the roots
|
|
roots.write[i] = current_node;
|
|
}
|
|
|
|
// Climb up the tree until they all have the same parent
|
|
bool all_same;
|
|
|
|
do {
|
|
all_same = true;
|
|
const GLTFNodeIndex first_parent = state.nodes[roots[0]]->parent;
|
|
|
|
for (int i = 1; i < roots.size(); ++i) {
|
|
all_same &= (first_parent == state.nodes[roots[i]]->parent);
|
|
}
|
|
|
|
if (!all_same) {
|
|
for (int i = 0; i < roots.size(); ++i) {
|
|
const GLTFNodeIndex current_node = roots[i];
|
|
const GLTFNodeIndex parent = state.nodes[current_node]->parent;
|
|
|
|
if (state.nodes[parent]->joint && skin.joints.find(parent) < 0) {
|
|
skin.joints.push_back(parent);
|
|
} else if (skin.non_joints.find(parent) < 0) {
|
|
skin.non_joints.push_back(parent);
|
|
}
|
|
|
|
roots.write[i] = parent;
|
|
}
|
|
}
|
|
|
|
} while (!all_same);
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_expand_skin(GLTFState &state, GLTFSkin &skin) {
|
|
_capture_nodes_for_multirooted_skin(state, skin);
|
|
|
|
// Grab all nodes that lay in between skin joints/nodes
|
|
DisjointSet<GLTFNodeIndex> disjoint_set;
|
|
|
|
Vector<GLTFNodeIndex> all_skin_nodes;
|
|
all_skin_nodes.append_array(skin.joints);
|
|
all_skin_nodes.append_array(skin.non_joints);
|
|
|
|
for (int i = 0; i < all_skin_nodes.size(); ++i) {
|
|
const GLTFNodeIndex node_index = all_skin_nodes[i];
|
|
const GLTFNodeIndex parent = state.nodes[node_index]->parent;
|
|
disjoint_set.insert(node_index);
|
|
|
|
if (all_skin_nodes.find(parent) >= 0) {
|
|
disjoint_set.create_union(parent, node_index);
|
|
}
|
|
}
|
|
|
|
Vector<GLTFNodeIndex> out_owners;
|
|
disjoint_set.get_representatives(out_owners);
|
|
|
|
Vector<GLTFNodeIndex> out_roots;
|
|
|
|
for (int i = 0; i < out_owners.size(); ++i) {
|
|
Vector<GLTFNodeIndex> set;
|
|
disjoint_set.get_members(set, out_owners[i]);
|
|
|
|
const GLTFNodeIndex root = _find_highest_node(state, set);
|
|
ERR_FAIL_COND_V(root < 0, FAILED);
|
|
out_roots.push_back(root);
|
|
}
|
|
|
|
out_roots.sort();
|
|
|
|
for (int i = 0; i < out_roots.size(); ++i) {
|
|
_capture_nodes_in_skin(state, skin, out_roots[i]);
|
|
}
|
|
|
|
skin.roots = out_roots;
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_verify_skin(GLTFState &state, GLTFSkin &skin) {
|
|
// This may seem duplicated from expand_skins, but this is really a sanity check! (so it kinda is)
|
|
// In case additional interpolating logic is added to the skins, this will help ensure that you
|
|
// do not cause it to self implode into a fiery blaze
|
|
|
|
// We are going to re-calculate the root nodes and compare them to the ones saved in the skin,
|
|
// then ensure the multiple trees (if they exist) are on the same sublevel
|
|
|
|
// Grab all nodes that lay in between skin joints/nodes
|
|
DisjointSet<GLTFNodeIndex> disjoint_set;
|
|
|
|
Vector<GLTFNodeIndex> all_skin_nodes;
|
|
all_skin_nodes.append_array(skin.joints);
|
|
all_skin_nodes.append_array(skin.non_joints);
|
|
|
|
for (int i = 0; i < all_skin_nodes.size(); ++i) {
|
|
const GLTFNodeIndex node_index = all_skin_nodes[i];
|
|
const GLTFNodeIndex parent = state.nodes[node_index]->parent;
|
|
disjoint_set.insert(node_index);
|
|
|
|
if (all_skin_nodes.find(parent) >= 0) {
|
|
disjoint_set.create_union(parent, node_index);
|
|
}
|
|
}
|
|
|
|
Vector<GLTFNodeIndex> out_owners;
|
|
disjoint_set.get_representatives(out_owners);
|
|
|
|
Vector<GLTFNodeIndex> out_roots;
|
|
|
|
for (int i = 0; i < out_owners.size(); ++i) {
|
|
Vector<GLTFNodeIndex> set;
|
|
disjoint_set.get_members(set, out_owners[i]);
|
|
|
|
const GLTFNodeIndex root = _find_highest_node(state, set);
|
|
ERR_FAIL_COND_V(root < 0, FAILED);
|
|
out_roots.push_back(root);
|
|
}
|
|
|
|
out_roots.sort();
|
|
|
|
ERR_FAIL_COND_V(out_roots.size() == 0, FAILED);
|
|
|
|
// Make sure the roots are the exact same (they better be)
|
|
ERR_FAIL_COND_V(out_roots.size() != skin.roots.size(), FAILED);
|
|
for (int i = 0; i < out_roots.size(); ++i) {
|
|
ERR_FAIL_COND_V(out_roots[i] != skin.roots[i], FAILED);
|
|
}
|
|
|
|
// Single rooted skin? Perfectly ok!
|
|
if (out_roots.size() == 1) {
|
|
return OK;
|
|
}
|
|
|
|
// Make sure all parents of a multi-rooted skin are the SAME
|
|
const GLTFNodeIndex parent = state.nodes[out_roots[0]]->parent;
|
|
for (int i = 1; i < out_roots.size(); ++i) {
|
|
if (state.nodes[out_roots[i]]->parent != parent) {
|
|
return FAILED;
|
|
}
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_parse_skins(GLTFState &state) {
|
|
if (!state.json.has("skins"))
|
|
return OK;
|
|
|
|
const Array &skins = state.json["skins"];
|
|
|
|
// Create the base skins, and mark nodes that are joints
|
|
for (int i = 0; i < skins.size(); i++) {
|
|
const Dictionary &d = skins[i];
|
|
|
|
GLTFSkin skin;
|
|
|
|
ERR_FAIL_COND_V(!d.has("joints"), ERR_PARSE_ERROR);
|
|
|
|
const Array &joints = d["joints"];
|
|
|
|
if (d.has("inverseBindMatrices")) {
|
|
skin.inverse_binds = _decode_accessor_as_xform(state, d["inverseBindMatrices"], false);
|
|
ERR_FAIL_COND_V(skin.inverse_binds.size() != joints.size(), ERR_PARSE_ERROR);
|
|
}
|
|
|
|
for (int j = 0; j < joints.size(); j++) {
|
|
const GLTFNodeIndex node = joints[j];
|
|
ERR_FAIL_INDEX_V(node, state.nodes.size(), ERR_PARSE_ERROR);
|
|
|
|
skin.joints.push_back(node);
|
|
skin.joints_original.push_back(node);
|
|
|
|
state.nodes[node]->joint = true;
|
|
}
|
|
|
|
if (d.has("name")) {
|
|
skin.name = d["name"];
|
|
}
|
|
|
|
if (d.has("skeleton")) {
|
|
skin.skin_root = d["skeleton"];
|
|
}
|
|
|
|
state.skins.push_back(skin);
|
|
}
|
|
|
|
for (GLTFSkinIndex i = 0; i < state.skins.size(); ++i) {
|
|
GLTFSkin &skin = state.skins.write[i];
|
|
|
|
// Expand the skin to capture all the extra non-joints that lie in between the actual joints,
|
|
// and expand the hierarchy to ensure multi-rooted trees lie on the same height level
|
|
ERR_FAIL_COND_V(_expand_skin(state, skin), ERR_PARSE_ERROR);
|
|
ERR_FAIL_COND_V(_verify_skin(state, skin), ERR_PARSE_ERROR);
|
|
}
|
|
|
|
print_verbose("glTF: Total skins: " + itos(state.skins.size()));
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_determine_skeletons(GLTFState &state) {
|
|
// Using a disjoint set, we are going to potentially combine all skins that are actually branches
|
|
// of a main skeleton, or treat skins defining the same set of nodes as ONE skeleton.
|
|
// This is another unclear issue caused by the current glTF specification.
|
|
|
|
DisjointSet<GLTFNodeIndex> skeleton_sets;
|
|
|
|
for (GLTFSkinIndex skin_i = 0; skin_i < state.skins.size(); ++skin_i) {
|
|
const GLTFSkin &skin = state.skins[skin_i];
|
|
|
|
Vector<GLTFNodeIndex> all_skin_nodes;
|
|
all_skin_nodes.append_array(skin.joints);
|
|
all_skin_nodes.append_array(skin.non_joints);
|
|
|
|
for (int i = 0; i < all_skin_nodes.size(); ++i) {
|
|
const GLTFNodeIndex node_index = all_skin_nodes[i];
|
|
const GLTFNodeIndex parent = state.nodes[node_index]->parent;
|
|
skeleton_sets.insert(node_index);
|
|
|
|
if (all_skin_nodes.find(parent) >= 0) {
|
|
skeleton_sets.create_union(parent, node_index);
|
|
}
|
|
}
|
|
|
|
// We are going to connect the separate skin subtrees in each skin together
|
|
// so that the final roots are entire sets of valid skin trees
|
|
for (int i = 1; i < skin.roots.size(); ++i) {
|
|
skeleton_sets.create_union(skin.roots[0], skin.roots[i]);
|
|
}
|
|
}
|
|
|
|
{ // attempt to joint all touching subsets (siblings/parent are part of another skin)
|
|
Vector<GLTFNodeIndex> groups_representatives;
|
|
skeleton_sets.get_representatives(groups_representatives);
|
|
|
|
Vector<GLTFNodeIndex> highest_group_members;
|
|
Vector<Vector<GLTFNodeIndex>> groups;
|
|
for (int i = 0; i < groups_representatives.size(); ++i) {
|
|
Vector<GLTFNodeIndex> group;
|
|
skeleton_sets.get_members(group, groups_representatives[i]);
|
|
highest_group_members.push_back(_find_highest_node(state, group));
|
|
groups.push_back(group);
|
|
}
|
|
|
|
for (int i = 0; i < highest_group_members.size(); ++i) {
|
|
const GLTFNodeIndex node_i = highest_group_members[i];
|
|
|
|
// Attach any siblings together (this needs to be done n^2/2 times)
|
|
for (int j = i + 1; j < highest_group_members.size(); ++j) {
|
|
const GLTFNodeIndex node_j = highest_group_members[j];
|
|
|
|
// Even if they are siblings under the root! :)
|
|
if (state.nodes[node_i]->parent == state.nodes[node_j]->parent) {
|
|
skeleton_sets.create_union(node_i, node_j);
|
|
}
|
|
}
|
|
|
|
// Attach any parenting going on together (we need to do this n^2 times)
|
|
const GLTFNodeIndex node_i_parent = state.nodes[node_i]->parent;
|
|
if (node_i_parent >= 0) {
|
|
for (int j = 0; j < groups.size() && i != j; ++j) {
|
|
const Vector<GLTFNodeIndex> &group = groups[j];
|
|
|
|
if (group.find(node_i_parent) >= 0) {
|
|
const GLTFNodeIndex node_j = highest_group_members[j];
|
|
skeleton_sets.create_union(node_i, node_j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// At this point, the skeleton groups should be finalized
|
|
Vector<GLTFNodeIndex> skeleton_owners;
|
|
skeleton_sets.get_representatives(skeleton_owners);
|
|
|
|
// Mark all the skins actual skeletons, after we have merged them
|
|
for (GLTFSkeletonIndex skel_i = 0; skel_i < skeleton_owners.size(); ++skel_i) {
|
|
const GLTFNodeIndex skeleton_owner = skeleton_owners[skel_i];
|
|
GLTFSkeleton skeleton;
|
|
|
|
Vector<GLTFNodeIndex> skeleton_nodes;
|
|
skeleton_sets.get_members(skeleton_nodes, skeleton_owner);
|
|
|
|
for (GLTFSkinIndex skin_i = 0; skin_i < state.skins.size(); ++skin_i) {
|
|
GLTFSkin &skin = state.skins.write[skin_i];
|
|
|
|
// If any of the the skeletons nodes exist in a skin, that skin now maps to the skeleton
|
|
for (int i = 0; i < skeleton_nodes.size(); ++i) {
|
|
GLTFNodeIndex skel_node_i = skeleton_nodes[i];
|
|
if (skin.joints.find(skel_node_i) >= 0 || skin.non_joints.find(skel_node_i) >= 0) {
|
|
skin.skeleton = skel_i;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
Vector<GLTFNodeIndex> non_joints;
|
|
for (int i = 0; i < skeleton_nodes.size(); ++i) {
|
|
const GLTFNodeIndex node_i = skeleton_nodes[i];
|
|
|
|
if (state.nodes[node_i]->joint) {
|
|
skeleton.joints.push_back(node_i);
|
|
} else {
|
|
non_joints.push_back(node_i);
|
|
}
|
|
}
|
|
|
|
state.skeletons.push_back(skeleton);
|
|
|
|
_reparent_non_joint_skeleton_subtrees(state, state.skeletons.write[skel_i], non_joints);
|
|
}
|
|
|
|
for (GLTFSkeletonIndex skel_i = 0; skel_i < state.skeletons.size(); ++skel_i) {
|
|
GLTFSkeleton &skeleton = state.skeletons.write[skel_i];
|
|
|
|
for (int i = 0; i < skeleton.joints.size(); ++i) {
|
|
const GLTFNodeIndex node_i = skeleton.joints[i];
|
|
GLTFNode *node = state.nodes[node_i];
|
|
|
|
ERR_FAIL_COND_V(!node->joint, ERR_PARSE_ERROR);
|
|
ERR_FAIL_COND_V(node->skeleton >= 0, ERR_PARSE_ERROR);
|
|
node->skeleton = skel_i;
|
|
}
|
|
|
|
ERR_FAIL_COND_V(_determine_skeleton_roots(state, skel_i), ERR_PARSE_ERROR);
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_reparent_non_joint_skeleton_subtrees(GLTFState &state, GLTFSkeleton &skeleton, const Vector<GLTFNodeIndex> &non_joints) {
|
|
DisjointSet<GLTFNodeIndex> subtree_set;
|
|
|
|
// Populate the disjoint set with ONLY non joints that are in the skeleton hierarchy (non_joints vector)
|
|
// This way we can find any joints that lie in between joints, as the current glTF specification
|
|
// mentions nothing about non-joints being in between joints of the same skin. Hopefully one day we
|
|
// can remove this code.
|
|
|
|
// skinD depicted here explains this issue:
|
|
// https://github.com/KhronosGroup/glTF-Asset-Generator/blob/master/Output/Positive/Animation_Skin
|
|
|
|
for (int i = 0; i < non_joints.size(); ++i) {
|
|
const GLTFNodeIndex node_i = non_joints[i];
|
|
|
|
subtree_set.insert(node_i);
|
|
|
|
const GLTFNodeIndex parent_i = state.nodes[node_i]->parent;
|
|
if (parent_i >= 0 && non_joints.find(parent_i) >= 0 && !state.nodes[parent_i]->joint) {
|
|
subtree_set.create_union(parent_i, node_i);
|
|
}
|
|
}
|
|
|
|
// Find all the non joint subtrees and re-parent them to a new "fake" joint
|
|
|
|
Vector<GLTFNodeIndex> non_joint_subtree_roots;
|
|
subtree_set.get_representatives(non_joint_subtree_roots);
|
|
|
|
for (int root_i = 0; root_i < non_joint_subtree_roots.size(); ++root_i) {
|
|
const GLTFNodeIndex subtree_root = non_joint_subtree_roots[root_i];
|
|
|
|
Vector<GLTFNodeIndex> subtree_nodes;
|
|
subtree_set.get_members(subtree_nodes, subtree_root);
|
|
|
|
for (int subtree_i = 0; subtree_i < subtree_nodes.size(); ++subtree_i) {
|
|
ERR_FAIL_COND_V(_reparent_to_fake_joint(state, skeleton, subtree_nodes[subtree_i]), FAILED);
|
|
|
|
// We modified the tree, recompute all the heights
|
|
_compute_node_heights(state);
|
|
}
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_reparent_to_fake_joint(GLTFState &state, GLTFSkeleton &skeleton, const GLTFNodeIndex node_index) {
|
|
GLTFNode *node = state.nodes[node_index];
|
|
|
|
// Can we just "steal" this joint if it is just a spatial node?
|
|
if (node->skin < 0 && node->mesh < 0 && node->camera < 0) {
|
|
node->joint = true;
|
|
// Add the joint to the skeletons joints
|
|
skeleton.joints.push_back(node_index);
|
|
return OK;
|
|
}
|
|
|
|
GLTFNode *fake_joint = memnew(GLTFNode);
|
|
const GLTFNodeIndex fake_joint_index = state.nodes.size();
|
|
state.nodes.push_back(fake_joint);
|
|
|
|
// We better not be a joint, or we messed up in our logic
|
|
if (node->joint)
|
|
return FAILED;
|
|
|
|
fake_joint->translation = node->translation;
|
|
fake_joint->rotation = node->rotation;
|
|
fake_joint->scale = node->scale;
|
|
fake_joint->xform = node->xform;
|
|
fake_joint->joint = true;
|
|
|
|
// We can use the exact same name here, because the joint will be inside a skeleton and not the scene
|
|
fake_joint->name = node->name;
|
|
|
|
// Clear the nodes transforms, since it will be parented to the fake joint
|
|
node->translation = Vector3(0, 0, 0);
|
|
node->rotation = Quat();
|
|
node->scale = Vector3(1, 1, 1);
|
|
node->xform = Transform();
|
|
|
|
// Transfer the node children to the fake joint
|
|
for (int child_i = 0; child_i < node->children.size(); ++child_i) {
|
|
GLTFNode *child = state.nodes[node->children[child_i]];
|
|
child->parent = fake_joint_index;
|
|
}
|
|
|
|
fake_joint->children = node->children;
|
|
node->children.clear();
|
|
|
|
// add the fake joint to the parent and remove the original joint
|
|
if (node->parent >= 0) {
|
|
GLTFNode *parent = state.nodes[node->parent];
|
|
parent->children.erase(node_index);
|
|
parent->children.push_back(fake_joint_index);
|
|
fake_joint->parent = node->parent;
|
|
}
|
|
|
|
// Add the node to the fake joint
|
|
fake_joint->children.push_back(node_index);
|
|
node->parent = fake_joint_index;
|
|
node->fake_joint_parent = fake_joint_index;
|
|
|
|
// Add the fake joint to the skeletons joints
|
|
skeleton.joints.push_back(fake_joint_index);
|
|
|
|
// Replace skin_skeletons with fake joints if we must.
|
|
for (GLTFSkinIndex skin_i = 0; skin_i < state.skins.size(); ++skin_i) {
|
|
GLTFSkin &skin = state.skins.write[skin_i];
|
|
if (skin.skin_root == node_index) {
|
|
skin.skin_root = fake_joint_index;
|
|
}
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_determine_skeleton_roots(GLTFState &state, const GLTFSkeletonIndex skel_i) {
|
|
DisjointSet<GLTFNodeIndex> disjoint_set;
|
|
|
|
for (GLTFNodeIndex i = 0; i < state.nodes.size(); ++i) {
|
|
const GLTFNode *node = state.nodes[i];
|
|
|
|
if (node->skeleton != skel_i) {
|
|
continue;
|
|
}
|
|
|
|
disjoint_set.insert(i);
|
|
|
|
if (node->parent >= 0 && state.nodes[node->parent]->skeleton == skel_i) {
|
|
disjoint_set.create_union(node->parent, i);
|
|
}
|
|
}
|
|
|
|
GLTFSkeleton &skeleton = state.skeletons.write[skel_i];
|
|
|
|
Vector<GLTFNodeIndex> owners;
|
|
disjoint_set.get_representatives(owners);
|
|
|
|
Vector<GLTFNodeIndex> roots;
|
|
|
|
for (int i = 0; i < owners.size(); ++i) {
|
|
Vector<GLTFNodeIndex> set;
|
|
disjoint_set.get_members(set, owners[i]);
|
|
const GLTFNodeIndex root = _find_highest_node(state, set);
|
|
ERR_FAIL_COND_V(root < 0, FAILED);
|
|
roots.push_back(root);
|
|
}
|
|
|
|
roots.sort();
|
|
|
|
skeleton.roots = roots;
|
|
|
|
if (roots.size() == 0) {
|
|
return FAILED;
|
|
} else if (roots.size() == 1) {
|
|
return OK;
|
|
}
|
|
|
|
// Check that the subtrees have the same parent root
|
|
const GLTFNodeIndex parent = state.nodes[roots[0]]->parent;
|
|
for (int i = 1; i < roots.size(); ++i) {
|
|
if (state.nodes[roots[i]]->parent != parent) {
|
|
return FAILED;
|
|
}
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_create_skeletons(GLTFState &state) {
|
|
for (GLTFSkeletonIndex skel_i = 0; skel_i < state.skeletons.size(); ++skel_i) {
|
|
GLTFSkeleton &gltf_skeleton = state.skeletons.write[skel_i];
|
|
|
|
Skeleton3D *skeleton = memnew(Skeleton3D);
|
|
gltf_skeleton.godot_skeleton = skeleton;
|
|
|
|
// Make a unique name, no gltf node represents this skeleton
|
|
skeleton->set_name(_gen_unique_name(state, "Skeleton"));
|
|
|
|
List<GLTFNodeIndex> bones;
|
|
|
|
for (int i = 0; i < gltf_skeleton.roots.size(); ++i) {
|
|
bones.push_back(gltf_skeleton.roots[i]);
|
|
}
|
|
|
|
// Make the skeleton creation deterministic by going through the roots in
|
|
// a sorted order, and DEPTH FIRST
|
|
bones.sort();
|
|
|
|
while (!bones.empty()) {
|
|
const GLTFNodeIndex node_i = bones.front()->get();
|
|
bones.pop_front();
|
|
|
|
GLTFNode *node = state.nodes[node_i];
|
|
ERR_FAIL_COND_V(node->skeleton != skel_i, FAILED);
|
|
|
|
{ // Add all child nodes to the stack (deterministically)
|
|
Vector<GLTFNodeIndex> child_nodes;
|
|
for (int i = 0; i < node->children.size(); ++i) {
|
|
const GLTFNodeIndex child_i = node->children[i];
|
|
if (state.nodes[child_i]->skeleton == skel_i) {
|
|
child_nodes.push_back(child_i);
|
|
}
|
|
}
|
|
|
|
// Depth first insertion
|
|
child_nodes.sort();
|
|
for (int i = child_nodes.size() - 1; i >= 0; --i) {
|
|
bones.push_front(child_nodes[i]);
|
|
}
|
|
}
|
|
|
|
const int bone_index = skeleton->get_bone_count();
|
|
|
|
if (node->name.empty()) {
|
|
node->name = "bone";
|
|
}
|
|
|
|
node->name = _gen_unique_bone_name(state, skel_i, node->name);
|
|
|
|
skeleton->add_bone(node->name);
|
|
skeleton->set_bone_rest(bone_index, node->xform);
|
|
|
|
if (node->parent >= 0 && state.nodes[node->parent]->skeleton == skel_i) {
|
|
const int bone_parent = skeleton->find_bone(state.nodes[node->parent]->name);
|
|
ERR_FAIL_COND_V(bone_parent < 0, FAILED);
|
|
skeleton->set_bone_parent(bone_index, skeleton->find_bone(state.nodes[node->parent]->name));
|
|
}
|
|
|
|
state.scene_nodes.insert(node_i, skeleton);
|
|
}
|
|
}
|
|
|
|
ERR_FAIL_COND_V(_map_skin_joints_indices_to_skeleton_bone_indices(state), ERR_PARSE_ERROR);
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_map_skin_joints_indices_to_skeleton_bone_indices(GLTFState &state) {
|
|
for (GLTFSkinIndex skin_i = 0; skin_i < state.skins.size(); ++skin_i) {
|
|
GLTFSkin &skin = state.skins.write[skin_i];
|
|
|
|
const GLTFSkeleton &skeleton = state.skeletons[skin.skeleton];
|
|
|
|
for (int joint_index = 0; joint_index < skin.joints_original.size(); ++joint_index) {
|
|
const GLTFNodeIndex node_i = skin.joints_original[joint_index];
|
|
const GLTFNode *node = state.nodes[node_i];
|
|
|
|
skin.joint_i_to_name.insert(joint_index, node->name);
|
|
|
|
const int bone_index = skeleton.godot_skeleton->find_bone(node->name);
|
|
ERR_FAIL_COND_V(bone_index < 0, FAILED);
|
|
|
|
skin.joint_i_to_bone_i.insert(joint_index, bone_index);
|
|
}
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_create_skins(GLTFState &state) {
|
|
for (GLTFSkinIndex skin_i = 0; skin_i < state.skins.size(); ++skin_i) {
|
|
GLTFSkin &gltf_skin = state.skins.write[skin_i];
|
|
|
|
Ref<Skin> skin;
|
|
skin.instance();
|
|
|
|
// Some skins don't have IBM's! What absolute monsters!
|
|
const bool has_ibms = !gltf_skin.inverse_binds.empty();
|
|
|
|
for (int joint_i = 0; joint_i < gltf_skin.joints_original.size(); ++joint_i) {
|
|
Transform xform;
|
|
if (has_ibms) {
|
|
xform = gltf_skin.inverse_binds[joint_i];
|
|
}
|
|
|
|
if (state.use_named_skin_binds) {
|
|
StringName name = gltf_skin.joint_i_to_name[joint_i];
|
|
skin->add_named_bind(name, xform);
|
|
} else {
|
|
int bone_i = gltf_skin.joint_i_to_bone_i[joint_i];
|
|
skin->add_bind(bone_i, xform);
|
|
}
|
|
}
|
|
|
|
gltf_skin.godot_skin = skin;
|
|
}
|
|
|
|
// Purge the duplicates!
|
|
_remove_duplicate_skins(state);
|
|
|
|
// Create unique names now, after removing duplicates
|
|
for (GLTFSkinIndex skin_i = 0; skin_i < state.skins.size(); ++skin_i) {
|
|
Ref<Skin> skin = state.skins[skin_i].godot_skin;
|
|
if (skin->get_name().empty()) {
|
|
// Make a unique name, no gltf node represents this skin
|
|
skin->set_name(_gen_unique_name(state, "Skin"));
|
|
}
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
bool EditorSceneImporterGLTF::_skins_are_same(const Ref<Skin> &skin_a, const Ref<Skin> &skin_b) {
|
|
if (skin_a->get_bind_count() != skin_b->get_bind_count()) {
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < skin_a->get_bind_count(); ++i) {
|
|
if (skin_a->get_bind_bone(i) != skin_b->get_bind_bone(i)) {
|
|
return false;
|
|
}
|
|
|
|
Transform a_xform = skin_a->get_bind_pose(i);
|
|
Transform b_xform = skin_b->get_bind_pose(i);
|
|
|
|
if (a_xform != b_xform) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void EditorSceneImporterGLTF::_remove_duplicate_skins(GLTFState &state) {
|
|
for (int i = 0; i < state.skins.size(); ++i) {
|
|
for (int j = i + 1; j < state.skins.size(); ++j) {
|
|
const Ref<Skin> &skin_i = state.skins[i].godot_skin;
|
|
const Ref<Skin> &skin_j = state.skins[j].godot_skin;
|
|
|
|
if (_skins_are_same(skin_i, skin_j)) {
|
|
// replace it and delete the old
|
|
state.skins.write[j].godot_skin = skin_i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_parse_cameras(GLTFState &state) {
|
|
if (!state.json.has("cameras"))
|
|
return OK;
|
|
|
|
const Array &cameras = state.json["cameras"];
|
|
|
|
for (GLTFCameraIndex i = 0; i < cameras.size(); i++) {
|
|
const Dictionary &d = cameras[i];
|
|
|
|
GLTFCamera camera;
|
|
ERR_FAIL_COND_V(!d.has("type"), ERR_PARSE_ERROR);
|
|
const String &type = d["type"];
|
|
if (type == "orthographic") {
|
|
camera.perspective = false;
|
|
if (d.has("orthographic")) {
|
|
const Dictionary &og = d["orthographic"];
|
|
camera.fov_size = og["ymag"];
|
|
camera.zfar = og["zfar"];
|
|
camera.znear = og["znear"];
|
|
} else {
|
|
camera.fov_size = 10;
|
|
}
|
|
|
|
} else if (type == "perspective") {
|
|
camera.perspective = true;
|
|
if (d.has("perspective")) {
|
|
const Dictionary &ppt = d["perspective"];
|
|
// GLTF spec is in radians, Godot's camera is in degrees.
|
|
camera.fov_size = (double)ppt["yfov"] * 180.0 / Math_PI;
|
|
camera.zfar = ppt["zfar"];
|
|
camera.znear = ppt["znear"];
|
|
} else {
|
|
camera.fov_size = 10;
|
|
}
|
|
} else {
|
|
ERR_FAIL_V_MSG(ERR_PARSE_ERROR, "Camera should be in 'orthographic' or 'perspective'");
|
|
}
|
|
|
|
state.cameras.push_back(camera);
|
|
}
|
|
|
|
print_verbose("glTF: Total cameras: " + itos(state.cameras.size()));
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorSceneImporterGLTF::_parse_animations(GLTFState &state) {
|
|
if (!state.json.has("animations"))
|
|
return OK;
|
|
|
|
const Array &animations = state.json["animations"];
|
|
|
|
for (GLTFAnimationIndex i = 0; i < animations.size(); i++) {
|
|
const Dictionary &d = animations[i];
|
|
|
|
GLTFAnimation animation;
|
|
|
|
if (!d.has("channels") || !d.has("samplers"))
|
|
continue;
|
|
|
|
Array channels = d["channels"];
|
|
Array samplers = d["samplers"];
|
|
|
|
if (d.has("name")) {
|
|
String name = d["name"];
|
|
if (name.begins_with("loop") || name.ends_with("loop") || name.begins_with("cycle") || name.ends_with("cycle")) {
|
|
animation.loop = true;
|
|
}
|
|
animation.name = _sanitize_scene_name(name);
|
|
}
|
|
|
|
for (int j = 0; j < channels.size(); j++) {
|
|
const Dictionary &c = channels[j];
|
|
if (!c.has("target"))
|
|
continue;
|
|
|
|
const Dictionary &t = c["target"];
|
|
if (!t.has("node") || !t.has("path")) {
|
|
continue;
|
|
}
|
|
|
|
ERR_FAIL_COND_V(!c.has("sampler"), ERR_PARSE_ERROR);
|
|
const int sampler = c["sampler"];
|
|
ERR_FAIL_INDEX_V(sampler, samplers.size(), ERR_PARSE_ERROR);
|
|
|
|
GLTFNodeIndex node = t["node"];
|
|
String path = t["path"];
|
|
|
|
ERR_FAIL_INDEX_V(node, state.nodes.size(), ERR_PARSE_ERROR);
|
|
|
|
GLTFAnimation::Track *track = nullptr;
|
|
|
|
if (!animation.tracks.has(node)) {
|
|
animation.tracks[node] = GLTFAnimation::Track();
|
|
}
|
|
|
|
track = &animation.tracks[node];
|
|
|
|
const Dictionary &s = samplers[sampler];
|
|
|
|
ERR_FAIL_COND_V(!s.has("input"), ERR_PARSE_ERROR);
|
|
ERR_FAIL_COND_V(!s.has("output"), ERR_PARSE_ERROR);
|
|
|
|
const int input = s["input"];
|
|
const int output = s["output"];
|
|
|
|
GLTFAnimation::Interpolation interp = GLTFAnimation::INTERP_LINEAR;
|
|
int output_count = 1;
|
|
if (s.has("interpolation")) {
|
|
const String &in = s["interpolation"];
|
|
if (in == "STEP") {
|
|
interp = GLTFAnimation::INTERP_STEP;
|
|
} else if (in == "LINEAR") {
|
|
interp = GLTFAnimation::INTERP_LINEAR;
|
|
} else if (in == "CATMULLROMSPLINE") {
|
|
interp = GLTFAnimation::INTERP_CATMULLROMSPLINE;
|
|
output_count = 3;
|
|
} else if (in == "CUBICSPLINE") {
|
|
interp = GLTFAnimation::INTERP_CUBIC_SPLINE;
|
|
output_count = 3;
|
|
}
|
|
}
|
|
|
|
const Vector<float> times = _decode_accessor_as_floats(state, input, false);
|
|
if (path == "translation") {
|
|
const Vector<Vector3> translations = _decode_accessor_as_vec3(state, output, false);
|
|
track->translation_track.interpolation = interp;
|
|
track->translation_track.times = Variant(times); //convert via variant
|
|
track->translation_track.values = Variant(translations); //convert via variant
|
|
} else if (path == "rotation") {
|
|
const Vector<Quat> rotations = _decode_accessor_as_quat(state, output, false);
|
|
track->rotation_track.interpolation = interp;
|
|
track->rotation_track.times = Variant(times); //convert via variant
|
|
track->rotation_track.values = rotations; //convert via variant
|
|
} else if (path == "scale") {
|
|
const Vector<Vector3> scales = _decode_accessor_as_vec3(state, output, false);
|
|
track->scale_track.interpolation = interp;
|
|
track->scale_track.times = Variant(times); //convert via variant
|
|
track->scale_track.values = Variant(scales); //convert via variant
|
|
} else if (path == "weights") {
|
|
const Vector<float> weights = _decode_accessor_as_floats(state, output, false);
|
|
|
|
ERR_FAIL_INDEX_V(state.nodes[node]->mesh, state.meshes.size(), ERR_PARSE_ERROR);
|
|
const GLTFMesh *mesh = &state.meshes[state.nodes[node]->mesh];
|
|
ERR_FAIL_COND_V(mesh->blend_weights.size() == 0, ERR_PARSE_ERROR);
|
|
const int wc = mesh->blend_weights.size();
|
|
|
|
track->weight_tracks.resize(wc);
|
|
|
|
const int expected_value_count = times.size() * output_count * wc;
|
|
ERR_FAIL_COND_V_MSG(weights.size() != expected_value_count, ERR_PARSE_ERROR, "Invalid weight data, expected " + itos(expected_value_count) + " weight values, got " + itos(weights.size()) + " instead.");
|
|
|
|
const int wlen = weights.size() / wc;
|
|
const float *r = weights.ptr();
|
|
for (int k = 0; k < wc; k++) { //separate tracks, having them together is not such a good idea
|
|
GLTFAnimation::Channel<float> cf;
|
|
cf.interpolation = interp;
|
|
cf.times = Variant(times);
|
|
Vector<float> wdata;
|
|
wdata.resize(wlen);
|
|
for (int l = 0; l < wlen; l++) {
|
|
wdata.write[l] = r[l * wc + k];
|
|
}
|
|
|
|
cf.values = wdata;
|
|
track->weight_tracks.write[k] = cf;
|
|
}
|
|
} else {
|
|
WARN_PRINT("Invalid path '" + path + "'.");
|
|
}
|
|
}
|
|
|
|
state.animations.push_back(animation);
|
|
}
|
|
|
|
print_verbose("glTF: Total animations '" + itos(state.animations.size()) + "'.");
|
|
|
|
return OK;
|
|
}
|
|
|
|
void EditorSceneImporterGLTF::_assign_scene_names(GLTFState &state) {
|
|
for (int i = 0; i < state.nodes.size(); i++) {
|
|
GLTFNode *n = state.nodes[i];
|
|
|
|
// Any joints get unique names generated when the skeleton is made, unique to the skeleton
|
|
if (n->skeleton >= 0)
|
|
continue;
|
|
|
|
if (n->name.empty()) {
|
|
if (n->mesh >= 0) {
|
|
n->name = "Mesh";
|
|
} else if (n->camera >= 0) {
|
|
n->name = "Camera";
|
|
} else {
|
|
n->name = "Node";
|
|
}
|
|
}
|
|
|
|
n->name = _gen_unique_name(state, n->name);
|
|
}
|
|
}
|
|
|
|
BoneAttachment3D *EditorSceneImporterGLTF::_generate_bone_attachment(GLTFState &state, Skeleton3D *skeleton, const GLTFNodeIndex node_index) {
|
|
const GLTFNode *gltf_node = state.nodes[node_index];
|
|
const GLTFNode *bone_node = state.nodes[gltf_node->parent];
|
|
|
|
BoneAttachment3D *bone_attachment = memnew(BoneAttachment3D);
|
|
print_verbose("glTF: Creating bone attachment for: " + gltf_node->name);
|
|
|
|
ERR_FAIL_COND_V(!bone_node->joint, nullptr);
|
|
|
|
bone_attachment->set_bone_name(bone_node->name);
|
|
|
|
return bone_attachment;
|
|
}
|
|
|
|
MeshInstance3D *EditorSceneImporterGLTF::_generate_mesh_instance(GLTFState &state, Node *scene_parent, const GLTFNodeIndex node_index) {
|
|
const GLTFNode *gltf_node = state.nodes[node_index];
|
|
|
|
ERR_FAIL_INDEX_V(gltf_node->mesh, state.meshes.size(), nullptr);
|
|
|
|
MeshInstance3D *mi = memnew(MeshInstance3D);
|
|
print_verbose("glTF: Creating mesh for: " + gltf_node->name);
|
|
|
|
GLTFMesh &mesh = state.meshes.write[gltf_node->mesh];
|
|
mi->set_mesh(mesh.mesh);
|
|
|
|
if (mesh.mesh->get_name() == "") {
|
|
mesh.mesh->set_name(gltf_node->name);
|
|
}
|
|
|
|
for (int i = 0; i < mesh.blend_weights.size(); i++) {
|
|
mi->set("blend_shapes/" + mesh.mesh->get_blend_shape_name(i), mesh.blend_weights[i]);
|
|
}
|
|
|
|
return mi;
|
|
}
|
|
|
|
Camera3D *EditorSceneImporterGLTF::_generate_camera(GLTFState &state, Node *scene_parent, const GLTFNodeIndex node_index) {
|
|
const GLTFNode *gltf_node = state.nodes[node_index];
|
|
|
|
ERR_FAIL_INDEX_V(gltf_node->camera, state.cameras.size(), nullptr);
|
|
|
|
Camera3D *camera = memnew(Camera3D);
|
|
print_verbose("glTF: Creating camera for: " + gltf_node->name);
|
|
|
|
const GLTFCamera &c = state.cameras[gltf_node->camera];
|
|
if (c.perspective) {
|
|
camera->set_perspective(c.fov_size, c.znear, c.zfar);
|
|
} else {
|
|
camera->set_orthogonal(c.fov_size, c.znear, c.zfar);
|
|
}
|
|
|
|
return camera;
|
|
}
|
|
|
|
Node3D *EditorSceneImporterGLTF::_generate_spatial(GLTFState &state, Node *scene_parent, const GLTFNodeIndex node_index) {
|
|
const GLTFNode *gltf_node = state.nodes[node_index];
|
|
|
|
Node3D *spatial = memnew(Node3D);
|
|
print_verbose("glTF: Creating spatial for: " + gltf_node->name);
|
|
|
|
return spatial;
|
|
}
|
|
|
|
void EditorSceneImporterGLTF::_generate_scene_node(GLTFState &state, Node *scene_parent, Node3D *scene_root, const GLTFNodeIndex node_index) {
|
|
const GLTFNode *gltf_node = state.nodes[node_index];
|
|
|
|
Node3D *current_node = nullptr;
|
|
|
|
// Is our parent a skeleton
|
|
Skeleton3D *active_skeleton = Object::cast_to<Skeleton3D>(scene_parent);
|
|
|
|
if (gltf_node->skeleton >= 0) {
|
|
Skeleton3D *skeleton = state.skeletons[gltf_node->skeleton].godot_skeleton;
|
|
|
|
if (active_skeleton != skeleton) {
|
|
ERR_FAIL_COND_MSG(active_skeleton != nullptr, "glTF: Generating scene detected direct parented Skeletons");
|
|
|
|
// Add it to the scene if it has not already been added
|
|
if (skeleton->get_parent() == nullptr) {
|
|
scene_parent->add_child(skeleton);
|
|
skeleton->set_owner(scene_root);
|
|
}
|
|
}
|
|
|
|
active_skeleton = skeleton;
|
|
current_node = skeleton;
|
|
}
|
|
|
|
// If we have an active skeleton, and the node is node skinned, we need to create a bone attachment
|
|
if (current_node == nullptr && active_skeleton != nullptr && gltf_node->skin < 0) {
|
|
BoneAttachment3D *bone_attachment = _generate_bone_attachment(state, active_skeleton, node_index);
|
|
|
|
scene_parent->add_child(bone_attachment);
|
|
bone_attachment->set_owner(scene_root);
|
|
|
|
// There is no gltf_node that represent this, so just directly create a unique name
|
|
bone_attachment->set_name(_gen_unique_name(state, "BoneAttachment"));
|
|
|
|
// We change the scene_parent to our bone attachment now. We do not set current_node because we want to make the node
|
|
// and attach it to the bone_attachment
|
|
scene_parent = bone_attachment;
|
|
}
|
|
|
|
// We still have not managed to make a node
|
|
if (current_node == nullptr) {
|
|
if (gltf_node->mesh >= 0) {
|
|
current_node = _generate_mesh_instance(state, scene_parent, node_index);
|
|
} else if (gltf_node->camera >= 0) {
|
|
current_node = _generate_camera(state, scene_parent, node_index);
|
|
} else {
|
|
current_node = _generate_spatial(state, scene_parent, node_index);
|
|
}
|
|
|
|
scene_parent->add_child(current_node);
|
|
current_node->set_owner(scene_root);
|
|
current_node->set_transform(gltf_node->xform);
|
|
current_node->set_name(gltf_node->name);
|
|
}
|
|
|
|
state.scene_nodes.insert(node_index, current_node);
|
|
|
|
for (int i = 0; i < gltf_node->children.size(); ++i) {
|
|
_generate_scene_node(state, current_node, scene_root, gltf_node->children[i]);
|
|
}
|
|
}
|
|
|
|
template <class T>
|
|
struct EditorSceneImporterGLTFInterpolate {
|
|
T lerp(const T &a, const T &b, float c) const {
|
|
return a + (b - a) * c;
|
|
}
|
|
|
|
T catmull_rom(const T &p0, const T &p1, const T &p2, const T &p3, float t) {
|
|
const float t2 = t * t;
|
|
const float t3 = t2 * t;
|
|
|
|
return 0.5f * ((2.0f * p1) + (-p0 + p2) * t + (2.0f * p0 - 5.0f * p1 + 4.0f * p2 - p3) * t2 + (-p0 + 3.0f * p1 - 3.0f * p2 + p3) * t3);
|
|
}
|
|
|
|
T bezier(T start, T control_1, T control_2, T end, float t) {
|
|
/* Formula from Wikipedia article on Bezier curves. */
|
|
const real_t omt = (1.0 - t);
|
|
const real_t omt2 = omt * omt;
|
|
const real_t omt3 = omt2 * omt;
|
|
const real_t t2 = t * t;
|
|
const real_t t3 = t2 * t;
|
|
|
|
return start * omt3 + control_1 * omt2 * t * 3.0 + control_2 * omt * t2 * 3.0 + end * t3;
|
|
}
|
|
};
|
|
|
|
// thank you for existing, partial specialization
|
|
template <>
|
|
struct EditorSceneImporterGLTFInterpolate<Quat> {
|
|
Quat lerp(const Quat &a, const Quat &b, const float c) const {
|
|
ERR_FAIL_COND_V_MSG(!a.is_normalized(), Quat(), "The quaternion \"a\" must be normalized.");
|
|
ERR_FAIL_COND_V_MSG(!b.is_normalized(), Quat(), "The quaternion \"b\" must be normalized.");
|
|
|
|
return a.slerp(b, c).normalized();
|
|
}
|
|
|
|
Quat catmull_rom(const Quat &p0, const Quat &p1, const Quat &p2, const Quat &p3, const float c) {
|
|
ERR_FAIL_COND_V_MSG(!p1.is_normalized(), Quat(), "The quaternion \"p1\" must be normalized.");
|
|
ERR_FAIL_COND_V_MSG(!p2.is_normalized(), Quat(), "The quaternion \"p2\" must be normalized.");
|
|
|
|
return p1.slerp(p2, c).normalized();
|
|
}
|
|
|
|
Quat bezier(const Quat start, const Quat control_1, const Quat control_2, const Quat end, const float t) {
|
|
ERR_FAIL_COND_V_MSG(!start.is_normalized(), Quat(), "The start quaternion must be normalized.");
|
|
ERR_FAIL_COND_V_MSG(!end.is_normalized(), Quat(), "The end quaternion must be normalized.");
|
|
|
|
return start.slerp(end, t).normalized();
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
T EditorSceneImporterGLTF::_interpolate_track(const Vector<float> &p_times, const Vector<T> &p_values, const float p_time, const GLTFAnimation::Interpolation p_interp) {
|
|
//could use binary search, worth it?
|
|
int idx = -1;
|
|
for (int i = 0; i < p_times.size(); i++) {
|
|
if (p_times[i] > p_time)
|
|
break;
|
|
idx++;
|
|
}
|
|
|
|
EditorSceneImporterGLTFInterpolate<T> interp;
|
|
|
|
switch (p_interp) {
|
|
case GLTFAnimation::INTERP_LINEAR: {
|
|
if (idx == -1) {
|
|
return p_values[0];
|
|
} else if (idx >= p_times.size() - 1) {
|
|
return p_values[p_times.size() - 1];
|
|
}
|
|
|
|
const float c = (p_time - p_times[idx]) / (p_times[idx + 1] - p_times[idx]);
|
|
|
|
return interp.lerp(p_values[idx], p_values[idx + 1], c);
|
|
|
|
} break;
|
|
case GLTFAnimation::INTERP_STEP: {
|
|
if (idx == -1) {
|
|
return p_values[0];
|
|
} else if (idx >= p_times.size() - 1) {
|
|
return p_values[p_times.size() - 1];
|
|
}
|
|
|
|
return p_values[idx];
|
|
|
|
} break;
|
|
case GLTFAnimation::INTERP_CATMULLROMSPLINE: {
|
|
if (idx == -1) {
|
|
return p_values[1];
|
|
} else if (idx >= p_times.size() - 1) {
|
|
return p_values[1 + p_times.size() - 1];
|
|
}
|
|
|
|
const float c = (p_time - p_times[idx]) / (p_times[idx + 1] - p_times[idx]);
|
|
|
|
return interp.catmull_rom(p_values[idx - 1], p_values[idx], p_values[idx + 1], p_values[idx + 3], c);
|
|
|
|
} break;
|
|
case GLTFAnimation::INTERP_CUBIC_SPLINE: {
|
|
if (idx == -1) {
|
|
return p_values[1];
|
|
} else if (idx >= p_times.size() - 1) {
|
|
return p_values[(p_times.size() - 1) * 3 + 1];
|
|
}
|
|
|
|
const float c = (p_time - p_times[idx]) / (p_times[idx + 1] - p_times[idx]);
|
|
|
|
const T from = p_values[idx * 3 + 1];
|
|
const T c1 = from + p_values[idx * 3 + 2];
|
|
const T to = p_values[idx * 3 + 4];
|
|
const T c2 = to + p_values[idx * 3 + 3];
|
|
|
|
return interp.bezier(from, c1, c2, to, c);
|
|
|
|
} break;
|
|
}
|
|
|
|
ERR_FAIL_V(p_values[0]);
|
|
}
|
|
|
|
void EditorSceneImporterGLTF::_import_animation(GLTFState &state, AnimationPlayer *ap, const GLTFAnimationIndex index, const int bake_fps) {
|
|
const GLTFAnimation &anim = state.animations[index];
|
|
|
|
String name = anim.name;
|
|
if (name.empty()) {
|
|
// No node represent these, and they are not in the hierarchy, so just make a unique name
|
|
name = _gen_unique_name(state, "Animation");
|
|
}
|
|
|
|
Ref<Animation> animation;
|
|
animation.instance();
|
|
animation->set_name(name);
|
|
|
|
if (anim.loop) {
|
|
animation->set_loop(true);
|
|
}
|
|
|
|
float length = 0;
|
|
|
|
for (Map<int, GLTFAnimation::Track>::Element *E = anim.tracks.front(); E; E = E->next()) {
|
|
const GLTFAnimation::Track &track = E->get();
|
|
//need to find the path
|
|
NodePath node_path;
|
|
|
|
GLTFNodeIndex node_index = E->key();
|
|
if (state.nodes[node_index]->fake_joint_parent >= 0) {
|
|
// Should be same as parent
|
|
node_index = state.nodes[node_index]->fake_joint_parent;
|
|
}
|
|
|
|
const GLTFNode *node = state.nodes[E->key()];
|
|
|
|
if (node->skeleton >= 0) {
|
|
const Skeleton3D *sk = Object::cast_to<Skeleton3D>(state.scene_nodes.find(node_index)->get());
|
|
ERR_FAIL_COND(sk == nullptr);
|
|
|
|
const String path = ap->get_parent()->get_path_to(sk);
|
|
const String bone = node->name;
|
|
node_path = path + ":" + bone;
|
|
} else {
|
|
node_path = ap->get_parent()->get_path_to(state.scene_nodes.find(node_index)->get());
|
|
}
|
|
|
|
for (int i = 0; i < track.rotation_track.times.size(); i++) {
|
|
length = MAX(length, track.rotation_track.times[i]);
|
|
}
|
|
for (int i = 0; i < track.translation_track.times.size(); i++) {
|
|
length = MAX(length, track.translation_track.times[i]);
|
|
}
|
|
for (int i = 0; i < track.scale_track.times.size(); i++) {
|
|
length = MAX(length, track.scale_track.times[i]);
|
|
}
|
|
|
|
for (int i = 0; i < track.weight_tracks.size(); i++) {
|
|
for (int j = 0; j < track.weight_tracks[i].times.size(); j++) {
|
|
length = MAX(length, track.weight_tracks[i].times[j]);
|
|
}
|
|
}
|
|
|
|
if (track.rotation_track.values.size() || track.translation_track.values.size() || track.scale_track.values.size()) {
|
|
//make transform track
|
|
int track_idx = animation->get_track_count();
|
|
animation->add_track(Animation::TYPE_TRANSFORM);
|
|
animation->track_set_path(track_idx, node_path);
|
|
//first determine animation length
|
|
|
|
const float increment = 1.0 / float(bake_fps);
|
|
float time = 0.0;
|
|
|
|
Vector3 base_pos;
|
|
Quat base_rot;
|
|
Vector3 base_scale = Vector3(1, 1, 1);
|
|
|
|
if (!track.rotation_track.values.size()) {
|
|
base_rot = state.nodes[E->key()]->rotation.normalized();
|
|
}
|
|
|
|
if (!track.translation_track.values.size()) {
|
|
base_pos = state.nodes[E->key()]->translation;
|
|
}
|
|
|
|
if (!track.scale_track.values.size()) {
|
|
base_scale = state.nodes[E->key()]->scale;
|
|
}
|
|
|
|
bool last = false;
|
|
while (true) {
|
|
Vector3 pos = base_pos;
|
|
Quat rot = base_rot;
|
|
Vector3 scale = base_scale;
|
|
|
|
if (track.translation_track.times.size()) {
|
|
pos = _interpolate_track<Vector3>(track.translation_track.times, track.translation_track.values, time, track.translation_track.interpolation);
|
|
}
|
|
|
|
if (track.rotation_track.times.size()) {
|
|
rot = _interpolate_track<Quat>(track.rotation_track.times, track.rotation_track.values, time, track.rotation_track.interpolation);
|
|
}
|
|
|
|
if (track.scale_track.times.size()) {
|
|
scale = _interpolate_track<Vector3>(track.scale_track.times, track.scale_track.values, time, track.scale_track.interpolation);
|
|
}
|
|
|
|
if (node->skeleton >= 0) {
|
|
Transform xform;
|
|
xform.basis.set_quat_scale(rot, scale);
|
|
xform.origin = pos;
|
|
|
|
const Skeleton3D *skeleton = state.skeletons[node->skeleton].godot_skeleton;
|
|
const int bone_idx = skeleton->find_bone(node->name);
|
|
xform = skeleton->get_bone_rest(bone_idx).affine_inverse() * xform;
|
|
|
|
rot = xform.basis.get_rotation_quat();
|
|
rot.normalize();
|
|
scale = xform.basis.get_scale();
|
|
pos = xform.origin;
|
|
}
|
|
|
|
animation->transform_track_insert_key(track_idx, time, pos, rot, scale);
|
|
|
|
if (last) {
|
|
break;
|
|
}
|
|
time += increment;
|
|
if (time >= length) {
|
|
last = true;
|
|
time = length;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < track.weight_tracks.size(); i++) {
|
|
ERR_CONTINUE(node->mesh < 0 || node->mesh >= state.meshes.size());
|
|
const GLTFMesh &mesh = state.meshes[node->mesh];
|
|
const String prop = "blend_shapes/" + mesh.mesh->get_blend_shape_name(i);
|
|
|
|
const String blend_path = String(node_path) + ":" + prop;
|
|
|
|
const int track_idx = animation->get_track_count();
|
|
animation->add_track(Animation::TYPE_VALUE);
|
|
animation->track_set_path(track_idx, blend_path);
|
|
|
|
// Only LINEAR and STEP (NEAREST) can be supported out of the box by Godot's Animation,
|
|
// the other modes have to be baked.
|
|
GLTFAnimation::Interpolation gltf_interp = track.weight_tracks[i].interpolation;
|
|
if (gltf_interp == GLTFAnimation::INTERP_LINEAR || gltf_interp == GLTFAnimation::INTERP_STEP) {
|
|
animation->track_set_interpolation_type(track_idx, gltf_interp == GLTFAnimation::INTERP_STEP ? Animation::INTERPOLATION_NEAREST : Animation::INTERPOLATION_LINEAR);
|
|
for (int j = 0; j < track.weight_tracks[i].times.size(); j++) {
|
|
const float t = track.weight_tracks[i].times[j];
|
|
const float w = track.weight_tracks[i].values[j];
|
|
animation->track_insert_key(track_idx, t, w);
|
|
}
|
|
} else {
|
|
// CATMULLROMSPLINE or CUBIC_SPLINE have to be baked, apologies.
|
|
const float increment = 1.0 / float(bake_fps);
|
|
float time = 0.0;
|
|
bool last = false;
|
|
while (true) {
|
|
_interpolate_track<float>(track.weight_tracks[i].times, track.weight_tracks[i].values, time, gltf_interp);
|
|
if (last) {
|
|
break;
|
|
}
|
|
time += increment;
|
|
if (time >= length) {
|
|
last = true;
|
|
time = length;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
animation->set_length(length);
|
|
|
|
ap->add_animation(name, animation);
|
|
}
|
|
|
|
void EditorSceneImporterGLTF::_process_mesh_instances(GLTFState &state, Node3D *scene_root) {
|
|
for (GLTFNodeIndex node_i = 0; node_i < state.nodes.size(); ++node_i) {
|
|
const GLTFNode *node = state.nodes[node_i];
|
|
|
|
if (node->skin >= 0 && node->mesh >= 0) {
|
|
const GLTFSkinIndex skin_i = node->skin;
|
|
|
|
Map<GLTFNodeIndex, Node *>::Element *mi_element = state.scene_nodes.find(node_i);
|
|
MeshInstance3D *mi = Object::cast_to<MeshInstance3D>(mi_element->get());
|
|
ERR_FAIL_COND(mi == nullptr);
|
|
|
|
const GLTFSkeletonIndex skel_i = state.skins[node->skin].skeleton;
|
|
const GLTFSkeleton &gltf_skeleton = state.skeletons[skel_i];
|
|
Skeleton3D *skeleton = gltf_skeleton.godot_skeleton;
|
|
ERR_FAIL_COND(skeleton == nullptr);
|
|
|
|
mi->get_parent()->remove_child(mi);
|
|
skeleton->add_child(mi);
|
|
mi->set_owner(scene_root);
|
|
|
|
mi->set_skin(state.skins[skin_i].godot_skin);
|
|
mi->set_skeleton_path(mi->get_path_to(skeleton));
|
|
mi->set_transform(Transform());
|
|
}
|
|
}
|
|
}
|
|
|
|
Node3D *EditorSceneImporterGLTF::_generate_scene(GLTFState &state, const int p_bake_fps) {
|
|
Node3D *root = memnew(Node3D);
|
|
|
|
// scene_name is already unique
|
|
root->set_name(state.scene_name);
|
|
|
|
for (int i = 0; i < state.root_nodes.size(); ++i) {
|
|
_generate_scene_node(state, root, root, state.root_nodes[i]);
|
|
}
|
|
|
|
_process_mesh_instances(state, root);
|
|
|
|
if (state.animations.size()) {
|
|
AnimationPlayer *ap = memnew(AnimationPlayer);
|
|
ap->set_name("AnimationPlayer");
|
|
root->add_child(ap);
|
|
ap->set_owner(root);
|
|
|
|
for (int i = 0; i < state.animations.size(); i++) {
|
|
_import_animation(state, ap, i, p_bake_fps);
|
|
}
|
|
}
|
|
|
|
return root;
|
|
}
|
|
|
|
Node *EditorSceneImporterGLTF::import_scene(const String &p_path, uint32_t p_flags, int p_bake_fps, List<String> *r_missing_deps, Error *r_err) {
|
|
GLTFState state;
|
|
|
|
if (p_path.to_lower().ends_with("glb")) {
|
|
//binary file
|
|
//text file
|
|
Error err = _parse_glb(p_path, state);
|
|
if (err)
|
|
return nullptr;
|
|
} else {
|
|
//text file
|
|
Error err = _parse_json(p_path, state);
|
|
if (err)
|
|
return nullptr;
|
|
}
|
|
|
|
ERR_FAIL_COND_V(!state.json.has("asset"), nullptr);
|
|
|
|
Dictionary asset = state.json["asset"];
|
|
|
|
ERR_FAIL_COND_V(!asset.has("version"), nullptr);
|
|
|
|
String version = asset["version"];
|
|
|
|
state.major_version = version.get_slice(".", 0).to_int();
|
|
state.minor_version = version.get_slice(".", 1).to_int();
|
|
state.use_named_skin_binds = p_flags & IMPORT_USE_NAMED_SKIN_BINDS;
|
|
|
|
/* STEP 0 PARSE SCENE */
|
|
Error err = _parse_scenes(state);
|
|
if (err != OK)
|
|
return nullptr;
|
|
|
|
/* STEP 1 PARSE NODES */
|
|
err = _parse_nodes(state);
|
|
if (err != OK)
|
|
return nullptr;
|
|
|
|
/* STEP 2 PARSE BUFFERS */
|
|
err = _parse_buffers(state, p_path.get_base_dir());
|
|
if (err != OK)
|
|
return nullptr;
|
|
|
|
/* STEP 3 PARSE BUFFER VIEWS */
|
|
err = _parse_buffer_views(state);
|
|
if (err != OK)
|
|
return nullptr;
|
|
|
|
/* STEP 4 PARSE ACCESSORS */
|
|
err = _parse_accessors(state);
|
|
if (err != OK)
|
|
return nullptr;
|
|
|
|
/* STEP 5 PARSE IMAGES */
|
|
err = _parse_images(state, p_path.get_base_dir());
|
|
if (err != OK)
|
|
return nullptr;
|
|
|
|
/* STEP 6 PARSE TEXTURES */
|
|
err = _parse_textures(state);
|
|
if (err != OK)
|
|
return nullptr;
|
|
|
|
/* STEP 7 PARSE TEXTURES */
|
|
err = _parse_materials(state);
|
|
if (err != OK)
|
|
return nullptr;
|
|
|
|
/* STEP 9 PARSE SKINS */
|
|
err = _parse_skins(state);
|
|
if (err != OK)
|
|
return nullptr;
|
|
|
|
/* STEP 10 DETERMINE SKELETONS */
|
|
err = _determine_skeletons(state);
|
|
if (err != OK)
|
|
return nullptr;
|
|
|
|
/* STEP 11 CREATE SKELETONS */
|
|
err = _create_skeletons(state);
|
|
if (err != OK)
|
|
return nullptr;
|
|
|
|
/* STEP 12 CREATE SKINS */
|
|
err = _create_skins(state);
|
|
if (err != OK)
|
|
return nullptr;
|
|
|
|
/* STEP 13 PARSE MESHES (we have enough info now) */
|
|
err = _parse_meshes(state);
|
|
if (err != OK)
|
|
return nullptr;
|
|
|
|
/* STEP 14 PARSE CAMERAS */
|
|
err = _parse_cameras(state);
|
|
if (err != OK)
|
|
return nullptr;
|
|
|
|
/* STEP 15 PARSE ANIMATIONS */
|
|
err = _parse_animations(state);
|
|
if (err != OK)
|
|
return nullptr;
|
|
|
|
/* STEP 16 ASSIGN SCENE NAMES */
|
|
_assign_scene_names(state);
|
|
|
|
/* STEP 17 MAKE SCENE! */
|
|
Node3D *scene = _generate_scene(state, p_bake_fps);
|
|
|
|
return scene;
|
|
}
|
|
|
|
Ref<Animation> EditorSceneImporterGLTF::import_animation(const String &p_path, uint32_t p_flags, int p_bake_fps) {
|
|
return Ref<Animation>();
|
|
}
|
|
|
|
EditorSceneImporterGLTF::EditorSceneImporterGLTF() {
|
|
}
|