Blender V5.3
usd_writer_transform.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2019 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
6
7#include <pxr/base/gf/matrix4d.h>
8#include <pxr/base/gf/matrix4f.h>
9#include <pxr/usd/usdGeom/xform.h>
10
11#include "BKE_object.hh"
12
13#include "DNA_object_types.h"
14
15#include "BLI_math_matrix.hh"
20#include "BLI_vector.hh"
21
22#include "CLG_log.h"
23
24namespace blender {
25
26static CLG_LogRef LOG = {"io.usd"};
27
28namespace io::usd {
29
31
32pxr::UsdGeomXformable USDTransformWriter::create_xformable() const
33{
34 pxr::UsdGeomXform xform;
35
36 /* If prim exists, cast to #UsdGeomXform
37 * (Solves merge transform and shape issue for animated exports). */
38 pxr::UsdPrim existing_prim = usd_export_context_.stage->GetPrimAtPath(
40 if (existing_prim.IsValid() && existing_prim.IsA<pxr::UsdGeomXform>()) {
41 xform = pxr::UsdGeomXform(existing_prim);
42 }
43 else {
44 xform = pxr::UsdGeomXform::Define(usd_export_context_.stage, usd_export_context_.usd_path);
45 }
46
47 return pxr::UsdGeomXformable(xform.GetPrim());
48}
49
51{
54 {
55 return false;
56 }
57
59 return false;
60 }
61
62 if (context.export_parent != nullptr) {
63 return false;
64 }
65
66 return true;
67}
68
70{
71 if (context.is_point_proto || context.is_point_instance) {
72 return;
73 }
74
75 pxr::UsdGeomXformable xform = create_xformable();
76
77 if (!xform) {
78 CLOG_ERROR(&LOG, "USDTransformWriter: couldn't create xformable");
79 return;
80 }
81
82 float4x4 parent_relative_matrix; /* The object matrix relative to the parent. */
83
84 if (should_apply_root_xform(context)) {
85 float4x4 matrix_world = context.matrix_world;
86
88 float3x3 mrot;
94 mrot.ptr());
95 mat.view<3, 3>() = math::transpose(mrot);
96 matrix_world = mat * context.matrix_world;
97 }
98
101 const float4x4 mat_scale = math::from_scale<float4x4>(scale);
102 matrix_world = mat_scale * matrix_world;
103 }
104
105 parent_relative_matrix = context.parent_matrix_inv_world * matrix_world;
106 }
107 else {
108 parent_relative_matrix = context.parent_matrix_inv_world * context.matrix_world;
109 }
110
111 /* USD Xforms are by default the identity transform; only write if necessary when static. */
112 if (is_animated_ || !math::is_equal(parent_relative_matrix, float4x4::identity(), 0.000000001f))
113 {
114 set_xform_ops(parent_relative_matrix, xform);
115 }
116
117 if (usd_export_context_.export_params.use_instancing && context.is_instance()) {
118 mark_as_instance(context, xform.GetPrim());
119 }
120
121 if (context.object) {
122 auto prim = xform.GetPrim();
123 add_to_prim_map(prim.GetPath(), &context.object->id);
124 write_id_properties(prim, context.object->id, get_export_time_code());
125 }
126}
127
129{
130 if (context.duplicator != nullptr) {
131 /* This object is being duplicated, so could be emitted by a particle system and thus
132 * influenced by forces. TODO(Sybren): Make this more strict. Probably better to get from the
133 * depsgraph whether this object instance has a time source. */
134 return true;
135 }
136 if (check_has_physics(context)) {
137 return true;
138 }
139 return BKE_object_moves_in_time(context.object, context.animation_check_include_parent);
140}
141
142void USDTransformWriter::set_xform_ops(const float4x4 &parent_relative_matrix,
143 const pxr::UsdGeomXformable &xf)
144{
145 if (!xf) {
146 return;
147 }
148
150
151 if (xformOps_.is_empty()) {
152 switch (xfOpMode) {
153 case XformOpMode::TRS:
154 xformOps_.append(xf.AddTranslateOp());
155 xformOps_.append(xf.AddRotateXYZOp());
156 xformOps_.append(xf.AddScaleOp());
157 break;
158 case XformOpMode::TOS:
159 xformOps_.append(xf.AddTranslateOp());
160 xformOps_.append(xf.AddOrientOp());
161 xformOps_.append(xf.AddScaleOp());
162 break;
163 case XformOpMode::MAT:
164 xformOps_.append(xf.AddTransformOp());
165 break;
166 default:
167 CLOG_WARN(&LOG, "Unknown XformOp type");
168 xformOps_.append(xf.AddTransformOp());
169 break;
170 }
171 }
172
173 if (xformOps_.is_empty()) {
174 /* Shouldn't happen. */
175 return;
176 }
177
178 pxr::UsdTimeCode time_code = get_export_time_code();
179
180 if (xformOps_.size() == 1) {
181 pxr::GfMatrix4d mat_val(parent_relative_matrix.ptr());
182 usd_value_writer_.SetAttribute(xformOps_[0].GetAttr(), mat_val, time_code);
183 }
184 else if (xformOps_.size() == 3) {
185 float3 loc;
188
189 math::to_loc_rot_scale<true>(parent_relative_matrix, loc, rot, scale);
190
191 if (xfOpMode == XformOpMode::TRS) {
192 pxr::GfVec3d loc_val(loc.x, loc.y, loc.z);
193 usd_value_writer_.SetAttribute(xformOps_[0].GetAttr(), loc_val, time_code);
194
195 const math::EulerXYZ eul = math::to_euler(rot);
196 pxr::GfVec3f rot_val(eul.x().degree(), eul.y().degree(), eul.z().degree());
197 usd_value_writer_.SetAttribute(xformOps_[1].GetAttr(), rot_val, time_code);
198
199 pxr::GfVec3f scale_val(scale.x, scale.y, scale.z);
200 usd_value_writer_.SetAttribute(xformOps_[2].GetAttr(), scale_val, time_code);
201 }
202 else if (xfOpMode == XformOpMode::TOS) {
203 pxr::GfVec3d loc_val(loc.x, loc.y, loc.z);
204 usd_value_writer_.SetAttribute(xformOps_[0].GetAttr(), loc_val, time_code);
205
206 pxr::GfQuatf quat_val(rot.w, rot.x, rot.y, rot.z);
207 usd_value_writer_.SetAttribute(xformOps_[1].GetAttr(), quat_val, time_code);
208
209 pxr::GfVec3f scale_val(scale.x, scale.y, scale.z);
210 usd_value_writer_.SetAttribute(xformOps_[2].GetAttr(), scale_val, time_code);
211 }
212 }
213}
214
215} // namespace io::usd
216} // namespace blender
General operations, lookup, etc. for blender objects.
#define CLOG_ERROR(clg_ref,...)
Definition CLG_log.h:188
#define CLOG_WARN(clg_ref,...)
Definition CLG_log.h:189
Object is a sort of wrapper for general info.
static bool check_has_physics(const HierarchyContext &context)
void add_to_prim_map(const pxr::SdfPath &usd_path, const ID *id) const
virtual bool mark_as_instance(const HierarchyContext &context, const pxr::UsdPrim &prim)
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
const USDExporterContext usd_export_context_
USDTransformWriter(const USDExporterContext &ctx)
void set_xform_ops(const float4x4 &parent_relative_matrix, const pxr::UsdGeomXformable &xf)
bool check_is_animated(const HierarchyContext &context) const override
void do_write(HierarchyContext &context) override
virtual pxr::UsdGeomXformable create_xformable() const
bool should_apply_root_xform(const HierarchyContext &context) const
#define rot(x, k)
float3x3 scale(float3x3 mat, float2 scale)
double get_meters_per_unit(const USDExportParams &params)
QuaternionBase< float > Quaternion
MatBase< T, NumCol, NumRow > transpose(const MatBase< T, NumRow, NumCol > &mat)
EulerXYZBase< float > EulerXYZ
MatT from_scale(const VecBase< typename MatT::base_type, ScaleDim > &scale)
bool is_equal(const MatBase< T, NumCol, NumRow > &a, const MatBase< T, NumCol, NumRow > &b, const T epsilon=T(0))
void to_loc_rot_scale(const MatBase< T, 3, 3 > &mat, VecBase< T, 2 > &r_location, AngleRadianBase< T > &r_rotation, VecBase< T, 2 > &r_scale)
Euler3Base< T > to_euler(const AxisAngleBase< T, AngleT > &axis_angle, EulerOrder order)
BMesh Iterators.
bool BKE_object_moves_in_time(const Object *object, bool recurse_parent)
Definition object.cc:4968
MatBase< float, 4, 4 > float4x4
bool mat3_from_axis_conversion(int src_forward, int src_up, int dst_forward, int dst_up, float r_mat[3][3])
MatBase< float, 3, 3 > float3x3
static CLG_LogRef LOG
Definition logging.cpp:12
VecBase< float, 3 > float3
const c_style_mat & ptr() const
const MatView< T, ViewNumCol, ViewNumRow, NumCol, NumRow, SrcStartCol, SrcStartRow, Alignment > view() const