godot/modules/fbx/fbx_document.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

2374 lines
87 KiB
C++
Raw Normal View History

/**************************************************************************/
/* 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 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;
}
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("Root");
}
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.origin = _as_vec3(fbx_node->local_transform.translation);
node->transform.basis.set_quaternion_scale(_as_quaternion(fbx_node->local_transform.rotation), _as_vec3(fbx_node->local_transform.scale));
if (fbx_node->bind_pose) {
ufbx_bone_pose *pose = ufbx_get_bone_pose(fbx_node->bind_pose, fbx_node);
ufbx_transform rest_transform = ufbx_matrix_to_transform(&pose->bone_to_parent);
Vector3 rest_position = _as_vec3(rest_transform.translation);
Quaternion rest_rotation = _as_quaternion(rest_transform.rotation);
Vector3 rest_scale = _as_vec3(rest_transform.scale);
Transform3D godot_rest_xform;
godot_rest_xform.basis.set_quaternion_scale(rest_rotation, rest_scale);
godot_rest_xform.origin = rest_position;
node->set_additional_data("GODOT_rest_transform", godot_rest_xform);
} else {
node->set_additional_data("GODOT_rest_transform", node->transform);
}
}
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);
path = ProjectSettings::get_singleton()->localize_path(path);
if (path.is_absolute_path() && !path.is_resource_file()) {
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);
}
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
material->set_albedo(Color(1, 1, 1));
// 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));
material->set_emission_energy_multiplier(float(fbx_material->pbr.emission_factor.value_real));
}
const ufbx_texture *emission_texture = _get_file_texture(fbx_material->pbr.ambient_occlusion.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));
}
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 (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);
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 (fbx_root_node && fbx_root_node->get_parent()) {
root = fbx_root_node->get_parent();
}
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 {
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 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;
}