Cleanup: move Alembic, AVI, Collada, and USD to `source/blender/io`

This moves the `alembic`, `avi`, `collada`, and `usd` modules into a common
`io` directory.

This also cleans up some `#include "../../{somedir}/{somefile}.h"` by
adding `../../io/{somedir}` to `CMakeLists.txt` and then just using
`#include "{somefile}.h"`.

No functional changes.

1 files changed, 254 insertions, 0 deletions

diff --git a/source/blender/io/collada/AnimationImporter.h b/source/blender/io/collada/AnimationImporter.h
new file mode 100644
index 00000000000..0043dad7116
--- /dev/null
+++ b/source/blender/io/collada/AnimationImporter.h
@@ -0,0 +1,254 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+/** \file
+ * \ingroup collada
+ */
+
+#ifndef __ANIMATIONIMPORTER_H__
+#define __ANIMATIONIMPORTER_H__
+
+#include <map>
+#include <vector>
+
+#include "COLLADAFWAnimation.h"
+#include "COLLADAFWAnimationCurve.h"
+#include "COLLADAFWAnimationList.h"
+#include "COLLADAFWNode.h"
+#include "COLLADAFWUniqueId.h"
+#include "COLLADAFWLight.h"
+#include "COLLADAFWCamera.h"
+#include "COLLADAFWMaterial.h"
+#include "COLLADAFWEffect.h"
+#include "COLLADAFWInstanceGeometry.h"
+
+extern "C" {
+#include "BKE_context.h"
+#include "DNA_anim_types.h"
+#include "DNA_object_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_light_types.h"
+#include "DNA_camera_types.h"
+}
+
+//#include "ArmatureImporter.h"
+#include "TransformReader.h"
+
+#include "collada_internal.h"
+
+class ArmatureImporter;
+
+class AnimationImporterBase {
+ public:
+  // virtual void change_eul_to_quat(Object *ob, bAction *act) = 0;
+};
+
+class AnimationImporter : private TransformReader, public AnimationImporterBase {
+ private:
+  bContext *mContext;
+  ArmatureImporter *armature_importer;
+  Scene *scene;
+
+  std::map<COLLADAFW::UniqueId, std::vector<FCurve *>> curve_map;
+  std::map<COLLADAFW::UniqueId, TransformReader::Animation> uid_animated_map;
+  // std::map<bActionGroup*, std::vector<FCurve*> > fcurves_actionGroup_map;
+  std::map<COLLADAFW::UniqueId, const COLLADAFW::AnimationList *> animlist_map;
+  std::vector<FCurve *> unused_curves;
+  std::map<COLLADAFW::UniqueId, Object *> joint_objects;
+
+  FCurve *create_fcurve(int array_index, const char *rna_path);
+
+  void add_bezt(FCurve *fcu,
+                float frame,
+                float value,
+                eBezTriple_Interpolation ipo = BEZT_IPO_LIN);
+
+  // create one or several fcurves depending on the number of parameters being animated
+  void animation_to_fcurves(COLLADAFW::AnimationCurve *curve);
+
+  void fcurve_deg_to_rad(FCurve *cu);
+  void fcurve_scale(FCurve *cu, int scale);
+
+  void fcurve_is_used(FCurve *fcu);
+
+  void add_fcurves_to_object(Main *bmain,
+                             Object *ob,
+                             std::vector<FCurve *> &curves,
+                             char *rna_path,
+                             int array_index,
+                             Animation *animated);
+
+  int typeFlag;
+
+  std::string import_from_version;
+
+  enum lightAnim {
+    //      INANIMATE = 0,
+    LIGHT_COLOR = 2,
+    LIGHT_FOA = 4,
+    LIGHT_FOE = 8,
+  };
+
+  enum cameraAnim {
+    //      INANIMATE = 0,
+    CAMERA_XFOV = 2,
+    CAMERA_XMAG = 4,
+    CAMERA_YFOV = 8,
+    CAMERA_YMAG = 16,
+    CAMERA_ZFAR = 32,
+    CAMERA_ZNEAR = 64,
+  };
+
+  enum matAnim {
+    MATERIAL_SHININESS = 2,
+    MATERIAL_SPEC_COLOR = 4,
+    MATERIAL_DIFF_COLOR = 1 << 3,
+    MATERIAL_TRANSPARENCY = 1 << 4,
+    MATERIAL_IOR = 1 << 5,
+  };
+
+  enum AnimationType {
+    BC_INANIMATE = 0,
+    BC_NODE_TRANSFORM = 1,
+  };
+
+  struct AnimMix {
+    int transform;
+    int light;
+    int camera;
+    int material;
+    int texture;
+  };
+
+ public:
+  AnimationImporter(bContext *C, UnitConverter *conv, ArmatureImporter *arm, Scene *scene)
+      : TransformReader(conv), mContext(C), armature_importer(arm), scene(scene)
+  {
+  }
+
+  ~AnimationImporter();
+
+  void set_import_from_version(std::string import_from_version);
+  bool write_animation(const COLLADAFW::Animation *anim);
+
+  // called on post-process stage after writeVisualScenes
+  bool write_animation_list(const COLLADAFW::AnimationList *animlist);
+
+  void read_node_transform(COLLADAFW::Node *node, Object *ob);
+#if 0
+  virtual void change_eul_to_quat(Object *ob, bAction *act);
+#endif
+
+  void translate_Animations(COLLADAFW::Node *Node,
+                            std::map<COLLADAFW::UniqueId, COLLADAFW::Node *> &root_map,
+                            std::multimap<COLLADAFW::UniqueId, Object *> &object_map,
+                            std::map<COLLADAFW::UniqueId, const COLLADAFW::Object *> FW_object_map,
+                            std::map<COLLADAFW::UniqueId, Material *> uid_material_map);
+
+  AnimMix *get_animation_type(
+      const COLLADAFW::Node *node,
+      std::map<COLLADAFW::UniqueId, const COLLADAFW::Object *> FW_object_map);
+
+  void apply_matrix_curves(Object *ob,
+                           std::vector<FCurve *> &animcurves,
+                           COLLADAFW::Node *root,
+                           COLLADAFW::Node *node,
+                           COLLADAFW::Transformation *tm);
+
+  void add_bone_animation_sampled(Object *ob,
+                                  std::vector<FCurve *> &animcurves,
+                                  COLLADAFW::Node *root,
+                                  COLLADAFW::Node *node,
+                                  COLLADAFW::Transformation *tm);
+
+  void Assign_transform_animations(COLLADAFW::Transformation *transform,
+                                   const COLLADAFW::AnimationList::AnimationBinding *binding,
+                                   std::vector<FCurve *> *curves,
+                                   bool is_joint,
+                                   char *joint_path);
+
+  void Assign_color_animations(const COLLADAFW::UniqueId &listid,
+                               ListBase *AnimCurves,
+                               const char *anim_type);
+  void Assign_float_animations(const COLLADAFW::UniqueId &listid,
+                               ListBase *AnimCurves,
+                               const char *anim_type);
+  void Assign_lens_animations(const COLLADAFW::UniqueId &listid,
+                              ListBase *AnimCurves,
+                              const double aspect,
+                              Camera *cam,
+                              const char *anim_type,
+                              int fov_type);
+
+  int setAnimType(const COLLADAFW::Animatable *prop, int type, int addition);
+
+  void modify_fcurve(std::vector<FCurve *> *curves,
+                     const char *rna_path,
+                     int array_index,
+                     int scale = 1);
+  void unused_fcurve(std::vector<FCurve *> *curves);
+  // prerequisites:
+  // animlist_map - map animlist id -> animlist
+  // curve_map - map anim id -> curve(s)
+  Object *translate_animation_OLD(COLLADAFW::Node *node,
+                                  std::map<COLLADAFW::UniqueId, Object *> &object_map,
+                                  std::map<COLLADAFW::UniqueId, COLLADAFW::Node *> &root_map,
+                                  COLLADAFW::Transformation::TransformationType tm_type,
+                                  Object *par_job = NULL);
+
+  void find_frames(std::vector<float> *frames, std::vector<FCurve *> *curves);
+  void find_frames_old(std::vector<float> *frames,
+                       COLLADAFW::Node *node,
+                       COLLADAFW::Transformation::TransformationType tm_type);
+  // internal, better make it private
+  // warning: evaluates only rotation
+  // prerequisites: animlist_map, curve_map
+  void evaluate_transform_at_frame(float mat[4][4], COLLADAFW::Node *node, float fra);
+
+  // return true to indicate that mat contains a sane value
+  bool evaluate_animation(COLLADAFW::Transformation *tm,
+                          float mat[4][4],
+                          float fra,
+                          const char *node_id);
+
+  // gives a world-space mat of joint at rest position
+  void get_joint_rest_mat(float mat[4][4], COLLADAFW::Node *root, COLLADAFW::Node *node);
+
+  // gives a world-space mat, end's mat not included
+  bool calc_joint_parent_mat_rest(float mat[4][4],
+                                  float par[4][4],
+                                  COLLADAFW::Node *node,
+                                  COLLADAFW::Node *end);
+
+  float convert_to_focal_length(float in_xfov, int fov_type, float aspect, float sensorx);
+
+#ifdef ARMATURE_TEST
+  Object *get_joint_object(COLLADAFW::Node *root, COLLADAFW::Node *node, Object *par_job);
+#endif
+
+#if 0
+  // recursively evaluates joint tree until end is found, mat then is world-space matrix of end
+  // mat must be identity on enter, node must be root
+  bool evaluate_joint_world_transform_at_frame(
+      float mat[4][4], float par[4][4], COLLADAFW::Node *node, COLLADAFW::Node *end, float fra);
+#endif
+
+  void add_bone_fcurve(Object *ob, COLLADAFW::Node *node, FCurve *fcu);
+
+  void extra_data_importer(std::string elementName);
+};
+
+#endif