← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Externals/MayaDataModel/include/MayaDMSkinCluster.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/MayaDMSkinCluster.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_SKINCLUSTER_H__
 
11
#define __MayaDM_SKINCLUSTER_H__
 
12
#include "MayaDMTypes.h"
 
13
#include "MayaDMConnectables.h"
 
14
#include "MayaDMGeometryFilter.h"
 
15
namespace MayaDM
 
16
{
 
17
class SkinCluster : public GeometryFilter
 
18
{
 
19
public:
 
20
        struct WeightList{
 
21
                double* weights;
 
22
                void write(FILE* file) const
 
23
                {
 
24
                        size_t size = sizeof(weights)/sizeof(double);
 
25
                        for(size_t i=0; i<size; ++i)
 
26
                        {
 
27
                                fprintf(file,"%f", weights[i]);
 
28
                                if(i+1<size) fprintf(file," ");
 
29
                        }
 
30
                }
 
31
        };
 
32
public:
 
33
 
 
34
        SkinCluster():GeometryFilter(){}
 
35
        SkinCluster(FILE* file,const std::string& name,const std::string& parent="",bool shared=false,bool create=true)
 
36
                :GeometryFilter(file, name, parent, "skinCluster", shared, create){}
 
37
        virtual ~SkinCluster(){}
 
38
 
 
39
        void setWeightList(size_t wl_i,const WeightList& wl)
 
40
        {
 
41
                fprintf(mFile,"\tsetAttr \".wl[%i]\" ",wl_i);
 
42
                wl.write(mFile);
 
43
                fprintf(mFile,";\n");
 
44
        }
 
45
        void setWeightList(size_t wl_start,size_t wl_end,WeightList* wl)
 
46
        {
 
47
                fprintf(mFile,"\tsetAttr \".wl[%i:%i]\" ", wl_start,wl_end);
 
48
                size_t size = (wl_end-wl_start)*1+1;
 
49
                for(size_t i=0;i<size;++i)
 
50
                {
 
51
                        wl[i].write(mFile);
 
52
                        fprintf(mFile,"\n");
 
53
                }
 
54
                fprintf(mFile,";\n");
 
55
        }
 
56
        void startWeightList(size_t wl_start,size_t wl_end)const
 
57
        {
 
58
                fprintf(mFile,"\tsetAttr \".wl[%i:%i]\"",wl_start,wl_end);
 
59
                fprintf(mFile," -type \"WeightList\" ");
 
60
        }
 
61
        void appendWeightList(const WeightList& wl)const
 
62
        {
 
63
                fprintf(mFile," ");
 
64
                wl.write(mFile);
 
65
        }
 
66
        void endWeightList()const
 
67
        {
 
68
                fprintf(mFile,";\n");
 
69
        }
 
70
        void setWeights(size_t wl_i,size_t w_i,double w)
 
71
        {
 
72
                if(w == 0.0) return;
 
73
                fprintf(mFile,"\tsetAttr \".wl[%i].w[%i]\" %f;\n", wl_i,w_i,w);
 
74
        }
 
75
        void setWeights(size_t wl_i,size_t w_start,size_t w_end,double* w)
 
76
        {
 
77
                fprintf(mFile,"\tsetAttr \".wl[%i].w[%i:%i]\" ", wl_i,w_start,w_end);
 
78
                size_t size = (w_end-w_start)*1+1;
 
79
                for(size_t i=0;i<size;++i)
 
80
                {
 
81
                        fprintf(mFile,"%f",w[i]);
 
82
                        if(i+1<size) fprintf(mFile," ");
 
83
                }
 
84
                fprintf(mFile,";\n");
 
85
        }
 
86
        void startWeights(size_t wl_i,size_t w_start,size_t w_end)const
 
87
        {
 
88
                fprintf(mFile,"\tsetAttr \".wl[%i].w[%i:%i]\"",wl_i,w_start,w_end);
 
89
        }
 
90
        void appendWeights(double w)const
 
91
        {
 
92
                fprintf(mFile," %f",w);
 
93
        }
 
94
        void endWeights()const
 
95
        {
 
96
                fprintf(mFile,";\n");
 
97
        }
 
98
        void setBindPreMatrix(size_t pm_i,const matrix& pm)
 
99
        {
 
100
                if(pm == identity) return;
 
101
                fprintf(mFile,"\tsetAttr \".pm[%i]\" -type \"matrix\" ",pm_i);
 
102
                pm.write(mFile);
 
103
                fprintf(mFile,";\n");
 
104
        }
 
105
        void setBindPreMatrix(size_t pm_start,size_t pm_end,matrix* pm)
 
106
        {
 
107
                fprintf(mFile,"\tsetAttr \".pm[%i:%i]\" ", pm_start,pm_end);
 
108
                size_t size = (pm_end-pm_start)*1+1;
 
109
                for(size_t i=0;i<size;++i)
 
110
                {
 
111
                        pm[i].write(mFile);
 
112
                        fprintf(mFile,"\n");
 
113
                }
 
114
                fprintf(mFile,";\n");
 
115
        }
 
116
        void startBindPreMatrix(size_t pm_start,size_t pm_end)const
 
117
        {
 
118
                fprintf(mFile,"\tsetAttr \".pm[%i:%i]\"",pm_start,pm_end);
 
119
                fprintf(mFile," -type \"matrix\" ");
 
120
        }
 
121
        void appendBindPreMatrix(const matrix& pm)const
 
122
        {
 
123
                fprintf(mFile," ");
 
124
                pm.write(mFile);
 
125
        }
 
126
        void endBindPreMatrix()const
 
127
        {
 
128
                fprintf(mFile,";\n");
 
129
        }
 
130
        void setGeomMatrix(const matrix& gm)
 
131
        {
 
132
                if(gm == identity) return;
 
133
                fprintf(mFile,"\tsetAttr \".gm\" -type \"matrix\" ");
 
134
                gm.write(mFile);
 
135
                fprintf(mFile,";\n");
 
136
        }
 
137
        void setMatrix(size_t ma_i,const matrix& ma)
 
138
        {
 
139
                if(ma == identity) return;
 
140
                fprintf(mFile,"\tsetAttr \".ma[%i]\" -type \"matrix\" ",ma_i);
 
141
                ma.write(mFile);
 
142
                fprintf(mFile,";\n");
 
143
        }
 
144
        void setMatrix(size_t ma_start,size_t ma_end,matrix* ma)
 
145
        {
 
146
                fprintf(mFile,"\tsetAttr \".ma[%i:%i]\" ", ma_start,ma_end);
 
147
                size_t size = (ma_end-ma_start)*1+1;
 
148
                for(size_t i=0;i<size;++i)
 
149
                {
 
150
                        ma[i].write(mFile);
 
151
                        fprintf(mFile,"\n");
 
152
                }
 
153
                fprintf(mFile,";\n");
 
154
        }
 
155
        void startMatrix(size_t ma_start,size_t ma_end)const
 
156
        {
 
157
                fprintf(mFile,"\tsetAttr \".ma[%i:%i]\"",ma_start,ma_end);
 
158
                fprintf(mFile," -type \"matrix\" ");
 
159
        }
 
160
        void appendMatrix(const matrix& ma)const
 
161
        {
 
162
                fprintf(mFile," ");
 
163
                ma.write(mFile);
 
164
        }
 
165
        void endMatrix()const
 
166
        {
 
167
                fprintf(mFile,";\n");
 
168
        }
 
169
        void setDropoff(size_t dpf_i,double dpf)
 
170
        {
 
171
                if(dpf == 4.0) return;
 
172
                fprintf(mFile,"\tsetAttr \".dpf[%i]\" %f;\n", dpf_i,dpf);
 
173
        }
 
174
        void setDropoff(size_t dpf_start,size_t dpf_end,double* dpf)
 
175
        {
 
176
                fprintf(mFile,"\tsetAttr \".dpf[%i:%i]\" ", dpf_start,dpf_end);
 
177
                size_t size = (dpf_end-dpf_start)*1+1;
 
178
                for(size_t i=0;i<size;++i)
 
179
                {
 
180
                        fprintf(mFile,"%f",dpf[i]);
 
181
                        if(i+1<size) fprintf(mFile," ");
 
182
                }
 
183
                fprintf(mFile,";\n");
 
184
        }
 
185
        void startDropoff(size_t dpf_start,size_t dpf_end)const
 
186
        {
 
187
                fprintf(mFile,"\tsetAttr \".dpf[%i:%i]\"",dpf_start,dpf_end);
 
188
        }
 
189
        void appendDropoff(double dpf)const
 
190
        {
 
191
                fprintf(mFile," %f",dpf);
 
192
        }
 
193
        void endDropoff()const
 
194
        {
 
195
                fprintf(mFile,";\n");
 
196
        }
 
197
        void setSmoothness(size_t smt_i,double smt)
 
198
        {
 
199
                if(smt == 0.0) return;
 
200
                fprintf(mFile,"\tsetAttr \".smt[%i]\" %f;\n", smt_i,smt);
 
201
        }
 
202
        void setSmoothness(size_t smt_start,size_t smt_end,double* smt)
 
203
        {
 
204
                fprintf(mFile,"\tsetAttr \".smt[%i:%i]\" ", smt_start,smt_end);
 
205
                size_t size = (smt_end-smt_start)*1+1;
 
206
                for(size_t i=0;i<size;++i)
 
207
                {
 
208
                        fprintf(mFile,"%f",smt[i]);
 
209
                        if(i+1<size) fprintf(mFile," ");
 
210
                }
 
211
                fprintf(mFile,";\n");
 
212
        }
 
213
        void startSmoothness(size_t smt_start,size_t smt_end)const
 
214
        {
 
215
                fprintf(mFile,"\tsetAttr \".smt[%i:%i]\"",smt_start,smt_end);
 
216
        }
 
217
        void appendSmoothness(double smt)const
 
218
        {
 
219
                fprintf(mFile," %f",smt);
 
220
        }
 
221
        void endSmoothness()const
 
222
        {
 
223
                fprintf(mFile,";\n");
 
224
        }
 
225
        void setLockWeights(size_t lw_i,bool lw)
 
226
        {
 
227
                if(lw == false) return;
 
228
                fprintf(mFile,"\tsetAttr \".lw[%i]\" %i;\n", lw_i,lw);
 
229
        }
 
230
        void setLockWeights(size_t lw_start,size_t lw_end,bool* lw)
 
231
        {
 
232
                fprintf(mFile,"\tsetAttr \".lw[%i:%i]\" ", lw_start,lw_end);
 
233
                size_t size = (lw_end-lw_start)*1+1;
 
234
                for(size_t i=0;i<size;++i)
 
235
                {
 
236
                        fprintf(mFile,"%i",lw[i]);
 
237
                        if(i+1<size) fprintf(mFile," ");
 
238
                }
 
239
                fprintf(mFile,";\n");
 
240
        }
 
241
        void startLockWeights(size_t lw_start,size_t lw_end)const
 
242
        {
 
243
                fprintf(mFile,"\tsetAttr \".lw[%i:%i]\"",lw_start,lw_end);
 
244
        }
 
245
        void appendLockWeights(bool lw)const
 
246
        {
 
247
                fprintf(mFile," %i",lw);
 
248
        }
 
249
        void endLockWeights()const
 
250
        {
 
251
                fprintf(mFile,";\n");
 
252
        }
 
253
        void setMaintainMaxInfluences(bool mmi)
 
254
        {
 
255
                if(mmi == false) return;
 
256
                fprintf(mFile,"\tsetAttr \".mmi\" %i;\n", mmi);
 
257
        }
 
258
        void setMaxInfluences(int mi)
 
259
        {
 
260
                if(mi == 2) return;
 
261
                fprintf(mFile,"\tsetAttr \".mi\" %i;\n", mi);
 
262
        }
 
263
        void setBindMethod(int bm)
 
264
        {
 
265
                if(bm == 1) return;
 
266
                fprintf(mFile,"\tsetAttr \".bm\" %i;\n", bm);
 
267
        }
 
268
        void setPaintWeights(const doubleArray& ptw)
 
269
        {
 
270
                if(ptw.size == 0) return;
 
271
                fprintf(mFile,"\tsetAttr \".ptw\" -type \"doubleArray\" ");
 
272
                ptw.write(mFile);
 
273
                fprintf(mFile,";\n");
 
274
        }
 
275
        void setUseComponents(bool uc)
 
276
        {
 
277
                if(uc == 0) return;
 
278
                fprintf(mFile,"\tsetAttr \".uc\" %i;\n", uc);
 
279
        }
 
280
        void setNurbsSamples(size_t ns_i,int ns)
 
281
        {
 
282
                if(ns == 10) return;
 
283
                fprintf(mFile,"\tsetAttr \".ns[%i]\" %i;\n", ns_i,ns);
 
284
        }
 
285
        void setNurbsSamples(size_t ns_start,size_t ns_end,int* ns)
 
286
        {
 
287
                fprintf(mFile,"\tsetAttr \".ns[%i:%i]\" ", ns_start,ns_end);
 
288
                size_t size = (ns_end-ns_start)*1+1;
 
289
                for(size_t i=0;i<size;++i)
 
290
                {
 
291
                        fprintf(mFile,"%i",ns[i]);
 
292
                        if(i+1<size) fprintf(mFile," ");
 
293
                }
 
294
                fprintf(mFile,";\n");
 
295
        }
 
296
        void startNurbsSamples(size_t ns_start,size_t ns_end)const
 
297
        {
 
298
                fprintf(mFile,"\tsetAttr \".ns[%i:%i]\"",ns_start,ns_end);
 
299
        }
 
300
        void appendNurbsSamples(int ns)const
 
301
        {
 
302
                fprintf(mFile," %i",ns);
 
303
        }
 
304
        void endNurbsSamples()const
 
305
        {
 
306
                fprintf(mFile,";\n");
 
307
        }
 
308
        void setUseComponentsMatrix(bool ucm)
 
309
        {
 
310
                if(ucm == false) return;
 
311
                fprintf(mFile,"\tsetAttr \".ucm\" %i;\n", ucm);
 
312
        }
 
313
        void setNormalizeWeights(bool nw)
 
314
        {
 
315
                if(nw == true) return;
 
316
                fprintf(mFile,"\tsetAttr \".nw\" %i;\n", nw);
 
317
        }
 
318
        void setDeformUserNormals(bool dun)
 
319
        {
 
320
                if(dun == true) return;
 
321
                fprintf(mFile,"\tsetAttr \".dun\" %i;\n", dun);
 
322
        }
 
323
        void getWeightList(size_t wl_i)const
 
324
        {
 
325
                fprintf(mFile,"\"%s.wl[%i]\"",mName.c_str(),wl_i);
 
326
        }
 
327
        void getWeightList()const
 
328
        {
 
329
 
 
330
                fprintf(mFile,"\"%s.wl\"",mName.c_str());
 
331
        }
 
332
        void getWeights(size_t wl_i,size_t w_i)const
 
333
        {
 
334
                fprintf(mFile,"\"%s.wl[%i].w[%i]\"",mName.c_str(),wl_i,w_i);
 
335
        }
 
336
        void getWeights(size_t w_i)const
 
337
        {
 
338
 
 
339
                fprintf(mFile,"\"%s.wl.w[%i]\"",mName.c_str(),w_i);
 
340
        }
 
341
        void getBindPreMatrix(size_t pm_i)const
 
342
        {
 
343
                fprintf(mFile,"\"%s.pm[%i]\"",mName.c_str(),pm_i);
 
344
        }
 
345
        void getBindPreMatrix()const
 
346
        {
 
347
 
 
348
                fprintf(mFile,"\"%s.pm\"",mName.c_str());
 
349
        }
 
350
        void getGeomMatrix()const
 
351
        {
 
352
                fprintf(mFile,"\"%s.gm\"",mName.c_str());
 
353
        }
 
354
        void getMatrix(size_t ma_i)const
 
355
        {
 
356
                fprintf(mFile,"\"%s.ma[%i]\"",mName.c_str(),ma_i);
 
357
        }
 
358
        void getMatrix()const
 
359
        {
 
360
 
 
361
                fprintf(mFile,"\"%s.ma\"",mName.c_str());
 
362
        }
 
363
        void getDropoffRate()const
 
364
        {
 
365
                fprintf(mFile,"\"%s.dr\"",mName.c_str());
 
366
        }
 
367
        void getDropoff(size_t dpf_i)const
 
368
        {
 
369
                fprintf(mFile,"\"%s.dpf[%i]\"",mName.c_str(),dpf_i);
 
370
        }
 
371
        void getDropoff()const
 
372
        {
 
373
 
 
374
                fprintf(mFile,"\"%s.dpf\"",mName.c_str());
 
375
        }
 
376
        void getSmoothness(size_t smt_i)const
 
377
        {
 
378
                fprintf(mFile,"\"%s.smt[%i]\"",mName.c_str(),smt_i);
 
379
        }
 
380
        void getSmoothness()const
 
381
        {
 
382
 
 
383
                fprintf(mFile,"\"%s.smt\"",mName.c_str());
 
384
        }
 
385
        void getLockWeights(size_t lw_i)const
 
386
        {
 
387
                fprintf(mFile,"\"%s.lw[%i]\"",mName.c_str(),lw_i);
 
388
        }
 
389
        void getLockWeights()const
 
390
        {
 
391
 
 
392
                fprintf(mFile,"\"%s.lw\"",mName.c_str());
 
393
        }
 
394
        void getMaintainMaxInfluences()const
 
395
        {
 
396
                fprintf(mFile,"\"%s.mmi\"",mName.c_str());
 
397
        }
 
398
        void getMaxInfluences()const
 
399
        {
 
400
                fprintf(mFile,"\"%s.mi\"",mName.c_str());
 
401
        }
 
402
        void getBindMethod()const
 
403
        {
 
404
                fprintf(mFile,"\"%s.bm\"",mName.c_str());
 
405
        }
 
406
        void getDriverPoints(size_t drp_i)const
 
407
        {
 
408
                fprintf(mFile,"\"%s.drp[%i]\"",mName.c_str(),drp_i);
 
409
        }
 
410
        void getDriverPoints()const
 
411
        {
 
412
 
 
413
                fprintf(mFile,"\"%s.drp\"",mName.c_str());
 
414
        }
 
415
        void getBasePoints(size_t bsp_i)const
 
416
        {
 
417
                fprintf(mFile,"\"%s.bsp[%i]\"",mName.c_str(),bsp_i);
 
418
        }
 
419
        void getBasePoints()const
 
420
        {
 
421
 
 
422
                fprintf(mFile,"\"%s.bsp\"",mName.c_str());
 
423
        }
 
424
        void getBaseDirty()const
 
425
        {
 
426
                fprintf(mFile,"\"%s.bsd\"",mName.c_str());
 
427
        }
 
428
        void getPaintWeights()const
 
429
        {
 
430
                fprintf(mFile,"\"%s.ptw\"",mName.c_str());
 
431
        }
 
432
        void getPaintTrans()const
 
433
        {
 
434
                fprintf(mFile,"\"%s.ptt\"",mName.c_str());
 
435
        }
 
436
        void getPaintArrDirty()const
 
437
        {
 
438
                fprintf(mFile,"\"%s.pad\"",mName.c_str());
 
439
        }
 
440
        void getUseComponents()const
 
441
        {
 
442
                fprintf(mFile,"\"%s.uc\"",mName.c_str());
 
443
        }
 
444
        void getNurbsSamples(size_t ns_i)const
 
445
        {
 
446
                fprintf(mFile,"\"%s.ns[%i]\"",mName.c_str(),ns_i);
 
447
        }
 
448
        void getNurbsSamples()const
 
449
        {
 
450
 
 
451
                fprintf(mFile,"\"%s.ns\"",mName.c_str());
 
452
        }
 
453
        void getUseComponentsMatrix()const
 
454
        {
 
455
                fprintf(mFile,"\"%s.ucm\"",mName.c_str());
 
456
        }
 
457
        void getNormalizeWeights()const
 
458
        {
 
459
                fprintf(mFile,"\"%s.nw\"",mName.c_str());
 
460
        }
 
461
        void getDeformUserNormals()const
 
462
        {
 
463
                fprintf(mFile,"\"%s.dun\"",mName.c_str());
 
464
        }
 
465
        void getWtDrty()const
 
466
        {
 
467
                fprintf(mFile,"\"%s.wtd\"",mName.c_str());
 
468
        }
 
469
        void getBindPose()const
 
470
        {
 
471
                fprintf(mFile,"\"%s.bp\"",mName.c_str());
 
472
        }
 
473
protected:
 
474
        SkinCluster(FILE* file,const std::string& name,const std::string& parent,const std::string& nodeType,bool shared=false,bool create=true)
 
475
                :GeometryFilter(file, name, parent, nodeType, shared, create) {}
 
476
 
 
477
};
 
478
}//namespace MayaDM
 
479
#endif//__MayaDM_SKINCLUSTER_H__