49 return mesh !=
nullptr && skin !=
nullptr && skin->clusters.count > 0 &&
50 mesh->num_vertices > 0 && skin->vertices.count ==
mesh->num_vertices;
57 if (skin !=
nullptr) {
59 const ufbx_matrix &geom_to_world = fmesh->instances[0]->geometry_to_world;
60 ufbx_matrix world_to_geom = ufbx_matrix_invert(&geom_to_world);
61 for (
size_t i = 0; i < fmesh->vertex_position.values.count; i++) {
62 ufbx_matrix skin_mat = ufbx_get_skin_vertex_matrix(skin, i, &geom_to_world);
63 skin_mat = ufbx_matrix_mul(&world_to_geom, &skin_mat);
64 ufbx_vec3 val = ufbx_transform_position(&skin_mat, fmesh->vertex_position.values[i]);
65 positions[i] =
float3(val.x, val.y, val.z);
72 BLI_assert(positions.
size() == fmesh->vertex_position.values.count);
74 ufbx_vec3 val = fmesh->vertex_position.values[i];
75 positions[i] =
float3(val.x, val.y, val.z);
84 (face_offsets.
is_empty() && fmesh->num_faces == 0));
85 for (
size_t face_idx = 0; face_idx < fmesh->num_faces; face_idx++) {
87 const ufbx_face &fface = fmesh->faces[face_idx];
88 face_offsets[face_idx] = fface.index_begin;
89 for (
uint32_t i = 0; i < fface.num_indices; i++) {
90 const uint32_t corner_idx = fface.index_begin + i;
91 corner_verts[corner_idx] = fmesh->vertex_indices[corner_idx];
99 if (fmesh->face_material.count == fmesh->num_faces) {
102 for (
const int64_t i : materials.
span.index_range()) {
103 materials.
span[i] = fmesh->face_material[i];
112 if (fmesh->face_smoothing.count > 0 && fmesh->face_smoothing.count == fmesh->num_faces) {
116 smooth.span[i] = !fmesh->face_smoothing[i];
128 for (
size_t i = 0; i < fmesh->num_edges; i++) {
129 const ufbx_edge &fedge = fmesh->edges[i];
130 const int va = fmesh->vertex_indices[fedge.a];
131 const int vb = fmesh->vertex_indices[fedge.b];
132 edges[i] =
int2(va, vb);
137 if (fmesh->edge_crease.count > 0 && fmesh->edge_crease.count == fmesh->num_edges) {
140 for (
int64_t i = 0; i < fmesh->num_edges; i++) {
142 creases.
span[i] =
sqrtf(fmesh->edge_crease[i]);
147 if (fmesh->edge_smoothing.count > 0 && fmesh->edge_smoothing.count == fmesh->num_edges) {
150 for (
int64_t i = 0; i < fmesh->num_edges; i++) {
151 sharp.
span[i] = !fmesh->edge_smoothing[i];
162 bool set_active_uv =
true;
163 for (
const ufbx_uv_set &fuv_set : fmesh->uv_sets) {
166 mesh->uv_maps_active_set(attr_name);
167 mesh->uv_maps_default_set(attr_name);
168 set_active_uv =
false;
174 const int val_idx = fuv_set.vertex_uv.indices[i];
175 const ufbx_vec2 &uv = fuv_set.vertex_uv.values[val_idx];
188 std::string first_color_name;
189 for (
const ufbx_color_set &fcol_set : fmesh->color_sets) {
191 if (first_color_name.empty()) {
192 first_color_name = attr_name;
199 BLI_assert(fcol_set.vertex_color.indices.count == cols.
span.size());
201 const int val_idx = fcol_set.vertex_color.indices[i];
202 const ufbx_vec4 &col = fcol_set.vertex_color.values[val_idx];
216 BLI_assert(fcol_set.vertex_color.indices.count == cols.
span.size());
218 const int val_idx = fcol_set.vertex_color.indices[i];
219 const ufbx_vec4 &col = fcol_set.vertex_color.values[val_idx];
228 if (!first_color_name.empty()) {
229 mesh->active_color_attribute =
BLI_strdup(first_color_name.c_str());
230 mesh->default_color_attribute =
BLI_strdup(first_color_name.c_str());
237 if (!fmesh->vertex_normal.exists) {
242 BLI_assert(fmesh->vertex_normal.indices.count == normals.
span.size());
243 for (
const int64_t i : normals.
span.index_range()) {
244 const int val_idx = fmesh->vertex_normal.indices[i];
245 const ufbx_vec3 &normal = fmesh->vertex_normal.values[val_idx];
246 normals.
span[i] =
float3(normal.x, normal.y, normal.z);
253 const ufbx_mesh *fmesh)
256 for (
const ufbx_skin_deformer *skin : fmesh->skin_deformers) {
261 for (
const ufbx_skin_cluster *cluster : skin->clusters) {
262 if (cluster->num_weights == 0) {
267 name_set.
add(bone_name);
274 const ufbx_mesh *fmesh,
277 if (fmesh->skin_deformers.count == 0) {
290 for (
const ufbx_skin_deformer *skin : fmesh->skin_deformers) {
295 for (
const ufbx_skin_cluster *cluster : skin->clusters) {
296 if (cluster->num_weights == 0) {
300 const int group_index = bone_set.
index_of_try(bone_name);
301 if (group_index < 0) {
305 for (
int64_t i = 0; i < cluster->num_weights; i++) {
306 const int vertex = cluster->vertices[i];
309 dw->
weight = cluster->weights[i];
318 const ufbx_mesh *fmesh,
321 Key *mesh_key =
nullptr;
322 for (
const ufbx_blend_deformer *fdeformer : fmesh->blend_deformers) {
323 for (
const ufbx_blend_channel *fchan : fdeformer->channels) {
326 if (fchan->target_shape ==
nullptr) {
330 if (mesh_key ==
nullptr) {
333 mesh->key = mesh_key;
340 kb->
curval = fchan->weight;
347 for (
size_t i = 0; i < fchan->target_shape->num_offsets; i++) {
348 const int idx = fchan->target_shape->offset_vertices[i];
352 const ufbx_vec3 &delta = fchan->target_shape->position_offsets[i];
353 kb_data[idx] +=
float3(delta.x, delta.y, delta.z);
358 return mesh_key !=
nullptr;
364 const ufbx_mesh *fmesh,
368 for (
const ufbx_blend_deformer *fdeformer : fmesh->blend_deformers) {
369 for (
const ufbx_blend_channel *fchan : fdeformer->channels) {
371 if (fchan->target_shape ==
nullptr || key ==
nullptr) {
374 if (fchan->target_shape->offset_weights.count != fchan->target_shape->num_offsets) {
387 bool all_unorm =
true;
388 for (ufbx_real
w : fchan->target_shape->offset_weights) {
396 if (all_one || !all_unorm) {
401 if (group_index < 0) {
404 if (group_index < 0) {
410 for (
size_t i = 0; i < fchan->target_shape->num_offsets; i++) {
411 const int idx = fchan->target_shape->offset_vertices[i];
413 const float w = fchan->target_shape->offset_weights[i];
425 const ufbx_scene &
fbx,
432 const ufbx_mesh *fmesh = fbx.meshes.data[index];
433 if (fmesh->instances.count == 0) {
434 meshes[index] = nullptr;
443 CLOG_WARN(&LOG,
"Mesh '%s' too large to import, exceeds max int size", fmesh->name.data);
444 meshes[index] = nullptr;
450 fmesh->num_vertices, fmesh->num_edges, fmesh->num_faces, fmesh->num_indices);
463 bool has_custom_normals =
false;
474 for (
const std::string &name : bone_set) {
475 bDeformGroup *defgroup = MEM_new<bDeformGroup>(
"bDeformGroup");
483 const bool allow_missing_edges =
true;
485 const bool verbose_validate =
true;
487 const bool verbose_validate =
false;
495 if (has_custom_normals) {
512 if (
mesh ==
nullptr) {
515 const ufbx_mesh *fmesh = fbx.meshes[
index];
518 Mesh *mesh_main =
static_cast<Mesh *
>(
521 meshes[
index] = mesh_main;
523 if (params.use_custom_props) {
530 for (
const ufbx_node *
node : fmesh->instances) {
532 if (
node->is_geometry_transform_helper) {
540 obj->data = id_cast<ID *>(mesh_main);
541 if (!
node->visible) {
549 bool matrix_already_set =
false;
552 if (fmesh->skin_deformers.count > 0) {
554 for (
const ufbx_skin_deformer *skin : fmesh->skin_deformers) {
558 Object *arm_obj =
nullptr;
559 for (
const ufbx_skin_cluster *cluster : skin->clusters) {
560 if (cluster->num_weights == 0) {
563 arm_obj = mapping.bone_to_armature.lookup_default(cluster->bone_node,
nullptr);
564 if (arm_obj !=
nullptr) {
569 if (arm_obj !=
nullptr) {
574 ArmatureModifierData *ad =
reinterpret_cast<ArmatureModifierData *
>(md);
575 ad->object = arm_obj;
577 if (!matrix_already_set) {
578 matrix_already_set =
true;
579 obj->parent = arm_obj;
584 ufbx_matrix world_to_arm = mapping.armature_world_to_arm_node_matrix.lookup_default(
585 arm_obj, ufbx_identity_matrix);
586 ufbx_matrix world_to_arm_pose = mapping.armature_world_to_arm_pose_matrix
587 .lookup_default(arm_obj, ufbx_identity_matrix);
589 ufbx_matrix mtx = ufbx_matrix_mul(&world_to_arm, &
node->geometry_to_world);
594 ufbx_matrix mtx_inv = ufbx_matrix_invert(&mtx);
595 ufbx_matrix mtx_world = mapping.get_node_bind_matrix(
node);
596 ufbx_matrix mtx_parent_inverse = ufbx_matrix_mul(&mtx_world, &mtx_inv);
597 mtx_parent_inverse = ufbx_matrix_mul(&world_to_arm_pose, &mtx_parent_inverse);
609 if (fmesh->materials.count > 0 &&
node->materials.count == fmesh->materials.count) {
611 for (
size_t mi = 0; mi < fmesh->materials.count; mi++) {
612 const ufbx_material *mesh_fmat = fmesh->materials[mi];
613 const ufbx_material *node_fmat =
node->materials[mi];
614 Material *mesh_mat = mapping.mat_to_material.lookup_default(mesh_fmat,
nullptr);
615 Material *node_mat = mapping.mat_to_material.lookup_default(node_fmat,
nullptr);
616 if (mesh_mat !=
nullptr) {
622 if (!
ELEM(node_mat,
nullptr, mesh_mat)) {
633 if (params.import_subdivision &&
634 fmesh->subdivision_display_mode != UFBX_SUBDIVISION_DISPLAY_DISABLED &&
635 (fmesh->subdivision_preview_levels > 0 || fmesh->subdivision_render_levels > 0))
641 SubsurfModifierData *ssd =
reinterpret_cast<SubsurfModifierData *
>(md);
643 ssd->levels = fmesh->subdivision_preview_levels;
644 ssd->renderLevels = fmesh->subdivision_render_levels;
645 ssd->boundary_smooth = fmesh->subdivision_boundary ==
646 UFBX_SUBDIVISION_BOUNDARY_SHARP_CORNERS ?
651 if (params.use_custom_props) {
654 if (!matrix_already_set) {
657 mapping.el_to_object.add(&
node->element, obj);
658 mapping.imported_objects.add(obj);
Generic geometry attributes built on CustomData.
General operations, lookup, etc. for materials.
General operations, lookup, etc. for blender objects.
#define STRNCPY_UTF8(dst, src)
Object is a sort of wrapper for general info.
#define BLI_assert_unreachable()
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
static AttributeOwner from_id(ID *id)
constexpr IndexRange()=default
Value lookup_default(const Key &key, const Value &default_value) const
constexpr int64_t size() const
constexpr bool is_empty() const
constexpr IndexRange index_range() const
int64_t index_of_try(const Key &key) const
GSpanAttributeWriter lookup_or_add_for_write_only_span(StringRef name, AttrDomain domain, AttrType data_type)
void mesh_calc_edges(Mesh &mesh, bool keep_existing_edges, bool select_new_edges)
bool mesh_validate(Mesh &mesh, bool verbose=false, bool allow_missing_edges=false)
void mesh_set_custom_normals(Mesh &mesh, MutableSpan< float3 > corner_normals)
static VectorSet< std::string > get_skin_bone_name_set(const FbxElementMapping &mapping, const ufbx_mesh *fmesh)
void ufbx_matrix_to_obj(const ufbx_matrix &mtx, Object *obj)
static void import_blend_shape_full_weights(const FbxElementMapping &mapping, const ufbx_mesh *fmesh, Mesh *mesh, Object *obj)
static void import_colors(const ufbx_mesh *fmesh, Mesh *mesh, bke::MutableAttributeAccessor &attributes, AttributeOwner attr_owner, eFBXVertexColorMode color_mode)
const char * get_fbx_name(const ufbx_string &name, const char *def)
static bool import_blend_shapes(Main &bmain, FbxElementMapping &mapping, const ufbx_mesh *fmesh, Mesh *mesh)
void read_custom_properties(const ufbx_props &props, ID &id, bool enums_as_strings)
void node_matrix_to_obj(const ufbx_node *node, Object *obj, const FbxElementMapping &mapping)
static bool is_skin_deformer_usable(const ufbx_mesh *mesh, const ufbx_skin_deformer *skin)
static constexpr const char * temp_custom_normals_name
void matrix_to_m44(const ufbx_matrix &src, float dst[4][4])
static void import_skin_vertex_groups(const FbxElementMapping &mapping, const ufbx_mesh *fmesh, Mesh *mesh)
static void import_uvs(const ufbx_mesh *fmesh, Mesh *mesh, bke::MutableAttributeAccessor &attributes, AttributeOwner attr_owner)
static void import_face_smoothing(const ufbx_mesh *fmesh, bke::MutableAttributeAccessor &attributes)
static void import_faces(const ufbx_mesh *fmesh, Mesh *mesh)
static void import_face_material_indices(const ufbx_mesh *fmesh, bke::MutableAttributeAccessor &attributes)
static bool import_normals_into_temp_attribute(const ufbx_mesh *fmesh, bke::MutableAttributeAccessor &attributes)
static void import_vertex_positions(const ufbx_mesh *fmesh, Mesh *mesh)
static void import_edges(const ufbx_mesh *fmesh, Mesh *mesh, bke::MutableAttributeAccessor &attributes)
void import_meshes(Main &bmain, const ufbx_scene &fbx, FbxElementMapping &mapping, const FBXImportParams ¶ms)
bool size_fits_in_int(const int64_t size)
bool index_in_range(const int64_t index, const int64_t size)
void parallel_for_each(Range &&range, const Function &function)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
VecBase< uint8_t, 4 > uchar4
void BKE_mesh_nomain_to_mesh(Mesh *mesh_src, Mesh *mesh_dst, Object *ob, bool process_shape_keys=true)
void * BKE_object_obdata_add_from_type(Main *bmain, ObjectType type, const char *name) ATTR_NONNULL(1)
KeyBlock * BKE_keyblock_find_name(Key *key, const char name[])
void BKE_object_material_assign(Main *bmain, Object *ob, Material *ma, short act, int assign_type)
std::string BKE_attribute_calc_unique_name(const AttributeOwner &owner, StringRef name)
const char * BKE_id_name(const ID &id)
void BKE_modifiers_persistent_uid_init(const Object &object, ModifierData &md)
int BKE_defgroup_name_index(const ListBaseT< bDeformGroup > *defbase, StringRef name)
VecBase< float, 4 > float4
VecBase< int32_t, 2 > int2
VecBase< float, 2 > float2
Key * BKE_key_add(Main *bmain, ID *id)
ModifierData * BKE_modifier_new(int type)
Mesh * BKE_mesh_new_nomain(int verts_num, int edges_num, int faces_num, int corners_num)
MDeformWeight * BKE_defvert_ensure_index(MDeformVert *dv, int defgroup)
struct bDeformGroup * BKE_object_defgroup_add_name(struct Object *ob, const char *name)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
char * BLI_strdup(const char *str) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC
@ SUBSURF_TYPE_CATMULL_CLARK
KeyBlock * BKE_keyblock_add(Key *key, const char *name)
@ SUBSURF_BOUNDARY_SMOOTH_PRESERVE_CORNERS
@ SUBSURF_BOUNDARY_SMOOTH_ALL
void BKE_object_material_assign_single_obdata(Main *bmain, Object *ob, Material *ma, short act)
ColorSceneLinear4f< eAlpha::Premultiplied > ColorGeometry4f
VecBase< float, 3 > float3
Object * BKE_object_add_only_object(Main *bmain, ObjectType type, const char *name) ATTR_RETURNS_NONNULL
void BKE_keyblock_convert_from_mesh(const Mesh *mesh, const Key *key, KeyBlock *kb)
ColorSceneLinearByteEncoded4b< eAlpha::Premultiplied > ColorGeometry4b
MINLINE void rgba_float_to_uchar(unsigned char r_col[4], const float col_f[4])
eFBXVertexColorMode vertex_colors
ShapekeyContainerType type
MutableVArraySpan< T > span
Map< const ufbx_node *, std::string > node_to_name
Map< const ufbx_element *, Key * > el_to_shape_key