← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Externals/MayaDataModel/include/MayaDMClipScheduler.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/MayaDMClipScheduler.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_CLIPSCHEDULER_H__
 
11
#define __MayaDM_CLIPSCHEDULER_H__
 
12
#include "MayaDMTypes.h"
 
13
#include "MayaDMConnectables.h"
 
14
#include "MayaDMDependNode.h"
 
15
namespace MayaDM
 
16
{
 
17
class ClipScheduler : public DependNode
 
18
{
 
19
public:
 
20
        struct BlendList{
 
21
                struct BlendList_Inmap{
 
22
                        short blendList_InmapTo;
 
23
                        short blendList_InmapFrom;
 
24
                        void write(FILE* file) const
 
25
                        {
 
26
                                fprintf(file,"%i ", blendList_InmapTo);
 
27
                                fprintf(file,"%i", blendList_InmapFrom);
 
28
                        }
 
29
                }* blendList_Inmap;
 
30
                struct BlendList_Outmap{
 
31
                        short blendList_OutmapTo;
 
32
                        short blendList_OutmapFrom;
 
33
                        void write(FILE* file) const
 
34
                        {
 
35
                                fprintf(file,"%i ", blendList_OutmapTo);
 
36
                                fprintf(file,"%i", blendList_OutmapFrom);
 
37
                        }
 
38
                }* blendList_Outmap;
 
39
                void write(FILE* file) const
 
40
                {
 
41
                        size_t size = sizeof(blendList_Inmap)/sizeof(BlendList_Inmap);
 
42
                        for(size_t i=0; i<size; ++i)
 
43
                        {
 
44
                                blendList_Inmap[i].write(file);
 
45
                                fprintf(file, " ");
 
46
                                if(i+1<size) fprintf(file," ");
 
47
                        }
 
48
                        size = sizeof(blendList_Outmap)/sizeof(BlendList_Outmap);
 
49
                        for(size_t i=0; i<size; ++i)
 
50
                        {
 
51
                                blendList_Outmap[i].write(file);
 
52
                                if(i+1<size) fprintf(file," ");
 
53
                        }
 
54
                }
 
55
        };
 
56
        struct BlendClips{
 
57
                int firstClip;
 
58
                int secondClip;
 
59
                void write(FILE* file) const
 
60
                {
 
61
                        fprintf(file,"%i ", firstClip);
 
62
                        fprintf(file,"%i", secondClip);
 
63
                }
 
64
        };
 
65
        struct ClipFunction{
 
66
                struct ClipFunction_Inmap{
 
67
                        short clipFunction_InmapTo;
 
68
                        short clipFunction_InmapFrom;
 
69
                        void write(FILE* file) const
 
70
                        {
 
71
                                fprintf(file,"%i ", clipFunction_InmapTo);
 
72
                                fprintf(file,"%i", clipFunction_InmapFrom);
 
73
                        }
 
74
                }* clipFunction_Inmap;
 
75
                struct ClipFunction_Outmap{
 
76
                        short clipFunction_OutmapTo;
 
77
                        short clipFunction_OutmapFrom;
 
78
                        void write(FILE* file) const
 
79
                        {
 
80
                                fprintf(file,"%i ", clipFunction_OutmapTo);
 
81
                                fprintf(file,"%i", clipFunction_OutmapFrom);
 
82
                        }
 
83
                }* clipFunction_Outmap;
 
84
                void write(FILE* file) const
 
85
                {
 
86
                        size_t size = sizeof(clipFunction_Inmap)/sizeof(ClipFunction_Inmap);
 
87
                        for(size_t i=0; i<size; ++i)
 
88
                        {
 
89
                                clipFunction_Inmap[i].write(file);
 
90
                                fprintf(file, " ");
 
91
                                if(i+1<size) fprintf(file," ");
 
92
                        }
 
93
                        size = sizeof(clipFunction_Outmap)/sizeof(ClipFunction_Outmap);
 
94
                        for(size_t i=0; i<size; ++i)
 
95
                        {
 
96
                                clipFunction_Outmap[i].write(file);
 
97
                                if(i+1<size) fprintf(file," ");
 
98
                        }
 
99
                }
 
100
        };
 
101
public:
 
102
 
 
103
        ClipScheduler():DependNode(){}
 
104
        ClipScheduler(FILE* file,const std::string& name,const std::string& parent="",bool shared=false,bool create=true)
 
105
                :DependNode(file, name, parent, "clipScheduler", shared, create){}
 
106
        virtual ~ClipScheduler(){}
 
107
 
 
108
        void setBlendList(size_t bl_i,const BlendList& bl)
 
109
        {
 
110
                fprintf(mFile,"\tsetAttr \".bl[%i]\" ",bl_i);
 
111
                bl.write(mFile);
 
112
                fprintf(mFile,";\n");
 
113
        }
 
114
        void setBlendList(size_t bl_start,size_t bl_end,BlendList* bl)
 
115
        {
 
116
                fprintf(mFile,"\tsetAttr \".bl[%i:%i]\" ", bl_start,bl_end);
 
117
                size_t size = (bl_end-bl_start)*1+1;
 
118
                for(size_t i=0;i<size;++i)
 
119
                {
 
120
                        bl[i].write(mFile);
 
121
                        fprintf(mFile,"\n");
 
122
                }
 
123
                fprintf(mFile,";\n");
 
124
        }
 
125
        void startBlendList(size_t bl_start,size_t bl_end)const
 
126
        {
 
127
                fprintf(mFile,"\tsetAttr \".bl[%i:%i]\"",bl_start,bl_end);
 
128
                fprintf(mFile," -type \"BlendList\" ");
 
129
        }
 
130
        void appendBlendList(const BlendList& bl)const
 
131
        {
 
132
                fprintf(mFile," ");
 
133
                bl.write(mFile);
 
134
        }
 
135
        void endBlendList()const
 
136
        {
 
137
                fprintf(mFile,";\n");
 
138
        }
 
139
        void setBlendList_Inmap(size_t bl_i,size_t bli_i,const BlendList::BlendList_Inmap& bli)
 
140
        {
 
141
                fprintf(mFile,"\tsetAttr \".bl[%i].bli[%i]\" ",bl_i,bli_i);
 
142
                bli.write(mFile);
 
143
                fprintf(mFile,";\n");
 
144
        }
 
145
        void setBlendList_Inmap(size_t bl_i,size_t bli_start,size_t bli_end,BlendList::BlendList_Inmap* bli)
 
146
        {
 
147
                fprintf(mFile,"\tsetAttr \".bl[%i].bli[%i:%i]\" ", bl_i,bli_start,bli_end);
 
148
                size_t size = (bli_end-bli_start)*1+1;
 
149
                for(size_t i=0;i<size;++i)
 
150
                {
 
151
                        bli[i].write(mFile);
 
152
                        fprintf(mFile,"\n");
 
153
                }
 
154
                fprintf(mFile,";\n");
 
155
        }
 
156
        void startBlendList_Inmap(size_t bl_i,size_t bli_start,size_t bli_end)const
 
157
        {
 
158
                fprintf(mFile,"\tsetAttr \".bl[%i].bli[%i:%i]\"",bl_i,bli_start,bli_end);
 
159
                fprintf(mFile," -type \"BlendList::BlendList_Inmap\" ");
 
160
        }
 
161
        void appendBlendList_Inmap(const BlendList::BlendList_Inmap& bli)const
 
162
        {
 
163
                fprintf(mFile," ");
 
164
                bli.write(mFile);
 
165
        }
 
166
        void endBlendList_Inmap()const
 
167
        {
 
168
                fprintf(mFile,";\n");
 
169
        }
 
170
        void setBlendList_InmapTo(size_t bl_i,size_t bli_i,short blit)
 
171
        {
 
172
                if(blit == 0) return;
 
173
                fprintf(mFile,"\tsetAttr \".bl[%i].bli[%i].blit\" %i;\n", bl_i,bli_i,blit);
 
174
        }
 
175
        void setBlendList_InmapFrom(size_t bl_i,size_t bli_i,short blif)
 
176
        {
 
177
                if(blif == 0) return;
 
178
                fprintf(mFile,"\tsetAttr \".bl[%i].bli[%i].blif\" %i;\n", bl_i,bli_i,blif);
 
179
        }
 
180
        void setBlendList_Outmap(size_t bl_i,size_t blo_i,const BlendList::BlendList_Outmap& blo)
 
181
        {
 
182
                fprintf(mFile,"\tsetAttr \".bl[%i].blo[%i]\" ",bl_i,blo_i);
 
183
                blo.write(mFile);
 
184
                fprintf(mFile,";\n");
 
185
        }
 
186
        void setBlendList_Outmap(size_t bl_i,size_t blo_start,size_t blo_end,BlendList::BlendList_Outmap* blo)
 
187
        {
 
188
                fprintf(mFile,"\tsetAttr \".bl[%i].blo[%i:%i]\" ", bl_i,blo_start,blo_end);
 
189
                size_t size = (blo_end-blo_start)*1+1;
 
190
                for(size_t i=0;i<size;++i)
 
191
                {
 
192
                        blo[i].write(mFile);
 
193
                        fprintf(mFile,"\n");
 
194
                }
 
195
                fprintf(mFile,";\n");
 
196
        }
 
197
        void startBlendList_Outmap(size_t bl_i,size_t blo_start,size_t blo_end)const
 
198
        {
 
199
                fprintf(mFile,"\tsetAttr \".bl[%i].blo[%i:%i]\"",bl_i,blo_start,blo_end);
 
200
                fprintf(mFile," -type \"BlendList::BlendList_Outmap\" ");
 
201
        }
 
202
        void appendBlendList_Outmap(const BlendList::BlendList_Outmap& blo)const
 
203
        {
 
204
                fprintf(mFile," ");
 
205
                blo.write(mFile);
 
206
        }
 
207
        void endBlendList_Outmap()const
 
208
        {
 
209
                fprintf(mFile,";\n");
 
210
        }
 
211
        void setBlendList_OutmapTo(size_t bl_i,size_t blo_i,short blot)
 
212
        {
 
213
                if(blot == 0) return;
 
214
                fprintf(mFile,"\tsetAttr \".bl[%i].blo[%i].blot\" %i;\n", bl_i,blo_i,blot);
 
215
        }
 
216
        void setBlendList_OutmapFrom(size_t bl_i,size_t blo_i,short blof)
 
217
        {
 
218
                if(blof == 0) return;
 
219
                fprintf(mFile,"\tsetAttr \".bl[%i].blo[%i].blof\" %i;\n", bl_i,blo_i,blof);
 
220
        }
 
221
        void setBlendClips(size_t bc_i,const BlendClips& bc)
 
222
        {
 
223
                fprintf(mFile,"\tsetAttr \".bc[%i]\" ",bc_i);
 
224
                bc.write(mFile);
 
225
                fprintf(mFile,";\n");
 
226
        }
 
227
        void setBlendClips(size_t bc_start,size_t bc_end,BlendClips* bc)
 
228
        {
 
229
                fprintf(mFile,"\tsetAttr \".bc[%i:%i]\" ", bc_start,bc_end);
 
230
                size_t size = (bc_end-bc_start)*1+1;
 
231
                for(size_t i=0;i<size;++i)
 
232
                {
 
233
                        bc[i].write(mFile);
 
234
                        fprintf(mFile,"\n");
 
235
                }
 
236
                fprintf(mFile,";\n");
 
237
        }
 
238
        void startBlendClips(size_t bc_start,size_t bc_end)const
 
239
        {
 
240
                fprintf(mFile,"\tsetAttr \".bc[%i:%i]\"",bc_start,bc_end);
 
241
                fprintf(mFile," -type \"BlendClips\" ");
 
242
        }
 
243
        void appendBlendClips(const BlendClips& bc)const
 
244
        {
 
245
                fprintf(mFile," ");
 
246
                bc.write(mFile);
 
247
        }
 
248
        void endBlendClips()const
 
249
        {
 
250
                fprintf(mFile,";\n");
 
251
        }
 
252
        void setFirstClip(size_t bc_i,int fcl)
 
253
        {
 
254
                if(fcl == 0) return;
 
255
                fprintf(mFile,"\tsetAttr \".bc[%i].fcl\" %i;\n", bc_i,fcl);
 
256
        }
 
257
        void setSecondClip(size_t bc_i,int scl)
 
258
        {
 
259
                if(scl == 0) return;
 
260
                fprintf(mFile,"\tsetAttr \".bc[%i].scl\" %i;\n", bc_i,scl);
 
261
        }
 
262
        void setClipFunction_Inmap(size_t cfi_i,const ClipFunction::ClipFunction_Inmap& cfi)
 
263
        {
 
264
                fprintf(mFile,"\tsetAttr \".cf.cfi[%i]\" ",cfi_i);
 
265
                cfi.write(mFile);
 
266
                fprintf(mFile,";\n");
 
267
        }
 
268
        void setClipFunction_Inmap(size_t cfi_start,size_t cfi_end,ClipFunction::ClipFunction_Inmap* cfi)
 
269
        {
 
270
                fprintf(mFile,"\tsetAttr \".cf.cfi[%i:%i]\" ", cfi_start,cfi_end);
 
271
                size_t size = (cfi_end-cfi_start)*1+1;
 
272
                for(size_t i=0;i<size;++i)
 
273
                {
 
274
                        cfi[i].write(mFile);
 
275
                        fprintf(mFile,"\n");
 
276
                }
 
277
                fprintf(mFile,";\n");
 
278
        }
 
279
        void startClipFunction_Inmap(size_t cfi_start,size_t cfi_end)const
 
280
        {
 
281
                fprintf(mFile,"\tsetAttr \".cf.cfi[%i:%i]\"",cfi_start,cfi_end);
 
282
                fprintf(mFile," -type \"ClipFunction::ClipFunction_Inmap\" ");
 
283
        }
 
284
        void appendClipFunction_Inmap(const ClipFunction::ClipFunction_Inmap& cfi)const
 
285
        {
 
286
                fprintf(mFile," ");
 
287
                cfi.write(mFile);
 
288
        }
 
289
        void endClipFunction_Inmap()const
 
290
        {
 
291
                fprintf(mFile,";\n");
 
292
        }
 
293
        void setClipFunction_InmapTo(size_t cfi_i,short cfit)
 
294
        {
 
295
                if(cfit == 0) return;
 
296
                fprintf(mFile,"\tsetAttr \".cf.cfi[%i].cfit\" %i;\n", cfi_i,cfit);
 
297
        }
 
298
        void setClipFunction_InmapFrom(size_t cfi_i,short cfif)
 
299
        {
 
300
                if(cfif == 0) return;
 
301
                fprintf(mFile,"\tsetAttr \".cf.cfi[%i].cfif\" %i;\n", cfi_i,cfif);
 
302
        }
 
303
        void setClipFunction_Outmap(size_t cfo_i,const ClipFunction::ClipFunction_Outmap& cfo)
 
304
        {
 
305
                fprintf(mFile,"\tsetAttr \".cf.cfo[%i]\" ",cfo_i);
 
306
                cfo.write(mFile);
 
307
                fprintf(mFile,";\n");
 
308
        }
 
309
        void setClipFunction_Outmap(size_t cfo_start,size_t cfo_end,ClipFunction::ClipFunction_Outmap* cfo)
 
310
        {
 
311
                fprintf(mFile,"\tsetAttr \".cf.cfo[%i:%i]\" ", cfo_start,cfo_end);
 
312
                size_t size = (cfo_end-cfo_start)*1+1;
 
313
                for(size_t i=0;i<size;++i)
 
314
                {
 
315
                        cfo[i].write(mFile);
 
316
                        fprintf(mFile,"\n");
 
317
                }
 
318
                fprintf(mFile,";\n");
 
319
        }
 
320
        void startClipFunction_Outmap(size_t cfo_start,size_t cfo_end)const
 
321
        {
 
322
                fprintf(mFile,"\tsetAttr \".cf.cfo[%i:%i]\"",cfo_start,cfo_end);
 
323
                fprintf(mFile," -type \"ClipFunction::ClipFunction_Outmap\" ");
 
324
        }
 
325
        void appendClipFunction_Outmap(const ClipFunction::ClipFunction_Outmap& cfo)const
 
326
        {
 
327
                fprintf(mFile," ");
 
328
                cfo.write(mFile);
 
329
        }
 
330
        void endClipFunction_Outmap()const
 
331
        {
 
332
                fprintf(mFile,";\n");
 
333
        }
 
334
        void setClipFunction_OutmapTo(size_t cfo_i,short cfot)
 
335
        {
 
336
                if(cfot == 0) return;
 
337
                fprintf(mFile,"\tsetAttr \".cf.cfo[%i].cfot\" %i;\n", cfo_i,cfot);
 
338
        }
 
339
        void setClipFunction_OutmapFrom(size_t cfo_i,short cfof)
 
340
        {
 
341
                if(cfof == 0) return;
 
342
                fprintf(mFile,"\tsetAttr \".cf.cfo[%i].cfof\" %i;\n", cfo_i,cfof);
 
343
        }
 
344
        void setStart(size_t st_i,double st)
 
345
        {
 
346
                if(st == 0) return;
 
347
                fprintf(mFile,"\tsetAttr \".st[%i]\" %f;\n", st_i,st);
 
348
        }
 
349
        void setStart(size_t st_start,size_t st_end,double* st)
 
350
        {
 
351
                fprintf(mFile,"\tsetAttr \".st[%i:%i]\" ", st_start,st_end);
 
352
                size_t size = (st_end-st_start)*1+1;
 
353
                for(size_t i=0;i<size;++i)
 
354
                {
 
355
                        fprintf(mFile,"%f",st[i]);
 
356
                        if(i+1<size) fprintf(mFile," ");
 
357
                }
 
358
                fprintf(mFile,";\n");
 
359
        }
 
360
        void startStart(size_t st_start,size_t st_end)const
 
361
        {
 
362
                fprintf(mFile,"\tsetAttr \".st[%i:%i]\"",st_start,st_end);
 
363
        }
 
364
        void appendStart(double st)const
 
365
        {
 
366
                fprintf(mFile," %f",st);
 
367
        }
 
368
        void endStart()const
 
369
        {
 
370
                fprintf(mFile,";\n");
 
371
        }
 
372
        void setSourceStart(size_t ss_i,double ss)
 
373
        {
 
374
                if(ss == 0) return;
 
375
                fprintf(mFile,"\tsetAttr \".ss[%i]\" %f;\n", ss_i,ss);
 
376
        }
 
377
        void setSourceStart(size_t ss_start,size_t ss_end,double* ss)
 
378
        {
 
379
                fprintf(mFile,"\tsetAttr \".ss[%i:%i]\" ", ss_start,ss_end);
 
380
                size_t size = (ss_end-ss_start)*1+1;
 
381
                for(size_t i=0;i<size;++i)
 
382
                {
 
383
                        fprintf(mFile,"%f",ss[i]);
 
384
                        if(i+1<size) fprintf(mFile," ");
 
385
                }
 
386
                fprintf(mFile,";\n");
 
387
        }
 
388
        void startSourceStart(size_t ss_start,size_t ss_end)const
 
389
        {
 
390
                fprintf(mFile,"\tsetAttr \".ss[%i:%i]\"",ss_start,ss_end);
 
391
        }
 
392
        void appendSourceStart(double ss)const
 
393
        {
 
394
                fprintf(mFile," %f",ss);
 
395
        }
 
396
        void endSourceStart()const
 
397
        {
 
398
                fprintf(mFile,";\n");
 
399
        }
 
400
        void setSourceEnd(size_t se_i,double se)
 
401
        {
 
402
                if(se == 0) return;
 
403
                fprintf(mFile,"\tsetAttr \".se[%i]\" %f;\n", se_i,se);
 
404
        }
 
405
        void setSourceEnd(size_t se_start,size_t se_end,double* se)
 
406
        {
 
407
                fprintf(mFile,"\tsetAttr \".se[%i:%i]\" ", se_start,se_end);
 
408
                size_t size = (se_end-se_start)*1+1;
 
409
                for(size_t i=0;i<size;++i)
 
410
                {
 
411
                        fprintf(mFile,"%f",se[i]);
 
412
                        if(i+1<size) fprintf(mFile," ");
 
413
                }
 
414
                fprintf(mFile,";\n");
 
415
        }
 
416
        void startSourceEnd(size_t se_start,size_t se_end)const
 
417
        {
 
418
                fprintf(mFile,"\tsetAttr \".se[%i:%i]\"",se_start,se_end);
 
419
        }
 
420
        void appendSourceEnd(double se)const
 
421
        {
 
422
                fprintf(mFile," %f",se);
 
423
        }
 
424
        void endSourceEnd()const
 
425
        {
 
426
                fprintf(mFile,";\n");
 
427
        }
 
428
        void setScale(size_t sc_i,double sc)
 
429
        {
 
430
                if(sc == 1.0) return;
 
431
                fprintf(mFile,"\tsetAttr \".sc[%i]\" %f;\n", sc_i,sc);
 
432
        }
 
433
        void setScale(size_t sc_start,size_t sc_end,double* sc)
 
434
        {
 
435
                fprintf(mFile,"\tsetAttr \".sc[%i:%i]\" ", sc_start,sc_end);
 
436
                size_t size = (sc_end-sc_start)*1+1;
 
437
                for(size_t i=0;i<size;++i)
 
438
                {
 
439
                        fprintf(mFile,"%f",sc[i]);
 
440
                        if(i+1<size) fprintf(mFile," ");
 
441
                }
 
442
                fprintf(mFile,";\n");
 
443
        }
 
444
        void startScale(size_t sc_start,size_t sc_end)const
 
445
        {
 
446
                fprintf(mFile,"\tsetAttr \".sc[%i:%i]\"",sc_start,sc_end);
 
447
        }
 
448
        void appendScale(double sc)const
 
449
        {
 
450
                fprintf(mFile," %f",sc);
 
451
        }
 
452
        void endScale()const
 
453
        {
 
454
                fprintf(mFile,";\n");
 
455
        }
 
456
        void setHold(size_t h_i,double h)
 
457
        {
 
458
                if(h == 0) return;
 
459
                fprintf(mFile,"\tsetAttr \".h[%i]\" %f;\n", h_i,h);
 
460
        }
 
461
        void setHold(size_t h_start,size_t h_end,double* h)
 
462
        {
 
463
                fprintf(mFile,"\tsetAttr \".h[%i:%i]\" ", h_start,h_end);
 
464
                size_t size = (h_end-h_start)*1+1;
 
465
                for(size_t i=0;i<size;++i)
 
466
                {
 
467
                        fprintf(mFile,"%f",h[i]);
 
468
                        if(i+1<size) fprintf(mFile," ");
 
469
                }
 
470
                fprintf(mFile,";\n");
 
471
        }
 
472
        void startHold(size_t h_start,size_t h_end)const
 
473
        {
 
474
                fprintf(mFile,"\tsetAttr \".h[%i:%i]\"",h_start,h_end);
 
475
        }
 
476
        void appendHold(double h)const
 
477
        {
 
478
                fprintf(mFile," %f",h);
 
479
        }
 
480
        void endHold()const
 
481
        {
 
482
                fprintf(mFile,";\n");
 
483
        }
 
484
        void setWeight(size_t w_i,double w)
 
485
        {
 
486
                if(w == 1.0) return;
 
487
                fprintf(mFile,"\tsetAttr \".w[%i]\" %f;\n", w_i,w);
 
488
        }
 
489
        void setWeight(size_t w_start,size_t w_end,double* w)
 
490
        {
 
491
                fprintf(mFile,"\tsetAttr \".w[%i:%i]\" ", w_start,w_end);
 
492
                size_t size = (w_end-w_start)*1+1;
 
493
                for(size_t i=0;i<size;++i)
 
494
                {
 
495
                        fprintf(mFile,"%f",w[i]);
 
496
                        if(i+1<size) fprintf(mFile," ");
 
497
                }
 
498
                fprintf(mFile,";\n");
 
499
        }
 
500
        void startWeight(size_t w_start,size_t w_end)const
 
501
        {
 
502
                fprintf(mFile,"\tsetAttr \".w[%i:%i]\"",w_start,w_end);
 
503
        }
 
504
        void appendWeight(double w)const
 
505
        {
 
506
                fprintf(mFile," %f",w);
 
507
        }
 
508
        void endWeight()const
 
509
        {
 
510
                fprintf(mFile,";\n");
 
511
        }
 
512
        void setWeightStyle(size_t ws_i,unsigned int ws)
 
513
        {
 
514
                if(ws == 0) return;
 
515
                fprintf(mFile,"\tsetAttr \".ws[%i]\" %i;\n", ws_i,ws);
 
516
        }
 
517
        void setWeightStyle(size_t ws_start,size_t ws_end,unsigned int* ws)
 
518
        {
 
519
                fprintf(mFile,"\tsetAttr \".ws[%i:%i]\" ", ws_start,ws_end);
 
520
                size_t size = (ws_end-ws_start)*1+1;
 
521
                for(size_t i=0;i<size;++i)
 
522
                {
 
523
                        fprintf(mFile,"%i",ws[i]);
 
524
                        if(i+1<size) fprintf(mFile," ");
 
525
                }
 
526
                fprintf(mFile,";\n");
 
527
        }
 
528
        void startWeightStyle(size_t ws_start,size_t ws_end)const
 
529
        {
 
530
                fprintf(mFile,"\tsetAttr \".ws[%i:%i]\"",ws_start,ws_end);
 
531
        }
 
532
        void appendWeightStyle(unsigned int ws)const
 
533
        {
 
534
                fprintf(mFile," %i",ws);
 
535
        }
 
536
        void endWeightStyle()const
 
537
        {
 
538
                fprintf(mFile,";\n");
 
539
        }
 
540
        void setPreCycle(size_t cb_i,double cb)
 
541
        {
 
542
                if(cb == 0.0) return;
 
543
                fprintf(mFile,"\tsetAttr \".cb[%i]\" %f;\n", cb_i,cb);
 
544
        }
 
545
        void setPreCycle(size_t cb_start,size_t cb_end,double* cb)
 
546
        {
 
547
                fprintf(mFile,"\tsetAttr \".cb[%i:%i]\" ", cb_start,cb_end);
 
548
                size_t size = (cb_end-cb_start)*1+1;
 
549
                for(size_t i=0;i<size;++i)
 
550
                {
 
551
                        fprintf(mFile,"%f",cb[i]);
 
552
                        if(i+1<size) fprintf(mFile," ");
 
553
                }
 
554
                fprintf(mFile,";\n");
 
555
        }
 
556
        void startPreCycle(size_t cb_start,size_t cb_end)const
 
557
        {
 
558
                fprintf(mFile,"\tsetAttr \".cb[%i:%i]\"",cb_start,cb_end);
 
559
        }
 
560
        void appendPreCycle(double cb)const
 
561
        {
 
562
                fprintf(mFile," %f",cb);
 
563
        }
 
564
        void endPreCycle()const
 
565
        {
 
566
                fprintf(mFile,";\n");
 
567
        }
 
568
        void setPostCycle(size_t ca_i,double ca)
 
569
        {
 
570
                if(ca == 0.0) return;
 
571
                fprintf(mFile,"\tsetAttr \".ca[%i]\" %f;\n", ca_i,ca);
 
572
        }
 
573
        void setPostCycle(size_t ca_start,size_t ca_end,double* ca)
 
574
        {
 
575
                fprintf(mFile,"\tsetAttr \".ca[%i:%i]\" ", ca_start,ca_end);
 
576
                size_t size = (ca_end-ca_start)*1+1;
 
577
                for(size_t i=0;i<size;++i)
 
578
                {
 
579
                        fprintf(mFile,"%f",ca[i]);
 
580
                        if(i+1<size) fprintf(mFile," ");
 
581
                }
 
582
                fprintf(mFile,";\n");
 
583
        }
 
584
        void startPostCycle(size_t ca_start,size_t ca_end)const
 
585
        {
 
586
                fprintf(mFile,"\tsetAttr \".ca[%i:%i]\"",ca_start,ca_end);
 
587
        }
 
588
        void appendPostCycle(double ca)const
 
589
        {
 
590
                fprintf(mFile," %f",ca);
 
591
        }
 
592
        void endPostCycle()const
 
593
        {
 
594
                fprintf(mFile,";\n");
 
595
        }
 
596
        void setEnable(size_t ea_i,bool ea)
 
597
        {
 
598
                if(ea == 1) return;
 
599
                fprintf(mFile,"\tsetAttr \".ea[%i]\" %i;\n", ea_i,ea);
 
600
        }
 
601
        void setEnable(size_t ea_start,size_t ea_end,bool* ea)
 
602
        {
 
603
                fprintf(mFile,"\tsetAttr \".ea[%i:%i]\" ", ea_start,ea_end);
 
604
                size_t size = (ea_end-ea_start)*1+1;
 
605
                for(size_t i=0;i<size;++i)
 
606
                {
 
607
                        fprintf(mFile,"%i",ea[i]);
 
608
                        if(i+1<size) fprintf(mFile," ");
 
609
                }
 
610
                fprintf(mFile,";\n");
 
611
        }
 
612
        void startEnable(size_t ea_start,size_t ea_end)const
 
613
        {
 
614
                fprintf(mFile,"\tsetAttr \".ea[%i:%i]\"",ea_start,ea_end);
 
615
        }
 
616
        void appendEnable(bool ea)const
 
617
        {
 
618
                fprintf(mFile," %i",ea);
 
619
        }
 
620
        void endEnable()const
 
621
        {
 
622
                fprintf(mFile,";\n");
 
623
        }
 
624
        void setTrack(size_t tr_i,short tr)
 
625
        {
 
626
                if(tr == 0) return;
 
627
                fprintf(mFile,"\tsetAttr \".tr[%i]\" %i;\n", tr_i,tr);
 
628
        }
 
629
        void setTrack(size_t tr_start,size_t tr_end,short* tr)
 
630
        {
 
631
                fprintf(mFile,"\tsetAttr \".tr[%i:%i]\" ", tr_start,tr_end);
 
632
                size_t size = (tr_end-tr_start)*1+1;
 
633
                for(size_t i=0;i<size;++i)
 
634
                {
 
635
                        fprintf(mFile,"%i",tr[i]);
 
636
                        if(i+1<size) fprintf(mFile," ");
 
637
                }
 
638
                fprintf(mFile,";\n");
 
639
        }
 
640
        void startTrack(size_t tr_start,size_t tr_end)const
 
641
        {
 
642
                fprintf(mFile,"\tsetAttr \".tr[%i:%i]\"",tr_start,tr_end);
 
643
        }
 
644
        void appendTrack(short tr)const
 
645
        {
 
646
                fprintf(mFile," %i",tr);
 
647
        }
 
648
        void endTrack()const
 
649
        {
 
650
                fprintf(mFile,";\n");
 
651
        }
 
652
        void setTrackState(size_t ts_i,short ts)
 
653
        {
 
654
                if(ts == 0) return;
 
655
                fprintf(mFile,"\tsetAttr \".ts[%i]\" %i;\n", ts_i,ts);
 
656
        }
 
657
        void setTrackState(size_t ts_start,size_t ts_end,short* ts)
 
658
        {
 
659
                fprintf(mFile,"\tsetAttr \".ts[%i:%i]\" ", ts_start,ts_end);
 
660
                size_t size = (ts_end-ts_start)*1+1;
 
661
                for(size_t i=0;i<size;++i)
 
662
                {
 
663
                        fprintf(mFile,"%i",ts[i]);
 
664
                        if(i+1<size) fprintf(mFile," ");
 
665
                }
 
666
                fprintf(mFile,";\n");
 
667
        }
 
668
        void startTrackState(size_t ts_start,size_t ts_end)const
 
669
        {
 
670
                fprintf(mFile,"\tsetAttr \".ts[%i:%i]\"",ts_start,ts_end);
 
671
        }
 
672
        void appendTrackState(short ts)const
 
673
        {
 
674
                fprintf(mFile," %i",ts);
 
675
        }
 
676
        void endTrackState()const
 
677
        {
 
678
                fprintf(mFile,";\n");
 
679
        }
 
680
        void setNumTracks(short nt)
 
681
        {
 
682
                if(nt == 0) return;
 
683
                fprintf(mFile,"\tsetAttr \".nt\" %i;\n", nt);
 
684
        }
 
685
        void setCycle(size_t cy_i,double cy)
 
686
        {
 
687
                if(cy == 1.0) return;
 
688
                fprintf(mFile,"\tsetAttr \".cy[%i]\" %f;\n", cy_i,cy);
 
689
        }
 
690
        void setCycle(size_t cy_start,size_t cy_end,double* cy)
 
691
        {
 
692
                fprintf(mFile,"\tsetAttr \".cy[%i:%i]\" ", cy_start,cy_end);
 
693
                size_t size = (cy_end-cy_start)*1+1;
 
694
                for(size_t i=0;i<size;++i)
 
695
                {
 
696
                        fprintf(mFile,"%f",cy[i]);
 
697
                        if(i+1<size) fprintf(mFile," ");
 
698
                }
 
699
                fprintf(mFile,";\n");
 
700
        }
 
701
        void startCycle(size_t cy_start,size_t cy_end)const
 
702
        {
 
703
                fprintf(mFile,"\tsetAttr \".cy[%i:%i]\"",cy_start,cy_end);
 
704
        }
 
705
        void appendCycle(double cy)const
 
706
        {
 
707
                fprintf(mFile," %f",cy);
 
708
        }
 
709
        void endCycle()const
 
710
        {
 
711
                fprintf(mFile,";\n");
 
712
        }
 
713
        void getBlendList(size_t bl_i)const
 
714
        {
 
715
                fprintf(mFile,"\"%s.bl[%i]\"",mName.c_str(),bl_i);
 
716
        }
 
717
        void getBlendList()const
 
718
        {
 
719
 
 
720
                fprintf(mFile,"\"%s.bl\"",mName.c_str());
 
721
        }
 
722
        void getBlendList_Raw(size_t bl_i)const
 
723
        {
 
724
                fprintf(mFile,"\"%s.bl[%i].blr\"",mName.c_str(),bl_i);
 
725
        }
 
726
        void getBlendList_Raw()const
 
727
        {
 
728
 
 
729
                fprintf(mFile,"\"%s.bl.blr\"",mName.c_str());
 
730
        }
 
731
        void getBlendList_Inmap(size_t bl_i,size_t bli_i)const
 
732
        {
 
733
                fprintf(mFile,"\"%s.bl[%i].bli[%i]\"",mName.c_str(),bl_i,bli_i);
 
734
        }
 
735
        void getBlendList_Inmap(size_t bli_i)const
 
736
        {
 
737
 
 
738
                fprintf(mFile,"\"%s.bl.bli[%i]\"",mName.c_str(),bli_i);
 
739
        }
 
740
        void getBlendList_InmapTo(size_t bl_i,size_t bli_i)const
 
741
        {
 
742
                fprintf(mFile,"\"%s.bl[%i].bli[%i].blit\"",mName.c_str(),bl_i,bli_i);
 
743
        }
 
744
        void getBlendList_InmapTo(size_t bli_i)const
 
745
        {
 
746
 
 
747
                fprintf(mFile,"\"%s.bl.bli[%i].blit\"",mName.c_str(),bli_i);
 
748
        }
 
749
        void getBlendList_InmapFrom(size_t bl_i,size_t bli_i)const
 
750
        {
 
751
                fprintf(mFile,"\"%s.bl[%i].bli[%i].blif\"",mName.c_str(),bl_i,bli_i);
 
752
        }
 
753
        void getBlendList_InmapFrom(size_t bli_i)const
 
754
        {
 
755
 
 
756
                fprintf(mFile,"\"%s.bl.bli[%i].blif\"",mName.c_str(),bli_i);
 
757
        }
 
758
        void getBlendList_Outmap(size_t bl_i,size_t blo_i)const
 
759
        {
 
760
                fprintf(mFile,"\"%s.bl[%i].blo[%i]\"",mName.c_str(),bl_i,blo_i);
 
761
        }
 
762
        void getBlendList_Outmap(size_t blo_i)const
 
763
        {
 
764
 
 
765
                fprintf(mFile,"\"%s.bl.blo[%i]\"",mName.c_str(),blo_i);
 
766
        }
 
767
        void getBlendList_OutmapTo(size_t bl_i,size_t blo_i)const
 
768
        {
 
769
                fprintf(mFile,"\"%s.bl[%i].blo[%i].blot\"",mName.c_str(),bl_i,blo_i);
 
770
        }
 
771
        void getBlendList_OutmapTo(size_t blo_i)const
 
772
        {
 
773
 
 
774
                fprintf(mFile,"\"%s.bl.blo[%i].blot\"",mName.c_str(),blo_i);
 
775
        }
 
776
        void getBlendList_OutmapFrom(size_t bl_i,size_t blo_i)const
 
777
        {
 
778
                fprintf(mFile,"\"%s.bl[%i].blo[%i].blof\"",mName.c_str(),bl_i,blo_i);
 
779
        }
 
780
        void getBlendList_OutmapFrom(size_t blo_i)const
 
781
        {
 
782
 
 
783
                fprintf(mFile,"\"%s.bl.blo[%i].blof\"",mName.c_str(),blo_i);
 
784
        }
 
785
        void getClipEvaluate()const
 
786
        {
 
787
                fprintf(mFile,"\"%s.ce\"",mName.c_str());
 
788
        }
 
789
        void getClipFunction()const
 
790
        {
 
791
                fprintf(mFile,"\"%s.cf\"",mName.c_str());
 
792
        }
 
793
        void getClipFunction_Raw()const
 
794
        {
 
795
                fprintf(mFile,"\"%s.cf.cfr\"",mName.c_str());
 
796
        }
 
797
        void getClipFunction_Inmap(size_t cfi_i)const
 
798
        {
 
799
                fprintf(mFile,"\"%s.cf.cfi[%i]\"",mName.c_str(),cfi_i);
 
800
        }
 
801
        void getClipFunction_InmapTo(size_t cfi_i)const
 
802
        {
 
803
                fprintf(mFile,"\"%s.cf.cfi[%i].cfit\"",mName.c_str(),cfi_i);
 
804
        }
 
805
        void getClipFunction_InmapFrom(size_t cfi_i)const
 
806
        {
 
807
                fprintf(mFile,"\"%s.cf.cfi[%i].cfif\"",mName.c_str(),cfi_i);
 
808
        }
 
809
        void getClipFunction_Outmap(size_t cfo_i)const
 
810
        {
 
811
                fprintf(mFile,"\"%s.cf.cfo[%i]\"",mName.c_str(),cfo_i);
 
812
        }
 
813
        void getClipFunction_OutmapTo(size_t cfo_i)const
 
814
        {
 
815
                fprintf(mFile,"\"%s.cf.cfo[%i].cfot\"",mName.c_str(),cfo_i);
 
816
        }
 
817
        void getClipFunction_OutmapFrom(size_t cfo_i)const
 
818
        {
 
819
                fprintf(mFile,"\"%s.cf.cfo[%i].cfof\"",mName.c_str(),cfo_i);
 
820
        }
 
821
        void getClip(size_t cl_i)const
 
822
        {
 
823
                fprintf(mFile,"\"%s.cl[%i]\"",mName.c_str(),cl_i);
 
824
        }
 
825
        void getClip()const
 
826
        {
 
827
 
 
828
                fprintf(mFile,"\"%s.cl\"",mName.c_str());
 
829
        }
 
830
        void getStart(size_t st_i)const
 
831
        {
 
832
                fprintf(mFile,"\"%s.st[%i]\"",mName.c_str(),st_i);
 
833
        }
 
834
        void getStart()const
 
835
        {
 
836
 
 
837
                fprintf(mFile,"\"%s.st\"",mName.c_str());
 
838
        }
 
839
        void getSourceStart(size_t ss_i)const
 
840
        {
 
841
                fprintf(mFile,"\"%s.ss[%i]\"",mName.c_str(),ss_i);
 
842
        }
 
843
        void getSourceStart()const
 
844
        {
 
845
 
 
846
                fprintf(mFile,"\"%s.ss\"",mName.c_str());
 
847
        }
 
848
        void getSourceEnd(size_t se_i)const
 
849
        {
 
850
                fprintf(mFile,"\"%s.se[%i]\"",mName.c_str(),se_i);
 
851
        }
 
852
        void getSourceEnd()const
 
853
        {
 
854
 
 
855
                fprintf(mFile,"\"%s.se\"",mName.c_str());
 
856
        }
 
857
        void getScale(size_t sc_i)const
 
858
        {
 
859
                fprintf(mFile,"\"%s.sc[%i]\"",mName.c_str(),sc_i);
 
860
        }
 
861
        void getScale()const
 
862
        {
 
863
 
 
864
                fprintf(mFile,"\"%s.sc\"",mName.c_str());
 
865
        }
 
866
        void getHold(size_t h_i)const
 
867
        {
 
868
                fprintf(mFile,"\"%s.h[%i]\"",mName.c_str(),h_i);
 
869
        }
 
870
        void getHold()const
 
871
        {
 
872
 
 
873
                fprintf(mFile,"\"%s.h\"",mName.c_str());
 
874
        }
 
875
        void getWeight(size_t w_i)const
 
876
        {
 
877
                fprintf(mFile,"\"%s.w[%i]\"",mName.c_str(),w_i);
 
878
        }
 
879
        void getWeight()const
 
880
        {
 
881
 
 
882
                fprintf(mFile,"\"%s.w\"",mName.c_str());
 
883
        }
 
884
        void getWeightStyle(size_t ws_i)const
 
885
        {
 
886
                fprintf(mFile,"\"%s.ws[%i]\"",mName.c_str(),ws_i);
 
887
        }
 
888
        void getWeightStyle()const
 
889
        {
 
890
 
 
891
                fprintf(mFile,"\"%s.ws\"",mName.c_str());
 
892
        }
 
893
        void getPreCycle(size_t cb_i)const
 
894
        {
 
895
                fprintf(mFile,"\"%s.cb[%i]\"",mName.c_str(),cb_i);
 
896
        }
 
897
        void getPreCycle()const
 
898
        {
 
899
 
 
900
                fprintf(mFile,"\"%s.cb\"",mName.c_str());
 
901
        }
 
902
        void getPostCycle(size_t ca_i)const
 
903
        {
 
904
                fprintf(mFile,"\"%s.ca[%i]\"",mName.c_str(),ca_i);
 
905
        }
 
906
        void getPostCycle()const
 
907
        {
 
908
 
 
909
                fprintf(mFile,"\"%s.ca\"",mName.c_str());
 
910
        }
 
911
        void getEnable(size_t ea_i)const
 
912
        {
 
913
                fprintf(mFile,"\"%s.ea[%i]\"",mName.c_str(),ea_i);
 
914
        }
 
915
        void getEnable()const
 
916
        {
 
917
 
 
918
                fprintf(mFile,"\"%s.ea\"",mName.c_str());
 
919
        }
 
920
        void getCycle(size_t cy_i)const
 
921
        {
 
922
                fprintf(mFile,"\"%s.cy[%i]\"",mName.c_str(),cy_i);
 
923
        }
 
924
        void getCycle()const
 
925
        {
 
926
 
 
927
                fprintf(mFile,"\"%s.cy\"",mName.c_str());
 
928
        }
 
929
        void getStartPercent(size_t sp_i)const
 
930
        {
 
931
                fprintf(mFile,"\"%s.sp[%i]\"",mName.c_str(),sp_i);
 
932
        }
 
933
        void getStartPercent()const
 
934
        {
 
935
 
 
936
                fprintf(mFile,"\"%s.sp\"",mName.c_str());
 
937
        }
 
938
        void getAbsolute(size_t a_i)const
 
939
        {
 
940
                fprintf(mFile,"\"%s.a[%i]\"",mName.c_str(),a_i);
 
941
        }
 
942
        void getAbsolute()const
 
943
        {
 
944
 
 
945
                fprintf(mFile,"\"%s.a\"",mName.c_str());
 
946
        }
 
947
        void getAbsoluteRotations(size_t ar_i)const
 
948
        {
 
949
                fprintf(mFile,"\"%s.ar[%i]\"",mName.c_str(),ar_i);
 
950
        }
 
951
        void getAbsoluteRotations()const
 
952
        {
 
953
 
 
954
                fprintf(mFile,"\"%s.ar\"",mName.c_str());
 
955
        }
 
956
protected:
 
957
        ClipScheduler(FILE* file,const std::string& name,const std::string& parent,const std::string& nodeType,bool shared=false,bool create=true)
 
958
                :DependNode(file, name, parent, nodeType, shared, create) {}
 
959
 
 
960
};
 
961
}//namespace MayaDM
 
962
#endif//__MayaDM_CLIPSCHEDULER_H__