summaryrefslogtreecommitdiff
path: root/tools/collada/collada.h
diff options
context:
space:
mode:
Diffstat (limited to 'tools/collada/collada.h')
-rw-r--r--tools/collada/collada.h632
1 files changed, 632 insertions, 0 deletions
diff --git a/tools/collada/collada.h b/tools/collada/collada.h
new file mode 100644
index 0000000000..f54e8a59ff
--- /dev/null
+++ b/tools/collada/collada.h
@@ -0,0 +1,632 @@
+/*************************************************************************/
+/* collada.h */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* http://www.godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 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 "scene/resources/material.h"
+#include "globals.h"
+#include "io/xml_parser.h"
+#include "map.h"
+
+class Collada {
+public:
+
+ enum ImportFlags {
+ IMPORT_FLAG_SCENE=1,
+ IMPORT_FLAG_ANIMATION=2
+ };
+
+
+ struct Image {
+
+ String path;
+ };
+
+ struct Material {
+
+ String instance_effect;
+ };
+
+
+ struct Effect {
+
+ 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;
+
+ 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;
+
+ }
+ };
+
+ 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;
+ 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 (vertex==p_vert.vertex) {
+ if(normal==p_vert.normal) {
+ if(uv==p_vert.uv) {
+ if(uv2==p_vert.uv2) {
+ 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;
+
+ }
+ };
+ 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;
+ 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,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);
+
+ void _joint_set_owner(Collada::Node *p_node, NodeSkeleton *p_owner);
+ void _create_skeletons(Collada::Node **p_node);
+ 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_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
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-01 23:35:55 +0000