45 const int64_t tot_verts_object{mesh_geometry_.get_vertex_count()};
46 if (tot_verts_object <= 0) {
51 this->fixup_invalid_faces();
58 CLOG_WARN(&
LOG,
"OBJ mesh too large to import, exceeds max int size");
64 mesh_geometry_.edges_.size(),
65 mesh_geometry_.face_elements_.size(),
66 mesh_geometry_.total_corner_);
68 this->create_vertices(
mesh);
70 this->create_edges(
mesh);
71 this->create_uv_verts(
mesh);
72 this->create_normals(
mesh);
73 this->create_colors(
mesh);
74 this->create_vertex_groups(
mesh);
76 if (import_params.
validate_meshes || mesh_geometry_.has_invalid_faces_) {
77 bool verbose_validate =
false;
79 verbose_validate =
true;
89 Map<std::string, std::unique_ptr<MTLMaterial>> &materials,
95 if (
mesh ==
nullptr) {
101 if (ob_name.empty()) {
102 ob_name =
"Untitled";
108 this->create_materials(bmain,
122void MeshFromGeometry::fixup_invalid_faces()
141 const int vertex_idx = mesh_geometry_.
face_corners_[corner_idx].vert_index;
142 if (used_verts.
contains(vertex_idx)) {
146 used_verts.
add(vertex_idx);
154 Vector<int, 8> face_verts;
155 Vector<int, 8> face_uvs;
156 Vector<int, 8> face_normals;
162 const FaceCorner &corner = mesh_geometry_.face_corners_[corner_idx];
163 face_verts.append(corner.vert_index);
164 face_normals.append(corner.vertex_normal_index);
165 face_uvs.append(corner.uv_vert_index);
173 mesh_geometry_.face_elements_.remove_and_reorder(face_idx);
176 Vector<Vector<int>> new_faces =
fixup_invalid_face(global_vertices_.vertices, face_verts);
179 for (Span<int> face : new_faces) {
180 if (face.size() < 3) {
184 new_face.vertex_group_index = face_vertex_group;
185 new_face.material_index = face_material;
186 new_face.shaded_smooth = face_shaded_smooth;
187 new_face.start_index_ = mesh_geometry_.face_corners_.size();
188 new_face.corner_count_ = face.size();
189 for (
int idx : face) {
190 BLI_assert(idx >= 0 && idx < face_verts.size());
191 mesh_geometry_.face_corners_.append({face_verts[idx], face_uvs[idx], face_normals[idx]});
193 mesh_geometry_.face_elements_.append(new_face);
194 mesh_geometry_.total_corner_ += face.size();
199void MeshFromGeometry::create_vertices(Mesh *mesh)
201 MutableSpan<float3> positions = mesh->vert_positions_for_write();
206 mesh_geometry_.global_to_local_vertices_.
clear();
207 mesh_geometry_.global_to_local_vertices_.reserve(mesh_geometry_.vertices_.size());
208 for (
int vi = mesh_geometry_.vertex_index_min_; vi <= mesh_geometry_.vertex_index_max_; ++vi) {
209 BLI_assert(vi >= 0 && vi < global_vertices_.vertices.size());
210 if (!mesh_geometry_.vertices_.contains(vi)) {
213 int local_vi = int(mesh_geometry_.global_to_local_vertices_.size());
214 BLI_assert(local_vi >= 0 && local_vi < mesh->verts_num);
215 copy_v3_v3(positions[local_vi], global_vertices_.vertices[vi]);
216 mesh_geometry_.global_to_local_vertices_.add_new(vi, local_vi);
220void MeshFromGeometry::create_faces(Mesh *mesh,
bool use_vertex_groups)
222 MutableSpan<MDeformVert> dverts;
223 const int64_t total_verts = mesh_geometry_.get_vertex_count();
224 if (use_vertex_groups && total_verts && mesh_geometry_.has_vertex_groups_) {
225 dverts = mesh->deform_verts_for_write();
228 Span<float3> positions = mesh->vert_positions();
229 MutableSpan<int> face_offsets = mesh->face_offsets_for_write();
230 MutableSpan<int> corner_verts = mesh->corner_verts_for_write();
231 bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
232 bke::SpanAttributeWriter<int> material_indices =
235 const bool set_face_sharpness = !has_normals();
236 bke::SpanAttributeWriter<bool> sharp_faces = attributes.lookup_or_add_for_write_span<
bool>(
239 int corner_index = 0;
241 for (
int face_idx = 0; face_idx < mesh->faces_num; ++face_idx) {
242 const FaceElem &curr_face = mesh_geometry_.face_elements_[face_idx];
243 if (curr_face.corner_count_ < 3) {
245 CLOG_WARN(&
LOG,
"Face with less than 3 vertices found, skipping.");
249 face_offsets[face_idx] = corner_index;
250 if (set_face_sharpness) {
253 sharp_faces.span[face_idx] = !curr_face.shaded_smooth;
259 material_indices.span[face_idx] = std::max(material_indices.span[face_idx], 0);
261 for (
int64_t idx = 0; idx < curr_face.corner_count_; ++idx) {
262 const FaceCorner &curr_corner = mesh_geometry_.face_corners_[curr_face.start_index_ + idx];
263 corner_verts[corner_index] = mesh_geometry_.global_to_local_vertices_.lookup_default(
264 curr_corner.vert_index, 0);
267 if (!dverts.is_empty()) {
268 const int group_index = curr_face.vertex_group_index;
270 if (group_index >= 0) {
280 if (!set_face_sharpness) {
287 positions, corner_verts.slice(face_offsets[face_idx], curr_face.corner_count_));
288 if (area < 1.0e-12f) {
289 sharp_faces.span[face_idx] =
true;
294 material_indices.finish();
295 sharp_faces.finish();
298void MeshFromGeometry::create_vertex_groups(Mesh *mesh)
300 if (mesh->deform_verts().is_empty()) {
303 for (
const std::string &name : mesh_geometry_.group_order_) {
304 bDeformGroup *defgroup = MEM_new<bDeformGroup>(__func__);
305 StringRef(name).copy_utf8_truncated(defgroup->name);
310void MeshFromGeometry::create_edges(Mesh *mesh)
312 MutableSpan<int2> edges = mesh->edges_for_write();
314 const int64_t tot_edges{mesh_geometry_.edges_.size()};
315 const int64_t total_verts{mesh_geometry_.get_vertex_count()};
317 for (
int i = 0; i < tot_edges; ++i) {
318 const int2 &src_edge = mesh_geometry_.edges_[i];
319 int2 &dst_edge = edges[i];
320 dst_edge[0] = mesh_geometry_.global_to_local_vertices_.lookup_default(src_edge[0], 0);
321 dst_edge[1] = mesh_geometry_.global_to_local_vertices_.lookup_default(src_edge[1], 0);
322 BLI_assert(dst_edge[0] < total_verts && dst_edge[1] < total_verts);
330void MeshFromGeometry::create_uv_verts(Mesh *mesh)
332 if (global_vertices_.uv_vertices.size() <= 0) {
336 bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
337 bke::SpanAttributeWriter<float2> uv_map = attributes.lookup_or_add_for_write_only_span<
float2>(
340 int corner_index = 0;
341 bool added_uv =
false;
343 for (
const FaceElem &curr_face : mesh_geometry_.face_elements_) {
344 for (
int64_t idx = 0; idx < curr_face.corner_count_; ++idx) {
345 const FaceCorner &curr_corner = mesh_geometry_.face_corners_[curr_face.start_index_ + idx];
346 if (curr_corner.uv_vert_index >= 0 &&
347 curr_corner.uv_vert_index < global_vertices_.uv_vertices.size())
349 uv_map.span[corner_index] = global_vertices_.uv_vertices[curr_corner.uv_vert_index];
353 uv_map.span[corner_index] = {0.0f, 0.0f};
369 attributes.remove(
"UVMap");
372 mesh->uv_maps_active_set(
"UVMap");
373 mesh->uv_maps_default_set(
"UVMap");
378 const std::string &name,
379 Map<std::string, std::unique_ptr<MTLMaterial>> &materials,
386 if (found_mat !=
nullptr) {
392 if (existing_mat !=
nullptr &&
396 created_materials.
add_new(name, existing_mat);
401 const MTLMaterial &mtl = *materials.lookup_or_add(name, std::make_unique<MTLMaterial>());
411 created_materials.
add_new(name, mat);
415void MeshFromGeometry::create_materials(
Main *bmain,
416 Map<std::string, std::unique_ptr<MTLMaterial>> &materials,
424 bmain, name, materials, created_materials, relative_paths, mtl_name_collision_mode);
425 if (mat ==
nullptr) {
435bool MeshFromGeometry::has_normals()
const
437 return !global_vertices_.vert_normals.is_empty() && mesh_geometry_.total_corner_ != 0;
440void MeshFromGeometry::create_normals(Mesh *mesh)
442 if (!has_normals()) {
446 Array<float3> corner_normals(mesh_geometry_.total_corner_);
447 int corner_index = 0;
448 for (
const FaceElem &curr_face : mesh_geometry_.face_elements_) {
449 for (
int64_t idx = 0; idx < curr_face.corner_count_; ++idx) {
450 const FaceCorner &curr_corner = mesh_geometry_.face_corners_[curr_face.start_index_ + idx];
451 int n_index = curr_corner.vertex_normal_index;
453 if (n_index >= 0 && n_index < global_vertices_.vert_normals.size()) {
454 normal = global_vertices_.vert_normals[n_index];
456 corner_normals[corner_index] = normal;
463void MeshFromGeometry::create_colors(Mesh *mesh)
466 if (global_vertices_.vertex_colors.is_empty()) {
471 for (
int vi : mesh_geometry_.vertices_) {
472 if (!global_vertices_.has_vertex_color(vi)) {
479 bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
480 bke::SpanAttributeWriter attr = attributes.lookup_or_add_for_write_span<
ColorGeometry4f>(
484 MutableSpan<float4> colors = attr.span.cast<
float4>();
487 for (
auto item : mesh_geometry_.global_to_local_vertices_.items()) {
488 const int vi = item.key;
489 const int local_vi = item.value;
490 BLI_assert(vi >= 0 && vi < global_vertices_.vertex_colors.size());
491 BLI_assert(local_vi >= 0 && local_vi < mesh->verts_num);
492 const float3 &c = global_vertices_.vertex_colors[vi];
493 colors[local_vi] =
float4(c.
x, c.
y, c.
z, 1.0);
Generic geometry attributes built on CustomData.
General operations, lookup, etc. for materials.
General operations, lookup, etc. for blender objects.
#define CLOG_WARN(clg_ref,...)
Object is a sort of wrapper for general info.
#define UNUSED_VARS_NDEBUG(...)
void clear(bool preserve_shaders=false) override
static AttributeOwner from_id(ID *id)
constexpr IndexRange()=default
const Value * lookup_ptr(const Key &key) const
void add_new(const Key &key, const Value &value)
void reserve(const int64_t n)
bool contains(const Key &key) const
Mesh * create_mesh(const OBJImportParams &import_params)
Object * create_mesh_object(Main *bmain, Map< std::string, std::unique_ptr< MTLMaterial > > &materials, Map< std::string, Material * > &created_materials, const OBJImportParams &import_params)
float face_area_calc(Span< float3 > vert_positions, Span< int > face_verts)
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 Material * get_or_create_material(Main *bmain, const std::string &name, Map< std::string, std::unique_ptr< MTLMaterial > > &materials, Map< std::string, Material * > &created_materials, bool relative_paths, eOBJMtlNameCollisionMode mtl_name_collision_mode)
bNodeTree * create_mtl_node_tree(Main *bmain, const MTLMaterial &mtl_mat, Material *mat, bool relative_paths)
void transform_object(Object *object, const OBJImportParams &import_params)
Vector< Vector< int > > fixup_invalid_face(Span< float3 > vert_positions, Span< int > face_verts)
std::string get_geometry_name(const std::string &full_name, char separator)
bool size_fits_in_int(const int64_t size)
ID * BKE_libblock_find_name(Main *bmain, short type, const char *name, const std::optional< Library * > lib=std::nullopt) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void BKE_id_attributes_default_color_set(struct ID *id, std::optional< StringRef > name)
MINLINE void copy_v3_v3(float r[3], const float a[3])
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)
std::string BKE_attribute_calc_unique_name(const AttributeOwner &owner, StringRef name)
VecBase< float, 4 > float4
VecBase< int32_t, 2 > int2
VecBase< float, 2 > float2
void BKE_ntree_update_after_single_tree_change(Main &bmain, bNodeTree &modified_tree, const NodeTreeUpdateExtraParams ¶ms={})
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)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
void BKE_id_attributes_active_color_set(struct ID *id, std::optional< StringRef > name)
@ OBJ_MTL_NAME_COLLISION_REFERENCE_EXISTING
void BKE_object_material_assign_single_obdata(Main *bmain, Object *ob, Material *ma, short act)
ColorSceneLinear4f< eAlpha::Premultiplied > ColorGeometry4f
Material * BKE_material_add(Main *bmain, const char *name)
VecBase< float, 3 > float3
Object * BKE_object_add_only_object(Main *bmain, ObjectType type, const char *name) ATTR_RETURNS_NONNULL
char collection_separator
eOBJMtlNameCollisionMode mtl_name_collision_mode
bool import_vertex_groups
Vector< std::string > material_order_
Vector< FaceCorner > face_corners_
Vector< FaceElem > face_elements_