godot/editor/collada/collada.h
Rémi Verschelde 5dbf1809c6 A Whole New World (clang-format edition)
I can show you the code
Pretty, with proper whitespace
Tell me, coder, now when did
You last write readable code?

I can open your eyes
Make you see your bad indent
Force you to respect the style
The core devs agreed upon

A whole new world
A new fantastic code format
A de facto standard
With some sugar
Enforced with clang-format

A whole new world
A dazzling style we all dreamed of
And when we read it through
It's crystal clear
That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00

653 lines
14 KiB
C++

/*************************************************************************/
/* collada.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifdef TOOLS_ENABLED
#ifndef COLLADA_H
#define COLLADA_H
#include "global_config.h"
#include "io/xml_parser.h"
#include "map.h"
#include "scene/resources/material.h"
class Collada {
public:
enum ImportFlags {
IMPORT_FLAG_SCENE = 1,
IMPORT_FLAG_ANIMATION = 2
};
struct Image {
String path;
};
struct Material {
String name;
String instance_effect;
};
struct Effect {
String name;
Map<String, Variant> params;
struct Channel {
int uv_idx;
String texture;
Color color;
Channel() { uv_idx = 0; }
};
Channel diffuse, specular, emission, bump;
float shininess;
bool found_double_sided;
bool double_sided;
bool unshaded;
String get_texture_path(const String &p_source, Collada &state) const;
Effect() {
diffuse.color = Color(1, 1, 1, 1);
double_sided = true;
found_double_sided = false;
shininess = 40;
unshaded = false;
}
};
struct CameraData {
enum Mode {
MODE_PERSPECTIVE,
MODE_ORTHOGONAL
};
Mode mode;
union {
struct {
float x_fov;
float y_fov;
} perspective;
struct {
float x_mag;
float y_mag;
} orthogonal;
};
float aspect;
float z_near;
float z_far;
CameraData() {
mode = MODE_PERSPECTIVE;
perspective.y_fov = 0;
perspective.x_fov = 0;
aspect = 1;
z_near = 0.1;
z_far = 100;
}
};
struct LightData {
enum Mode {
MODE_AMBIENT,
MODE_DIRECTIONAL,
MODE_OMNI,
MODE_SPOT
};
Mode mode;
Color color;
float constant_att;
float linear_att;
float quad_att;
float spot_angle;
float spot_exp;
LightData() {
mode = MODE_AMBIENT;
color = Color(1, 1, 1, 1);
constant_att = 0;
linear_att = 0;
quad_att = 0;
spot_angle = 45;
spot_exp = 1;
}
};
struct MeshData {
String name;
struct Source {
Vector<float> array;
int stride;
};
Map<String, Source> sources;
struct Vertices {
Map<String, String> sources;
};
Map<String, Vertices> vertices;
struct Primitives {
struct SourceRef {
String source;
int offset;
};
String material;
Map<String, SourceRef> sources;
Vector<float> polygons;
Vector<float> indices;
int count;
int vertex_size;
};
Vector<Primitives> primitives;
bool found_double_sided;
bool double_sided;
MeshData() {
found_double_sided = false;
double_sided = true;
}
};
struct CurveData {
String name;
bool closed;
struct Source {
Vector<String> sarray;
Vector<float> array;
int stride;
};
Map<String, Source> sources;
Map<String, String> control_vertices;
CurveData() {
closed = false;
}
};
struct SkinControllerData {
String base;
bool use_idrefs;
Transform bind_shape;
struct Source {
Vector<String> sarray; //maybe for names
Vector<float> array;
int stride;
Source() {
stride = 1;
}
};
Map<String, Source> sources;
struct Joints {
Map<String, String> sources;
} joints;
struct Weights {
struct SourceRef {
String source;
int offset;
};
String material;
Map<String, SourceRef> sources;
Vector<float> sets;
Vector<float> indices;
int count;
} weights;
Map<String, Transform> bone_rest_map;
SkinControllerData() { use_idrefs = false; }
};
struct MorphControllerData {
String mesh;
String mode;
struct Source {
int stride;
Vector<String> sarray; //maybe for names
Vector<float> array;
Source() { stride = 1; }
};
Map<String, Source> sources;
Map<String, String> targets;
MorphControllerData() {}
};
struct Vertex {
int idx;
Vector3 vertex;
Vector3 normal;
Vector3 uv;
Vector3 uv2;
Plane tangent;
Color color;
int uid;
struct Weight {
int bone_idx;
float weight;
bool operator<(const Weight w) const { return weight > w.weight; } //heaviest first
};
Vector<Weight> weights;
void fix_weights() {
weights.sort();
if (weights.size() > 4) {
//cap to 4 and make weights add up 1
weights.resize(4);
float total = 0;
for (int i = 0; i < 4; i++)
total += weights[i].weight;
if (total)
for (int i = 0; i < 4; i++)
weights[i].weight /= total;
}
}
void fix_unit_scale(Collada &state);
bool operator<(const Vertex &p_vert) const {
if (uid == p_vert.uid) {
if (vertex == p_vert.vertex) {
if (normal == p_vert.normal) {
if (uv == p_vert.uv) {
if (uv2 == p_vert.uv2) {
if (!weights.empty() || !p_vert.weights.empty()) {
if (weights.size() == p_vert.weights.size()) {
for (int i = 0; i < weights.size(); i++) {
if (weights[i].bone_idx != p_vert.weights[i].bone_idx)
return weights[i].bone_idx < p_vert.weights[i].bone_idx;
if (weights[i].weight != p_vert.weights[i].weight)
return weights[i].weight < p_vert.weights[i].weight;
}
} else {
return weights.size() < p_vert.weights.size();
}
}
return (color < p_vert.color);
} else
return (uv2 < p_vert.uv2);
} else
return (uv < p_vert.uv);
} else
return (normal < p_vert.normal);
} else
return vertex < p_vert.vertex;
} else
return uid < p_vert.uid;
}
Vertex() {
uid = 0;
idx = 0;
}
};
struct Node {
enum Type {
TYPE_NODE,
TYPE_JOINT,
TYPE_SKELETON, //this bone is not collada, it's added afterwards as optimization
TYPE_LIGHT,
TYPE_CAMERA,
TYPE_GEOMETRY
};
struct XForm {
enum Op {
OP_ROTATE,
OP_SCALE,
OP_TRANSLATE,
OP_MATRIX,
OP_VISIBILITY
};
String id;
Op op;
Vector<float> data;
};
Type type;
String name;
String id;
String empty_draw_type;
bool noname;
Vector<XForm> xform_list;
Transform default_transform;
Transform post_transform;
Vector<Node *> children;
Node *parent;
Transform compute_transform(Collada &state) const;
Transform get_global_transform() const;
Transform get_transform() const;
bool ignore_anim;
Node() {
noname = false;
type = TYPE_NODE;
parent = NULL;
ignore_anim = false;
}
virtual ~Node() {
for (int i = 0; i < children.size(); i++)
memdelete(children[i]);
};
};
struct NodeSkeleton : public Node {
NodeSkeleton() { type = TYPE_SKELETON; }
};
struct NodeJoint : public Node {
NodeSkeleton *owner;
String sid;
NodeJoint() {
type = TYPE_JOINT;
owner = NULL;
}
};
struct NodeGeometry : public Node {
bool controller;
String source;
struct Material {
String target;
};
Map<String, Material> material_map;
Vector<String> skeletons;
NodeGeometry() { type = TYPE_GEOMETRY; }
};
struct NodeCamera : public Node {
String camera;
NodeCamera() { type = TYPE_CAMERA; }
};
struct NodeLight : public Node {
String light;
NodeLight() { type = TYPE_LIGHT; }
};
struct VisualScene {
String name;
Vector<Node *> root_nodes;
~VisualScene() {
for (int i = 0; i < root_nodes.size(); i++)
memdelete(root_nodes[i]);
}
};
struct AnimationClip {
String name;
float begin;
float end;
Vector<String> tracks;
AnimationClip() {
begin = 0;
end = 1;
}
};
struct AnimationTrack {
String id;
String target;
String param;
String component;
bool property;
enum InterpolationType {
INTERP_LINEAR,
INTERP_BEZIER
};
struct Key {
enum Type {
TYPE_FLOAT,
TYPE_MATRIX
};
float time;
Vector<float> data;
Point2 in_tangent;
Point2 out_tangent;
InterpolationType interp_type;
Key() { interp_type = INTERP_LINEAR; }
};
Vector<float> get_value_at_time(float p_time);
Vector<Key> keys;
AnimationTrack() { property = false; }
};
/****************/
/* IMPORT STATE */
/****************/
struct State {
int import_flags;
float unit_scale;
Vector3::Axis up_axis;
bool z_up;
struct Version {
int major, minor, rev;
bool operator<(const Version &p_ver) const { return (major == p_ver.major) ? ((minor == p_ver.minor) ? (rev < p_ver.rev) : minor < p_ver.minor) : major < p_ver.major; }
Version(int p_major = 0, int p_minor = 0, int p_rev = 0) {
major = p_major;
minor = p_minor;
rev = p_rev;
}
} version;
Map<String, CameraData> camera_data_map;
Map<String, MeshData> mesh_data_map;
Map<String, LightData> light_data_map;
Map<String, CurveData> curve_data_map;
Map<String, String> mesh_name_map;
Map<String, String> morph_name_map;
Map<String, String> morph_ownership_map;
Map<String, SkinControllerData> skin_controller_data_map;
Map<String, MorphControllerData> morph_controller_data_map;
Map<String, Image> image_map;
Map<String, Material> material_map;
Map<String, Effect> effect_map;
Map<String, VisualScene> visual_scene_map;
Map<String, Node *> scene_map;
Set<String> idref_joints;
Map<String, String> sid_to_node_map;
//Map<String,NodeJoint*> bone_map;
Map<String, Transform> bone_rest_map;
String local_path;
String root_visual_scene;
String root_physics_scene;
Vector<AnimationClip> animation_clips;
Vector<AnimationTrack> animation_tracks;
Map<String, Vector<int> > referenced_tracks;
Map<String, Vector<int> > by_id_tracks;
float animation_length;
State() {
unit_scale = 1.0;
up_axis = Vector3::AXIS_Y;
import_flags = 0;
animation_length = 0;
}
} state;
Error load(const String &p_path, int p_flags = 0);
Collada();
Transform fix_transform(const Transform &p_transform);
Transform get_root_transform() const;
int get_uv_channel(String p_name);
private: // private stuff
Map<String, int> channel_map;
void _parse_asset(XMLParser &parser);
void _parse_image(XMLParser &parser);
void _parse_material(XMLParser &parser);
void _parse_effect_material(XMLParser &parser, Effect &effect, String &id);
void _parse_effect(XMLParser &parser);
void _parse_camera(XMLParser &parser);
void _parse_light(XMLParser &parser);
void _parse_animation_clip(XMLParser &parser);
void _parse_mesh_geometry(XMLParser &parser, String p_id, String p_name);
void _parse_curve_geometry(XMLParser &parser, String p_id, String p_name);
void _parse_skin_controller(XMLParser &parser, String p_id);
void _parse_morph_controller(XMLParser &parser, String id);
void _parse_controller(XMLParser &parser);
Node *_parse_visual_instance_geometry(XMLParser &parser);
Node *_parse_visual_instance_camera(XMLParser &parser);
Node *_parse_visual_instance_light(XMLParser &parser);
Node *_parse_visual_node_instance_data(XMLParser &parser);
Node *_parse_visual_scene_node(XMLParser &parser);
void _parse_visual_scene(XMLParser &parser);
void _parse_animation(XMLParser &parser);
void _parse_scene(XMLParser &parser);
void _parse_library(XMLParser &parser);
Variant _parse_param(XMLParser &parser);
Vector<float> _read_float_array(XMLParser &parser);
Vector<String> _read_string_array(XMLParser &parser);
Transform _read_transform(XMLParser &parser);
String _read_empty_draw_type(XMLParser &parser);
void _joint_set_owner(Collada::Node *p_node, NodeSkeleton *p_owner);
void _create_skeletons(Collada::Node **p_node, NodeSkeleton *p_skeleton = NULL);
void _find_morph_nodes(VisualScene *p_vscene, Node *p_node);
bool _remove_node(Node *p_parent, Node *p_node);
void _remove_node(VisualScene *p_vscene, Node *p_node);
void _merge_skeletons2(VisualScene *p_vscene);
void _merge_skeletons(VisualScene *p_vscene, Node *p_node);
bool _optimize_skeletons(VisualScene *p_vscene, Node *p_node);
bool _move_geometry_to_skeletons(VisualScene *p_vscene, Node *p_node, List<Node *> *p_mgeom);
void _optimize();
};
#endif // COLLADA_H
#endif