← Back to branch summary

~ubuntu-branches/ubuntu/wily/opencollada/wily-proposed

« back to all changes in this revision

Viewing changes to Externals/MayaDataModel/include/MayaDMClipLibrary.h

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2015-05-14 17:23:27 UTC
  • Revision ID: package-import@ubuntu.com-20150514172327-f862u8envms01fra
Tags: upstream-0.1.0~20140703.ddf8f47+dfsg1
Import upstream version 0.1.0~20140703.ddf8f47+dfsg1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Externals/MayaDataModel/include/MayaDMClipLibrary.h
 
1
/*
 
2
    Copyright (c) 2008-2009 NetAllied Systems GmbH
 
3
 
 
4
    This file is part of MayaDataModel.
 
5
 
 
6
    Licensed under the MIT Open Source License,
 
7
    for details please see LICENSE file or the website
 
8
    http://www.opensource.org/licenses/mit-license.php
 
9
*/
 
10
#ifndef __MayaDM_CLIPLIBRARY_H__
 
11
#define __MayaDM_CLIPLIBRARY_H__
 
12
#include "MayaDMTypes.h"
 
13
#include "MayaDMConnectables.h"
 
14
#include "MayaDMDependNode.h"
 
15
namespace MayaDM
 
16
{
 
17
class ClipLibrary : public DependNode
 
18
{
 
19
public:
 
20
        struct ClipEvalList{
 
21
                struct ClipEval{
 
22
                        struct ClipEval_Inmap{
 
23
                                short clipEval_InmapTo;
 
24
                                short clipEval_InmapFrom;
 
25
                                void write(FILE* file) const
 
26
                                {
 
27
                                        fprintf(file,"%i ", clipEval_InmapTo);
 
28
                                        fprintf(file,"%i", clipEval_InmapFrom);
 
29
                                }
 
30
                        }* clipEval_Inmap;
 
31
                        struct ClipEval_Outmap{
 
32
                                short clipEval_OutmapTo;
 
33
                                short clipEval_OutmapFrom;
 
34
                                void write(FILE* file) const
 
35
                                {
 
36
                                        fprintf(file,"%i ", clipEval_OutmapTo);
 
37
                                        fprintf(file,"%i", clipEval_OutmapFrom);
 
38
                                }
 
39
                        }* clipEval_Outmap;
 
40
                        void write(FILE* file) const
 
41
                        {
 
42
                                size_t size = sizeof(clipEval_Inmap)/sizeof(ClipEval_Inmap);
 
43
                                for(size_t i=0; i<size; ++i)
 
44
                                {
 
45
                                        clipEval_Inmap[i].write(file);
 
46
                                        fprintf(file, " ");
 
47
                                        if(i+1<size) fprintf(file," ");
 
48
                                }
 
49
                                size = sizeof(clipEval_Outmap)/sizeof(ClipEval_Outmap);
 
50
                                for(size_t i=0; i<size; ++i)
 
51
                                {
 
52
                                        clipEval_Outmap[i].write(file);
 
53
                                        if(i+1<size) fprintf(file," ");
 
54
                                }
 
55
                        }
 
56
                }* clipEval;
 
57
                void write(FILE* file) const
 
58
                {
 
59
                        size_t size = sizeof(clipEval)/sizeof(ClipEval);
 
60
                        for(size_t i=0; i<size; ++i)
 
61
                        {
 
62
                                clipEval[i].write(file);
 
63
                                if(i+1<size) fprintf(file," ");
 
64
                        }
 
65
                }
 
66
        };
 
67
        struct Characterdata{
 
68
                intArray clipIndexMapping;
 
69
                void write(FILE* file) const
 
70
                {
 
71
                        clipIndexMapping.write(file);
 
72
                }
 
73
        };
 
74
public:
 
75
 
 
76
        ClipLibrary():DependNode(){}
 
77
        ClipLibrary(FILE* file,const std::string& name,const std::string& parent="",bool shared=false,bool create=true)
 
78
                :DependNode(file, name, parent, "clipLibrary", shared, create){}
 
79
        virtual ~ClipLibrary(){}
 
80
 
 
81
        void setClipEvalList(size_t cel_i,const ClipEvalList& cel)
 
82
        {
 
83
                fprintf(mFile,"\tsetAttr \".cel[%i]\" ",cel_i);
 
84
                cel.write(mFile);
 
85
                fprintf(mFile,";\n");
 
86
        }
 
87
        void setClipEvalList(size_t cel_start,size_t cel_end,ClipEvalList* cel)
 
88
        {
 
89
                fprintf(mFile,"\tsetAttr \".cel[%i:%i]\" ", cel_start,cel_end);
 
90
                size_t size = (cel_end-cel_start)*1+1;
 
91
                for(size_t i=0;i<size;++i)
 
92
                {
 
93
                        cel[i].write(mFile);
 
94
                        fprintf(mFile,"\n");
 
95
                }
 
96
                fprintf(mFile,";\n");
 
97
        }
 
98
        void startClipEvalList(size_t cel_start,size_t cel_end)const
 
99
        {
 
100
                fprintf(mFile,"\tsetAttr \".cel[%i:%i]\"",cel_start,cel_end);
 
101
                fprintf(mFile," -type \"ClipEvalList\" ");
 
102
        }
 
103
        void appendClipEvalList(const ClipEvalList& cel)const
 
104
        {
 
105
                fprintf(mFile," ");
 
106
                cel.write(mFile);
 
107
        }
 
108
        void endClipEvalList()const
 
109
        {
 
110
                fprintf(mFile,";\n");
 
111
        }
 
112
        void setClipEval(size_t cel_i,size_t cev_i,const ClipEvalList::ClipEval& cev)
 
113
        {
 
114
                fprintf(mFile,"\tsetAttr \".cel[%i].cev[%i]\" ",cel_i,cev_i);
 
115
                cev.write(mFile);
 
116
                fprintf(mFile,";\n");
 
117
        }
 
118
        void setClipEval(size_t cel_i,size_t cev_start,size_t cev_end,ClipEvalList::ClipEval* cev)
 
119
        {
 
120
                fprintf(mFile,"\tsetAttr \".cel[%i].cev[%i:%i]\" ", cel_i,cev_start,cev_end);
 
121
                size_t size = (cev_end-cev_start)*1+1;
 
122
                for(size_t i=0;i<size;++i)
 
123
                {
 
124
                        cev[i].write(mFile);
 
125
                        fprintf(mFile,"\n");
 
126
                }
 
127
                fprintf(mFile,";\n");
 
128
        }
 
129
        void startClipEval(size_t cel_i,size_t cev_start,size_t cev_end)const
 
130
        {
 
131
                fprintf(mFile,"\tsetAttr \".cel[%i].cev[%i:%i]\"",cel_i,cev_start,cev_end);
 
132
                fprintf(mFile," -type \"ClipEvalList::ClipEval\" ");
 
133
        }
 
134
        void appendClipEval(const ClipEvalList::ClipEval& cev)const
 
135
        {
 
136
                fprintf(mFile," ");
 
137
                cev.write(mFile);
 
138
        }
 
139
        void endClipEval()const
 
140
        {
 
141
                fprintf(mFile,";\n");
 
142
        }
 
143
        void setClipEval_Inmap(size_t cel_i,size_t cev_i,size_t cevi_i,const ClipEvalList::ClipEval::ClipEval_Inmap& cevi)
 
144
        {
 
145
                fprintf(mFile,"\tsetAttr \".cel[%i].cev[%i].cevi[%i]\" ",cel_i,cev_i,cevi_i);
 
146
                cevi.write(mFile);
 
147
                fprintf(mFile,";\n");
 
148
        }
 
149
        void setClipEval_Inmap(size_t cel_i,size_t cev_i,size_t cevi_start,size_t cevi_end,ClipEvalList::ClipEval::ClipEval_Inmap* cevi)
 
150
        {
 
151
                fprintf(mFile,"\tsetAttr \".cel[%i].cev[%i].cevi[%i:%i]\" ", cel_i,cev_i,cevi_start,cevi_end);
 
152
                size_t size = (cevi_end-cevi_start)*1+1;
 
153
                for(size_t i=0;i<size;++i)
 
154
                {
 
155
                        cevi[i].write(mFile);
 
156
                        fprintf(mFile,"\n");
 
157
                }
 
158
                fprintf(mFile,";\n");
 
159
        }
 
160
        void startClipEval_Inmap(size_t cel_i,size_t cev_i,size_t cevi_start,size_t cevi_end)const
 
161
        {
 
162
                fprintf(mFile,"\tsetAttr \".cel[%i].cev[%i].cevi[%i:%i]\"",cel_i,cev_i,cevi_start,cevi_end);
 
163
                fprintf(mFile," -type \"ClipEvalList::ClipEval::ClipEval_Inmap\" ");
 
164
        }
 
165
        void appendClipEval_Inmap(const ClipEvalList::ClipEval::ClipEval_Inmap& cevi)const
 
166
        {
 
167
                fprintf(mFile," ");
 
168
                cevi.write(mFile);
 
169
        }
 
170
        void endClipEval_Inmap()const
 
171
        {
 
172
                fprintf(mFile,";\n");
 
173
        }
 
174
        void setClipEval_InmapTo(size_t cel_i,size_t cev_i,size_t cevi_i,short cevit)
 
175
        {
 
176
                if(cevit == 0) return;
 
177
                fprintf(mFile,"\tsetAttr \".cel[%i].cev[%i].cevi[%i].cevit\" %i;\n", cel_i,cev_i,cevi_i,cevit);
 
178
        }
 
179
        void setClipEval_InmapFrom(size_t cel_i,size_t cev_i,size_t cevi_i,short cevif)
 
180
        {
 
181
                if(cevif == 0) return;
 
182
                fprintf(mFile,"\tsetAttr \".cel[%i].cev[%i].cevi[%i].cevif\" %i;\n", cel_i,cev_i,cevi_i,cevif);
 
183
        }
 
184
        void setClipEval_Outmap(size_t cel_i,size_t cev_i,size_t cevo_i,const ClipEvalList::ClipEval::ClipEval_Outmap& cevo)
 
185
        {
 
186
                fprintf(mFile,"\tsetAttr \".cel[%i].cev[%i].cevo[%i]\" ",cel_i,cev_i,cevo_i);
 
187
                cevo.write(mFile);
 
188
                fprintf(mFile,";\n");
 
189
        }
 
190
        void setClipEval_Outmap(size_t cel_i,size_t cev_i,size_t cevo_start,size_t cevo_end,ClipEvalList::ClipEval::ClipEval_Outmap* cevo)
 
191
        {
 
192
                fprintf(mFile,"\tsetAttr \".cel[%i].cev[%i].cevo[%i:%i]\" ", cel_i,cev_i,cevo_start,cevo_end);
 
193
                size_t size = (cevo_end-cevo_start)*1+1;
 
194
                for(size_t i=0;i<size;++i)
 
195
                {
 
196
                        cevo[i].write(mFile);
 
197
                        fprintf(mFile,"\n");
 
198
                }
 
199
                fprintf(mFile,";\n");
 
200
        }
 
201
        void startClipEval_Outmap(size_t cel_i,size_t cev_i,size_t cevo_start,size_t cevo_end)const
 
202
        {
 
203
                fprintf(mFile,"\tsetAttr \".cel[%i].cev[%i].cevo[%i:%i]\"",cel_i,cev_i,cevo_start,cevo_end);
 
204
                fprintf(mFile," -type \"ClipEvalList::ClipEval::ClipEval_Outmap\" ");
 
205
        }
 
206
        void appendClipEval_Outmap(const ClipEvalList::ClipEval::ClipEval_Outmap& cevo)const
 
207
        {
 
208
                fprintf(mFile," ");
 
209
                cevo.write(mFile);
 
210
        }
 
211
        void endClipEval_Outmap()const
 
212
        {
 
213
                fprintf(mFile,";\n");
 
214
        }
 
215
        void setClipEval_OutmapTo(size_t cel_i,size_t cev_i,size_t cevo_i,short cevot)
 
216
        {
 
217
                if(cevot == 0) return;
 
218
                fprintf(mFile,"\tsetAttr \".cel[%i].cev[%i].cevo[%i].cevot\" %i;\n", cel_i,cev_i,cevo_i,cevot);
 
219
        }
 
220
        void setClipEval_OutmapFrom(size_t cel_i,size_t cev_i,size_t cevo_i,short cevof)
 
221
        {
 
222
                if(cevof == 0) return;
 
223
                fprintf(mFile,"\tsetAttr \".cel[%i].cev[%i].cevo[%i].cevof\" %i;\n", cel_i,cev_i,cevo_i,cevof);
 
224
        }
 
225
        void setCharacterdata(size_t cd_i,const Characterdata& cd)
 
226
        {
 
227
                fprintf(mFile,"\tsetAttr \".cd[%i]\" ",cd_i);
 
228
                cd.write(mFile);
 
229
                fprintf(mFile,";\n");
 
230
        }
 
231
        void setCharacterdata(size_t cd_start,size_t cd_end,Characterdata* cd)
 
232
        {
 
233
                fprintf(mFile,"\tsetAttr \".cd[%i:%i]\" ", cd_start,cd_end);
 
234
                size_t size = (cd_end-cd_start)*1+1;
 
235
                for(size_t i=0;i<size;++i)
 
236
                {
 
237
                        cd[i].write(mFile);
 
238
                        fprintf(mFile,"\n");
 
239
                }
 
240
                fprintf(mFile,";\n");
 
241
        }
 
242
        void startCharacterdata(size_t cd_start,size_t cd_end)const
 
243
        {
 
244
                fprintf(mFile,"\tsetAttr \".cd[%i:%i]\"",cd_start,cd_end);
 
245
                fprintf(mFile," -type \"Characterdata\" ");
 
246
        }
 
247
        void appendCharacterdata(const Characterdata& cd)const
 
248
        {
 
249
                fprintf(mFile," ");
 
250
                cd.write(mFile);
 
251
        }
 
252
        void endCharacterdata()const
 
253
        {
 
254
                fprintf(mFile,";\n");
 
255
        }
 
256
        void setClipIndexMapping(size_t cd_i,const intArray& cim)
 
257
        {
 
258
                if(cim.size == 0) return;
 
259
                fprintf(mFile,"\tsetAttr \".cd[%i].cim\" -type \"intArray\" ",cd_i);
 
260
                cim.write(mFile);
 
261
                fprintf(mFile,";\n");
 
262
        }
 
263
        void setActiveClip(int act)
 
264
        {
 
265
                if(act == -1) return;
 
266
                fprintf(mFile,"\tsetAttr \".act\" %i;\n", act);
 
267
        }
 
268
        void getClipEvalList(size_t cel_i)const
 
269
        {
 
270
                fprintf(mFile,"\"%s.cel[%i]\"",mName.c_str(),cel_i);
 
271
        }
 
272
        void getClipEvalList()const
 
273
        {
 
274
 
 
275
                fprintf(mFile,"\"%s.cel\"",mName.c_str());
 
276
        }
 
277
        void getClipEval(size_t cel_i,size_t cev_i)const
 
278
        {
 
279
                fprintf(mFile,"\"%s.cel[%i].cev[%i]\"",mName.c_str(),cel_i,cev_i);
 
280
        }
 
281
        void getClipEval(size_t cev_i)const
 
282
        {
 
283
 
 
284
                fprintf(mFile,"\"%s.cel.cev[%i]\"",mName.c_str(),cev_i);
 
285
        }
 
286
        void getClipEval_Raw(size_t cel_i,size_t cev_i)const
 
287
        {
 
288
                fprintf(mFile,"\"%s.cel[%i].cev[%i].cevr\"",mName.c_str(),cel_i,cev_i);
 
289
        }
 
290
        void getClipEval_Raw(size_t cev_i)const
 
291
        {
 
292
 
 
293
                fprintf(mFile,"\"%s.cel.cev[%i].cevr\"",mName.c_str(),cev_i);
 
294
        }
 
295
        void getClipEval_Inmap(size_t cel_i,size_t cev_i,size_t cevi_i)const
 
296
        {
 
297
                fprintf(mFile,"\"%s.cel[%i].cev[%i].cevi[%i]\"",mName.c_str(),cel_i,cev_i,cevi_i);
 
298
        }
 
299
        void getClipEval_Inmap(size_t cev_i,size_t cevi_i)const
 
300
        {
 
301
 
 
302
                fprintf(mFile,"\"%s.cel.cev[%i].cevi[%i]\"",mName.c_str(),cev_i,cevi_i);
 
303
        }
 
304
        void getClipEval_InmapTo(size_t cel_i,size_t cev_i,size_t cevi_i)const
 
305
        {
 
306
                fprintf(mFile,"\"%s.cel[%i].cev[%i].cevi[%i].cevit\"",mName.c_str(),cel_i,cev_i,cevi_i);
 
307
        }
 
308
        void getClipEval_InmapTo(size_t cev_i,size_t cevi_i)const
 
309
        {
 
310
 
 
311
                fprintf(mFile,"\"%s.cel.cev[%i].cevi[%i].cevit\"",mName.c_str(),cev_i,cevi_i);
 
312
        }
 
313
        void getClipEval_InmapFrom(size_t cel_i,size_t cev_i,size_t cevi_i)const
 
314
        {
 
315
                fprintf(mFile,"\"%s.cel[%i].cev[%i].cevi[%i].cevif\"",mName.c_str(),cel_i,cev_i,cevi_i);
 
316
        }
 
317
        void getClipEval_InmapFrom(size_t cev_i,size_t cevi_i)const
 
318
        {
 
319
 
 
320
                fprintf(mFile,"\"%s.cel.cev[%i].cevi[%i].cevif\"",mName.c_str(),cev_i,cevi_i);
 
321
        }
 
322
        void getClipEval_Outmap(size_t cel_i,size_t cev_i,size_t cevo_i)const
 
323
        {
 
324
                fprintf(mFile,"\"%s.cel[%i].cev[%i].cevo[%i]\"",mName.c_str(),cel_i,cev_i,cevo_i);
 
325
        }
 
326
        void getClipEval_Outmap(size_t cev_i,size_t cevo_i)const
 
327
        {
 
328
 
 
329
                fprintf(mFile,"\"%s.cel.cev[%i].cevo[%i]\"",mName.c_str(),cev_i,cevo_i);
 
330
        }
 
331
        void getClipEval_OutmapTo(size_t cel_i,size_t cev_i,size_t cevo_i)const
 
332
        {
 
333
                fprintf(mFile,"\"%s.cel[%i].cev[%i].cevo[%i].cevot\"",mName.c_str(),cel_i,cev_i,cevo_i);
 
334
        }
 
335
        void getClipEval_OutmapTo(size_t cev_i,size_t cevo_i)const
 
336
        {
 
337
 
 
338
                fprintf(mFile,"\"%s.cel.cev[%i].cevo[%i].cevot\"",mName.c_str(),cev_i,cevo_i);
 
339
        }
 
340
        void getClipEval_OutmapFrom(size_t cel_i,size_t cev_i,size_t cevo_i)const
 
341
        {
 
342
                fprintf(mFile,"\"%s.cel[%i].cev[%i].cevo[%i].cevof\"",mName.c_str(),cel_i,cev_i,cevo_i);
 
343
        }
 
344
        void getClipEval_OutmapFrom(size_t cev_i,size_t cevo_i)const
 
345
        {
 
346
 
 
347
                fprintf(mFile,"\"%s.cel.cev[%i].cevo[%i].cevof\"",mName.c_str(),cev_i,cevo_i);
 
348
        }
 
349
        void getClipFunction()const
 
350
        {
 
351
                fprintf(mFile,"\"%s.cf\"",mName.c_str());
 
352
        }
 
353
        void getCharacterdata(size_t cd_i)const
 
354
        {
 
355
                fprintf(mFile,"\"%s.cd[%i]\"",mName.c_str(),cd_i);
 
356
        }
 
357
        void getCharacterdata()const
 
358
        {
 
359
 
 
360
                fprintf(mFile,"\"%s.cd\"",mName.c_str());
 
361
        }
 
362
        void getCharacterMapping(size_t cd_i)const
 
363
        {
 
364
                fprintf(mFile,"\"%s.cd[%i].cm\"",mName.c_str(),cd_i);
 
365
        }
 
366
        void getCharacterMapping()const
 
367
        {
 
368
 
 
369
                fprintf(mFile,"\"%s.cd.cm\"",mName.c_str());
 
370
        }
 
371
        void getClipIndexMapping(size_t cd_i)const
 
372
        {
 
373
                fprintf(mFile,"\"%s.cd[%i].cim\"",mName.c_str(),cd_i);
 
374
        }
 
375
        void getClipIndexMapping()const
 
376
        {
 
377
 
 
378
                fprintf(mFile,"\"%s.cd.cim\"",mName.c_str());
 
379
        }
 
380
        void getClipName(size_t cn_i)const
 
381
        {
 
382
                fprintf(mFile,"\"%s.cn[%i]\"",mName.c_str(),cn_i);
 
383
        }
 
384
        void getClipName()const
 
385
        {
 
386
 
 
387
                fprintf(mFile,"\"%s.cn\"",mName.c_str());
 
388
        }
 
389
        void getStart(size_t st_i)const
 
390
        {
 
391
                fprintf(mFile,"\"%s.st[%i]\"",mName.c_str(),st_i);
 
392
        }
 
393
        void getStart()const
 
394
        {
 
395
 
 
396
                fprintf(mFile,"\"%s.st\"",mName.c_str());
 
397
        }
 
398
        void getDuration(size_t du_i)const
 
399
        {
 
400
                fprintf(mFile,"\"%s.du[%i]\"",mName.c_str(),du_i);
 
401
        }
 
402
        void getDuration()const
 
403
        {
 
404
 
 
405
                fprintf(mFile,"\"%s.du\"",mName.c_str());
 
406
        }
 
407
        void getSourceClip(size_t sc_i)const
 
408
        {
 
409
                fprintf(mFile,"\"%s.sc[%i]\"",mName.c_str(),sc_i);
 
410
        }
 
411
        void getSourceClip()const
 
412
        {
 
413
 
 
414
                fprintf(mFile,"\"%s.sc\"",mName.c_str());
 
415
        }
 
416
        void getClip(size_t cl_i)const
 
417
        {
 
418
                fprintf(mFile,"\"%s.cl[%i]\"",mName.c_str(),cl_i);
 
419
        }
 
420
        void getClip()const
 
421
        {
 
422
 
 
423
                fprintf(mFile,"\"%s.cl\"",mName.c_str());
 
424
        }
 
425
protected:
 
426
        ClipLibrary(FILE* file,const std::string& name,const std::string& parent,const std::string& nodeType,bool shared=false,bool create=true)
 
427
                :DependNode(file, name, parent, nodeType, shared, create) {}
 
428
 
 
429
};
 
430
}//namespace MayaDM
 
431
#endif//__MayaDM_CLIPLIBRARY_H__