[Bf-blender-cvs] [d9a9e64e8cb] master: Cleanup: USD, refactored export graph construction

[Sybren A. Stüvel]

Commit: d9a9e64e8cb0b7c15fc310dc0f286f593f7c5801
Author: Sybren A. Stüvel
Date:   Fri May 8 11:59:08 2020 +0200
Branches: master
https://developer.blender.org/rBd9a9e64e8cb0b7c15fc310dc0f286f593f7c5801

Cleanup: USD, refactored export graph construction

The construction of the export graph is now split into a few steps:
- Construct a `HierarchyContext` object for the to-be-exported object.
- Determine the graph index, i.e. the export-parent and the duplicator.
- Update the `HierarchyContext` object for this graph index.

This allows the upcoming new Alembic exporter to override the location of
an object in the export graph, in order to support "flattened" exports.
Aside from that, this also simply makes the code cleaner.

No functional changes.

===================================================================

M	source/blender/io/usd/intern/abstract_hierarchy_iterator.cc
M	source/blender/io/usd/intern/abstract_hierarchy_iterator.h

===================================================================

diff --git a/source/blender/io/usd/intern/abstract_hierarchy_iterator.cc b/source/blender/io/usd/intern/abstract_hierarchy_iterator.cc
index d837d3d8dd3..3c7a86b2c34 100644
--- a/source/blender/io/usd/intern/abstract_hierarchy_iterator.cc
+++ b/source/blender/io/usd/intern/abstract_hierarchy_iterator.cc
@@ -345,8 +345,11 @@ void AbstractHierarchyIterator::visit_object(Object *object,
   context->original_export_path = "";
   copy_m4_m4(context->matrix_world, object->obmat);
 
+  ExportGraph::key_type graph_index = determine_graph_index_object(context);
+  context_update_for_graph_index(context, graph_index);
+
   // Store this HierarchyContext as child of the export parent.
-  export_graph_[std::make_pair(export_parent, nullptr)].insert(context);
+  export_graph_[graph_index].insert(context);
 
   // Create an empty entry for this object to indicate it is part of the export. This will be used
   // by connect_loose_objects(). Having such an "indicator" will make it possible to do an O(log n)
@@ -359,38 +362,25 @@ void AbstractHierarchyIterator::visit_object(Object *object,
   }
 }
 
+AbstractHierarchyIterator::ExportGraph::key_type AbstractHierarchyIterator::
+    determine_graph_index_object(const HierarchyContext *context)
+{
+  return std::make_pair(context->export_parent, nullptr);
+}
+
 void AbstractHierarchyIterator::visit_dupli_object(DupliObject *dupli_object,
                                                    Object *duplicator,
                                                    const std::set<Object *> &dupli_set)
 {
-  ExportGraph::key_type graph_index;
-  bool animation_check_include_parent = false;
-
   HierarchyContext *context = new HierarchyContext();
   context->object = dupli_object->ob;
   context->duplicator = duplicator;
   context->weak_export = false;
   context->export_path = "";
   context->original_export_path = "";
+  context->export_path = "";
+  context->animation_check_include_parent = false;
 
-  /* If the dupli-object's parent is also instanced by this object, use that as the
-   * export parent. Otherwise use the dupli-parent as export parent. */
-  Object *parent = dupli_object->ob->parent;
-  if (parent != nullptr && dupli_set.find(parent) != dupli_set.end()) {
-    // The parent object is part of the duplicated collection.
-    context->export_parent = parent;
-    graph_index = std::make_pair(parent, duplicator);
-  }
-  else {
-    /* The parent object is NOT part of the duplicated collection. This means that the world
-     * transform of this dupli-object can be influenced by objects that are not part of its
-     * export graph. */
-    animation_check_include_parent = true;
-    context->export_parent = duplicator;
-    graph_index = std::make_pair(duplicator, nullptr);
-  }
-
-  context->animation_check_include_parent = animation_check_include_parent;
   copy_m4_m4(context->matrix_world, dupli_object->mat);
 
   // Construct export name for the dupli-instance.
@@ -401,9 +391,39 @@ void AbstractHierarchyIterator::visit_dupli_object(DupliObject *dupli_object,
   }
   context->export_name = make_valid_name(get_object_name(context->object) + suffix_stream.str());
 
+  ExportGraph::key_type graph_index = determine_graph_index_dupli(context, dupli_set);
+  context_update_for_graph_index(context, graph_index);
   export_graph_[graph_index].insert(context);
 }
 
+AbstractHierarchyIterator::ExportGraph::key_type AbstractHierarchyIterator::
+    determine_graph_index_dupli(const HierarchyContext *context,
+                                const std::set<Object *> &dupli_set)
+{
+  /* If the dupli-object's parent is also instanced by this object, use that as the
+   * export parent. Otherwise use the dupli-parent as export parent. */
+
+  Object *parent = context->object->parent;
+  if (parent != nullptr && dupli_set.find(parent) != dupli_set.end()) {
+    // The parent object is part of the duplicated collection.
+    return std::make_pair(parent, context->duplicator);
+  }
+  return std::make_pair(context->duplicator, nullptr);
+}
+
+void AbstractHierarchyIterator::context_update_for_graph_index(
+    HierarchyContext *context, const ExportGraph::key_type &graph_index) const
+{
+  // Update the HierarchyContext so that it is consistent with the graph index.
+  context->export_parent = graph_index.first;
+  if (context->export_parent != context->object->parent) {
+    /* The parent object in Blender is NOT used as the export parent. This means
+     * that the world transform of this object can be influenced by objects that
+     * are not part of its export graph. */
+    context->animation_check_include_parent = true;
+  }
+}
+
 AbstractHierarchyIterator::ExportChildren &AbstractHierarchyIterator::graph_children(
     const HierarchyContext *context)
 {
diff --git a/source/blender/io/usd/intern/abstract_hierarchy_iterator.h b/source/blender/io/usd/intern/abstract_hierarchy_iterator.h
index 08b50e2560d..295430d903f 100644
--- a/source/blender/io/usd/intern/abstract_hierarchy_iterator.h
+++ b/source/blender/io/usd/intern/abstract_hierarchy_iterator.h
@@ -56,7 +56,7 @@ class AbstractHierarchyWriter;
  * struct contains everything necessary to export a single object to a file. */
 struct HierarchyContext {
   /*********** Determined during hierarchy iteration: ***************/
-  Object *object;
+  Object *object; /* Evaluated object. */
   Object *export_parent;
   Object *duplicator;
   float matrix_world[4][4];
@@ -188,6 +188,8 @@ class AbstractHierarchyIterator {
                           const std::set<Object *> &dupli_set);
 
   ExportChildren &graph_children(const HierarchyContext *parent_context);
+  void context_update_for_graph_index(HierarchyContext *context,
+                                      const ExportGraph::key_type &graph_index) const;
 
   void determine_export_paths(const HierarchyContext *parent_context);
   void determine_duplication_references(const HierarchyContext *parent_context,
@@ -233,6 +235,10 @@ class AbstractHierarchyIterator {
 
   virtual bool should_visit_dupli_object(const DupliObject *dupli_object) const;
 
+  virtual ExportGraph::key_type determine_graph_index_object(const HierarchyContext *context);
+  virtual ExportGraph::key_type determine_graph_index_dupli(const HierarchyContext *context,
+                                                            const std::set<Object *> &dupli_set);
+
   /* These functions should create an AbstractHierarchyWriter subclass instance, or return
    * nullptr if the object or its data should not be exported. Returning a nullptr for
    * data/hair/particle will NOT prevent the transform to be written.