Importer base for Chingiz.
[blender-staging.git] / source / blender / collada / DocumentImporter.cpp
1 #include "COLLADAFWStableHeaders.h"
2 #include "COLLADAFWIWriter.h"
3 #include "COLLADAFWRoot.h"
4 #include "COLLADAFWNode.h"
5 #include "COLLADAFWVisualScene.h"
6 #include "COLLADAFWInstanceGeometry.h"
7 #include "COLLADAFWFileInfo.h"
8 #include "COLLADAFWRoot.h"
9 #include "COLLADAFWLight.h"
10 #include "COLLADAFWImage.h"
11 #include "COLLADAFWMaterial.h"
12 #include "COLLADAFWGeometry.h"
13 #include "COLLADAFWMesh.h"
14
15 #include "COLLADASaxFWLLoader.h"
16
17 extern "C" 
18 {
19 #include "BKE_main.h"
20 #include "BKE_mesh.h"
21 #include "BKE_context.h"
22
23 #include "DNA_object_types.h"
24
25 #include "ED_object.h"
26
27 #include "DocumentImporter.h"
28 }
29
30
31 /** Class that needs to be implemented by a writer. 
32         IMPORTANT: The write functions are called in arbitrary order.*/
33 class Writer: public COLLADAFW::IWriter
34 {
35 private:
36         std::string mFilename;
37         
38         std::vector<COLLADAFW::VisualScene> mVisualScenes;
39
40         bContext *mContext;
41
42         class UnitConverter
43         {
44         private:
45                 COLLADAFW::FileInfo::Unit mUnit;
46                 COLLADAFW::FileInfo::UpAxisType mUpAxis;
47         public:
48                 UnitConverter(COLLADAFW::FileInfo::UpAxisType upAxis, COLLADAFW::FileInfo::Unit& unit) :
49                         mUpAxis(upAxis), mUnit(unit)
50                 {
51                 }
52
53                 // TODO
54                 // convert vector vec from COLLADA format to Blender
55                 void convertVec3(float *vec)
56                 {
57                 }
58                 
59                 // TODO need also for angle conversion, time conversion...
60         };
61
62 public:
63
64         /** Constructor. */
65         Writer(bContext *C, const char *filename) : mContext(C), mFilename(filename) {};
66
67         /** Destructor. */
68         ~Writer() {};
69
70         bool write()
71         {
72                 COLLADASaxFWL::Loader loader;
73                 COLLADAFW::Root root(&loader, this);
74
75                 // XXX report error
76                 if (!root.loadDocument(mFilename))
77                         return false;
78         }
79
80         /** This method will be called if an error in the loading process occurred and the loader cannot
81                 continue to to load. The writer should undo all operations that have been performed.
82                 @param errorMessage A message containing informations about the error that occurred.
83         */
84         virtual void cancel(const COLLADAFW::String& errorMessage)
85         {
86         }
87
88         /** This is the method called. The writer hast to prepare to receive data.*/
89         virtual void start()
90         {
91         }
92
93         /** This method is called after the last write* method. No other methods will be called after this.*/
94         virtual void finish()
95         {
96                 // using mVisualScenes, do:
97                 // - write <node> data to Objects: materials, transforms, etc.
98         }
99
100         /** When this method is called, the writer must write the global document asset.
101                 @return The writer should return true, if writing succeeded, false otherwise.*/
102         virtual bool writeGlobalAsset ( const COLLADAFW::FileInfo* asset ) 
103         {
104                 // XXX take up_axis, unit into account
105                 // COLLADAFW::FileInfo::Unit unit = asset->getUnit();
106                 // COLLADAFW::FileInfo::UpAxisType upAxis = asset->getUpAxisType();
107
108                 return true;
109         }
110
111         /** When this method is called, the writer must write the scene.
112                 @return The writer should return true, if writing succeeded, false otherwise.*/
113         virtual bool writeScene ( const COLLADAFW::Scene* scene ) 
114         {
115                 // XXX could store the scene id, but do nothing for now
116                 return true;
117         }
118
119         /** When this method is called, the writer must write the entire visual scene.
120                 @return The writer should return true, if writing succeeded, false otherwise.*/
121         virtual bool writeVisualScene ( const COLLADAFW::VisualScene* visualScene ) 
122         {
123                 // for the sake of clarity link nodes to geometries at a later stage
124                 mVisualScenes.push_back(*visualScene);
125                 return true;
126         }
127
128         /** When this method is called, the writer must handle all nodes contained in the 
129                 library nodes.
130                 @return The writer should return true, if writing succeeded, false otherwise.*/
131         virtual bool writeLibraryNodes ( const COLLADAFW::LibraryNodes* libraryNodes ) 
132         {
133                 return true;
134         }
135
136         /** When this method is called, the writer must write the geometry.
137                 @return The writer should return true, if writing succeeded, false otherwise.*/
138         virtual bool writeGeometry ( const COLLADAFW::Geometry* geometry ) 
139         {
140                 // - create a mesh object
141                 // - enter editmode getting editmesh
142                 // - write geometry
143                 // - exit editmode
144
145                 // check geometry->getType() first
146                 COLLADAFW::Mesh *mesh = (COLLADAFW::Mesh*)geometry;
147
148                 // create a mesh object
149                 Object *ob = ED_object_add_type(mContext, OB_MESH);
150                 Mesh *me = (Mesh*)ob->data;
151
152                 // enter editmode
153                 ED_object_enter_editmode(mContext, 0);
154
155                 EditMesh *em = BKE_mesh_get_editmesh(me);
156
157                 // write geometry
158                 // currently only support <triangles>
159
160                 BKE_mesh_end_editmesh(me, em);
161
162                 // exit editmode
163                 ED_object_exit_editmode(mContext, EM_FREEDATA);
164
165                 return true;
166         }
167
168         /** When this method is called, the writer must write the material.
169                 @return The writer should return true, if writing succeeded, false otherwise.*/
170         virtual bool writeMaterial( const COLLADAFW::Material* material ) 
171         {
172                 // TODO: create and store a material.
173                 // Let it have 0 users for now.
174                 return true;
175         }
176
177         /** When this method is called, the writer must write the effect.
178                 @return The writer should return true, if writing succeeded, false otherwise.*/
179         virtual bool writeEffect( const COLLADAFW::Effect* effect ) 
180         {
181                 return true;
182         }
183
184         /** When this method is called, the writer must write the camera.
185                 @return The writer should return true, if writing succeeded, false otherwise.*/
186         virtual bool writeCamera( const COLLADAFW::Camera* camera ) 
187         {
188                 return true;
189         }
190
191         /** When this method is called, the writer must write the image.
192                 @return The writer should return true, if writing succeeded, false otherwise.*/
193         virtual bool writeImage( const COLLADAFW::Image* image ) 
194         {
195                 return true;
196         }
197
198         /** When this method is called, the writer must write the light.
199                 @return The writer should return true, if writing succeeded, false otherwise.*/
200         virtual bool writeLight( const COLLADAFW::Light* light ) 
201         {
202                 return true;
203         }
204
205         /** When this method is called, the writer must write the Animation.
206                 @return The writer should return true, if writing succeeded, false otherwise.*/
207         virtual bool writeAnimation( const COLLADAFW::Animation* animation ) 
208         {
209                 return true;
210         }
211
212         /** When this method is called, the writer must write the AnimationList.
213                 @return The writer should return true, if writing succeeded, false otherwise.*/
214         virtual bool writeAnimationList( const COLLADAFW::AnimationList* animationList ) 
215         {
216                 return true;
217         }
218
219         /** When this method is called, the writer must write the skin controller data.
220                 @return The writer should return true, if writing succeeded, false otherwise.*/
221         virtual bool writeSkinControllerData( const COLLADAFW::SkinControllerData* skinControllerData ) 
222         {
223                 return true;
224         }
225
226         /** When this method is called, the writer must write the controller.
227                 @return The writer should return true, if writing succeeded, false otherwise.*/
228         virtual bool writeController( const COLLADAFW::Controller* Controller ) 
229         {
230                 return true;
231         }
232 };
233
234 void DocumentImporter::import(bContext *C, const char *filename)
235 {
236         Writer w(C, filename);
237         w.write();
238 }