source/blender/alembic/intern/abc_object.cc

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * Contributor(s): Esteban Tovagliari, Cedric Paille, Kevin Dietrich
  19  *
  20  * ***** END GPL LICENSE BLOCK *****
  21  */
  22
  23 #include "abc_object.h"
  24
  25 #include "abc_util.h"
  26
  27 extern "C" {
  28 #include "DNA_cachefile_types.h"
  29 #include "DNA_constraint_types.h"
  30 #include "DNA_modifier_types.h"
  31 #include "DNA_object_types.h"
  32 #include "DNA_space_types.h"  /* for FILE_MAX */
  33
  34 #include "BKE_constraint.h"
  35 #include "BKE_idprop.h"
  36 #include "BKE_library.h"
  37 #include "BKE_modifier.h"
  38 #include "BKE_object.h"
  39
  40 #include "BLI_listbase.h"
  41 #include "BLI_math.h"
  42 #include "BLI_string.h"
  43 }
  44
  45 using Alembic::AbcGeom::IObject;
  46 using Alembic::AbcGeom::IXform;
  47 using Alembic::AbcGeom::IXformSchema;
  48
  49 using Alembic::AbcGeom::OCompoundProperty;
  50 using Alembic::AbcGeom::ODoubleArrayProperty;
  51 using Alembic::AbcGeom::ODoubleProperty;
  52 using Alembic::AbcGeom::OFloatArrayProperty;
  53 using Alembic::AbcGeom::OFloatProperty;
  54 using Alembic::AbcGeom::OInt32ArrayProperty;
  55 using Alembic::AbcGeom::OInt32Property;
  56 using Alembic::AbcGeom::OStringArrayProperty;
  57 using Alembic::AbcGeom::OStringProperty;
  58
  59 /* ************************************************************************** */
  60
  61 AbcObjectWriter::AbcObjectWriter(Scene *scene,
  62                                  Object *ob,
  63                                  uint32_t time_sampling,
  64                                  ExportSettings &settings,
  65                                  AbcObjectWriter *parent)
  66     : m_object(ob)
  67     , m_settings(settings)
  68     , m_scene(scene)
  69     , m_time_sampling(time_sampling)
  70     , m_first_frame(true)
  71 {
  72         m_name = get_id_name(m_object) + "Shape";
  73
  74         if (parent) {
  75                 parent->addChild(this);
  76         }
  77 }
  78
  79 AbcObjectWriter::~AbcObjectWriter()
  80 {}
  81
  82 void AbcObjectWriter::addChild(AbcObjectWriter *child)
  83 {
  84         m_children.push_back(child);
  85 }
  86
  87 Imath::Box3d AbcObjectWriter::bounds()
  88 {
  89         BoundBox *bb = BKE_object_boundbox_get(this->m_object);
  90
  91         if (!bb) {
  92                 if (this->m_object->type != OB_CAMERA) {
  93                         ABC_LOG(m_settings.logger) << "Bounding box is null!\n";
  94                 }
  95
  96                 return Imath::Box3d();
  97         }
  98
  99         /* Convert Z-up to Y-up. This also changes which vector goes into which min/max property. */
 100         this->m_bounds.min.x = bb->vec[0][0];
 101         this->m_bounds.min.y = bb->vec[0][2];
 102         this->m_bounds.min.z = -bb->vec[6][1];
 103
 104         this->m_bounds.max.x = bb->vec[6][0];
 105         this->m_bounds.max.y = bb->vec[6][2];
 106         this->m_bounds.max.z = -bb->vec[0][1];
 107
 108         return this->m_bounds;
 109 }
 110
 111 void AbcObjectWriter::write()
 112 {
 113         do_write();
 114         m_first_frame = false;
 115 }
 116
 117 /* ************************************************************************** */
 118
 119 AbcObjectReader::AbcObjectReader(const IObject &object, ImportSettings &settings)
 120     : m_name("")
 121     , m_object_name("")
 122     , m_data_name("")
 123     , m_object(NULL)
 124     , m_iobject(object)
 125     , m_settings(&settings)
 126     , m_min_time(std::numeric_limits<chrono_t>::max())
 127     , m_max_time(std::numeric_limits<chrono_t>::min())
 128     , m_refcount(0)
 129     , parent_reader(NULL)
 130 {
 131         m_name = object.getFullName();
 132         std::vector<std::string> parts;
 133         split(m_name, '/', parts);
 134
 135         if (parts.size() >= 2) {
 136                 m_object_name = parts[parts.size() - 2];
 137                 m_data_name = parts[parts.size() - 1];
 138         }
 139         else {
 140                 m_object_name = m_data_name = parts[parts.size() - 1];
 141         }
 142 }
 143
 144 AbcObjectReader::~AbcObjectReader()
 145 {}
 146
 147 const IObject &AbcObjectReader::iobject() const
 148 {
 149         return m_iobject;
 150 }
 151
 152 Object *AbcObjectReader::object() const
 153 {
 154         return m_object;
 155 }
 156
 157 void AbcObjectReader::object(Object *ob)
 158 {
 159         m_object = ob;
 160 }
 161
 162 static Imath::M44d blend_matrices(const Imath::M44d &m0, const Imath::M44d &m1, const float weight)
 163 {
 164         float mat0[4][4], mat1[4][4], ret[4][4];
 165
 166         /* Cannot use Imath::M44d::getValue() since this returns a pointer to
 167          * doubles and interp_m4_m4m4 expects pointers to floats. So need to convert
 168          * the matrices manually.
 169          */
 170
 171         for (int i = 0; i < 4; ++i) {
 172                 for (int j = 0; j < 4; ++j) {
 173                         mat0[i][j] = static_cast<float>(m0[i][j]);
 174                 }
 175         }
 176
 177         for (int i = 0; i < 4; ++i) {
 178                 for (int j = 0; j < 4; ++j) {
 179                         mat1[i][j] = static_cast<float>(m1[i][j]);
 180                 }
 181         }
 182
 183         interp_m4_m4m4(ret, mat0, mat1, weight);
 184
 185         Imath::M44d m;
 186
 187         for (int i = 0; i < 4; ++i) {
 188                 for (int j = 0; j < 4; ++j) {
 189                         m[i][j] = ret[i][j];
 190                 }
 191         }
 192
 193         return m;
 194 }
 195
 196 Imath::M44d get_matrix(const IXformSchema &schema, const float time)
 197 {
 198         Alembic::AbcGeom::index_t i0, i1;
 199         Alembic::AbcGeom::XformSample s0, s1;
 200
 201         const float weight = get_weight_and_index(time,
 202                                                   schema.getTimeSampling(),
 203                                                   schema.getNumSamples(),
 204                                                   i0,
 205                                                   i1);
 206
 207         schema.get(s0, Alembic::AbcGeom::ISampleSelector(i0));
 208
 209         if (i0 != i1) {
 210                 schema.get(s1, Alembic::AbcGeom::ISampleSelector(i1));
 211                 return blend_matrices(s0.getMatrix(), s1.getMatrix(), weight);
 212         }
 213
 214         return s0.getMatrix();
 215 }
 216
 217 DerivedMesh *AbcObjectReader::read_derivedmesh(DerivedMesh *dm,
 218                                                const Alembic::Abc::ISampleSelector &UNUSED(sample_sel),
 219                                                int UNUSED(read_flag),
 220                                                const char **UNUSED(err_str))
 221 {
 222         return dm;
 223 }
 224
 225 void AbcObjectReader::setupObjectTransform(const float time)
 226 {
 227         bool is_constant = false;
 228
 229         this->read_matrix(m_object->obmat, time, m_settings->scale, is_constant);
 230         invert_m4_m4(m_object->imat, m_object->obmat);
 231
 232         BKE_object_apply_mat4(m_object, m_object->obmat, false,  false);
 233
 234         if (!is_constant) {
 235                 bConstraint *con = BKE_constraint_add_for_object(m_object, NULL, CONSTRAINT_TYPE_TRANSFORM_CACHE);
 236                 bTransformCacheConstraint *data = static_cast<bTransformCacheConstraint *>(con->data);
 237                 BLI_strncpy(data->object_path, m_iobject.getFullName().c_str(), FILE_MAX);
 238
 239                 data->cache_file = m_settings->cache_file;
 240                 id_us_plus(&data->cache_file->id);
 241
 242                 data->reader = reinterpret_cast<CacheReader *>(this);
 243                 this->incref();
 244         }
 245 }
 246
 247 Alembic::AbcGeom::IXform AbcObjectReader::xform()
 248 {
 249         /* Check that we have an empty object (locator, bone head/tail...).  */
 250         if (IXform::matches(m_iobject.getMetaData())) {
 251                 return IXform(m_iobject, Alembic::AbcGeom::kWrapExisting);
 252         }
 253
 254         /* Check that we have an object with actual data, in which case the
 255          * parent Alembic object should contain the transform. */
 256         IObject abc_parent = m_iobject.getParent();
 257
 258         /* The archive's top object can be recognised by not having a parent. */
 259         if (abc_parent.getParent()
 260                 && IXform::matches(abc_parent.getMetaData())) {
 261                 return IXform(abc_parent, Alembic::AbcGeom::kWrapExisting);
 262         }
 263
 264         /* Should not happen. */
 265         std::cerr << "AbcObjectReader::xform(): "
 266                   << "unable to find IXform for Alembic object '"
 267                   << m_iobject.getFullName() << "'\n";
 268         BLI_assert(false);
 269
 270         return IXform();
 271 }
 272
 273 void AbcObjectReader::read_matrix(float r_mat[4][4], const float time,
 274                                   const float scale, bool &is_constant)
 275 {
 276         IXform ixform = xform();
 277         if (!ixform) {
 278                 return;
 279         }
 280
 281         const IXformSchema & schema(ixform.getSchema());
 282         if (!schema.valid()) {
 283                 std::cerr << "Alembic object " << ixform.getFullName()
 284                           << " has an invalid schema." << std::endl;
 285                 return;
 286         }
 287
 288         bool has_alembic_parent;
 289         IObject ixform_parent = ixform.getParent();
 290         if (!ixform_parent.getParent()) {
 291                 /* The archive top object certainly is not a transform itself, so handle
 292                  * it as "no parent". */
 293                 has_alembic_parent = false;
 294         }
 295         else {
 296                 has_alembic_parent = ixform_parent && schema.getInheritsXforms();
 297
 298                 if (has_alembic_parent && m_object->parent == NULL) {
 299                         /* TODO Sybren: This happened in some files. I think I solved it,
 300                          * but I'll leave this check in here anyway until we've tested it
 301                          * more thoroughly. Better than crashing on a null parent anyway. */
 302                         std::cerr << "Alembic object " << m_iobject.getFullName()
 303                                   << " with transform " << ixform.getFullName()
 304                                   << " has an Alembic parent but no parent Blender object."
 305                                   << std::endl;
 306                         has_alembic_parent = false;
 307                 }
 308         }
 309
 310         const Imath::M44d matrix = get_matrix(schema, time);
 311         convert_matrix(matrix, m_object, r_mat);
 312
 313         if (has_alembic_parent) {
 314                 /* In this case, the matrix in Alembic is in local coordinates, so
 315                  * convert to world matrix. To prevent us from reading and accumulating
 316                  * all parent matrices in the Alembic file, we assume that the Blender
 317                  * parent object is already updated for the current timekey, and use its
 318                  * world matrix. */
 319                 BLI_assert(m_object->parent);
 320                 mul_m4_m4m4(r_mat, m_object->parent->obmat, r_mat);
 321         }
 322         else {
 323                 /* Only apply scaling to root objects, parenting will propagate it. */
 324                 float scale_mat[4][4];
 325                 scale_m4_fl(scale_mat, scale);
 326                 scale_mat[3][3] = scale; /* scale translations too */
 327                 mul_m4_m4m4(r_mat, r_mat, scale_mat);
 328         }
 329
 330         is_constant = schema.isConstant();
 331 }
 332
 333 void AbcObjectReader::addCacheModifier()
 334 {
 335         ModifierData *md = modifier_new(eModifierType_MeshSequenceCache);
 336         BLI_addtail(&m_object->modifiers, md);
 337
 338         MeshSeqCacheModifierData *mcmd = reinterpret_cast<MeshSeqCacheModifierData *>(md);
 339
 340         mcmd->cache_file = m_settings->cache_file;
 341         id_us_plus(&mcmd->cache_file->id);
 342
 343         BLI_strncpy(mcmd->object_path, m_iobject.getFullName().c_str(), FILE_MAX);
 344
 345         mcmd->reader = reinterpret_cast<CacheReader *>(this);
 346         this->incref();
 347 }
 348
 349 chrono_t AbcObjectReader::minTime() const
 350 {
 351         return m_min_time;
 352 }
 353
 354 chrono_t AbcObjectReader::maxTime() const
 355 {
 356         return m_max_time;
 357 }
 358
 359 int AbcObjectReader::refcount() const
 360 {
 361         return m_refcount;
 362 }
 363
 364 void AbcObjectReader::incref()
 365 {
 366         ++m_refcount;
 367 }
 368
 369 void AbcObjectReader::decref()
 370 {
 371         --m_refcount;
 372         BLI_assert(m_refcount >= 0);
 373 }