13#include <pxr/usd/usdGeom/mesh.h>
14#include <pxr/usd/usdGeom/primvarsAPI.h>
15#include <pxr/usd/usdShade/material.h>
16#include <pxr/usd/usdShade/materialBindingAPI.h>
17#include <pxr/usd/usdSkel/bindingAPI.h>
81 if ((md->
mode & mod_mode) != mod_mode) {
94 Object *object_eval = context.object;
95 bool needsfree =
false;
98 if (
mesh ==
nullptr) {
103 const bool tag_only =
false;
121 mesh = triangulated_mesh;
130 write_mesh(context,
mesh, subsurfData);
133 if (prim.IsValid() && object_eval) {
151void USDGenericMeshWriter::write_custom_data(
const Object *
obj,
153 const pxr::UsdGeomMesh &usd_mesh)
157 const StringRef active_uvmap_name =
mesh->default_uv_map_name();
199 this->write_uv_data(mesh, usd_mesh, iter, active_uvmap_name);
204 this->write_generic_data(mesh, usd_mesh, iter);
212 switch (blender_domain) {
214 return pxr::UsdGeomTokens->faceVarying;
216 return pxr::UsdGeomTokens->vertex;
218 return pxr::UsdGeomTokens->uniform;
226void USDGenericMeshWriter::write_generic_data(
const Mesh *
mesh,
227 const pxr::UsdGeomMesh &usd_mesh,
230 const pxr::TfToken pv_name(
237 if (!pv_interp || !pv_type) {
240 "Mesh '%s', Attribute '%s' (domain %d, type %d) cannot be converted to USD",
254 const pxr::UsdGeomPrimvarsAPI pv_api = pxr::UsdGeomPrimvarsAPI(usd_mesh);
256 pxr::UsdGeomPrimvar pv_attr = pv_api.CreatePrimvar(pv_name, *pv_type, *pv_interp);
261void USDGenericMeshWriter::write_uv_data(
const Mesh *mesh,
262 const pxr::UsdGeomMesh &usd_mesh,
263 const bke::AttributeIter &attr,
264 const StringRef active_uvmap_name)
267 if (buffer.is_empty()) {
274 active_uvmap_name == attr.name ?
279 const OffsetIndices<int> faces = mesh->faces();
280 const Span<int> corner_verts = mesh->corner_verts();
281 const VArraySpan<float2> uv_data(buffer);
289 "Couldn't resolve UV connectivity for mesh %s",
296 pxr::VtArray<pxr::GfVec2f> unique_uvs;
297 unique_uvs.reserve(mesh->verts_num);
298 Array<int> corner_to_uv_index(corner_verts.
size(), -1);
299 for (
int vertex_index = 0; vertex_index < mesh->verts_num; vertex_index++) {
304 for (; uv_vert; uv_vert = uv_vert->next) {
305 const int corner_index = faces[uv_vert->face_index].start() + uv_vert->loop_of_face_index;
306 const float2 uv = uv_data[corner_index];
307 if (uv_vert->separate) {
308 unique_uvs.push_back(pxr::GfVec2f(uv.
x, uv.
y));
310 corner_to_uv_index[corner_index] = unique_uvs.size() - 1;
316 pxr::VtIntArray indices;
317 indices.reserve(corner_verts.
size());
318 for (
const int corner_idx : corner_verts.
index_range()) {
319 indices.push_back(corner_to_uv_index[corner_idx]);
323 const pxr::TfToken pv_name(
325 const pxr::UsdGeomPrimvarsAPI pv_api = pxr::UsdGeomPrimvarsAPI(usd_mesh);
327 pxr::UsdGeomPrimvar pv_uv = pv_api.CreatePrimvar(
328 pv_name, pxr::SdfValueTypeNames->TexCoord2fArray, pxr::UsdGeomTokens->faceVarying);
331 pxr::UsdAttribute attr_indices = pv_uv.CreateIndicesAttr();
332 if (!attr_indices.HasValue()) {
333 attr_indices.Set(indices, time);
380 pxr::UsdGeomMesh usd_mesh = pxr::UsdGeomMesh::Define(stage,
usd_path);
386 get_geometry_data(
mesh, usd_mesh_data);
388 pxr::UsdAttribute attr_points = usd_mesh.CreatePointsAttr(pxr::VtValue(),
true);
389 pxr::UsdAttribute attr_face_vertex_counts = usd_mesh.CreateFaceVertexCountsAttr(pxr::VtValue(),
391 pxr::UsdAttribute attr_face_vertex_indices = usd_mesh.CreateFaceVertexIndicesAttr(pxr::VtValue(),
394 if (!attr_points.HasValue()) {
397 attr_points.Set(usd_mesh_data.
points, pxr::UsdTimeCode::Default());
398 attr_face_vertex_counts.Set(usd_mesh_data.
face_vertex_counts, pxr::UsdTimeCode::Default());
399 attr_face_vertex_indices.Set(usd_mesh_data.
face_indices, pxr::UsdTimeCode::Default());
406 attr_face_vertex_indices, pxr::VtValue(usd_mesh_data.
face_indices), time);
409 pxr::UsdAttribute attr_crease_lengths = usd_mesh.CreateCreaseLengthsAttr(pxr::VtValue(),
true);
410 pxr::UsdAttribute attr_crease_indices = usd_mesh.CreateCreaseIndicesAttr(pxr::VtValue(),
true);
411 pxr::UsdAttribute attr_crease_sharpness = usd_mesh.CreateCreaseSharpnessesAttr(pxr::VtValue(),
414 if (!attr_crease_lengths.HasValue()) {
415 attr_crease_lengths.Set(usd_mesh_data.
crease_lengths, pxr::UsdTimeCode::Default());
417 attr_crease_sharpness.Set(usd_mesh_data.
crease_sharpnesses, pxr::UsdTimeCode::Default());
421 attr_crease_lengths, pxr::VtValue(usd_mesh_data.
crease_lengths), time);
431 pxr::UsdAttribute attr_corner_indices = usd_mesh.CreateCornerIndicesAttr(pxr::VtValue(),
true);
432 pxr::UsdAttribute attr_corner_sharpnesses = usd_mesh.CreateCornerSharpnessesAttr(
433 pxr::VtValue(),
true);
435 if (!attr_corner_indices.HasValue()) {
436 attr_corner_indices.Set(usd_mesh_data.
corner_indices, pxr::UsdTimeCode::Default());
437 attr_corner_sharpnesses.Set(usd_mesh_data.
corner_sharpnesses, pxr::UsdTimeCode::Default());
441 attr_corner_indices, pxr::VtValue(usd_mesh_data.
corner_indices), time);
446 write_custom_data(
context.object, mesh, usd_mesh);
447 write_surface_velocity(mesh, usd_mesh);
449 const pxr::TfToken subdiv_scheme = get_subdiv_scheme(subsurfData);
455 subdiv_scheme == pxr::UsdGeomTokens->none)
457 write_normals(mesh, usd_mesh);
469 write_subdiv(subdiv_scheme, usd_mesh, subsurfData);
472 assign_materials(context, usd_mesh, usd_mesh_data.
face_groups);
476pxr::TfToken USDGenericMeshWriter::get_subdiv_scheme(
const SubsurfModifierData *subsurfData)
479 pxr::TfToken subdiv_scheme = pxr::UsdGeomTokens->none;
486 subdiv_scheme = pxr::UsdGeomTokens->catmullClark;
494 "USD export: Simple subdivision not supported, exporting subdivided mesh");
498 return subdiv_scheme;
501void USDGenericMeshWriter::write_subdiv(
const pxr::TfToken &subdiv_scheme,
502 const pxr::UsdGeomMesh &usd_mesh,
503 const SubsurfModifierData *subsurfData)
505 usd_mesh.CreateSubdivisionSchemeAttr().Set(subdiv_scheme);
506 if (subdiv_scheme == pxr::UsdGeomTokens->catmullClark) {
511 switch (subsurfData->uv_smooth) {
513 usd_mesh.CreateFaceVaryingLinearInterpolationAttr().Set(pxr::UsdGeomTokens->
all);
516 usd_mesh.CreateFaceVaryingLinearInterpolationAttr().Set(pxr::UsdGeomTokens->cornersOnly);
519 usd_mesh.CreateFaceVaryingLinearInterpolationAttr().Set(pxr::UsdGeomTokens->cornersPlus1);
522 usd_mesh.CreateFaceVaryingLinearInterpolationAttr().Set(pxr::UsdGeomTokens->cornersPlus2);
525 usd_mesh.CreateFaceVaryingLinearInterpolationAttr().Set(pxr::UsdGeomTokens->boundaries);
528 usd_mesh.CreateFaceVaryingLinearInterpolationAttr().Set(pxr::UsdGeomTokens->none);
537 switch (subsurfData->boundary_smooth) {
539 usd_mesh.CreateInterpolateBoundaryAttr().Set(pxr::UsdGeomTokens->edgeOnly);
542 usd_mesh.CreateInterpolateBoundaryAttr().Set(pxr::UsdGeomTokens->edgeAndCorner);
553 usd_mesh_data.
points = pxr::VtArray<pxr::GfVec3f>(positions.
begin(), positions.
end());
592 const float crease = std::clamp(creases[i], 0.0f, 1.0f);
594 if (crease != 0.0f) {
613 const float crease = std::clamp(creases[i], 0.0f, 1.0f);
615 if (crease != 0.0f) {
631 const pxr::UsdGeomMesh &usd_mesh,
642 bool mesh_material_bound =
false;
643 auto mesh_prim = usd_mesh.GetPrim();
644 pxr::UsdShadeMaterialBindingAPI material_binding_api(mesh_prim);
645 for (
int mat_num = 0; mat_num < totcol; mat_num++) {
647 if (material ==
nullptr) {
652 material_binding_api.Bind(usd_material);
656 usd_mesh.CreateDoubleSidedAttr(
659 mesh_material_bound =
true;
663 if (mesh_material_bound) {
667 pxr::UsdShadeMaterialBindingAPI::Apply(mesh_prim);
671 usd_mesh.CreateDoubleSidedAttr(pxr::VtValue(
true));
674 if (!mesh_material_bound || usd_face_groups.
size() < 2) {
683 short material_number = face_group.key;
684 const pxr::VtIntArray &face_indices = face_group.value;
687 if (material ==
nullptr) {
692 pxr::TfToken material_name = usd_material.GetPath().GetNameToken();
694 pxr::UsdGeomSubset usd_face_subset = material_binding_api.CreateMaterialBindSubset(
695 material_name, face_indices);
696 auto subset_prim = usd_face_subset.GetPrim();
697 auto subset_material_api = pxr::UsdShadeMaterialBindingAPI(subset_prim);
698 subset_material_api.Bind(usd_material);
700 pxr::UsdShadeMaterialBindingAPI::Apply(subset_prim);
704void USDGenericMeshWriter::write_normals(
const Mesh *mesh, pxr::UsdGeomMesh &usd_mesh)
708 Span<float3> src_normals;
710 pxr::TfToken interpolation;
711 switch (mesh->normals_domain()) {
713 src_normals = mesh->vert_normals();
714 interpolation = pxr::UsdGeomTokens->vertex;
718 src_normals = mesh->face_normals();
719 interpolation = pxr::UsdGeomTokens->uniform;
723 src_normals = mesh->corner_normals();
724 interpolation = pxr::UsdGeomTokens->faceVarying;
732 pxr::UsdAttribute attr_normals = usd_mesh.CreateNormalsAttr(pxr::VtValue(),
true);
733 if (!attr_normals.HasValue()) {
734 attr_normals.Set(loop_normals, pxr::UsdTimeCode::Default());
737 usd_mesh.SetNormalsInterpolation(interpolation);
740void USDGenericMeshWriter::write_surface_velocity(
const Mesh *mesh,
741 const pxr::UsdGeomMesh &usd_mesh)
752 Span<pxr::GfVec3f>
data =
velocity.cast<pxr::GfVec3f>();
753 pxr::VtVec3fArray usd_velocities;
754 usd_velocities.assign(
data.begin(),
data.end());
757 pxr::UsdAttribute attr_vel = usd_mesh.CreateVelocitiesAttr(pxr::VtValue(),
true);
758 if (!attr_vel.HasValue()) {
759 attr_vel.Set(usd_velocities, pxr::UsdTimeCode::Default());
772 write_skinned_mesh_ =
false;
773 write_blend_shapes_ =
false;
792 if (!mesh_prim.IsValid()) {
794 "%s: couldn't get valid mesh prim for mesh %s",
800 pxr::UsdSkelBindingAPI skel_api = pxr::UsdSkelBindingAPI::Apply(mesh_prim);
804 "Couldn't apply UsdSkelBindingAPI to mesh prim %s",
814 "Couldn't get armature modifier object for skinned mesh %s",
825 "No armature bones for skinned mesh %s",
830 bool needsfree =
false;
833 if (
mesh ==
nullptr) {
858 if (!mesh_prim.IsValid()) {
860 "Couldn't get valid mesh prim for mesh %s",
861 mesh_prim.GetPath().GetAsString().c_str());
879 if (write_blend_shapes_) {
887 if (write_skinned_mesh_) {
891 if (write_blend_shapes_) {
899 if (write_blend_shapes_) {
906 if (write_skinned_mesh_) {
914 r_needsfree = coerce.
owned !=
nullptr;
915 coerce.
owned =
nullptr;
939 if (!mesh_prim.IsValid()) {
941 "Couldn't get valid mesh prim for mesh %s",
951 pxr::UsdAttribute temp_weights_attr = pxr::UsdGeomPrimvarsAPI(mesh_prim).CreatePrimvar(
954 if (!temp_weights_attr) {
956 "Couldn't create primvar %s on prim %s",
958 mesh_prim.GetPath().GetAsString().c_str());
962 temp_weights_attr.Set(weights, time);
General operations, lookup, etc. for materials.
#define STD_UV_CONNECT_LIMIT
General operations, lookup, etc. for blender objects.
#define CLOG_WARN(clg_ref,...)
Object is a sort of wrapper for general info.
#define BLI_assert_msg(a, msg)
constexpr int64_t size() const
constexpr IndexRange index_range() const
Value & lookup_or_add_default(const Key &key)
MapItem< short, pxr::VtArray< int > > Item
ItemIterator items() const &
constexpr const T * end() const
constexpr IndexRange index_range() const
constexpr const T * begin() const
constexpr const char * c_str() const
GAttributeReader lookup_or_default(StringRef name, AttrDomain domain, AttrType data_type, const void *default_value=nullptr) const
void foreach_attribute(const FunctionRef< void(const AttributeIter &)> fn) const
GAttributeReader lookup(const StringRef name) const
GAttributeReader get() const
constexpr IndexRange index_range() const
constexpr int64_t rfind(char c, int64_t pos=INT64_MAX) const
constexpr bool is_empty() const
pxr::UsdShadeMaterial ensure_usd_material(const HierarchyContext &context, Material *material) const
bool frame_has_been_written_
void author_extent(const pxr::UsdGeomBoundable &boundable, const pxr::UsdTimeCode time)
const pxr::SdfPath & usd_path() const
void add_to_prim_map(const pxr::SdfPath &usd_path, const ID *id) const
ReportList * reports() const
pxr::UsdTimeCode get_export_time_code() const
pxr::UsdUtilsSparseValueWriter usd_value_writer_
USDAbstractWriter(const USDExporterContext &usd_export_context)
void write_id_properties(const pxr::UsdPrim &prim, const ID &id, pxr::UsdTimeCode=pxr::UsdTimeCode::Default()) const
void write_visibility(const HierarchyContext &context, const pxr::UsdTimeCode time, const pxr::UsdGeomImageable &usd_geometry)
const USDExporterContext usd_export_context_
USDGenericMeshWriter(const USDExporterContext &ctx)
void do_write(HierarchyContext &context) override
bool is_supported(const HierarchyContext *context) const override
virtual Mesh * get_export_mesh(Object *object_eval, bool &r_needsfree)=0
virtual void free_export_mesh(Mesh *mesh)
void do_write(HierarchyContext &context) override
USDMeshWriter(const USDExporterContext &ctx)
void add_shape_key_weights_sample(const Object *obj)
void init_skinned_mesh(const HierarchyContext &context)
void init_blend_shapes(const HierarchyContext &context)
Mesh * get_export_mesh(Object *object_eval, bool &r_needsfree) override
void set_skel_export_flags(const HierarchyContext &context)
IndexRange index_range() const
bool all(VecOp< bool, D >) RET
void copy(const GVArray &src, GMutableSpan dst, exec_mode::Mode mode=exec_mode::parallel)
BLI_INLINE float crease_to_sharpness(float crease)
bool attribute_name_is_anonymous(const StringRef name)
std::string time(const std::tm &date_time, TimeFormat format=TimeFormat::H24)
int context(const bContext *C, const char *member, bContextDataResult *result)
void get_positions(const Span< float3 > positions, std::vector< Imath::V3f > &points)
static void get_loops_polys(const Mesh *mesh, USDMeshData &usd_mesh_data)
static const SubsurfModifierData * get_last_subdiv_modifier(eEvaluationMode eval_mode, Object *obj)
static void get_vert_creases(const Mesh *mesh, USDMeshData &usd_mesh_data)
Map< short, pxr::VtArray< int > > MaterialFaceGroups
void copy_blender_attribute_to_primvar(const GVArray &attribute, const bke::AttrType data_type, const pxr::UsdTimeCode time, const pxr::UsdGeomPrimvar &primvar, pxr::UsdUtilsSparseValueWriter &value_writer)
void get_armature_bone_names(const Object *ob_arm, const bool use_deform, Vector< StringRef > &r_names)
void export_deform_verts(const Mesh *mesh, const pxr::UsdSkelBindingAPI &skel_api, const Span< StringRef > bone_names)
std::optional< pxr::SdfValueTypeName > convert_blender_type_to_usd(const bke::AttrType blender_type, bool use_color3f_type)
static void get_positions(const Mesh *mesh, USDMeshData &usd_mesh_data)
bool is_armature_modifier_bone_name(const Object &obj, const StringRefNull name, const Depsgraph *depsgraph)
static std::optional< pxr::TfToken > convert_blender_domain_to_usd(const bke::AttrDomain blender_domain, bool is_bezier)
void create_blend_shapes(pxr::UsdStageRefPtr stage, const Object *obj, const pxr::UsdPrim &mesh_prim, bool allow_unicode)
const Key * get_mesh_shape_key(const Object *obj)
static void get_edge_creases(const Mesh *mesh, USDMeshData &usd_mesh_data)
pxr::TfToken TempBlendShapeWeightsPrimvarName
void set_attribute(const pxr::UsdAttribute &attr, const USDT value, pxr::UsdTimeCode time, pxr::UsdUtilsSparseValueWriter &value_writer)
const Object * get_armature_modifier_obj(const Object &obj, const Depsgraph *depsgraph)
pxr::VtFloatArray get_blendshape_weights(const Key *key)
bool can_export_skinned_mesh(const Object &obj, const Depsgraph *depsgraph)
std::string make_safe_primvar_name(const StringRef name, bool allow_unicode)
Mesh * get_shape_key_basis_mesh(Object *obj)
bool is_mesh_with_shape_keys(const Object *obj)
const Mesh * mesh_coerce_for_export_setup(MeshCoerceForExport &coerce, Depsgraph *depsgraph, Object *obj_eval, const bool apply_modifiers)
constexpr StringRefNull velocity
void copy_group_sizes(OffsetIndices< int > offsets, const IndexMask &mask, MutableSpan< int > sizes)
const pxr::TfToken displayColor("displayColor", pxr::TfToken::Immortal)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void BKE_mesh_uv_vert_map_free(UvVertMap *vmap)
int BKE_object_material_count_eval(const Object *ob)
void BM_mesh_free(BMesh *bm)
BMesh Free Mesh.
UvMapVert * BKE_mesh_uv_vert_map_get_vert(UvVertMap *vmap, unsigned int v)
@ SUBSURF_UV_SMOOTH_PRESERVE_CORNERS_AND_JUNCTIONS
@ SUBSURF_UV_SMOOTH_PRESERVE_BOUNDARIES
@ SUBSURF_UV_SMOOTH_PRESERVE_CORNERS
@ SUBSURF_UV_SMOOTH_PRESERVE_CORNERS_JUNCTIONS_AND_CONCAVE
void BKE_mesh_wrapper_ensure_mdata(Mesh *mesh)
const char * BKE_id_name(const ID &id)
VecBase< float, 2 > float2
BMesh * BKE_mesh_to_bmesh_ex(const Mesh *mesh, const BMeshCreateParams *create_params, const BMeshFromMeshParams *convert_params)
BMesh const char void * data
UvVertMap * BKE_mesh_uv_vert_map_create(OffsetIndices< int > faces, Span< int > corner_verts, Span< float2 > uv_map, int verts_num, const float2 &limit, bool use_winding)
void BKE_id_free(Main *bmain, void *idv)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
@ SUBSURF_TYPE_CATMULL_CLARK
Mesh * BKE_mesh_from_bmesh_for_eval_nomain(BMesh *bm, const CustomData_MeshMasks *cd_mask_extra, const Mesh *me_settings)
@ SUBSURF_BOUNDARY_SMOOTH_PRESERVE_CORNERS
@ SUBSURF_BOUNDARY_SMOOTH_ALL
Material * BKE_object_material_get_eval(Object *ob, short act)
void BM_mesh_triangulate(BMesh *bm, const int quad_method, const int ngon_method, const int min_vertices, const bool tag_only, BMOperator *op, BMOpSlot *slot_facemap_out, BMOpSlot *slot_facemap_double_out)
VecBase< float, 3 > float3
Mesh * BKE_object_get_evaluated_mesh(const Object *object_eval)
PipelineCompute loop_normals(loop_normals_main)
eObject_DuplicatorVisibilityFlag duplicator_visibility_flag
enum eEvaluationMode evaluation_mode
SubdivExportMode export_subdiv
const USDExportParams & export_params
const pxr::SdfPath usd_path
const pxr::UsdStageRefPtr stage
pxr::VtIntArray face_vertex_counts
pxr::VtIntArray crease_vertex_indices
pxr::VtIntArray face_indices
MaterialFaceGroups face_groups
pxr::VtIntArray crease_lengths
pxr::VtFloatArray corner_sharpnesses
pxr::VtFloatArray crease_sharpnesses
pxr::VtIntArray corner_indices
pxr::VtArray< pxr::GfVec3f > points