mirror of
https://github.com/godotengine/godot.git
synced 2024-12-27 11:24:59 +08:00
095569011c
Turns out that the information in FBX Pose objects is relatively often broken. Using skin cluster bind poses seems more reliable, but cannot capture the bind pose of the root bone.
2451 lines
90 KiB
C++
2451 lines
90 KiB
C++
/**************************************************************************/
|
|
/* fbx_document.cpp */
|
|
/**************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/**************************************************************************/
|
|
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
|
|
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* 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 "fbx_document.h"
|
|
|
|
#include "core/config/project_settings.h"
|
|
#include "core/crypto/crypto_core.h"
|
|
#include "core/io/config_file.h"
|
|
#include "core/io/file_access.h"
|
|
#include "core/io/file_access_memory.h"
|
|
#include "core/io/image.h"
|
|
#include "core/math/color.h"
|
|
#include "scene/3d/bone_attachment_3d.h"
|
|
#include "scene/3d/camera_3d.h"
|
|
#include "scene/3d/importer_mesh_instance_3d.h"
|
|
#include "scene/3d/light_3d.h"
|
|
#include "scene/resources/image_texture.h"
|
|
#include "scene/resources/material.h"
|
|
#include "scene/resources/portable_compressed_texture.h"
|
|
#include "scene/resources/surface_tool.h"
|
|
|
|
#include "modules/gltf/extensions/gltf_light.h"
|
|
#include "modules/gltf/gltf_defines.h"
|
|
#include "modules/gltf/skin_tool.h"
|
|
#include "modules/gltf/structures/gltf_animation.h"
|
|
#include "modules/gltf/structures/gltf_camera.h"
|
|
|
|
#ifdef TOOLS_ENABLED
|
|
#include "editor/editor_file_system.h"
|
|
#endif
|
|
|
|
// FIXME: Hardcoded to avoid editor dependency.
|
|
#define FBX_IMPORT_USE_NAMED_SKIN_BINDS 16
|
|
#define FBX_IMPORT_DISCARD_MESHES_AND_MATERIALS 32
|
|
#define FBX_IMPORT_FORCE_DISABLE_MESH_COMPRESSION 64
|
|
|
|
#include <ufbx.h>
|
|
|
|
static size_t _file_access_read_fn(void *user, void *data, size_t size) {
|
|
FileAccess *file = static_cast<FileAccess *>(user);
|
|
return (size_t)file->get_buffer((uint8_t *)data, (uint64_t)size);
|
|
}
|
|
|
|
static bool _file_access_skip_fn(void *user, size_t size) {
|
|
FileAccess *file = static_cast<FileAccess *>(user);
|
|
file->seek(file->get_position() + size);
|
|
return true;
|
|
}
|
|
|
|
static Vector2 _as_vec2(const ufbx_vec2 &p_vector) {
|
|
return Vector2(real_t(p_vector.x), real_t(p_vector.y));
|
|
}
|
|
|
|
static Color _as_color(const ufbx_vec4 &p_vector) {
|
|
return Color(real_t(p_vector.x), real_t(p_vector.y), real_t(p_vector.z), real_t(p_vector.w));
|
|
}
|
|
|
|
static Quaternion _as_quaternion(const ufbx_quat &p_quat) {
|
|
return Quaternion(real_t(p_quat.x), real_t(p_quat.y), real_t(p_quat.z), real_t(p_quat.w));
|
|
}
|
|
|
|
static Transform3D _as_transform(const ufbx_transform &p_xform) {
|
|
Transform3D result;
|
|
result.origin = FBXDocument::_as_vec3(p_xform.translation);
|
|
result.basis.set_quaternion_scale(_as_quaternion(p_xform.rotation), FBXDocument::_as_vec3(p_xform.scale));
|
|
return result;
|
|
}
|
|
|
|
static real_t _relative_error(const Vector3 &p_a, const Vector3 &p_b) {
|
|
return p_a.distance_to(p_b) / MAX(p_a.length(), p_b.length());
|
|
}
|
|
|
|
static Color _material_color(const ufbx_material_map &p_map) {
|
|
if (p_map.value_components == 1) {
|
|
float r = float(p_map.value_real);
|
|
return Color(r, r, r);
|
|
} else if (p_map.value_components == 3) {
|
|
float r = float(p_map.value_vec3.x);
|
|
float g = float(p_map.value_vec3.y);
|
|
float b = float(p_map.value_vec3.z);
|
|
return Color(r, g, b);
|
|
} else {
|
|
float r = float(p_map.value_vec4.x);
|
|
float g = float(p_map.value_vec4.y);
|
|
float b = float(p_map.value_vec4.z);
|
|
float a = float(p_map.value_vec4.z);
|
|
return Color(r, g, b, a);
|
|
}
|
|
}
|
|
|
|
static Color _material_color(const ufbx_material_map &p_map, const ufbx_material_map &p_factor) {
|
|
Color color = _material_color(p_map);
|
|
if (p_factor.has_value) {
|
|
float factor = float(p_factor.value_real);
|
|
color.r *= factor;
|
|
color.g *= factor;
|
|
color.b *= factor;
|
|
}
|
|
return color;
|
|
}
|
|
|
|
static const ufbx_texture *_get_file_texture(const ufbx_texture *p_texture) {
|
|
if (!p_texture) {
|
|
return nullptr;
|
|
}
|
|
for (const ufbx_texture *texture : p_texture->file_textures) {
|
|
if (texture->file_index != UFBX_NO_INDEX) {
|
|
return texture;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
static Ref<Image> _get_decompressed_image(Ref<Texture2D> texture) {
|
|
if (texture.is_null()) {
|
|
return Ref<Image>();
|
|
}
|
|
Ref<Image> image = texture->get_image();
|
|
if (image.is_null()) {
|
|
return Ref<Image>();
|
|
}
|
|
image = image->duplicate();
|
|
image->decompress();
|
|
return image;
|
|
}
|
|
|
|
static Vector<Vector2> _decode_vertex_attrib_vec2(const ufbx_vertex_vec2 &p_attrib, const Vector<uint32_t> &p_indices) {
|
|
Vector<Vector2> ret;
|
|
|
|
int num_indices = p_indices.size();
|
|
ret.resize(num_indices);
|
|
for (int i = 0; i < num_indices; i++) {
|
|
ret.write[i] = _as_vec2(p_attrib[p_indices[i]]);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static Vector<Vector3> _decode_vertex_attrib_vec3(const ufbx_vertex_vec3 &p_attrib, const Vector<uint32_t> &p_indices) {
|
|
Vector<Vector3> ret;
|
|
|
|
int num_indices = p_indices.size();
|
|
ret.resize(num_indices);
|
|
for (int i = 0; i < num_indices; i++) {
|
|
ret.write[i] = FBXDocument::_as_vec3(p_attrib[p_indices[i]]);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static Vector<float> _decode_vertex_attrib_vec3_as_tangent(const ufbx_vertex_vec3 &p_attrib, const Vector<uint32_t> &p_indices) {
|
|
Vector<float> ret;
|
|
|
|
int num_indices = p_indices.size();
|
|
ret.resize(num_indices * 4);
|
|
for (int i = 0; i < num_indices; i++) {
|
|
Vector3 v = FBXDocument::_as_vec3(p_attrib[p_indices[i]]);
|
|
ret.write[i * 4 + 0] = v.x;
|
|
ret.write[i * 4 + 1] = v.y;
|
|
ret.write[i * 4 + 2] = v.z;
|
|
ret.write[i * 4 + 3] = 1.0f;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static Vector<Color> _decode_vertex_attrib_color(const ufbx_vertex_vec4 &p_attrib, const Vector<uint32_t> &p_indices) {
|
|
Vector<Color> ret;
|
|
|
|
int num_indices = p_indices.size();
|
|
ret.resize(num_indices);
|
|
for (int i = 0; i < num_indices; i++) {
|
|
ret.write[i] = _as_color(p_attrib[p_indices[i]]);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static Vector3 _encode_vertex_index(uint32_t p_index) {
|
|
return Vector3(real_t(p_index & 0xffff), real_t(p_index >> 16), 0.0f);
|
|
}
|
|
|
|
static uint32_t _decode_vertex_index(const Vector3 &p_vertex) {
|
|
return uint32_t(p_vertex.x) | uint32_t(p_vertex.y) << 16;
|
|
}
|
|
|
|
static ufbx_skin_deformer *_find_skin_deformer(ufbx_skin_cluster *p_cluster) {
|
|
for (const ufbx_connection &conn : p_cluster->element.connections_src) {
|
|
ufbx_skin_deformer *deformer = ufbx_as_skin_deformer(conn.dst);
|
|
if (deformer) {
|
|
return deformer;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
struct ThreadPoolFBX {
|
|
struct Group {
|
|
ufbx_thread_pool_context ctx = {};
|
|
WorkerThreadPool::GroupID task_id = {};
|
|
uint32_t start_index = 0;
|
|
};
|
|
|
|
WorkerThreadPool *pool = nullptr;
|
|
Group groups[UFBX_THREAD_GROUP_COUNT] = {};
|
|
};
|
|
|
|
static void _thread_pool_task(void *user, uint32_t index) {
|
|
ThreadPoolFBX::Group *group = (ThreadPoolFBX::Group *)user;
|
|
ufbx_thread_pool_run_task(group->ctx, group->start_index + index);
|
|
}
|
|
|
|
static bool _thread_pool_init_fn(void *user, ufbx_thread_pool_context ctx, const ufbx_thread_pool_info *info) {
|
|
ThreadPoolFBX *pool = (ThreadPoolFBX *)user;
|
|
for (ThreadPoolFBX::Group &group : pool->groups) {
|
|
group.ctx = ctx;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool _thread_pool_run_fn(void *user, ufbx_thread_pool_context ctx, uint32_t group, uint32_t start_index, uint32_t count) {
|
|
ThreadPoolFBX *pool = (ThreadPoolFBX *)user;
|
|
ThreadPoolFBX::Group &pool_group = pool->groups[group];
|
|
pool_group.start_index = start_index;
|
|
pool_group.task_id = pool->pool->add_native_group_task(_thread_pool_task, &pool_group, (int)count, -1, true, "ufbx");
|
|
return true;
|
|
}
|
|
|
|
static bool _thread_pool_wait_fn(void *user, ufbx_thread_pool_context ctx, uint32_t group, uint32_t max_index) {
|
|
ThreadPoolFBX *pool = (ThreadPoolFBX *)user;
|
|
pool->pool->wait_for_group_task_completion(pool->groups[group].task_id);
|
|
return true;
|
|
}
|
|
|
|
String FBXDocument::_gen_unique_name(HashSet<String> &unique_names, const String &p_name) {
|
|
const String s_name = p_name.validate_node_name();
|
|
|
|
String u_name;
|
|
int index = 1;
|
|
while (true) {
|
|
u_name = s_name;
|
|
|
|
if (index > 1) {
|
|
u_name += itos(index);
|
|
}
|
|
if (!unique_names.has(u_name)) {
|
|
break;
|
|
}
|
|
index++;
|
|
}
|
|
|
|
unique_names.insert(u_name);
|
|
|
|
return u_name;
|
|
}
|
|
|
|
String FBXDocument::_sanitize_animation_name(const String &p_name) {
|
|
// Animations disallow the normal node invalid characters as well as "," and "["
|
|
// (See animation/animation_player.cpp::add_animation)
|
|
|
|
// TODO: Consider adding invalid_characters or a validate_animation_name to animation_player to mirror Node.
|
|
String anim_name = p_name.validate_node_name();
|
|
anim_name = anim_name.replace(",", "");
|
|
anim_name = anim_name.replace("[", "");
|
|
return anim_name;
|
|
}
|
|
|
|
String FBXDocument::_gen_unique_animation_name(Ref<FBXState> p_state, const String &p_name) {
|
|
const String s_name = _sanitize_animation_name(p_name);
|
|
|
|
String u_name;
|
|
int index = 1;
|
|
while (true) {
|
|
u_name = s_name;
|
|
|
|
if (index > 1) {
|
|
u_name += itos(index);
|
|
}
|
|
if (!p_state->unique_animation_names.has(u_name)) {
|
|
break;
|
|
}
|
|
index++;
|
|
}
|
|
|
|
p_state->unique_animation_names.insert(u_name);
|
|
|
|
return u_name;
|
|
}
|
|
|
|
Error FBXDocument::_parse_scenes(Ref<FBXState> p_state) {
|
|
p_state->unique_names.insert("Skeleton3D"); // Reserve skeleton name.
|
|
|
|
const ufbx_scene *fbx_scene = p_state->scene.get();
|
|
|
|
// TODO: Multi-document support, would need test files for structure
|
|
p_state->scene_name = "";
|
|
|
|
// TODO: Append the root node directly if we use root-based space conversion
|
|
for (const ufbx_node *root_node : fbx_scene->root_node->children) {
|
|
p_state->root_nodes.push_back(int(root_node->typed_id));
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error FBXDocument::_parse_nodes(Ref<FBXState> p_state) {
|
|
const ufbx_scene *fbx_scene = p_state->scene.get();
|
|
|
|
for (int node_i = 0; node_i < static_cast<int>(fbx_scene->nodes.count); node_i++) {
|
|
const ufbx_node *fbx_node = fbx_scene->nodes[node_i];
|
|
|
|
Ref<GLTFNode> node;
|
|
node.instantiate();
|
|
|
|
node->height = int(fbx_node->node_depth);
|
|
|
|
if (fbx_node->name.length > 0) {
|
|
node->set_name(_as_string(fbx_node->name));
|
|
node->set_original_name(node->get_name());
|
|
} else if (fbx_node->is_root) {
|
|
node->set_name("RootNode");
|
|
}
|
|
if (fbx_node->camera) {
|
|
node->camera = fbx_node->camera->typed_id;
|
|
}
|
|
if (fbx_node->light) {
|
|
node->light = fbx_node->light->typed_id;
|
|
}
|
|
if (fbx_node->mesh) {
|
|
node->mesh = fbx_node->mesh->typed_id;
|
|
}
|
|
|
|
{
|
|
node->transform = _as_transform(fbx_node->local_transform);
|
|
|
|
bool found_rest_xform = false;
|
|
bool bad_rest_xform = false;
|
|
Transform3D candidate_rest_xform;
|
|
|
|
if (fbx_node->parent) {
|
|
// Attempt to resolve a rest pose for bones: This uses internal FBX connections to find
|
|
// all skin clusters connected to the bone.
|
|
for (const ufbx_connection &child_conn : fbx_node->element.connections_src) {
|
|
ufbx_skin_cluster *child_cluster = ufbx_as_skin_cluster(child_conn.dst);
|
|
if (!child_cluster)
|
|
continue;
|
|
ufbx_skin_deformer *child_deformer = _find_skin_deformer(child_cluster);
|
|
if (!child_deformer)
|
|
continue;
|
|
|
|
// Found a skin cluster: Now iterate through all the skin clusters of the parent and
|
|
// try to find one that used by the same deformer.
|
|
for (const ufbx_connection &parent_conn : fbx_node->parent->element.connections_src) {
|
|
ufbx_skin_cluster *parent_cluster = ufbx_as_skin_cluster(parent_conn.dst);
|
|
if (!parent_cluster)
|
|
continue;
|
|
ufbx_skin_deformer *parent_deformer = _find_skin_deformer(parent_cluster);
|
|
if (parent_deformer != child_deformer)
|
|
continue;
|
|
|
|
// Success: Found two skin clusters from the same deformer, now we can resolve the
|
|
// local bind pose from the difference between the two world-space bind poses.
|
|
ufbx_matrix child_to_world = child_cluster->bind_to_world;
|
|
ufbx_matrix world_to_parent = ufbx_matrix_invert(&parent_cluster->bind_to_world);
|
|
ufbx_matrix child_to_parent = ufbx_matrix_mul(&world_to_parent, &child_to_world);
|
|
Transform3D xform = _as_transform(ufbx_matrix_to_transform(&child_to_parent));
|
|
|
|
if (!found_rest_xform) {
|
|
// Found the first bind pose for the node, assume that this one is good
|
|
found_rest_xform = true;
|
|
candidate_rest_xform = xform;
|
|
} else if (!bad_rest_xform) {
|
|
// Found another: Let's hope it's similar to the previous one, if not warn and
|
|
// use the initial pose, which is used by default if rest pose is not found.
|
|
real_t error = 0.0f;
|
|
error += _relative_error(candidate_rest_xform.origin, xform.origin);
|
|
for (int i = 0; i < 3; i++) {
|
|
error += _relative_error(candidate_rest_xform.basis.rows[i], xform.basis.rows[i]);
|
|
}
|
|
const real_t max_error = 0.01f;
|
|
if (error >= max_error) {
|
|
WARN_PRINT(vformat("FBX: Node '%s' has multiple bind poses, using initial pose as rest pose.", node->get_name()));
|
|
bad_rest_xform = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Transform3D godot_rest_xform = node->transform;
|
|
if (found_rest_xform && !bad_rest_xform) {
|
|
godot_rest_xform = candidate_rest_xform;
|
|
}
|
|
node->set_additional_data("GODOT_rest_transform", godot_rest_xform);
|
|
}
|
|
|
|
for (const ufbx_node *child : fbx_node->children) {
|
|
node->children.push_back(child->typed_id);
|
|
}
|
|
|
|
p_state->nodes.push_back(node);
|
|
}
|
|
|
|
// build the hierarchy
|
|
for (GLTFNodeIndex node_i = 0; node_i < p_state->nodes.size(); node_i++) {
|
|
for (int j = 0; j < p_state->nodes[node_i]->children.size(); j++) {
|
|
GLTFNodeIndex child_i = p_state->nodes[node_i]->children[j];
|
|
|
|
ERR_FAIL_INDEX_V(child_i, p_state->nodes.size(), ERR_FILE_CORRUPT);
|
|
ERR_CONTINUE(p_state->nodes[child_i]->parent != -1); //node already has a parent, wtf.
|
|
|
|
p_state->nodes.write[child_i]->parent = node_i;
|
|
}
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error FBXDocument::_parse_meshes(Ref<FBXState> p_state) {
|
|
ufbx_scene *fbx_scene = p_state->scene.get();
|
|
|
|
LocalVector<int> nodes_by_mesh_id;
|
|
nodes_by_mesh_id.reserve(fbx_scene->meshes.count);
|
|
for (size_t i = 0; i < fbx_scene->meshes.count; i++) {
|
|
nodes_by_mesh_id.push_back(-1);
|
|
}
|
|
for (int i = 0; i < p_state->nodes.size(); i++) {
|
|
const Ref<GLTFNode> &node = p_state->nodes[i];
|
|
if (node->mesh >= 0 && (unsigned)node->mesh < nodes_by_mesh_id.size()) {
|
|
nodes_by_mesh_id[node->mesh] = i;
|
|
}
|
|
}
|
|
|
|
for (const ufbx_mesh *fbx_mesh : fbx_scene->meshes) {
|
|
print_verbose("FBX: Parsing mesh: " + itos(int64_t(fbx_mesh->typed_id)));
|
|
|
|
static const Mesh::PrimitiveType primitive_types[] = {
|
|
Mesh::PRIMITIVE_TRIANGLES,
|
|
Mesh::PRIMITIVE_POINTS,
|
|
Mesh::PRIMITIVE_LINES,
|
|
};
|
|
|
|
Ref<ImporterMesh> import_mesh;
|
|
import_mesh.instantiate();
|
|
String mesh_name = "mesh";
|
|
String original_name;
|
|
if (fbx_mesh->name.length > 0) {
|
|
mesh_name = _as_string(fbx_mesh->name);
|
|
original_name = mesh_name;
|
|
} else if (fbx_mesh->typed_id < (unsigned)p_state->nodes.size() && nodes_by_mesh_id[fbx_mesh->typed_id] != -1) {
|
|
const Ref<GLTFNode> &node = p_state->nodes[nodes_by_mesh_id[fbx_mesh->typed_id]];
|
|
original_name = node->get_original_name();
|
|
mesh_name = node->get_name();
|
|
}
|
|
import_mesh->set_name(_gen_unique_name(p_state->unique_mesh_names, mesh_name));
|
|
|
|
bool use_blend_shapes = false;
|
|
if (fbx_mesh->blend_deformers.count > 0) {
|
|
use_blend_shapes = true;
|
|
}
|
|
|
|
Vector<float> blend_weights;
|
|
Vector<int> blend_channels;
|
|
if (use_blend_shapes) {
|
|
print_verbose("FBX: Mesh has targets");
|
|
|
|
import_mesh->set_blend_shape_mode(Mesh::BLEND_SHAPE_MODE_NORMALIZED);
|
|
|
|
for (const ufbx_blend_deformer *fbx_deformer : fbx_mesh->blend_deformers) {
|
|
for (const ufbx_blend_channel *fbx_channel : fbx_deformer->channels) {
|
|
if (fbx_channel->keyframes.count == 0) {
|
|
continue;
|
|
}
|
|
String bs_name;
|
|
if (fbx_channel->name.length > 0) {
|
|
bs_name = _as_string(fbx_channel->name);
|
|
} else {
|
|
bs_name = String("morph_") + itos(blend_channels.size());
|
|
}
|
|
import_mesh->add_blend_shape(bs_name);
|
|
blend_weights.push_back(float(fbx_channel->weight));
|
|
blend_channels.push_back(float(fbx_channel->typed_id));
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const ufbx_mesh_part &fbx_mesh_part : fbx_mesh->material_parts) {
|
|
for (Mesh::PrimitiveType primitive : primitive_types) {
|
|
uint32_t num_indices = 0;
|
|
switch (primitive) {
|
|
case Mesh::PRIMITIVE_POINTS:
|
|
num_indices = fbx_mesh_part.num_point_faces * 1;
|
|
break;
|
|
case Mesh::PRIMITIVE_LINES:
|
|
num_indices = fbx_mesh_part.num_line_faces * 2;
|
|
break;
|
|
case Mesh::PRIMITIVE_TRIANGLES:
|
|
num_indices = fbx_mesh_part.num_triangles * 3;
|
|
break;
|
|
case Mesh::PRIMITIVE_TRIANGLE_STRIP:
|
|
// FIXME 2021-09-15 fire
|
|
break;
|
|
case Mesh::PRIMITIVE_LINE_STRIP:
|
|
// FIXME 2021-09-15 fire
|
|
break;
|
|
default:
|
|
// FIXME 2021-09-15 fire
|
|
break;
|
|
}
|
|
if (num_indices == 0) {
|
|
continue;
|
|
}
|
|
|
|
Vector<uint32_t> indices;
|
|
indices.resize(num_indices);
|
|
|
|
uint32_t offset = 0;
|
|
for (uint32_t face_index : fbx_mesh_part.face_indices) {
|
|
ufbx_face face = fbx_mesh->faces[face_index];
|
|
switch (primitive) {
|
|
case Mesh::PRIMITIVE_POINTS: {
|
|
if (face.num_indices == 1) {
|
|
indices.write[offset] = face.index_begin;
|
|
offset += 1;
|
|
}
|
|
} break;
|
|
case Mesh::PRIMITIVE_LINES:
|
|
if (face.num_indices == 2) {
|
|
indices.write[offset] = face.index_begin;
|
|
indices.write[offset + 1] = face.index_begin + 1;
|
|
offset += 2;
|
|
}
|
|
break;
|
|
case Mesh::PRIMITIVE_TRIANGLES:
|
|
if (face.num_indices >= 3) {
|
|
uint32_t *dst = indices.ptrw() + offset;
|
|
size_t space = indices.size() - offset;
|
|
uint32_t num_triangles = ufbx_triangulate_face(dst, space, fbx_mesh, face);
|
|
offset += num_triangles * 3;
|
|
|
|
// Godot uses clockwise winding order!
|
|
for (uint32_t i = 0; i < num_triangles; i++) {
|
|
SWAP(dst[i * 3 + 0], dst[i * 3 + 2]);
|
|
}
|
|
}
|
|
break;
|
|
case Mesh::PRIMITIVE_TRIANGLE_STRIP:
|
|
// FIXME 2021-09-15 fire
|
|
break;
|
|
case Mesh::PRIMITIVE_LINE_STRIP:
|
|
// FIXME 2021-09-15 fire
|
|
break;
|
|
default:
|
|
// FIXME 2021-09-15 fire
|
|
break;
|
|
}
|
|
}
|
|
ERR_CONTINUE((uint64_t)offset != (uint64_t)indices.size());
|
|
|
|
int32_t vertex_num = indices.size();
|
|
bool has_vertex_color = false;
|
|
|
|
uint32_t flags = 0;
|
|
|
|
Array array;
|
|
array.resize(Mesh::ARRAY_MAX);
|
|
|
|
// HACK: If we have blend shapes we cannot merge vertices at identical positions
|
|
// if they have different indices in the file. To avoid this encode the vertex index
|
|
// into the vertex position for the time being.
|
|
// Ideally this would be an extra channel in the vertex but as the vertex format is
|
|
// fixed and we already use user data for extra UV channels this'll do.
|
|
if (use_blend_shapes) {
|
|
Vector<Vector3> vertex_indices;
|
|
int num_blend_shape_indices = indices.size();
|
|
vertex_indices.resize(num_blend_shape_indices);
|
|
for (int i = 0; i < num_blend_shape_indices; i++) {
|
|
vertex_indices.write[i] = _encode_vertex_index(fbx_mesh->vertex_indices[indices[i]]);
|
|
}
|
|
array[Mesh::ARRAY_VERTEX] = vertex_indices;
|
|
} else {
|
|
array[Mesh::ARRAY_VERTEX] = _decode_vertex_attrib_vec3(fbx_mesh->vertex_position, indices);
|
|
}
|
|
|
|
// Normals always exist as they're generated if missing,
|
|
// see `ufbx_load_opts.generate_missing_normals`.
|
|
Vector<Vector3> normals = _decode_vertex_attrib_vec3(fbx_mesh->vertex_normal, indices);
|
|
array[Mesh::ARRAY_NORMAL] = normals;
|
|
|
|
if (fbx_mesh->vertex_tangent.exists) {
|
|
Vector<float> tangents = _decode_vertex_attrib_vec3_as_tangent(fbx_mesh->vertex_tangent, indices);
|
|
|
|
// Patch bitangent sign if available
|
|
if (fbx_mesh->vertex_bitangent.exists) {
|
|
for (int i = 0; i < vertex_num; i++) {
|
|
Vector3 tangent = Vector3(tangents[i * 4], tangents[i * 4 + 1], tangents[i * 4 + 2]);
|
|
Vector3 bitangent = _as_vec3(fbx_mesh->vertex_bitangent[indices[i]]);
|
|
Vector3 generated_bitangent = normals[i].cross(tangent);
|
|
if (generated_bitangent.dot(bitangent) < 0.0f) {
|
|
tangents.write[i * 4 + 3] = -1.0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
array[Mesh::ARRAY_TANGENT] = tangents;
|
|
}
|
|
|
|
if (fbx_mesh->vertex_uv.exists) {
|
|
PackedVector2Array uv_array = _decode_vertex_attrib_vec2(fbx_mesh->vertex_uv, indices);
|
|
_process_uv_set(uv_array);
|
|
array[Mesh::ARRAY_TEX_UV] = uv_array;
|
|
}
|
|
|
|
if (fbx_mesh->uv_sets.count >= 2 && fbx_mesh->uv_sets[1].vertex_uv.exists) {
|
|
PackedVector2Array uv2_array = _decode_vertex_attrib_vec2(fbx_mesh->uv_sets[1].vertex_uv, indices);
|
|
_process_uv_set(uv2_array);
|
|
array[Mesh::ARRAY_TEX_UV2] = uv2_array;
|
|
}
|
|
|
|
for (int uv_i = 2; uv_i < 8; uv_i += 2) {
|
|
Vector<float> cur_custom;
|
|
Vector<Vector2> texcoord_first;
|
|
Vector<Vector2> texcoord_second;
|
|
|
|
int texcoord_i = uv_i;
|
|
int texcoord_next = texcoord_i + 1;
|
|
int num_channels = 0;
|
|
if (texcoord_i < static_cast<int>(fbx_mesh->uv_sets.count) && fbx_mesh->uv_sets[texcoord_i].vertex_uv.exists) {
|
|
texcoord_first = _decode_vertex_attrib_vec2(fbx_mesh->uv_sets[texcoord_i].vertex_uv, indices);
|
|
_process_uv_set(texcoord_first);
|
|
num_channels = 2;
|
|
}
|
|
if (texcoord_next < static_cast<int>(fbx_mesh->uv_sets.count) && fbx_mesh->uv_sets[texcoord_next].vertex_uv.exists) {
|
|
texcoord_second = _decode_vertex_attrib_vec2(fbx_mesh->uv_sets[texcoord_next].vertex_uv, indices);
|
|
_process_uv_set(texcoord_second);
|
|
num_channels = 4;
|
|
}
|
|
if (!num_channels) {
|
|
break;
|
|
}
|
|
cur_custom.resize(vertex_num * num_channels);
|
|
for (int32_t uv_first_i = 0; uv_first_i < texcoord_first.size() && uv_first_i < vertex_num; uv_first_i++) {
|
|
int index = uv_first_i * num_channels;
|
|
cur_custom.write[index] = texcoord_first[uv_first_i].x;
|
|
cur_custom.write[index + 1] = texcoord_first[uv_first_i].y;
|
|
}
|
|
if (num_channels == 4) {
|
|
for (int32_t uv_second_i = 0; uv_second_i < texcoord_second.size() && uv_second_i < vertex_num; uv_second_i++) {
|
|
int index = uv_second_i * num_channels;
|
|
cur_custom.write[index + 2] = texcoord_second[uv_second_i].x;
|
|
cur_custom.write[index + 3] = texcoord_second[uv_second_i].y;
|
|
}
|
|
_zero_unused_elements(cur_custom, texcoord_second.size(), vertex_num, num_channels);
|
|
} else if (num_channels == 2) {
|
|
_zero_unused_elements(cur_custom, texcoord_first.size(), vertex_num, num_channels);
|
|
}
|
|
if (!cur_custom.is_empty()) {
|
|
array[Mesh::ARRAY_CUSTOM0 + ((uv_i - 2) / 2)] = cur_custom; // Map uv2-uv7 to custom0-custom2
|
|
int custom_shift = Mesh::ARRAY_FORMAT_CUSTOM0_SHIFT + ((uv_i - 2) / 2) * Mesh::ARRAY_FORMAT_CUSTOM_BITS;
|
|
flags |= (num_channels == 2 ? Mesh::ARRAY_CUSTOM_RG_FLOAT : Mesh::ARRAY_CUSTOM_RGBA_FLOAT) << custom_shift;
|
|
}
|
|
}
|
|
|
|
if (fbx_mesh->vertex_color.exists) {
|
|
array[Mesh::ARRAY_COLOR] = _decode_vertex_attrib_color(fbx_mesh->vertex_color, indices);
|
|
has_vertex_color = true;
|
|
}
|
|
|
|
int32_t num_skin_weights = 0;
|
|
|
|
// Find the first imported skin deformer
|
|
for (ufbx_skin_deformer *fbx_skin : fbx_mesh->skin_deformers) {
|
|
if (!p_state->skin_indices.has(fbx_skin->typed_id)) {
|
|
continue;
|
|
}
|
|
GLTFSkinIndex skin_i = p_state->skin_indices[fbx_skin->typed_id];
|
|
if (skin_i < 0) {
|
|
continue;
|
|
}
|
|
|
|
// Tag all nodes to use the skin
|
|
for (const ufbx_node *node : fbx_mesh->instances) {
|
|
p_state->nodes[node->typed_id]->skin = skin_i;
|
|
}
|
|
|
|
num_skin_weights = fbx_skin->max_weights_per_vertex > 4 ? 8 : 4;
|
|
|
|
Vector<int32_t> bones;
|
|
Vector<float> weights;
|
|
|
|
bones.resize(vertex_num * num_skin_weights);
|
|
weights.resize(vertex_num * num_skin_weights);
|
|
for (int32_t vertex_i = 0; vertex_i < vertex_num; vertex_i++) {
|
|
uint32_t fbx_vertex_index = fbx_mesh->vertex_indices[indices[vertex_i]];
|
|
ufbx_skin_vertex skin_vertex = fbx_skin->vertices[fbx_vertex_index];
|
|
float total_weight = 0.0f;
|
|
int32_t num_weights = MIN(int32_t(skin_vertex.num_weights), num_skin_weights);
|
|
for (int32_t i = 0; i < num_weights; i++) {
|
|
ufbx_skin_weight skin_weight = fbx_skin->weights[skin_vertex.weight_begin + i];
|
|
int index = vertex_i * num_skin_weights + i;
|
|
float weight = float(skin_weight.weight);
|
|
bones.write[index] = int(skin_weight.cluster_index);
|
|
weights.write[index] = weight;
|
|
total_weight += weight;
|
|
}
|
|
if (total_weight > 0.0f) {
|
|
for (int32_t i = 0; i < num_weights; i++) {
|
|
int index = vertex_i * num_skin_weights + i;
|
|
weights.write[index] /= total_weight;
|
|
}
|
|
}
|
|
// Pad the rest with empty weights
|
|
for (int32_t i = num_weights; i < num_skin_weights; i++) {
|
|
int index = vertex_i * num_skin_weights + i;
|
|
bones.write[index] = 0; // TODO: What should this be padded with?
|
|
weights.write[index] = 0.0f;
|
|
}
|
|
}
|
|
array[Mesh::ARRAY_BONES] = bones;
|
|
array[Mesh::ARRAY_WEIGHTS] = weights;
|
|
|
|
if (num_skin_weights == 8) {
|
|
flags |= Mesh::ARRAY_FLAG_USE_8_BONE_WEIGHTS;
|
|
}
|
|
|
|
// Only use the first found skin
|
|
break;
|
|
}
|
|
|
|
bool generate_tangents = (primitive == Mesh::PRIMITIVE_TRIANGLES && !array[Mesh::ARRAY_TANGENT] && array[Mesh::ARRAY_TEX_UV] && array[Mesh::ARRAY_NORMAL]);
|
|
|
|
Ref<SurfaceTool> mesh_surface_tool;
|
|
mesh_surface_tool.instantiate();
|
|
mesh_surface_tool->create_from_triangle_arrays(array);
|
|
mesh_surface_tool->set_skin_weight_count(num_skin_weights == 8 ? SurfaceTool::SKIN_8_WEIGHTS : SurfaceTool::SKIN_4_WEIGHTS);
|
|
mesh_surface_tool->index();
|
|
if (generate_tangents) {
|
|
//must generate mikktspace tangents.. ergh..
|
|
mesh_surface_tool->generate_tangents();
|
|
}
|
|
array = mesh_surface_tool->commit_to_arrays();
|
|
|
|
Array morphs;
|
|
//blend shapes
|
|
if (use_blend_shapes) {
|
|
print_verbose("FBX: Mesh has targets");
|
|
|
|
import_mesh->set_blend_shape_mode(Mesh::BLEND_SHAPE_MODE_NORMALIZED);
|
|
|
|
for (const ufbx_blend_deformer *fbx_deformer : fbx_mesh->blend_deformers) {
|
|
for (const ufbx_blend_channel *fbx_channel : fbx_deformer->channels) {
|
|
if (fbx_channel->keyframes.count == 0) {
|
|
continue;
|
|
}
|
|
|
|
// Use the last shape keyframe by default
|
|
ufbx_blend_shape *fbx_shape = fbx_channel->keyframes[fbx_channel->keyframes.count - 1].shape;
|
|
|
|
Array array_copy;
|
|
array_copy.resize(Mesh::ARRAY_MAX);
|
|
|
|
for (int l = 0; l < Mesh::ARRAY_MAX; l++) {
|
|
array_copy[l] = array[l];
|
|
}
|
|
|
|
Vector<Vector3> varr;
|
|
Vector<Vector3> narr;
|
|
const Vector<Vector3> src_varr = array[Mesh::ARRAY_VERTEX];
|
|
const Vector<Vector3> src_narr = array[Mesh::ARRAY_NORMAL];
|
|
const int size = src_varr.size();
|
|
ERR_FAIL_COND_V(size == 0, ERR_PARSE_ERROR);
|
|
{
|
|
varr.resize(size);
|
|
narr.resize(size);
|
|
|
|
Vector3 *w_varr = varr.ptrw();
|
|
Vector3 *w_narr = narr.ptrw();
|
|
const Vector3 *r_varr = src_varr.ptr();
|
|
const Vector3 *r_narr = src_narr.ptr();
|
|
for (int l = 0; l < size; l++) {
|
|
uint32_t vertex_index = _decode_vertex_index(r_varr[l]);
|
|
uint32_t offset_index = ufbx_get_blend_shape_offset_index(fbx_shape, vertex_index);
|
|
Vector3 position = _as_vec3(fbx_mesh->vertices[vertex_index]);
|
|
Vector3 normal = r_narr[l];
|
|
|
|
if (offset_index != UFBX_NO_INDEX && offset_index < fbx_shape->position_offsets.count) {
|
|
Vector3 blend_shape_position_offset = _as_vec3(fbx_shape->position_offsets[offset_index]);
|
|
w_varr[l] = position + blend_shape_position_offset;
|
|
} else {
|
|
w_varr[l] = position;
|
|
}
|
|
|
|
if (offset_index != UFBX_NO_INDEX && offset_index < fbx_shape->normal_offsets.count) {
|
|
w_narr[l] = (normal.normalized() + _as_vec3(fbx_shape->normal_offsets[offset_index])).normalized();
|
|
} else {
|
|
w_narr[l] = normal;
|
|
}
|
|
}
|
|
}
|
|
array_copy[Mesh::ARRAY_VERTEX] = varr;
|
|
array_copy[Mesh::ARRAY_NORMAL] = narr;
|
|
|
|
Ref<SurfaceTool> blend_surface_tool;
|
|
blend_surface_tool.instantiate();
|
|
blend_surface_tool->create_from_triangle_arrays(array_copy);
|
|
blend_surface_tool->set_skin_weight_count(num_skin_weights == 8 ? SurfaceTool::SKIN_8_WEIGHTS : SurfaceTool::SKIN_4_WEIGHTS);
|
|
if (generate_tangents) {
|
|
//must generate mikktspace tangents.. ergh..
|
|
blend_surface_tool->generate_tangents();
|
|
}
|
|
array_copy = blend_surface_tool->commit_to_arrays();
|
|
|
|
// Enforce blend shape mask array format
|
|
for (int l = 0; l < Mesh::ARRAY_MAX; l++) {
|
|
if (!(Mesh::ARRAY_FORMAT_BLEND_SHAPE_MASK & (static_cast<int64_t>(1) << l))) {
|
|
array_copy[l] = Variant();
|
|
}
|
|
}
|
|
|
|
morphs.push_back(array_copy);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Decode the original vertex positions now that we're done processing blend shapes.
|
|
if (use_blend_shapes) {
|
|
Vector<Vector3> varr = array[Mesh::ARRAY_VERTEX];
|
|
Vector3 *w_varr = varr.ptrw();
|
|
const int size = varr.size();
|
|
for (int i = 0; i < size; i++) {
|
|
uint32_t vertex_index = _decode_vertex_index(w_varr[i]);
|
|
w_varr[i] = _as_vec3(fbx_mesh->vertices[vertex_index]);
|
|
}
|
|
array[Mesh::ARRAY_VERTEX] = varr;
|
|
}
|
|
|
|
Ref<Material> mat;
|
|
String mat_name;
|
|
if (!p_state->discard_meshes_and_materials) {
|
|
ufbx_material *fbx_material = nullptr;
|
|
if (fbx_mesh_part.index < fbx_mesh->materials.count) {
|
|
fbx_material = fbx_mesh->materials[fbx_mesh_part.index];
|
|
}
|
|
if (fbx_material) {
|
|
const int material = int(fbx_material->typed_id);
|
|
ERR_FAIL_INDEX_V(material, p_state->materials.size(), ERR_FILE_CORRUPT);
|
|
Ref<Material> mat3d = p_state->materials[material];
|
|
ERR_FAIL_NULL_V(mat3d, ERR_FILE_CORRUPT);
|
|
|
|
Ref<BaseMaterial3D> base_material = mat3d;
|
|
if (has_vertex_color && base_material.is_valid()) {
|
|
base_material->set_flag(BaseMaterial3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
|
|
}
|
|
mat = mat3d;
|
|
|
|
} else {
|
|
Ref<StandardMaterial3D> mat3d;
|
|
mat3d.instantiate();
|
|
if (has_vertex_color) {
|
|
mat3d->set_flag(StandardMaterial3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
|
|
}
|
|
mat = mat3d;
|
|
}
|
|
ERR_FAIL_NULL_V(mat, ERR_FILE_CORRUPT);
|
|
mat_name = mat->get_name();
|
|
}
|
|
import_mesh->add_surface(primitive, array, morphs,
|
|
Dictionary(), mat, mat_name, flags);
|
|
}
|
|
}
|
|
|
|
Ref<GLTFMesh> mesh;
|
|
mesh.instantiate();
|
|
Dictionary additional_data;
|
|
additional_data["blend_channels"] = blend_channels;
|
|
mesh->set_additional_data("GODOT_mesh_blend_channels", additional_data);
|
|
mesh->set_blend_weights(blend_weights);
|
|
mesh->set_mesh(import_mesh);
|
|
mesh->set_name(import_mesh->get_name());
|
|
mesh->set_original_name(original_name);
|
|
|
|
p_state->meshes.push_back(mesh);
|
|
}
|
|
|
|
print_verbose("FBX: Total meshes: " + itos(p_state->meshes.size()));
|
|
|
|
return OK;
|
|
}
|
|
|
|
Ref<Image> FBXDocument::_parse_image_bytes_into_image(Ref<FBXState> p_state, const Vector<uint8_t> &p_bytes, const String &p_filename, int p_index) {
|
|
Ref<Image> r_image;
|
|
r_image.instantiate();
|
|
// Try to import first based on filename.
|
|
String filename_lower = p_filename.to_lower();
|
|
if (filename_lower.ends_with(".png")) {
|
|
r_image->load_png_from_buffer(p_bytes);
|
|
} else if (filename_lower.ends_with(".jpg")) {
|
|
r_image->load_jpg_from_buffer(p_bytes);
|
|
} else if (filename_lower.ends_with(".tga")) {
|
|
r_image->load_tga_from_buffer(p_bytes);
|
|
}
|
|
// If we didn't pass the above tests, try loading as each option.
|
|
if (r_image->is_empty()) { // Try PNG first.
|
|
r_image->load_png_from_buffer(p_bytes);
|
|
}
|
|
if (r_image->is_empty()) { // And then JPEG.
|
|
r_image->load_jpg_from_buffer(p_bytes);
|
|
}
|
|
if (r_image->is_empty()) { // And then TGA.
|
|
r_image->load_jpg_from_buffer(p_bytes);
|
|
}
|
|
// If it still can't be loaded, give up and insert an empty image as placeholder.
|
|
if (r_image->is_empty()) {
|
|
ERR_PRINT(vformat("FBX: Couldn't load image index '%d'", p_index));
|
|
}
|
|
return r_image;
|
|
}
|
|
|
|
GLTFImageIndex FBXDocument::_parse_image_save_image(Ref<FBXState> p_state, const Vector<uint8_t> &p_bytes, const String &p_file_extension, int p_index, Ref<Image> p_image) {
|
|
FBXState::GLTFHandleBinary handling = FBXState::GLTFHandleBinary(p_state->handle_binary_image);
|
|
if (p_image->is_empty() || handling == FBXState::GLTFHandleBinary::HANDLE_BINARY_DISCARD_TEXTURES) {
|
|
if (p_index < 0) {
|
|
return -1;
|
|
}
|
|
p_state->images.push_back(Ref<Texture2D>());
|
|
p_state->source_images.push_back(Ref<Image>());
|
|
return p_state->images.size() - 1;
|
|
}
|
|
#ifdef TOOLS_ENABLED
|
|
if (Engine::get_singleton()->is_editor_hint() && handling == FBXState::GLTFHandleBinary::HANDLE_BINARY_EXTRACT_TEXTURES) {
|
|
if (p_state->base_path.is_empty()) {
|
|
if (p_index < 0) {
|
|
return -1;
|
|
}
|
|
p_state->images.push_back(Ref<Texture2D>());
|
|
p_state->source_images.push_back(Ref<Image>());
|
|
} else if (p_image->get_name().is_empty()) {
|
|
if (p_index < 0) {
|
|
return -1;
|
|
}
|
|
WARN_PRINT(vformat("FBX: Image index '%d' couldn't be named. Skipping it.", p_index));
|
|
p_state->images.push_back(Ref<Texture2D>());
|
|
p_state->source_images.push_back(Ref<Image>());
|
|
} else {
|
|
bool must_import = true;
|
|
Vector<uint8_t> img_data = p_image->get_data();
|
|
Dictionary generator_parameters;
|
|
String file_path = p_state->get_base_path().path_join(p_state->filename.get_basename() + "_" + p_image->get_name());
|
|
file_path += p_file_extension.is_empty() ? ".png" : p_file_extension;
|
|
if (FileAccess::exists(file_path + ".import")) {
|
|
Ref<ConfigFile> config;
|
|
config.instantiate();
|
|
config->load(file_path + ".import");
|
|
if (config->has_section_key("remap", "generator_parameters")) {
|
|
generator_parameters = (Dictionary)config->get_value("remap", "generator_parameters");
|
|
}
|
|
if (!generator_parameters.has("md5")) {
|
|
must_import = false; // Didn't come from a gltf document; don't overwrite.
|
|
}
|
|
}
|
|
if (must_import) {
|
|
String existing_md5 = generator_parameters["md5"];
|
|
unsigned char md5_hash[16];
|
|
CryptoCore::md5(img_data.ptr(), img_data.size(), md5_hash);
|
|
String new_md5 = String::hex_encode_buffer(md5_hash, 16);
|
|
generator_parameters["md5"] = new_md5;
|
|
if (new_md5 == existing_md5) {
|
|
must_import = false;
|
|
}
|
|
}
|
|
if (must_import) {
|
|
Error err = OK;
|
|
if (p_file_extension.is_empty()) {
|
|
// If a file extension was not specified, save the image data to a PNG file.
|
|
err = p_image->save_png(file_path);
|
|
ERR_FAIL_COND_V(err != OK, -1);
|
|
} else {
|
|
// If a file extension was specified, save the original bytes to a file with that extension.
|
|
Ref<FileAccess> file = FileAccess::open(file_path, FileAccess::WRITE, &err);
|
|
ERR_FAIL_COND_V(err != OK, -1);
|
|
file->store_buffer(p_bytes);
|
|
file->close();
|
|
}
|
|
// ResourceLoader::import will crash if not is_editor_hint(), so this case is protected above and will fall through to uncompressed.
|
|
HashMap<StringName, Variant> custom_options;
|
|
custom_options[SNAME("mipmaps/generate")] = true;
|
|
// Will only use project settings defaults if custom_importer is empty.
|
|
EditorFileSystem::get_singleton()->update_file(file_path);
|
|
EditorFileSystem::get_singleton()->reimport_append(file_path, custom_options, String(), generator_parameters);
|
|
}
|
|
Ref<Texture2D> saved_image = ResourceLoader::load(_get_texture_path(p_state->get_base_path(), file_path), "Texture2D");
|
|
if (saved_image.is_valid()) {
|
|
p_state->images.push_back(saved_image);
|
|
p_state->source_images.push_back(saved_image->get_image());
|
|
} else if (p_index < 0) {
|
|
return -1;
|
|
} else {
|
|
WARN_PRINT(vformat("FBX: Image index '%d' couldn't be loaded with the name: %s. Skipping it.", p_index, p_image->get_name()));
|
|
// Placeholder to keep count.
|
|
p_state->images.push_back(Ref<Texture2D>());
|
|
p_state->source_images.push_back(Ref<Image>());
|
|
}
|
|
}
|
|
return p_state->images.size() - 1;
|
|
}
|
|
#endif // TOOLS_ENABLED
|
|
if (handling == FBXState::HANDLE_BINARY_EMBED_AS_BASISU) {
|
|
Ref<PortableCompressedTexture2D> tex;
|
|
tex.instantiate();
|
|
tex->set_name(p_image->get_name());
|
|
tex->set_keep_compressed_buffer(true);
|
|
tex->create_from_image(p_image, PortableCompressedTexture2D::COMPRESSION_MODE_BASIS_UNIVERSAL);
|
|
p_state->images.push_back(tex);
|
|
p_state->source_images.push_back(p_image);
|
|
return p_state->images.size() - 1;
|
|
}
|
|
// This handles the case of HANDLE_BINARY_EMBED_AS_UNCOMPRESSED, and it also serves
|
|
// as a fallback for HANDLE_BINARY_EXTRACT_TEXTURES when this is not the editor.
|
|
Ref<ImageTexture> tex;
|
|
tex.instantiate();
|
|
tex->set_name(p_image->get_name());
|
|
tex->set_image(p_image);
|
|
p_state->images.push_back(tex);
|
|
p_state->source_images.push_back(p_image);
|
|
return p_state->images.size() - 1;
|
|
}
|
|
|
|
Error FBXDocument::_parse_images(Ref<FBXState> p_state, const String &p_base_path) {
|
|
ERR_FAIL_NULL_V(p_state, ERR_INVALID_PARAMETER);
|
|
|
|
const ufbx_scene *fbx_scene = p_state->scene.get();
|
|
for (int texture_i = 0; texture_i < static_cast<int>(fbx_scene->texture_files.count); texture_i++) {
|
|
const ufbx_texture_file &fbx_texture_file = fbx_scene->texture_files[texture_i];
|
|
String path = _as_string(fbx_texture_file.filename);
|
|
// Use only filename for absolute paths to avoid portability issues.
|
|
if (path.is_absolute_path()) {
|
|
path = path.get_file();
|
|
}
|
|
if (!p_base_path.is_empty()) {
|
|
path = p_base_path.path_join(path);
|
|
}
|
|
path = path.simplify_path();
|
|
Vector<uint8_t> data;
|
|
if (fbx_texture_file.content.size > 0 && fbx_texture_file.content.size <= INT_MAX) {
|
|
data.resize(int(fbx_texture_file.content.size));
|
|
memcpy(data.ptrw(), fbx_texture_file.content.data, fbx_texture_file.content.size);
|
|
} else {
|
|
String base_dir = p_state->get_base_path();
|
|
Ref<Texture2D> texture = ResourceLoader::load(_get_texture_path(base_dir, path), "Texture2D");
|
|
if (texture.is_valid()) {
|
|
p_state->images.push_back(texture);
|
|
p_state->source_images.push_back(texture->get_image());
|
|
continue;
|
|
}
|
|
// Fallback to loading as byte array.
|
|
data = FileAccess::get_file_as_bytes(path);
|
|
if (data.size() == 0) {
|
|
WARN_PRINT(vformat("FBX: Image index '%d' couldn't be loaded from path: %s because there was no data to load. Skipping it.", texture_i, path));
|
|
p_state->images.push_back(Ref<Texture2D>()); // Placeholder to keep count.
|
|
p_state->source_images.push_back(Ref<Image>());
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Parse the image data from bytes into an Image resource and save if needed.
|
|
String file_extension;
|
|
Ref<Image> img = _parse_image_bytes_into_image(p_state, data, path, texture_i);
|
|
img->set_name(itos(texture_i));
|
|
_parse_image_save_image(p_state, data, file_extension, texture_i, img);
|
|
}
|
|
|
|
// Create a texture for each file texture.
|
|
for (int texture_file_i = 0; texture_file_i < static_cast<int>(fbx_scene->texture_files.count); texture_file_i++) {
|
|
Ref<GLTFTexture> texture;
|
|
texture.instantiate();
|
|
texture->set_src_image(GLTFImageIndex(texture_file_i));
|
|
p_state->textures.push_back(texture);
|
|
}
|
|
|
|
print_verbose("FBX: Total images: " + itos(p_state->images.size()));
|
|
|
|
return OK;
|
|
}
|
|
|
|
Ref<Texture2D> FBXDocument::_get_texture(Ref<FBXState> p_state, const GLTFTextureIndex p_texture, int p_texture_types) {
|
|
ERR_FAIL_INDEX_V(p_texture, p_state->textures.size(), Ref<Texture2D>());
|
|
const GLTFImageIndex image = p_state->textures[p_texture]->get_src_image();
|
|
ERR_FAIL_INDEX_V(image, p_state->images.size(), Ref<Texture2D>());
|
|
if (FBXState::GLTFHandleBinary(p_state->handle_binary_image) == FBXState::HANDLE_BINARY_EMBED_AS_BASISU) {
|
|
ERR_FAIL_INDEX_V(image, p_state->source_images.size(), Ref<Texture2D>());
|
|
Ref<PortableCompressedTexture2D> portable_texture;
|
|
portable_texture.instantiate();
|
|
portable_texture->set_keep_compressed_buffer(true);
|
|
Ref<Image> new_img = p_state->source_images[image]->duplicate();
|
|
ERR_FAIL_COND_V(new_img.is_null(), Ref<Texture2D>());
|
|
new_img->generate_mipmaps();
|
|
if (p_texture_types) {
|
|
portable_texture->create_from_image(new_img, PortableCompressedTexture2D::COMPRESSION_MODE_BASIS_UNIVERSAL, true);
|
|
} else {
|
|
portable_texture->create_from_image(new_img, PortableCompressedTexture2D::COMPRESSION_MODE_BASIS_UNIVERSAL, false);
|
|
}
|
|
p_state->images.write[image] = portable_texture;
|
|
p_state->source_images.write[image] = new_img;
|
|
}
|
|
return p_state->images[image];
|
|
}
|
|
|
|
Error FBXDocument::_parse_materials(Ref<FBXState> p_state) {
|
|
const ufbx_scene *fbx_scene = p_state->scene.get();
|
|
for (GLTFMaterialIndex material_i = 0; material_i < static_cast<GLTFMaterialIndex>(fbx_scene->materials.count); material_i++) {
|
|
const ufbx_material *fbx_material = fbx_scene->materials[material_i];
|
|
|
|
Ref<StandardMaterial3D> material;
|
|
material.instantiate();
|
|
if (fbx_material->name.length > 0) {
|
|
material->set_name(_as_string(fbx_material->name));
|
|
} else {
|
|
material->set_name(vformat("material_%s", itos(material_i)));
|
|
}
|
|
material->set_flag(BaseMaterial3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
|
|
Dictionary material_extensions;
|
|
|
|
if (fbx_material->pbr.base_color.has_value) {
|
|
Color albedo = _material_color(fbx_material->pbr.base_color, fbx_material->pbr.base_factor);
|
|
material->set_albedo(albedo.linear_to_srgb());
|
|
}
|
|
|
|
if (fbx_material->features.double_sided.enabled) {
|
|
material->set_cull_mode(BaseMaterial3D::CULL_DISABLED);
|
|
}
|
|
|
|
const ufbx_texture *base_texture = _get_file_texture(fbx_material->pbr.base_color.texture);
|
|
if (base_texture) {
|
|
bool wrap = base_texture->wrap_u == UFBX_WRAP_REPEAT && base_texture->wrap_v == UFBX_WRAP_REPEAT;
|
|
material->set_flag(BaseMaterial3D::FLAG_USE_TEXTURE_REPEAT, wrap);
|
|
|
|
Ref<Texture2D> albedo_texture = _get_texture(p_state, GLTFTextureIndex(base_texture->file_index), TEXTURE_TYPE_GENERIC);
|
|
|
|
// Search for transparency map.
|
|
Ref<Texture2D> transparency_texture;
|
|
const ufbx_texture *transparency_sources[] = {
|
|
fbx_material->pbr.opacity.texture,
|
|
fbx_material->fbx.transparency_color.texture,
|
|
};
|
|
for (const ufbx_texture *transparency_source : transparency_sources) {
|
|
const ufbx_texture *fbx_transparency_texture = _get_file_texture(transparency_source);
|
|
if (fbx_transparency_texture) {
|
|
transparency_texture = _get_texture(p_state, GLTFTextureIndex(fbx_transparency_texture->file_index), TEXTURE_TYPE_GENERIC);
|
|
if (transparency_texture.is_valid()) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Multiply the albedo alpha with the transparency texture if necessary.
|
|
if (albedo_texture.is_valid() && transparency_texture.is_valid() && albedo_texture != transparency_texture) {
|
|
Pair<uint64_t, uint64_t> key = { albedo_texture->get_rid().get_id(), transparency_texture->get_rid().get_id() };
|
|
GLTFTextureIndex *texture_index_ptr = p_state->albedo_transparency_textures.getptr(key);
|
|
if (texture_index_ptr != nullptr) {
|
|
if (*texture_index_ptr >= 0) {
|
|
albedo_texture = _get_texture(p_state, *texture_index_ptr, TEXTURE_TYPE_GENERIC);
|
|
}
|
|
} else {
|
|
Ref<Image> albedo_image = _get_decompressed_image(albedo_texture);
|
|
Ref<Image> transparency_image = _get_decompressed_image(transparency_texture);
|
|
|
|
if (albedo_image.is_valid() && transparency_image.is_valid()) {
|
|
albedo_image->convert(Image::Format::FORMAT_RGBA8);
|
|
transparency_image->resize(albedo_texture->get_width(), albedo_texture->get_height(), Image::INTERPOLATE_LANCZOS);
|
|
for (int y = 0; y < albedo_image->get_height(); y++) {
|
|
for (int x = 0; x < albedo_image->get_width(); x++) {
|
|
Color albedo_pixel = albedo_image->get_pixel(x, y);
|
|
Color transparency_pixel = transparency_image->get_pixel(x, y);
|
|
albedo_pixel.a *= transparency_pixel.r;
|
|
albedo_image->set_pixel(x, y, albedo_pixel);
|
|
}
|
|
}
|
|
|
|
albedo_image->clear_mipmaps();
|
|
albedo_image->generate_mipmaps();
|
|
|
|
albedo_image->set_name(vformat("alpha_%d", p_state->albedo_transparency_textures.size()));
|
|
|
|
GLTFImageIndex new_image = _parse_image_save_image(p_state, PackedByteArray(), "", -1, albedo_image);
|
|
if (new_image >= 0) {
|
|
Ref<GLTFTexture> new_texture;
|
|
new_texture.instantiate();
|
|
new_texture->set_src_image(GLTFImageIndex(new_image));
|
|
p_state->textures.push_back(new_texture);
|
|
|
|
GLTFTextureIndex texture_index = p_state->textures.size() - 1;
|
|
p_state->albedo_transparency_textures[key] = texture_index;
|
|
|
|
albedo_texture = _get_texture(p_state, texture_index, TEXTURE_TYPE_GENERIC);
|
|
} else {
|
|
WARN_PRINT(vformat("FBX: Could not save modified albedo texture from RID (%d, %d).", key.first, key.second));
|
|
p_state->albedo_transparency_textures[key] = -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Image::AlphaMode alpha_mode;
|
|
if (albedo_texture.is_valid()) {
|
|
Image::AlphaMode *alpha_mode_ptr = p_state->alpha_mode_cache.getptr(albedo_texture->get_rid().get_id());
|
|
if (alpha_mode_ptr != nullptr) {
|
|
alpha_mode = *alpha_mode_ptr;
|
|
} else {
|
|
Ref<Image> albedo_image = _get_decompressed_image(albedo_texture);
|
|
alpha_mode = albedo_image->detect_alpha();
|
|
p_state->alpha_mode_cache[albedo_texture->get_rid().get_id()] = alpha_mode;
|
|
}
|
|
|
|
if (alpha_mode == Image::ALPHA_BLEND) {
|
|
material->set_transparency(BaseMaterial3D::TRANSPARENCY_ALPHA_DEPTH_PRE_PASS);
|
|
} else if (alpha_mode == Image::ALPHA_BIT) {
|
|
material->set_transparency(BaseMaterial3D::TRANSPARENCY_ALPHA_SCISSOR);
|
|
}
|
|
material->set_texture(BaseMaterial3D::TEXTURE_ALBEDO, albedo_texture);
|
|
}
|
|
|
|
// Combined textures and factors are very unreliable in FBX
|
|
Color albedo_factor = Color(1, 1, 1);
|
|
if (fbx_material->pbr.base_factor.has_value) {
|
|
albedo_factor *= (float)fbx_material->pbr.base_factor.value_real;
|
|
}
|
|
material->set_albedo(albedo_factor.linear_to_srgb());
|
|
|
|
// TODO: Does not support rotation, could be inverted?
|
|
material->set_uv1_offset(_as_vec3(base_texture->uv_transform.translation));
|
|
Vector3 scale = _as_vec3(base_texture->uv_transform.scale);
|
|
material->set_uv1_scale(scale);
|
|
}
|
|
|
|
if (fbx_material->features.pbr.enabled) {
|
|
if (fbx_material->pbr.metalness.has_value) {
|
|
material->set_metallic(float(fbx_material->pbr.metalness.value_real));
|
|
} else {
|
|
material->set_metallic(1.0);
|
|
}
|
|
|
|
if (fbx_material->pbr.roughness.has_value) {
|
|
material->set_roughness(float(fbx_material->pbr.roughness.value_real));
|
|
} else {
|
|
material->set_roughness(1.0);
|
|
}
|
|
|
|
const ufbx_texture *metalness_texture = _get_file_texture(fbx_material->pbr.metalness.texture);
|
|
if (metalness_texture) {
|
|
material->set_texture(BaseMaterial3D::TEXTURE_METALLIC, _get_texture(p_state, GLTFTextureIndex(metalness_texture->file_index), TEXTURE_TYPE_GENERIC));
|
|
material->set_metallic_texture_channel(BaseMaterial3D::TEXTURE_CHANNEL_RED);
|
|
material->set_metallic(1.0);
|
|
}
|
|
|
|
const ufbx_texture *roughness_texture = _get_file_texture(fbx_material->pbr.roughness.texture);
|
|
if (roughness_texture) {
|
|
material->set_texture(BaseMaterial3D::TEXTURE_ROUGHNESS, _get_texture(p_state, GLTFTextureIndex(roughness_texture->file_index), TEXTURE_TYPE_GENERIC));
|
|
material->set_roughness_texture_channel(BaseMaterial3D::TEXTURE_CHANNEL_RED);
|
|
material->set_roughness(1.0);
|
|
}
|
|
}
|
|
|
|
const ufbx_texture *normal_texture = _get_file_texture(fbx_material->pbr.normal_map.texture);
|
|
if (normal_texture) {
|
|
material->set_texture(BaseMaterial3D::TEXTURE_NORMAL, _get_texture(p_state, GLTFTextureIndex(normal_texture->file_index), TEXTURE_TYPE_NORMAL));
|
|
material->set_feature(BaseMaterial3D::FEATURE_NORMAL_MAPPING, true);
|
|
if (fbx_material->pbr.normal_map.has_value) {
|
|
material->set_normal_scale(fbx_material->pbr.normal_map.value_real);
|
|
}
|
|
}
|
|
|
|
const ufbx_texture *occlusion_texture = _get_file_texture(fbx_material->pbr.ambient_occlusion.texture);
|
|
if (occlusion_texture) {
|
|
material->set_texture(BaseMaterial3D::TEXTURE_AMBIENT_OCCLUSION, _get_texture(p_state, GLTFTextureIndex(occlusion_texture->file_index), TEXTURE_TYPE_GENERIC));
|
|
material->set_ao_texture_channel(BaseMaterial3D::TEXTURE_CHANNEL_RED);
|
|
material->set_feature(BaseMaterial3D::FEATURE_AMBIENT_OCCLUSION, true);
|
|
}
|
|
|
|
if (fbx_material->pbr.emission_color.has_value) {
|
|
material->set_feature(BaseMaterial3D::FEATURE_EMISSION, true);
|
|
material->set_emission(_material_color(fbx_material->pbr.emission_color).linear_to_srgb());
|
|
material->set_emission_energy_multiplier(float(fbx_material->pbr.emission_factor.value_real));
|
|
}
|
|
|
|
const ufbx_texture *emission_texture = _get_file_texture(fbx_material->pbr.emission_color.texture);
|
|
if (emission_texture) {
|
|
material->set_texture(BaseMaterial3D::TEXTURE_EMISSION, _get_texture(p_state, GLTFTextureIndex(emission_texture->file_index), TEXTURE_TYPE_GENERIC));
|
|
material->set_feature(BaseMaterial3D::FEATURE_EMISSION, true);
|
|
material->set_emission(Color(0, 0, 0));
|
|
}
|
|
|
|
if (fbx_material->features.double_sided.enabled && fbx_material->features.double_sided.is_explicit) {
|
|
material->set_cull_mode(BaseMaterial3D::CULL_DISABLED);
|
|
}
|
|
p_state->materials.push_back(material);
|
|
}
|
|
|
|
print_verbose("Total materials: " + itos(p_state->materials.size()));
|
|
|
|
return OK;
|
|
}
|
|
Error FBXDocument::_parse_cameras(Ref<FBXState> p_state) {
|
|
const ufbx_scene *fbx_scene = p_state->scene.get();
|
|
for (GLTFCameraIndex i = 0; i < static_cast<GLTFCameraIndex>(fbx_scene->cameras.count); i++) {
|
|
const ufbx_camera *fbx_camera = fbx_scene->cameras[i];
|
|
|
|
Ref<GLTFCamera> camera;
|
|
camera.instantiate();
|
|
camera->set_name(_as_string(fbx_camera->name));
|
|
if (fbx_camera->projection_mode == UFBX_PROJECTION_MODE_PERSPECTIVE) {
|
|
camera->set_perspective(true);
|
|
camera->set_fov(Math::deg_to_rad(real_t(fbx_camera->field_of_view_deg.y)));
|
|
} else {
|
|
camera->set_perspective(false);
|
|
camera->set_size_mag(real_t(fbx_camera->orthographic_size.y * 0.5f));
|
|
}
|
|
if (fbx_camera->near_plane != 0.0f) {
|
|
camera->set_depth_near(fbx_camera->near_plane);
|
|
}
|
|
if (fbx_camera->far_plane != 0.0f) {
|
|
camera->set_depth_far(fbx_camera->far_plane);
|
|
}
|
|
p_state->cameras.push_back(camera);
|
|
}
|
|
|
|
print_verbose("FBX: Total cameras: " + itos(p_state->cameras.size()));
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error FBXDocument::_parse_animations(Ref<FBXState> p_state) {
|
|
const ufbx_scene *fbx_scene = p_state->scene.get();
|
|
for (GLTFAnimationIndex animation_i = 0; animation_i < static_cast<GLTFAnimationIndex>(fbx_scene->anim_stacks.count); animation_i++) {
|
|
const ufbx_anim_stack *fbx_anim_stack = fbx_scene->anim_stacks[animation_i];
|
|
|
|
Ref<GLTFAnimation> animation;
|
|
animation.instantiate();
|
|
|
|
if (fbx_anim_stack->name.length > 0) {
|
|
const String anim_name = _as_string(fbx_anim_stack->name);
|
|
const String anim_name_lower = anim_name.to_lower();
|
|
if (anim_name_lower.begins_with("loop") || anim_name_lower.ends_with("loop") || anim_name_lower.begins_with("cycle") || anim_name_lower.ends_with("cycle")) {
|
|
animation->set_loop(true);
|
|
}
|
|
animation->set_original_name(anim_name);
|
|
animation->set_name(_gen_unique_animation_name(p_state, anim_name));
|
|
}
|
|
|
|
Dictionary additional_data;
|
|
additional_data["time_begin"] = fbx_anim_stack->time_begin;
|
|
additional_data["time_end"] = fbx_anim_stack->time_end;
|
|
animation->set_additional_data("GODOT_animation_time_begin_time_end", additional_data);
|
|
ufbx_bake_opts opts = {};
|
|
ufbx_error error;
|
|
ufbx_unique_ptr<ufbx_baked_anim> fbx_baked_anim{ ufbx_bake_anim(fbx_scene, fbx_anim_stack->anim, &opts, &error) };
|
|
if (!fbx_baked_anim) {
|
|
char err_buf[512];
|
|
ufbx_format_error(err_buf, sizeof(err_buf), &error);
|
|
ERR_FAIL_V_MSG(FAILED, err_buf);
|
|
}
|
|
|
|
for (const ufbx_baked_node &fbx_baked_node : fbx_baked_anim->nodes) {
|
|
const GLTFNodeIndex node = fbx_baked_node.typed_id;
|
|
GLTFAnimation::Track &track = animation->get_tracks()[node];
|
|
|
|
for (const ufbx_baked_vec3 &key : fbx_baked_node.translation_keys) {
|
|
track.position_track.times.push_back(float(key.time));
|
|
track.position_track.values.push_back(_as_vec3(key.value));
|
|
}
|
|
|
|
for (const ufbx_baked_quat &key : fbx_baked_node.rotation_keys) {
|
|
track.rotation_track.times.push_back(float(key.time));
|
|
track.rotation_track.values.push_back(_as_quaternion(key.value));
|
|
}
|
|
|
|
for (const ufbx_baked_vec3 &key : fbx_baked_node.scale_keys) {
|
|
track.scale_track.times.push_back(float(key.time));
|
|
track.scale_track.values.push_back(_as_vec3(key.value));
|
|
}
|
|
}
|
|
|
|
Dictionary blend_shape_animations;
|
|
|
|
for (const ufbx_baked_element &fbx_baked_element : fbx_baked_anim->elements) {
|
|
const ufbx_element *fbx_element = fbx_scene->elements[fbx_baked_element.element_id];
|
|
|
|
for (const ufbx_baked_prop &fbx_baked_prop : fbx_baked_element.props) {
|
|
String prop_name = _as_string(fbx_baked_prop.name);
|
|
|
|
if (fbx_element->type == UFBX_ELEMENT_BLEND_CHANNEL && prop_name == UFBX_DeformPercent) {
|
|
const ufbx_blend_channel *fbx_blend_channel = ufbx_as_blend_channel(fbx_element);
|
|
|
|
int blend_i = fbx_blend_channel->typed_id;
|
|
Vector<real_t> track_times;
|
|
Vector<real_t> track_values;
|
|
|
|
for (const ufbx_baked_vec3 &key : fbx_baked_prop.keys) {
|
|
track_times.push_back(float(key.time));
|
|
track_values.push_back(real_t(key.value.x / 100.0));
|
|
}
|
|
|
|
Dictionary track;
|
|
track["times"] = track_times;
|
|
track["values"] = track_values;
|
|
blend_shape_animations[blend_i] = track;
|
|
}
|
|
}
|
|
}
|
|
|
|
animation->set_additional_data("GODOT_blend_shape_animations", blend_shape_animations);
|
|
|
|
p_state->animations.push_back(animation);
|
|
}
|
|
|
|
print_verbose("FBX: Total animations '" + itos(p_state->animations.size()) + "'.");
|
|
|
|
return OK;
|
|
}
|
|
|
|
void FBXDocument::_assign_node_names(Ref<FBXState> p_state) {
|
|
for (int i = 0; i < p_state->nodes.size(); i++) {
|
|
Ref<GLTFNode> fbx_node = p_state->nodes[i];
|
|
|
|
// Any joints get unique names generated when the skeleton is made, unique to the skeleton
|
|
if (fbx_node->skeleton >= 0) {
|
|
continue;
|
|
}
|
|
|
|
if (fbx_node->get_name().is_empty()) {
|
|
if (fbx_node->mesh >= 0) {
|
|
fbx_node->set_name(_gen_unique_name(p_state->unique_names, "Mesh"));
|
|
} else if (fbx_node->camera >= 0) {
|
|
fbx_node->set_name(_gen_unique_name(p_state->unique_names, "Camera3D"));
|
|
} else {
|
|
fbx_node->set_name(_gen_unique_name(p_state->unique_names, "Node"));
|
|
}
|
|
}
|
|
|
|
fbx_node->set_name(_gen_unique_name(p_state->unique_names, fbx_node->get_name()));
|
|
}
|
|
}
|
|
|
|
BoneAttachment3D *FBXDocument::_generate_bone_attachment(Ref<FBXState> p_state, Skeleton3D *p_skeleton, const GLTFNodeIndex p_node_index, const GLTFNodeIndex p_bone_index) {
|
|
Ref<GLTFNode> fbx_node = p_state->nodes[p_node_index];
|
|
Ref<GLTFNode> bone_node = p_state->nodes[p_bone_index];
|
|
BoneAttachment3D *bone_attachment = memnew(BoneAttachment3D);
|
|
print_verbose("FBX: Creating bone attachment for: " + fbx_node->get_name());
|
|
|
|
ERR_FAIL_COND_V(!bone_node->joint, nullptr);
|
|
|
|
bone_attachment->set_bone_name(bone_node->get_name());
|
|
|
|
return bone_attachment;
|
|
}
|
|
|
|
ImporterMeshInstance3D *FBXDocument::_generate_mesh_instance(Ref<FBXState> p_state, const GLTFNodeIndex p_node_index) {
|
|
Ref<GLTFNode> fbx_node = p_state->nodes[p_node_index];
|
|
|
|
ERR_FAIL_INDEX_V(fbx_node->mesh, p_state->meshes.size(), nullptr);
|
|
|
|
ImporterMeshInstance3D *mi = memnew(ImporterMeshInstance3D);
|
|
print_verbose("FBX: Creating mesh for: " + fbx_node->get_name());
|
|
|
|
p_state->scene_mesh_instances.insert(p_node_index, mi);
|
|
Ref<GLTFMesh> mesh = p_state->meshes.write[fbx_node->mesh];
|
|
if (mesh.is_null()) {
|
|
return mi;
|
|
}
|
|
Ref<ImporterMesh> import_mesh = mesh->get_mesh();
|
|
if (import_mesh.is_null()) {
|
|
return mi;
|
|
}
|
|
mi->set_mesh(import_mesh);
|
|
return mi;
|
|
}
|
|
|
|
Camera3D *FBXDocument::_generate_camera(Ref<FBXState> p_state, const GLTFNodeIndex p_node_index) {
|
|
Ref<GLTFNode> fbx_node = p_state->nodes[p_node_index];
|
|
|
|
ERR_FAIL_INDEX_V(fbx_node->camera, p_state->cameras.size(), nullptr);
|
|
|
|
print_verbose("FBX: Creating camera for: " + fbx_node->get_name());
|
|
|
|
Ref<GLTFCamera> c = p_state->cameras[fbx_node->camera];
|
|
return c->to_node();
|
|
}
|
|
|
|
Light3D *FBXDocument::_generate_light(Ref<FBXState> p_state, const GLTFNodeIndex p_node_index) {
|
|
Ref<GLTFNode> fbx_node = p_state->nodes[p_node_index];
|
|
|
|
ERR_FAIL_INDEX_V(fbx_node->light, p_state->lights.size(), nullptr);
|
|
|
|
print_verbose("FBX: Creating light for: " + fbx_node->get_name());
|
|
|
|
Ref<GLTFLight> l = p_state->lights[fbx_node->light];
|
|
Light3D *light = nullptr;
|
|
|
|
if (l->get_light_type() == "point") {
|
|
light = memnew(OmniLight3D);
|
|
} else if (l->get_light_type() == "directional") {
|
|
light = memnew(DirectionalLight3D);
|
|
} else if (l->get_light_type() == "spot") {
|
|
light = memnew(SpotLight3D);
|
|
} else {
|
|
ERR_FAIL_NULL_V(light, nullptr);
|
|
}
|
|
|
|
if (light) {
|
|
light->set_name(l->get_name());
|
|
light->set_color(l->get_color());
|
|
light->set_param(Light3D::PARAM_ENERGY, l->get_intensity());
|
|
Dictionary additional_data = l->get_additional_data("GODOT_fbx_light");
|
|
if (additional_data.has("castShadows")) {
|
|
light->set_shadow(additional_data["castShadows"]);
|
|
}
|
|
if (additional_data.has("castLight")) {
|
|
light->set_visible(additional_data["castLight"]);
|
|
}
|
|
|
|
Transform3D transform;
|
|
DirectionalLight3D *dir_light = Object::cast_to<DirectionalLight3D>(light);
|
|
SpotLight3D *spot_light = Object::cast_to<SpotLight3D>(light);
|
|
OmniLight3D *omni_light = Object::cast_to<OmniLight3D>(light);
|
|
if (dir_light) {
|
|
dir_light->set_transform(transform);
|
|
} else if (spot_light) {
|
|
spot_light->set_transform(transform);
|
|
spot_light->set_param(SpotLight3D::PARAM_SPOT_ANGLE, l->get_outer_cone_angle() / 2.0f);
|
|
}
|
|
if (omni_light || spot_light) {
|
|
light->set_param(OmniLight3D::PARAM_RANGE, 4096);
|
|
}
|
|
|
|
// This is "correct", but FBX files may have unexpected decay modes.
|
|
// Also does not match with what FBX2glTF does, so it might be better to not do any of this..
|
|
#if 0
|
|
if (omni_light || spot_light) {
|
|
float attenuation = 1.0f;
|
|
if (additional_data.has("decay")) {
|
|
String decay_type = additional_data["decay"];
|
|
if (decay_type == "none") {
|
|
attenuation = 0.001f;
|
|
} else if (decay_type == "linear") {
|
|
attenuation = 1.0f;
|
|
} else if (decay_type == "quadratic") {
|
|
attenuation = 2.0f;
|
|
} else if (decay_type == "cubic") {
|
|
attenuation = 3.0f;
|
|
}
|
|
}
|
|
light->set_param(Light3D::PARAM_ATTENUATION, attenuation);
|
|
}
|
|
#endif
|
|
|
|
if (spot_light) {
|
|
// Line of best fit derived from guessing, see https://www.desmos.com/calculator/biiflubp8b
|
|
// The points in desmos are not exact, except for (1, infinity).
|
|
float angle_ratio = l->get_inner_cone_angle() / l->get_outer_cone_angle();
|
|
float angle_attenuation = 0.2 / (1 - angle_ratio) - 0.1;
|
|
light->set_param(SpotLight3D::PARAM_SPOT_ATTENUATION, angle_attenuation);
|
|
}
|
|
}
|
|
|
|
return light;
|
|
}
|
|
|
|
Node3D *FBXDocument::_generate_spatial(Ref<FBXState> p_state, const GLTFNodeIndex p_node_index) {
|
|
Ref<GLTFNode> fbx_node = p_state->nodes[p_node_index];
|
|
|
|
Node3D *spatial = memnew(Node3D);
|
|
print_verbose("FBX: Converting spatial: " + fbx_node->get_name());
|
|
|
|
return spatial;
|
|
}
|
|
|
|
void FBXDocument::_generate_scene_node(Ref<FBXState> p_state, const GLTFNodeIndex p_node_index, Node *p_scene_parent, Node *p_scene_root) {
|
|
Ref<GLTFNode> fbx_node = p_state->nodes[p_node_index];
|
|
|
|
if (fbx_node->skeleton >= 0) {
|
|
_generate_skeleton_bone_node(p_state, p_node_index, p_scene_parent, p_scene_root);
|
|
return;
|
|
}
|
|
|
|
Node3D *current_node = nullptr;
|
|
|
|
// Is our parent a skeleton
|
|
Skeleton3D *active_skeleton = Object::cast_to<Skeleton3D>(p_scene_parent);
|
|
|
|
const bool non_bone_parented_to_skeleton = active_skeleton;
|
|
|
|
// skinned meshes must not be placed in a bone attachment.
|
|
if (non_bone_parented_to_skeleton && fbx_node->skin < 0) {
|
|
// Bone Attachment - Parent Case
|
|
BoneAttachment3D *bone_attachment = _generate_bone_attachment(p_state, active_skeleton, p_node_index, fbx_node->parent);
|
|
|
|
p_scene_parent->add_child(bone_attachment, true);
|
|
bone_attachment->set_owner(p_scene_root);
|
|
|
|
// There is no fbx_node that represent this, so just directly create a unique name
|
|
bone_attachment->set_name(fbx_node->get_name());
|
|
|
|
// 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
|
|
p_scene_parent = bone_attachment;
|
|
}
|
|
if (!current_node) {
|
|
if (fbx_node->skin >= 0 && fbx_node->mesh >= 0 && !fbx_node->children.is_empty()) {
|
|
current_node = _generate_spatial(p_state, p_node_index);
|
|
Node3D *mesh_inst = _generate_mesh_instance(p_state, p_node_index);
|
|
mesh_inst->set_name(fbx_node->get_name());
|
|
|
|
current_node->add_child(mesh_inst, true);
|
|
} else if (fbx_node->mesh >= 0) {
|
|
current_node = _generate_mesh_instance(p_state, p_node_index);
|
|
} else if (fbx_node->camera >= 0) {
|
|
current_node = _generate_camera(p_state, p_node_index);
|
|
} else if (fbx_node->light >= 0) {
|
|
current_node = _generate_light(p_state, p_node_index);
|
|
} else {
|
|
current_node = _generate_spatial(p_state, p_node_index);
|
|
}
|
|
}
|
|
|
|
ERR_FAIL_NULL(current_node);
|
|
|
|
// Add the node we generated and set the owner to the scene root.
|
|
p_scene_parent->add_child(current_node, true);
|
|
if (current_node != p_scene_root) {
|
|
Array args;
|
|
args.append(p_scene_root);
|
|
current_node->propagate_call(StringName("set_owner"), args);
|
|
}
|
|
current_node->set_transform(fbx_node->transform);
|
|
current_node->set_name(fbx_node->get_name());
|
|
|
|
p_state->scene_nodes.insert(p_node_index, current_node);
|
|
for (int i = 0; i < fbx_node->children.size(); ++i) {
|
|
_generate_scene_node(p_state, fbx_node->children[i], current_node, p_scene_root);
|
|
}
|
|
}
|
|
|
|
void FBXDocument::_generate_skeleton_bone_node(Ref<FBXState> p_state, const GLTFNodeIndex p_node_index, Node *p_scene_parent, Node *p_scene_root) {
|
|
Ref<GLTFNode> fbx_node = p_state->nodes[p_node_index];
|
|
|
|
Node3D *current_node = nullptr;
|
|
|
|
Skeleton3D *skeleton = p_state->skeletons[fbx_node->skeleton]->godot_skeleton;
|
|
// In this case, this node is already a bone in skeleton.
|
|
const bool is_skinned_mesh = (fbx_node->skin >= 0 && fbx_node->mesh >= 0);
|
|
const bool requires_extra_node = (fbx_node->mesh >= 0 || fbx_node->camera >= 0 || fbx_node->light >= 0);
|
|
|
|
Skeleton3D *active_skeleton = Object::cast_to<Skeleton3D>(p_scene_parent);
|
|
if (active_skeleton != skeleton) {
|
|
if (active_skeleton) {
|
|
// Should no longer be possible.
|
|
ERR_PRINT(vformat("FBX: Generating scene detected direct parented Skeletons at node %d", p_node_index));
|
|
BoneAttachment3D *bone_attachment = _generate_bone_attachment(p_state, active_skeleton, p_node_index, fbx_node->parent);
|
|
p_scene_parent->add_child(bone_attachment, true);
|
|
bone_attachment->set_owner(p_scene_root);
|
|
// There is no fbx_node that represent this, so just directly create a unique name
|
|
bone_attachment->set_name(_gen_unique_name(p_state->unique_names, "BoneAttachment3D"));
|
|
// 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
|
|
p_scene_parent = bone_attachment;
|
|
}
|
|
if (skeleton->get_parent() == nullptr) {
|
|
p_scene_parent->add_child(skeleton, true);
|
|
skeleton->set_owner(p_scene_root);
|
|
}
|
|
}
|
|
|
|
active_skeleton = skeleton;
|
|
current_node = active_skeleton;
|
|
if (active_skeleton) {
|
|
p_scene_parent = active_skeleton;
|
|
}
|
|
|
|
if (requires_extra_node) {
|
|
current_node = nullptr;
|
|
// skinned meshes must not be placed in a bone attachment.
|
|
if (!is_skinned_mesh) {
|
|
// Bone Attachment - Same Node Case
|
|
BoneAttachment3D *bone_attachment = _generate_bone_attachment(p_state, active_skeleton, p_node_index, p_node_index);
|
|
|
|
p_scene_parent->add_child(bone_attachment, true);
|
|
bone_attachment->set_owner(p_scene_root);
|
|
|
|
// There is no fbx_node that represent this, so just directly create a unique name
|
|
bone_attachment->set_name(fbx_node->get_name());
|
|
|
|
// 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
|
|
p_scene_parent = bone_attachment;
|
|
}
|
|
// TODO: 20240118 // fire
|
|
// // Check if any GLTFDocumentExtension classes want to generate a node for us.
|
|
// for (Ref<GLTFDocumentExtension> ext : document_extensions) {
|
|
// ERR_CONTINUE(ext.is_null());
|
|
// current_node = ext->generate_scene_node(p_state, fbx_node, p_scene_parent);
|
|
// if (current_node) {
|
|
// break;
|
|
// }
|
|
// }
|
|
// If none of our GLTFDocumentExtension classes generated us a node, we generate one.
|
|
if (!current_node) {
|
|
if (fbx_node->mesh >= 0) {
|
|
current_node = _generate_mesh_instance(p_state, p_node_index);
|
|
} else if (fbx_node->camera >= 0) {
|
|
current_node = _generate_camera(p_state, p_node_index);
|
|
} else {
|
|
current_node = _generate_spatial(p_state, p_node_index);
|
|
}
|
|
}
|
|
// Add the node we generated and set the owner to the scene root.
|
|
p_scene_parent->add_child(current_node, true);
|
|
if (current_node != p_scene_root) {
|
|
Array args;
|
|
args.append(p_scene_root);
|
|
current_node->propagate_call(StringName("set_owner"), args);
|
|
}
|
|
// Do not set transform here. Transform is already applied to our bone.
|
|
current_node->set_name(fbx_node->get_name());
|
|
}
|
|
|
|
p_state->scene_nodes.insert(p_node_index, current_node);
|
|
|
|
for (int i = 0; i < fbx_node->children.size(); ++i) {
|
|
_generate_scene_node(p_state, fbx_node->children[i], active_skeleton, p_scene_root);
|
|
}
|
|
}
|
|
|
|
void FBXDocument::_import_animation(Ref<FBXState> p_state, AnimationPlayer *p_animation_player, const GLTFAnimationIndex p_index, const float p_bake_fps, const bool p_trimming, const bool p_remove_immutable_tracks) {
|
|
Ref<GLTFAnimation> anim = p_state->animations[p_index];
|
|
|
|
String anim_name = anim->get_name();
|
|
if (anim_name.is_empty()) {
|
|
// No node represent these, and they are not in the hierarchy, so just make a unique name
|
|
anim_name = _gen_unique_name(p_state->unique_names, "Animation");
|
|
}
|
|
|
|
Ref<Animation> animation;
|
|
animation.instantiate();
|
|
animation->set_name(anim_name);
|
|
animation->set_step(1.0 / p_bake_fps);
|
|
|
|
if (anim->get_loop()) {
|
|
animation->set_loop_mode(Animation::LOOP_LINEAR);
|
|
}
|
|
|
|
Dictionary additional_animation_data = anim->get_additional_data("GODOT_animation_time_begin_time_end");
|
|
|
|
double anim_start_offset = p_trimming ? double(additional_animation_data["time_begin"]) : 0.0;
|
|
|
|
for (const KeyValue<int, GLTFAnimation::Track> &track_i : anim->get_tracks()) {
|
|
const GLTFAnimation::Track &track = track_i.value;
|
|
//need to find the path: for skeletons, weight tracks will affect the mesh
|
|
NodePath node_path;
|
|
//for skeletons, transform tracks always affect bones
|
|
NodePath transform_node_path;
|
|
GLTFNodeIndex node_index = track_i.key;
|
|
Node *root = p_animation_player->get_parent();
|
|
ERR_FAIL_NULL(root);
|
|
HashMap<GLTFNodeIndex, Node *>::Iterator node_element = p_state->scene_nodes.find(node_index);
|
|
ERR_CONTINUE_MSG(!node_element, vformat("Unable to find node %d for animation.", node_index));
|
|
node_path = root->get_path_to(node_element->value);
|
|
|
|
const Ref<GLTFNode> fbx_node = p_state->nodes[track_i.key];
|
|
|
|
if (fbx_node->skeleton >= 0) {
|
|
const Skeleton3D *sk = p_state->skeletons[fbx_node->skeleton]->godot_skeleton;
|
|
ERR_FAIL_NULL(sk);
|
|
|
|
const String path = p_animation_player->get_parent()->get_path_to(sk);
|
|
const String bone = fbx_node->get_name();
|
|
transform_node_path = path + ":" + bone;
|
|
} else {
|
|
transform_node_path = node_path;
|
|
}
|
|
|
|
// Animated TRS properties will not affect a skinned mesh.
|
|
const bool transform_affects_skinned_mesh_instance = fbx_node->skeleton < 0 && fbx_node->skin >= 0;
|
|
if ((track.rotation_track.values.size() || track.position_track.values.size() || track.scale_track.values.size()) && !transform_affects_skinned_mesh_instance) {
|
|
// Make a transform track.
|
|
int base_idx = animation->get_track_count();
|
|
int position_idx = -1;
|
|
int rotation_idx = -1;
|
|
int scale_idx = -1;
|
|
|
|
if (track.position_track.values.size()) {
|
|
bool is_default = true; // Discard the track if all it contains is default values.
|
|
if (p_remove_immutable_tracks) {
|
|
Vector3 base_pos = p_state->nodes[track_i.key]->transform.origin;
|
|
for (int i = 0; i < track.position_track.times.size(); i++) {
|
|
Vector3 value = track.position_track.values[track.position_track.interpolation == GLTFAnimation::INTERP_CUBIC_SPLINE ? (1 + i * 3) : i];
|
|
if (!value.is_equal_approx(base_pos)) {
|
|
is_default = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!p_remove_immutable_tracks || !is_default) {
|
|
position_idx = base_idx;
|
|
animation->add_track(Animation::TYPE_POSITION_3D);
|
|
animation->track_set_path(position_idx, transform_node_path);
|
|
animation->track_set_imported(position_idx, true); // Helps merging positions later.
|
|
base_idx++;
|
|
}
|
|
}
|
|
if (track.rotation_track.values.size()) {
|
|
bool is_default = true; // Discard the track if all the track contains is the default values.
|
|
if (p_remove_immutable_tracks) {
|
|
Quaternion base_rot = p_state->nodes[track_i.key]->transform.basis.get_rotation_quaternion();
|
|
for (int i = 0; i < track.rotation_track.times.size(); i++) {
|
|
Quaternion value = track.rotation_track.values[track.rotation_track.interpolation == GLTFAnimation::INTERP_CUBIC_SPLINE ? (1 + i * 3) : i].normalized();
|
|
if (!value.is_equal_approx(base_rot)) {
|
|
is_default = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!p_remove_immutable_tracks || !is_default) {
|
|
rotation_idx = base_idx;
|
|
animation->add_track(Animation::TYPE_ROTATION_3D);
|
|
animation->track_set_path(rotation_idx, transform_node_path);
|
|
animation->track_set_imported(rotation_idx, true); //helps merging later
|
|
base_idx++;
|
|
}
|
|
}
|
|
if (track.scale_track.values.size()) {
|
|
bool is_default = true; // Discard the track if all the track contains is the default values.
|
|
if (p_remove_immutable_tracks) {
|
|
Vector3 base_scale = p_state->nodes[track_i.key]->transform.basis.get_scale();
|
|
for (int i = 0; i < track.scale_track.times.size(); i++) {
|
|
Vector3 value = track.scale_track.values[track.scale_track.interpolation == GLTFAnimation::INTERP_CUBIC_SPLINE ? (1 + i * 3) : i];
|
|
if (!value.is_equal_approx(base_scale)) {
|
|
is_default = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!p_remove_immutable_tracks || !is_default) {
|
|
scale_idx = base_idx;
|
|
animation->add_track(Animation::TYPE_SCALE_3D);
|
|
animation->track_set_path(scale_idx, transform_node_path);
|
|
animation->track_set_imported(scale_idx, true); //helps merging later
|
|
base_idx++;
|
|
}
|
|
}
|
|
|
|
if (position_idx != -1) {
|
|
animation->track_set_interpolation_type(position_idx, Animation::INTERPOLATION_LINEAR);
|
|
for (int j = 0; j < track.position_track.times.size(); j++) {
|
|
const float t = track.position_track.times[j] - anim_start_offset;
|
|
const Vector3 value = track.position_track.values[j];
|
|
animation->position_track_insert_key(position_idx, t, value);
|
|
}
|
|
}
|
|
|
|
if (rotation_idx != -1) {
|
|
animation->track_set_interpolation_type(rotation_idx, Animation::INTERPOLATION_LINEAR);
|
|
for (int j = 0; j < track.rotation_track.times.size(); j++) {
|
|
const float t = track.rotation_track.times[j] - anim_start_offset;
|
|
const Quaternion value = track.rotation_track.values[j];
|
|
animation->rotation_track_insert_key(rotation_idx, t, value);
|
|
}
|
|
}
|
|
|
|
if (scale_idx != -1) {
|
|
animation->track_set_interpolation_type(scale_idx, Animation::INTERPOLATION_LINEAR);
|
|
for (int j = 0; j < track.scale_track.times.size(); j++) {
|
|
const float t = track.scale_track.times[j] - anim_start_offset;
|
|
const Vector3 value = track.scale_track.values[j];
|
|
animation->scale_track_insert_key(scale_idx, t, value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Dictionary blend_shape_animations = anim->get_additional_data("GODOT_blend_shape_animations");
|
|
|
|
for (GLTFNodeIndex node_index = 0; node_index < p_state->nodes.size(); node_index++) {
|
|
Ref<GLTFNode> node = p_state->nodes[node_index];
|
|
if (node->mesh < 0) {
|
|
continue;
|
|
}
|
|
|
|
// For meshes, especially skinned meshes, there are cases where it will be added as a child.
|
|
NodePath mesh_instance_node_path;
|
|
|
|
Node *root = p_animation_player->get_parent();
|
|
ERR_FAIL_NULL(root);
|
|
HashMap<GLTFNodeIndex, Node *>::Iterator node_element = p_state->scene_nodes.find(node_index);
|
|
ERR_CONTINUE_MSG(!node_element, vformat("Unable to find node %d for animation.", node_index));
|
|
NodePath node_path = root->get_path_to(node_element->value);
|
|
HashMap<GLTFNodeIndex, ImporterMeshInstance3D *>::Iterator mesh_instance_element = p_state->scene_mesh_instances.find(node_index);
|
|
if (mesh_instance_element) {
|
|
mesh_instance_node_path = root->get_path_to(mesh_instance_element->value);
|
|
} else {
|
|
mesh_instance_node_path = node_path;
|
|
}
|
|
|
|
Ref<GLTFMesh> mesh = p_state->meshes[node->mesh];
|
|
ERR_CONTINUE(mesh.is_null());
|
|
ERR_CONTINUE(mesh->get_mesh().is_null());
|
|
ERR_CONTINUE(mesh->get_mesh()->get_mesh().is_null());
|
|
|
|
Dictionary mesh_additional_data = mesh->get_additional_data("GODOT_mesh_blend_channels");
|
|
Vector<int> blend_channels = mesh_additional_data["blend_channels"];
|
|
|
|
for (int i = 0; i < blend_channels.size(); i++) {
|
|
int blend_i = blend_channels[i];
|
|
if (!blend_shape_animations.has(blend_i)) {
|
|
continue;
|
|
}
|
|
Dictionary blend_track = blend_shape_animations[blend_i];
|
|
|
|
GLTFAnimation::Channel<real_t> weights;
|
|
weights.interpolation = GLTFAnimation::INTERP_LINEAR;
|
|
weights.times = blend_track["times"];
|
|
weights.values = blend_track["values"];
|
|
|
|
const String blend_path = String(mesh_instance_node_path) + ":" + String(mesh->get_mesh()->get_blend_shape_name(i));
|
|
const int track_idx = animation->get_track_count();
|
|
animation->add_track(Animation::TYPE_BLEND_SHAPE);
|
|
animation->track_set_path(track_idx, blend_path);
|
|
animation->track_set_imported(track_idx, true); // Helps merging later.
|
|
|
|
animation->track_set_interpolation_type(track_idx, Animation::INTERPOLATION_LINEAR);
|
|
for (int j = 0; j < weights.times.size(); j++) {
|
|
const double t = weights.times[j] - anim_start_offset;
|
|
const real_t attribs = weights.values[j];
|
|
animation->blend_shape_track_insert_key(track_idx, t, attribs);
|
|
}
|
|
}
|
|
}
|
|
double time_begin = additional_animation_data["time_begin"];
|
|
double time_end = additional_animation_data["time_end"];
|
|
double length = p_trimming ? time_end - time_begin : time_end;
|
|
animation->set_length(length);
|
|
|
|
Ref<AnimationLibrary> library;
|
|
if (!p_animation_player->has_animation_library("")) {
|
|
library.instantiate();
|
|
p_animation_player->add_animation_library("", library);
|
|
} else {
|
|
library = p_animation_player->get_animation_library("");
|
|
}
|
|
library->add_animation(anim_name, animation);
|
|
}
|
|
|
|
void FBXDocument::_process_mesh_instances(Ref<FBXState> p_state, Node *p_scene_root) {
|
|
for (GLTFNodeIndex node_i = 0; node_i < p_state->nodes.size(); ++node_i) {
|
|
Ref<GLTFNode> node = p_state->nodes[node_i];
|
|
|
|
if (node.is_null() || !(node->skin >= 0 && node->mesh >= 0)) {
|
|
continue;
|
|
}
|
|
|
|
const GLTFSkinIndex skin_i = node->skin;
|
|
|
|
ImporterMeshInstance3D *mi = nullptr;
|
|
HashMap<GLTFNodeIndex, ImporterMeshInstance3D *>::Iterator mi_element = p_state->scene_mesh_instances.find(node_i);
|
|
if (!mi_element) {
|
|
HashMap<GLTFNodeIndex, Node *>::Iterator si_element = p_state->scene_nodes.find(node_i);
|
|
ERR_CONTINUE_MSG(!si_element, vformat("Unable to find node %d", node_i));
|
|
mi = Object::cast_to<ImporterMeshInstance3D>(si_element->value);
|
|
ERR_CONTINUE_MSG(mi == nullptr, vformat("Unable to cast node %d of type %s to ImporterMeshInstance3D", node_i, si_element->value->get_class_name()));
|
|
} else {
|
|
mi = mi_element->value;
|
|
}
|
|
|
|
bool is_skin_valid = node->skin >= 0;
|
|
bool is_skin_accessible = is_skin_valid && node->skin < p_state->skins.size();
|
|
bool is_valid = is_skin_accessible && p_state->skins.write[node->skin]->skeleton >= 0;
|
|
|
|
if (!is_valid) {
|
|
continue;
|
|
}
|
|
|
|
const GLTFSkeletonIndex skel_i = p_state->skins.write[node->skin]->skeleton;
|
|
Ref<GLTFSkeleton> fbx_skeleton = p_state->skeletons.write[skel_i];
|
|
Skeleton3D *skeleton = fbx_skeleton->godot_skeleton;
|
|
ERR_CONTINUE_MSG(skeleton == nullptr, vformat("Unable to find Skeleton for node %d skin %d", node_i, skin_i));
|
|
|
|
mi->get_parent()->remove_child(mi);
|
|
skeleton->add_child(mi, true);
|
|
mi->set_owner(skeleton->get_owner());
|
|
|
|
mi->set_skin(p_state->skins.write[skin_i]->godot_skin);
|
|
mi->set_skeleton_path(mi->get_path_to(skeleton));
|
|
mi->set_transform(Transform3D());
|
|
}
|
|
}
|
|
|
|
Error FBXDocument::_parse(Ref<FBXState> p_state, String p_path, Ref<FileAccess> p_file) {
|
|
p_state->scene.reset();
|
|
|
|
Error err = ERR_INVALID_DATA;
|
|
if (p_file.is_null()) {
|
|
return FAILED;
|
|
}
|
|
|
|
ufbx_load_opts opts = {};
|
|
opts.target_axes = ufbx_axes_right_handed_y_up;
|
|
opts.target_unit_meters = 1.0f;
|
|
opts.space_conversion = UFBX_SPACE_CONVERSION_MODIFY_GEOMETRY;
|
|
if (!p_state->get_allow_geometry_helper_nodes()) {
|
|
opts.geometry_transform_handling = UFBX_GEOMETRY_TRANSFORM_HANDLING_MODIFY_GEOMETRY_NO_FALLBACK;
|
|
opts.inherit_mode_handling = UFBX_INHERIT_MODE_HANDLING_IGNORE;
|
|
} else {
|
|
opts.geometry_transform_handling = UFBX_GEOMETRY_TRANSFORM_HANDLING_HELPER_NODES;
|
|
opts.inherit_mode_handling = UFBX_INHERIT_MODE_HANDLING_COMPENSATE;
|
|
}
|
|
opts.pivot_handling = UFBX_PIVOT_HANDLING_ADJUST_TO_PIVOT;
|
|
opts.geometry_transform_helper_name.data = "GeometryTransformHelper";
|
|
opts.geometry_transform_helper_name.length = SIZE_MAX;
|
|
opts.scale_helper_name.data = "ScaleHelper";
|
|
opts.scale_helper_name.length = SIZE_MAX;
|
|
opts.node_depth_limit = 512;
|
|
opts.target_camera_axes = ufbx_axes_right_handed_y_up;
|
|
opts.target_light_axes = ufbx_axes_right_handed_y_up;
|
|
opts.clean_skin_weights = true;
|
|
if (p_state->discard_meshes_and_materials) {
|
|
opts.ignore_geometry = true;
|
|
opts.ignore_embedded = true;
|
|
}
|
|
opts.generate_missing_normals = true;
|
|
|
|
ThreadPoolFBX thread_pool;
|
|
thread_pool.pool = WorkerThreadPool::get_singleton();
|
|
|
|
opts.thread_opts.pool.init_fn = &_thread_pool_init_fn;
|
|
opts.thread_opts.pool.run_fn = &_thread_pool_run_fn;
|
|
opts.thread_opts.pool.wait_fn = &_thread_pool_wait_fn;
|
|
opts.thread_opts.pool.user = &thread_pool;
|
|
opts.thread_opts.memory_limit = 64 * 1024 * 1024;
|
|
|
|
ufbx_error error;
|
|
ufbx_stream file_stream = {};
|
|
file_stream.read_fn = &_file_access_read_fn;
|
|
file_stream.skip_fn = &_file_access_skip_fn;
|
|
file_stream.user = p_file.ptr();
|
|
p_state->scene.reset(ufbx_load_stream(&file_stream, &opts, &error));
|
|
|
|
if (!p_state->scene.get()) {
|
|
char err_buf[512];
|
|
ufbx_format_error(err_buf, sizeof(err_buf), &error);
|
|
ERR_FAIL_V_MSG(ERR_PARSE_ERROR, err_buf);
|
|
}
|
|
|
|
err = _parse_fbx_state(p_state, p_path);
|
|
ERR_FAIL_COND_V(err != OK, err);
|
|
|
|
return OK;
|
|
}
|
|
|
|
void FBXDocument::_bind_methods() {
|
|
}
|
|
|
|
Node *FBXDocument::generate_scene(Ref<GLTFState> p_state, float p_bake_fps, bool p_trimming, bool p_remove_immutable_tracks) {
|
|
Ref<FBXState> state = p_state;
|
|
ERR_FAIL_COND_V(state.is_null(), nullptr);
|
|
ERR_FAIL_NULL_V(state, nullptr);
|
|
ERR_FAIL_INDEX_V(0, state->root_nodes.size(), nullptr);
|
|
GLTFNodeIndex fbx_root = state->root_nodes.write[0];
|
|
Node *fbx_root_node = state->get_scene_node(fbx_root);
|
|
Node *root = fbx_root_node;
|
|
if (root && root->get_owner() && root->get_owner() != root) {
|
|
root = root->get_owner();
|
|
}
|
|
ERR_FAIL_NULL_V(root, nullptr);
|
|
_process_mesh_instances(state, root);
|
|
if (state->get_create_animations() && state->animations.size()) {
|
|
AnimationPlayer *ap = memnew(AnimationPlayer);
|
|
root->add_child(ap, true);
|
|
ap->set_owner(root);
|
|
for (int i = 0; i < state->animations.size(); i++) {
|
|
_import_animation(state, ap, i, p_bake_fps, p_trimming, p_remove_immutable_tracks);
|
|
}
|
|
}
|
|
ERR_FAIL_NULL_V(root, nullptr);
|
|
return root;
|
|
}
|
|
|
|
Error FBXDocument::append_from_buffer(PackedByteArray p_bytes, String p_base_path, Ref<GLTFState> p_state, uint32_t p_flags) {
|
|
Ref<FBXState> state = p_state;
|
|
ERR_FAIL_COND_V(state.is_null(), ERR_INVALID_PARAMETER);
|
|
ERR_FAIL_NULL_V(p_bytes.ptr(), ERR_INVALID_DATA);
|
|
Error err = FAILED;
|
|
state->use_named_skin_binds = p_flags & FBX_IMPORT_USE_NAMED_SKIN_BINDS;
|
|
state->discard_meshes_and_materials = p_flags & FBX_IMPORT_DISCARD_MESHES_AND_MATERIALS;
|
|
|
|
Ref<FileAccessMemory> file_access;
|
|
file_access.instantiate();
|
|
file_access->open_custom(p_bytes.ptr(), p_bytes.size());
|
|
state->base_path = p_base_path.get_base_dir();
|
|
err = _parse(state, state->base_path, file_access);
|
|
ERR_FAIL_COND_V(err != OK, err);
|
|
// TODO: 202040118 // fire
|
|
// for (Ref<GLTFDocumentExtension> ext : get_all_gltf_document_extensions()) {
|
|
// ERR_CONTINUE(ext.is_null());
|
|
// err = ext->import_post_parse(state);
|
|
// ERR_FAIL_COND_V(err != OK, err);
|
|
// }
|
|
return OK;
|
|
}
|
|
|
|
Error FBXDocument::_parse_fbx_state(Ref<FBXState> p_state, const String &p_search_path) {
|
|
Error err;
|
|
|
|
// Abort parsing if the scene is not loaded.
|
|
ERR_FAIL_NULL_V(p_state->scene.get(), ERR_PARSE_ERROR);
|
|
|
|
/* PARSE SCENE */
|
|
err = _parse_scenes(p_state);
|
|
ERR_FAIL_COND_V(err != OK, ERR_PARSE_ERROR);
|
|
|
|
/* PARSE NODES */
|
|
err = _parse_nodes(p_state);
|
|
ERR_FAIL_COND_V(err != OK, ERR_PARSE_ERROR);
|
|
|
|
if (!p_state->discard_meshes_and_materials) {
|
|
/* PARSE IMAGES */
|
|
err = _parse_images(p_state, p_search_path);
|
|
|
|
ERR_FAIL_COND_V(err != OK, ERR_PARSE_ERROR);
|
|
|
|
/* PARSE MATERIALS */
|
|
err = _parse_materials(p_state);
|
|
|
|
ERR_FAIL_COND_V(err != OK, ERR_PARSE_ERROR);
|
|
}
|
|
|
|
/* PARSE SKINS */
|
|
err = _parse_skins(p_state);
|
|
ERR_FAIL_COND_V(err != OK, ERR_PARSE_ERROR);
|
|
|
|
/* DETERMINE SKELETONS */
|
|
err = SkinTool::_determine_skeletons(p_state->skins, p_state->nodes, p_state->skeletons, p_state->get_import_as_skeleton_bones() ? p_state->root_nodes : Vector<GLTFNodeIndex>());
|
|
ERR_FAIL_COND_V(err != OK, ERR_PARSE_ERROR);
|
|
|
|
/* CREATE SKELETONS */
|
|
err = SkinTool::_create_skeletons(p_state->unique_names, p_state->skins, p_state->nodes, p_state->skeleton3d_to_fbx_skeleton, p_state->skeletons, p_state->scene_nodes);
|
|
ERR_FAIL_COND_V(err != OK, ERR_PARSE_ERROR);
|
|
|
|
/* CREATE SKINS */
|
|
err = SkinTool::_create_skins(p_state->skins, p_state->nodes, p_state->use_named_skin_binds, p_state->unique_names);
|
|
ERR_FAIL_COND_V(err != OK, ERR_PARSE_ERROR);
|
|
|
|
/* PARSE MESHES (we have enough info now) */
|
|
err = _parse_meshes(p_state);
|
|
ERR_FAIL_COND_V(err != OK, ERR_PARSE_ERROR);
|
|
|
|
/* PARSE LIGHTS */
|
|
err = _parse_lights(p_state);
|
|
ERR_FAIL_COND_V(err != OK, ERR_PARSE_ERROR);
|
|
|
|
/* PARSE CAMERAS */
|
|
err = _parse_cameras(p_state);
|
|
ERR_FAIL_COND_V(err != OK, ERR_PARSE_ERROR);
|
|
|
|
/* PARSE ANIMATIONS */
|
|
err = _parse_animations(p_state);
|
|
ERR_FAIL_COND_V(err != OK, ERR_PARSE_ERROR);
|
|
|
|
/* ASSIGN SCENE NAMES */
|
|
_assign_node_names(p_state);
|
|
|
|
Node3D *root = memnew(Node3D);
|
|
for (int32_t root_i = 0; root_i < p_state->root_nodes.size(); root_i++) {
|
|
_generate_scene_node(p_state, p_state->root_nodes[root_i], root, root);
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error FBXDocument::append_from_file(String p_path, Ref<GLTFState> p_state, uint32_t p_flags, String p_base_path) {
|
|
Ref<FBXState> state = p_state;
|
|
ERR_FAIL_COND_V(state.is_null(), ERR_INVALID_PARAMETER);
|
|
ERR_FAIL_COND_V(p_path.is_empty(), ERR_FILE_NOT_FOUND);
|
|
if (p_state == Ref<FBXState>()) {
|
|
p_state.instantiate();
|
|
}
|
|
state->filename = p_path.get_file().get_basename();
|
|
state->use_named_skin_binds = p_flags & FBX_IMPORT_USE_NAMED_SKIN_BINDS;
|
|
state->discard_meshes_and_materials = p_flags & FBX_IMPORT_DISCARD_MESHES_AND_MATERIALS;
|
|
Error err;
|
|
Ref<FileAccess> file = FileAccess::open(p_path, FileAccess::READ, &err);
|
|
ERR_FAIL_COND_V(err != OK, ERR_FILE_CANT_OPEN);
|
|
ERR_FAIL_NULL_V(file, ERR_FILE_CANT_OPEN);
|
|
String base_path = p_base_path;
|
|
if (base_path.is_empty()) {
|
|
base_path = p_path.get_base_dir();
|
|
}
|
|
state->base_path = base_path;
|
|
err = _parse(p_state, base_path, file);
|
|
ERR_FAIL_COND_V(err != OK, err);
|
|
// TODO: 20240118 // fire
|
|
// for (Ref<GLTFDocumentExtension> ext : document_extensions) {
|
|
// ERR_CONTINUE(ext.is_null());
|
|
// err = ext->import_post_parse(p_state);
|
|
// ERR_FAIL_COND_V(err != OK, err);
|
|
// }
|
|
return OK;
|
|
}
|
|
|
|
void FBXDocument::_process_uv_set(PackedVector2Array &uv_array) {
|
|
int uv_size = uv_array.size();
|
|
for (int uv_i = 0; uv_i < uv_size; uv_i++) {
|
|
Vector2 &uv = uv_array.write[uv_i];
|
|
uv.y = 1.0 - uv.y;
|
|
}
|
|
}
|
|
|
|
void FBXDocument::_zero_unused_elements(Vector<float> &cur_custom, int start, int end, int num_channels) {
|
|
for (int32_t uv_i = start; uv_i < end; uv_i++) {
|
|
int index = uv_i * num_channels;
|
|
for (int channel = 0; channel < num_channels; channel++) {
|
|
cur_custom.write[index + channel] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
Error FBXDocument::_parse_lights(Ref<FBXState> p_state) {
|
|
const ufbx_scene *fbx_scene = p_state->scene.get();
|
|
for (size_t i = 0; i < fbx_scene->lights.count; i++) {
|
|
const ufbx_light *fbx_light = fbx_scene->lights.data[i];
|
|
Ref<GLTFLight> light;
|
|
light.instantiate();
|
|
light->set_name(_as_string(fbx_light->name));
|
|
light->set_color(Color(fbx_light->color.x, fbx_light->color.y, fbx_light->color.z));
|
|
light->set_intensity(fbx_light->intensity);
|
|
switch (fbx_light->type) {
|
|
case UFBX_LIGHT_POINT:
|
|
light->set_light_type("point");
|
|
break;
|
|
case UFBX_LIGHT_DIRECTIONAL:
|
|
light->set_light_type("directional");
|
|
break;
|
|
case UFBX_LIGHT_SPOT:
|
|
light->set_light_type("spot");
|
|
break;
|
|
case UFBX_LIGHT_AREA:
|
|
light->set_light_type("area");
|
|
break;
|
|
case UFBX_LIGHT_VOLUME:
|
|
light->set_light_type("volume");
|
|
break;
|
|
default:
|
|
light->set_light_type("unknown");
|
|
break;
|
|
}
|
|
|
|
Dictionary additional_data;
|
|
additional_data["shadow"] = fbx_light->cast_shadows;
|
|
if (fbx_light->decay == UFBX_LIGHT_DECAY_NONE) {
|
|
additional_data["decay"] = "none";
|
|
|
|
} else if (fbx_light->decay == UFBX_LIGHT_DECAY_LINEAR) {
|
|
additional_data["decay"] = "linear";
|
|
|
|
} else if (fbx_light->decay == UFBX_LIGHT_DECAY_QUADRATIC) {
|
|
additional_data["decay"] = "quadratic";
|
|
|
|
} else if (fbx_light->decay == UFBX_LIGHT_DECAY_CUBIC) {
|
|
additional_data["decay"] = "cubic";
|
|
}
|
|
|
|
if (fbx_light->area_shape == UFBX_LIGHT_AREA_SHAPE_RECTANGLE) {
|
|
additional_data["areaShape"] = "rectangle";
|
|
} else if (fbx_light->area_shape == UFBX_LIGHT_AREA_SHAPE_SPHERE) {
|
|
additional_data["areaShape"] = "sphere";
|
|
}
|
|
|
|
light->set_inner_cone_angle(fbx_light->inner_angle);
|
|
light->set_outer_cone_angle(fbx_light->outer_angle);
|
|
|
|
additional_data["castLight"] = fbx_light->cast_light;
|
|
additional_data["castShadows"] = fbx_light->cast_shadows;
|
|
light->set_additional_data("GODOT_fbx_light", additional_data);
|
|
p_state->lights.push_back(light);
|
|
}
|
|
print_verbose("FBX: Total lights: " + itos(p_state->lights.size()));
|
|
return OK;
|
|
}
|
|
|
|
String FBXDocument::_get_texture_path(const String &p_base_dir, const String &p_source_file_path) const {
|
|
// Check if the original path exists first.
|
|
if (FileAccess::exists(p_source_file_path)) {
|
|
return p_source_file_path.strip_edges();
|
|
}
|
|
const String tex_file_name = p_source_file_path.get_file();
|
|
const Vector<String> subdirs = {
|
|
"", "textures/", "Textures/", "images/",
|
|
"Images/", "materials/", "Materials/",
|
|
"maps/", "Maps/", "tex/", "Tex/"
|
|
};
|
|
String base_dir = p_base_dir;
|
|
const String source_file_name = tex_file_name;
|
|
while (!base_dir.is_empty()) {
|
|
String old_base_dir = base_dir;
|
|
for (int i = 0; i < subdirs.size(); ++i) {
|
|
String full_path = base_dir.path_join(subdirs[i] + source_file_name);
|
|
if (FileAccess::exists(full_path)) {
|
|
return full_path.strip_edges();
|
|
}
|
|
}
|
|
base_dir = base_dir.get_base_dir();
|
|
if (base_dir == old_base_dir) {
|
|
break;
|
|
}
|
|
}
|
|
return String();
|
|
}
|
|
|
|
Error FBXDocument::_parse_skins(Ref<FBXState> p_state) {
|
|
const ufbx_scene *fbx_scene = p_state->scene.get();
|
|
HashMap<GLTFNodeIndex, bool> joint_mapping;
|
|
|
|
for (const ufbx_skin_deformer *fbx_skin : fbx_scene->skin_deformers) {
|
|
if (fbx_skin->clusters.count == 0) {
|
|
p_state->skin_indices.push_back(-1);
|
|
continue;
|
|
}
|
|
|
|
Ref<GLTFSkin> skin;
|
|
skin.instantiate();
|
|
|
|
skin->inverse_binds.resize(fbx_skin->clusters.count);
|
|
for (int skin_i = 0; skin_i < static_cast<int>(fbx_skin->clusters.count); skin_i++) {
|
|
const ufbx_skin_cluster *fbx_cluster = fbx_skin->clusters[skin_i];
|
|
skin->inverse_binds.write[skin_i] = FBXDocument::_as_xform(fbx_cluster->geometry_to_bone);
|
|
const GLTFNodeIndex node = fbx_cluster->bone_node->typed_id;
|
|
|
|
skin->joints.push_back(node);
|
|
skin->joints_original.push_back(node);
|
|
p_state->nodes.write[node]->joint = true;
|
|
}
|
|
|
|
if (fbx_skin->name.length > 0) {
|
|
skin->set_name(FBXDocument::_as_string(fbx_skin->name));
|
|
} else {
|
|
skin->set_name(vformat("skin_%s", itos(fbx_skin->typed_id)));
|
|
}
|
|
p_state->skin_indices.push_back(p_state->skins.size());
|
|
p_state->skins.push_back(skin);
|
|
}
|
|
|
|
for (const ufbx_bone *fbx_bone : fbx_scene->bones) {
|
|
for (const ufbx_node *fbx_node : fbx_bone->instances) {
|
|
const GLTFNodeIndex node = fbx_node->typed_id;
|
|
if (!p_state->nodes.write[node]->joint) {
|
|
p_state->nodes.write[node]->joint = true;
|
|
|
|
if (!(fbx_node->parent && fbx_node->parent->attrib_type == UFBX_ELEMENT_BONE)) {
|
|
Ref<GLTFSkin> skin;
|
|
skin.instantiate();
|
|
skin->joints.push_back(node);
|
|
skin->joints_original.push_back(node);
|
|
skin->set_name(vformat("skin_%s", itos(p_state->skins.size())));
|
|
p_state->skin_indices.push_back(p_state->skins.size());
|
|
p_state->skins.push_back(skin);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Error err = SkinTool::_asset_parse_skins(
|
|
p_state->skin_indices.duplicate(),
|
|
p_state->skins.duplicate(),
|
|
p_state->nodes.duplicate(),
|
|
p_state->skin_indices,
|
|
p_state->skins,
|
|
joint_mapping);
|
|
if (err != OK) {
|
|
return err;
|
|
}
|
|
for (int i = 0; i < p_state->skins.size(); ++i) {
|
|
Ref<GLTFSkin> skin = p_state->skins.write[i];
|
|
ERR_FAIL_COND_V(skin.is_null(), ERR_PARSE_ERROR);
|
|
// Expand and verify the skin
|
|
ERR_FAIL_COND_V(SkinTool::_expand_skin(p_state->nodes, skin), ERR_PARSE_ERROR);
|
|
ERR_FAIL_COND_V(SkinTool::_verify_skin(p_state->nodes, skin), ERR_PARSE_ERROR);
|
|
}
|
|
|
|
print_verbose("FBX: Total skins: " + itos(p_state->skins.size()));
|
|
|
|
for (HashMap<GLTFNodeIndex, bool>::Iterator it = joint_mapping.begin(); it != joint_mapping.end(); ++it) {
|
|
GLTFNodeIndex node_index = it->key;
|
|
bool is_joint = it->value;
|
|
if (is_joint) {
|
|
if (p_state->nodes.size() > node_index) {
|
|
p_state->nodes.write[node_index]->joint = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
PackedByteArray FBXDocument::generate_buffer(Ref<GLTFState> p_state) {
|
|
return PackedByteArray();
|
|
}
|
|
|
|
Error FBXDocument::write_to_filesystem(Ref<GLTFState> p_state, const String &p_path) {
|
|
return ERR_UNAVAILABLE;
|
|
}
|
|
|
|
Error FBXDocument::append_from_scene(Node *p_node, Ref<GLTFState> p_state, uint32_t p_flags) {
|
|
return ERR_UNAVAILABLE;
|
|
}
|
|
|
|
Vector3 FBXDocument::_as_vec3(const ufbx_vec3 &p_vector) {
|
|
return Vector3(real_t(p_vector.x), real_t(p_vector.y), real_t(p_vector.z));
|
|
}
|
|
|
|
String FBXDocument::_as_string(const ufbx_string &p_string) {
|
|
return String::utf8(p_string.data, (int)p_string.length);
|
|
}
|
|
|
|
Transform3D FBXDocument::_as_xform(const ufbx_matrix &p_mat) {
|
|
Transform3D xform;
|
|
xform.basis.set_column(Vector3::AXIS_X, _as_vec3(p_mat.cols[0]));
|
|
xform.basis.set_column(Vector3::AXIS_Y, _as_vec3(p_mat.cols[1]));
|
|
xform.basis.set_column(Vector3::AXIS_Z, _as_vec3(p_mat.cols[2]));
|
|
xform.set_origin(_as_vec3(p_mat.cols[3]));
|
|
return xform;
|
|
}
|