e955c94ed3
Listing the "Blender Foundation" as copyright holder implied the Blender Foundation holds copyright to files which may include work from many developers. While keeping copyright on headers makes sense for isolated libraries, Blender's own code may be refactored or moved between files in a way that makes the per file copyright holders less meaningful. Copyright references to the "Blender Foundation" have been replaced with "Blender Authors", with the exception of `./extern/` since these this contains libraries which are more isolated, any changed to license headers there can be handled on a case-by-case basis. Some directories in `./intern/` have also been excluded: - `./intern/cycles/` it's own `AUTHORS` file is planned. - `./intern/opensubdiv/`. An "AUTHORS" file has been added, using the chromium projects authors file as a template. Design task: #110784 Ref !110783.
272 lines
9.0 KiB
C++
272 lines
9.0 KiB
C++
/* SPDX-FileCopyrightText: 2023 Blender Authors
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
|
|
/** \file
|
|
* \ingroup collada
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <map>
|
|
#include <vector>
|
|
|
|
#include "COLLADAFWAnimation.h"
|
|
#include "COLLADAFWAnimationCurve.h"
|
|
#include "COLLADAFWAnimationList.h"
|
|
#include "COLLADAFWCamera.h"
|
|
#include "COLLADAFWEffect.h"
|
|
#include "COLLADAFWInstanceGeometry.h"
|
|
#include "COLLADAFWLight.h"
|
|
#include "COLLADAFWMaterial.h"
|
|
#include "COLLADAFWNode.h"
|
|
#include "COLLADAFWUniqueId.h"
|
|
|
|
#include "BKE_context.h"
|
|
|
|
#include "DNA_anim_types.h"
|
|
|
|
#include "DNA_camera_types.h"
|
|
#include "DNA_light_types.h"
|
|
#include "DNA_object_types.h"
|
|
#include "DNA_scene_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);
|
|
|
|
/**
|
|
* \todo refactor read_node_transform to not automatically apply anything,
|
|
* but rather return the transform matrix, so caller can do with it what is
|
|
* necessary. Same for \ref get_node_mat
|
|
*/
|
|
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);
|
|
|
|
/**
|
|
* Check if object is animated by checking if animlist_map
|
|
* holds the animlist_id of node transforms.
|
|
*/
|
|
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);
|
|
|
|
/**
|
|
* Creates the rna_paths and array indices of fcurves from animations using transformation and
|
|
* bound animation class of each animation.
|
|
*/
|
|
void Assign_transform_animations(COLLADAFW::Transformation *transform,
|
|
const COLLADAFW::AnimationList::AnimationBinding *binding,
|
|
std::vector<FCurve *> *curves,
|
|
bool is_joint,
|
|
char *joint_path);
|
|
|
|
/**
|
|
* Creates the rna_paths and array indices of fcurves from animations using color and bound
|
|
* animation class of each animation.
|
|
*/
|
|
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);
|
|
/**
|
|
* Lens animations must be stored in COLLADA by using FOV,
|
|
* while blender internally uses focal length.
|
|
* The imported animation curves must be converted appropriately.
|
|
*/
|
|
void Assign_lens_animations(const COLLADAFW::UniqueId &listid,
|
|
ListBase *AnimCurves,
|
|
double aspect,
|
|
Camera *cam,
|
|
const char *anim_type,
|
|
int fov_type);
|
|
|
|
int setAnimType(const COLLADAFW::Animatable *prop, int type, int addition);
|
|
|
|
/** Sets the rna_path and array index to curve. */
|
|
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);
|
|
/** Is not used anymore. */
|
|
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 and only assigns matrix transforms now
|
|
* 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);
|
|
};
|