← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Externals/MayaDataModel/include/MayaDMPfxToon.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/MayaDMPfxToon.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_PFXTOON_H__
 
11
#define __MayaDM_PFXTOON_H__
 
12
#include "MayaDMTypes.h"
 
13
#include "MayaDMConnectables.h"
 
14
#include "MayaDMPfxGeometry.h"
 
15
namespace MayaDM
 
16
{
 
17
class PfxToon : public PfxGeometry
 
18
{
 
19
public:
 
20
        struct InputSurface{
 
21
                void write(FILE* file) const
 
22
                {
 
23
                }
 
24
        };
 
25
        struct CurvatureWidth{
 
26
                float curvatureWidth_Position;
 
27
                float curvatureWidth_FloatValue;
 
28
                unsigned int curvatureWidth_Interp;
 
29
                void write(FILE* file) const
 
30
                {
 
31
                        fprintf(file,"%f ", curvatureWidth_Position);
 
32
                        fprintf(file,"%f ", curvatureWidth_FloatValue);
 
33
                        fprintf(file,"%i", curvatureWidth_Interp);
 
34
                }
 
35
        };
 
36
public:
 
37
 
 
38
        PfxToon():PfxGeometry(){}
 
39
        PfxToon(FILE* file,const std::string& name,const std::string& parent="",bool shared=false,bool create=true)
 
40
                :PfxGeometry(file, name, parent, "pfxToon", shared, create){}
 
41
        virtual ~PfxToon(){}
 
42
 
 
43
        void setDisplayInViewport(bool div)
 
44
        {
 
45
                if(div == true) return;
 
46
                fprintf(mFile,"\tsetAttr \".div\" %i;\n", div);
 
47
        }
 
48
        void setProfileLines(unsigned int pln)
 
49
        {
 
50
                if(pln == 1) return;
 
51
                fprintf(mFile,"\tsetAttr \".pln\" %i;\n", pln);
 
52
        }
 
53
        void setCreaseLines(bool cln)
 
54
        {
 
55
                if(cln == true) return;
 
56
                fprintf(mFile,"\tsetAttr \".cln\" %i;\n", cln);
 
57
        }
 
58
        void setBorderLines(unsigned int bln)
 
59
        {
 
60
                if(bln == 1) return;
 
61
                fprintf(mFile,"\tsetAttr \".bln\" %i;\n", bln);
 
62
        }
 
63
        void setIntersectionLines(bool iln)
 
64
        {
 
65
                if(iln == false) return;
 
66
                fprintf(mFile,"\tsetAttr \".iln\" %i;\n", iln);
 
67
        }
 
68
        void setSelfIntersect(bool sei)
 
69
        {
 
70
                if(sei == false) return;
 
71
                fprintf(mFile,"\tsetAttr \".sei\" %i;\n", sei);
 
72
        }
 
73
        void setLineWidth(double lwd)
 
74
        {
 
75
                if(lwd == 0.1) return;
 
76
                fprintf(mFile,"\tsetAttr \".lwd\" %f;\n", lwd);
 
77
        }
 
78
        void setLineWidthMap(double lwm)
 
79
        {
 
80
                if(lwm == 0.5) return;
 
81
                fprintf(mFile,"\tsetAttr \".lwm\" %f;\n", lwm);
 
82
        }
 
83
        void setLineOpacity(double lop)
 
84
        {
 
85
                if(lop == 1.0) return;
 
86
                fprintf(mFile,"\tsetAttr \".lop\" %f;\n", lop);
 
87
        }
 
88
        void setLineOpacityMap(double lpm)
 
89
        {
 
90
                if(lpm == 1.0) return;
 
91
                fprintf(mFile,"\tsetAttr \".lpm\" %f;\n", lpm);
 
92
        }
 
93
        void setLocalOcclusion(unsigned int lcl)
 
94
        {
 
95
                if(lcl == 0) return;
 
96
                fprintf(mFile,"\tsetAttr \".lcl\" %i;\n", lcl);
 
97
        }
 
98
        void setOcclusionTolerance(double otl)
 
99
        {
 
100
                if(otl == 0.01) return;
 
101
                fprintf(mFile,"\tsetAttr \".otl\" %f;\n", otl);
 
102
        }
 
103
        void setDepthBias(double dbs)
 
104
        {
 
105
                if(dbs == 0.0) return;
 
106
                fprintf(mFile,"\tsetAttr \".dbs\" %f;\n", dbs);
 
107
        }
 
108
        void setProfileLineWidth(double plw)
 
109
        {
 
110
                if(plw == 1.0) return;
 
111
                fprintf(mFile,"\tsetAttr \".plw\" %f;\n", plw);
 
112
        }
 
113
        void setCreaseLineWidth(double clw)
 
114
        {
 
115
                if(clw == 1.0) return;
 
116
                fprintf(mFile,"\tsetAttr \".clw\" %f;\n", clw);
 
117
        }
 
118
        void setBorderLineWidth(double blw)
 
119
        {
 
120
                if(blw == 1.0) return;
 
121
                fprintf(mFile,"\tsetAttr \".blw\" %f;\n", blw);
 
122
        }
 
123
        void setIntersectionLineWidth(double ilw)
 
124
        {
 
125
                if(ilw == 1.0) return;
 
126
                fprintf(mFile,"\tsetAttr \".ilw\" %f;\n", ilw);
 
127
        }
 
128
        void setLineOffset(double lof)
 
129
        {
 
130
                if(lof == 0.0) return;
 
131
                fprintf(mFile,"\tsetAttr \".lof\" %f;\n", lof);
 
132
        }
 
133
        void setLineOffsetMap(double lom)
 
134
        {
 
135
                if(lom == 0.0) return;
 
136
                fprintf(mFile,"\tsetAttr \".lom\" %f;\n", lom);
 
137
        }
 
138
        void setLightingBasedWidth(double lbw)
 
139
        {
 
140
                if(lbw == 0.0) return;
 
141
                fprintf(mFile,"\tsetAttr \".lbw\" %f;\n", lbw);
 
142
        }
 
143
        void setOcclusionWidthScale(bool ows)
 
144
        {
 
145
                if(ows == true) return;
 
146
                fprintf(mFile,"\tsetAttr \".ows\" %i;\n", ows);
 
147
        }
 
148
        void setDepthOffset(double dff)
 
149
        {
 
150
                if(dff == 0.0) return;
 
151
                fprintf(mFile,"\tsetAttr \".dff\" %f;\n", dff);
 
152
        }
 
153
        void setCreaseAngleMin(double amn)
 
154
        {
 
155
                if(amn == 20.0) return;
 
156
                fprintf(mFile,"\tsetAttr \".amn\" %f;\n", amn);
 
157
        }
 
158
        void setCreaseAngleMax(double amx)
 
159
        {
 
160
                if(amx == 90.0) return;
 
161
                fprintf(mFile,"\tsetAttr \".amx\" %f;\n", amx);
 
162
        }
 
163
        void setHardCreasesOnly(bool hco)
 
164
        {
 
165
                if(hco == true) return;
 
166
                fprintf(mFile,"\tsetAttr \".hco\" %i;\n", hco);
 
167
        }
 
168
        void setBackfacingCreases(bool bfc)
 
169
        {
 
170
                if(bfc == true) return;
 
171
                fprintf(mFile,"\tsetAttr \".bfc\" %i;\n", bfc);
 
172
        }
 
173
        void setIntersectionAngleMin(double imn)
 
174
        {
 
175
                if(imn == 1.0) return;
 
176
                fprintf(mFile,"\tsetAttr \".imn\" %f;\n", imn);
 
177
        }
 
178
        void setIntersectionAngleMax(double imx)
 
179
        {
 
180
                if(imx == 1.0) return;
 
181
                fprintf(mFile,"\tsetAttr \".imx\" %f;\n", imx);
 
182
        }
 
183
        void setSmoothProfile(bool spf)
 
184
        {
 
185
                if(spf == true) return;
 
186
                fprintf(mFile,"\tsetAttr \".spf\" %i;\n", spf);
 
187
        }
 
188
        void setTighterProfile(bool tpf)
 
189
        {
 
190
                if(tpf == false) return;
 
191
                fprintf(mFile,"\tsetAttr \".tpf\" %i;\n", tpf);
 
192
        }
 
193
        void setCurvatureModulation(bool cmo)
 
194
        {
 
195
                if(cmo == false) return;
 
196
                fprintf(mFile,"\tsetAttr \".cmo\" %i;\n", cmo);
 
197
        }
 
198
        void setCurvatureWidth(size_t cwd_i,const CurvatureWidth& cwd)
 
199
        {
 
200
                fprintf(mFile,"\tsetAttr \".cwd[%i]\" ",cwd_i);
 
201
                cwd.write(mFile);
 
202
                fprintf(mFile,";\n");
 
203
        }
 
204
        void setCurvatureWidth(size_t cwd_start,size_t cwd_end,CurvatureWidth* cwd)
 
205
        {
 
206
                fprintf(mFile,"\tsetAttr \".cwd[%i:%i]\" ", cwd_start,cwd_end);
 
207
                size_t size = (cwd_end-cwd_start)*1+1;
 
208
                for(size_t i=0;i<size;++i)
 
209
                {
 
210
                        cwd[i].write(mFile);
 
211
                        fprintf(mFile,"\n");
 
212
                }
 
213
                fprintf(mFile,";\n");
 
214
        }
 
215
        void startCurvatureWidth(size_t cwd_start,size_t cwd_end)const
 
216
        {
 
217
                fprintf(mFile,"\tsetAttr \".cwd[%i:%i]\"",cwd_start,cwd_end);
 
218
                fprintf(mFile," -type \"CurvatureWidth\" ");
 
219
        }
 
220
        void appendCurvatureWidth(const CurvatureWidth& cwd)const
 
221
        {
 
222
                fprintf(mFile," ");
 
223
                cwd.write(mFile);
 
224
        }
 
225
        void endCurvatureWidth()const
 
226
        {
 
227
                fprintf(mFile,";\n");
 
228
        }
 
229
        void setCurvatureWidth_Position(size_t cwd_i,float cwdp)
 
230
        {
 
231
                if(cwdp == 0.0) return;
 
232
                fprintf(mFile,"\tsetAttr \".cwd[%i].cwdp\" %f;\n", cwd_i,cwdp);
 
233
        }
 
234
        void setCurvatureWidth_FloatValue(size_t cwd_i,float cwdfv)
 
235
        {
 
236
                if(cwdfv == 0.0) return;
 
237
                fprintf(mFile,"\tsetAttr \".cwd[%i].cwdfv\" %f;\n", cwd_i,cwdfv);
 
238
        }
 
239
        void setCurvatureWidth_Interp(size_t cwd_i,unsigned int cwdi)
 
240
        {
 
241
                if(cwdi == 0) return;
 
242
                fprintf(mFile,"\tsetAttr \".cwd[%i].cwdi\" %i;\n", cwd_i,cwdi);
 
243
        }
 
244
        void setProfileWidthModulation(double pwm)
 
245
        {
 
246
                if(pwm == 0.0) return;
 
247
                fprintf(mFile,"\tsetAttr \".pwm\" %f;\n", pwm);
 
248
        }
 
249
        void setCreaseWidthModulation(double cwm)
 
250
        {
 
251
                if(cwm == 0.0) return;
 
252
                fprintf(mFile,"\tsetAttr \".cwm\" %f;\n", cwm);
 
253
        }
 
254
        void setBorderWidthModulation(double bwm)
 
255
        {
 
256
                if(bwm == 0.5) return;
 
257
                fprintf(mFile,"\tsetAttr \".bwm\" %f;\n", bwm);
 
258
        }
 
259
        void setIntersectionWidthModulation(double imd)
 
260
        {
 
261
                if(imd == 0.0) return;
 
262
                fprintf(mFile,"\tsetAttr \".imd\" %f;\n", imd);
 
263
        }
 
264
        void setProfileBreakAngle(double pba)
 
265
        {
 
266
                if(pba == 180.0) return;
 
267
                fprintf(mFile,"\tsetAttr \".pba\" %f;\n", pba);
 
268
        }
 
269
        void setCreaseBreakAngle(double cba)
 
270
        {
 
271
                if(cba == 80) return;
 
272
                fprintf(mFile,"\tsetAttr \".cba\" %f;\n", cba);
 
273
        }
 
274
        void setBorderBreakAngle(double bba)
 
275
        {
 
276
                if(bba == 80.0) return;
 
277
                fprintf(mFile,"\tsetAttr \".bba\" %f;\n", bba);
 
278
        }
 
279
        void setIntersectionBreakAngle(double iba)
 
280
        {
 
281
                if(iba == 180.0) return;
 
282
                fprintf(mFile,"\tsetAttr \".iba\" %f;\n", iba);
 
283
        }
 
284
        void setRemoveFlushBorders(bool rfb)
 
285
        {
 
286
                if(rfb == false) return;
 
287
                fprintf(mFile,"\tsetAttr \".rfb\" %i;\n", rfb);
 
288
        }
 
289
        void setFlushTolerance(double tfl)
 
290
        {
 
291
                if(tfl == 0.01) return;
 
292
                fprintf(mFile,"\tsetAttr \".tfl\" %f;\n", tfl);
 
293
        }
 
294
        void setFlushAngleMax(double fmx)
 
295
        {
 
296
                if(fmx == 4.0) return;
 
297
                fprintf(mFile,"\tsetAttr \".fmx\" %f;\n", fmx);
 
298
        }
 
299
        void setLineEndThinning(double let)
 
300
        {
 
301
                if(let == 0.0) return;
 
302
                fprintf(mFile,"\tsetAttr \".let\" %f;\n", let);
 
303
        }
 
304
        void setLineExtend(double lex)
 
305
        {
 
306
                if(lex == 0.0) return;
 
307
                fprintf(mFile,"\tsetAttr \".lex\" %f;\n", lex);
 
308
        }
 
309
        void setResampleProfile(bool rpf)
 
310
        {
 
311
                if(rpf == false) return;
 
312
                fprintf(mFile,"\tsetAttr \".rpf\" %i;\n", rpf);
 
313
        }
 
314
        void setResampleCrease(bool rcr)
 
315
        {
 
316
                if(rcr == false) return;
 
317
                fprintf(mFile,"\tsetAttr \".rcr\" %i;\n", rcr);
 
318
        }
 
319
        void setResampleBorder(bool rbd)
 
320
        {
 
321
                if(rbd == false) return;
 
322
                fprintf(mFile,"\tsetAttr \".rbd\" %i;\n", rbd);
 
323
        }
 
324
        void setResampleIntersection(bool rin)
 
325
        {
 
326
                if(rin == false) return;
 
327
                fprintf(mFile,"\tsetAttr \".rin\" %i;\n", rin);
 
328
        }
 
329
        void setMaxSegmentLength(double msl)
 
330
        {
 
331
                if(msl == 0.5) return;
 
332
                fprintf(mFile,"\tsetAttr \".msl\" %f;\n", msl);
 
333
        }
 
334
        void setMinSegmentLength(double mns)
 
335
        {
 
336
                if(mns == 0.0) return;
 
337
                fprintf(mFile,"\tsetAttr \".mns\" %f;\n", mns);
 
338
        }
 
339
        void setScreenSpaceResampling(double ssr)
 
340
        {
 
341
                if(ssr == 0.0) return;
 
342
                fprintf(mFile,"\tsetAttr \".ssr\" %f;\n", ssr);
 
343
        }
 
344
        void setPfxRandomize(bool prz)
 
345
        {
 
346
                if(prz == false) return;
 
347
                fprintf(mFile,"\tsetAttr \".prz\" %i;\n", prz);
 
348
        }
 
349
        void setScreenspaceWidth(bool spw)
 
350
        {
 
351
                if(spw == false) return;
 
352
                fprintf(mFile,"\tsetAttr \".spw\" %i;\n", spw);
 
353
        }
 
354
        void setDistanceScaling(double dsl)
 
355
        {
 
356
                if(dsl == 0.0) return;
 
357
                fprintf(mFile,"\tsetAttr \".dsl\" %f;\n", dsl);
 
358
        }
 
359
        void setMinPixelWidth(double mpw)
 
360
        {
 
361
                if(mpw == 0.0) return;
 
362
                fprintf(mFile,"\tsetAttr \".mpw\" %f;\n", mpw);
 
363
        }
 
364
        void setMaxPixelWidth(double mxp)
 
365
        {
 
366
                if(mxp == 1000.0) return;
 
367
                fprintf(mFile,"\tsetAttr \".mxp\" %f;\n", mxp);
 
368
        }
 
369
        void setProfileColor(const float3& pcl)
 
370
        {
 
371
                fprintf(mFile,"\tsetAttr \".pcl\" -type \"float3\" ");
 
372
                pcl.write(mFile);
 
373
                fprintf(mFile,";\n");
 
374
        }
 
375
        void setProfileColorR(float pcr)
 
376
        {
 
377
                if(pcr == 0.0) return;
 
378
                fprintf(mFile,"\tsetAttr \".pcl.pcr\" %f;\n", pcr);
 
379
        }
 
380
        void setProfileColorG(float pcg)
 
381
        {
 
382
                if(pcg == 0.0) return;
 
383
                fprintf(mFile,"\tsetAttr \".pcl.pcg\" %f;\n", pcg);
 
384
        }
 
385
        void setProfileColorB(float pcb)
 
386
        {
 
387
                if(pcb == 0.0) return;
 
388
                fprintf(mFile,"\tsetAttr \".pcl.pcb\" %f;\n", pcb);
 
389
        }
 
390
        void setCreaseColor(const float3& ccl)
 
391
        {
 
392
                fprintf(mFile,"\tsetAttr \".ccl\" -type \"float3\" ");
 
393
                ccl.write(mFile);
 
394
                fprintf(mFile,";\n");
 
395
        }
 
396
        void setCreaseColorR(float ccr)
 
397
        {
 
398
                if(ccr == 0.0) return;
 
399
                fprintf(mFile,"\tsetAttr \".ccl.ccr\" %f;\n", ccr);
 
400
        }
 
401
        void setCreaseColorG(float ccg)
 
402
        {
 
403
                if(ccg == 0.0) return;
 
404
                fprintf(mFile,"\tsetAttr \".ccl.ccg\" %f;\n", ccg);
 
405
        }
 
406
        void setCreaseColorB(float ccb)
 
407
        {
 
408
                if(ccb == 0.0) return;
 
409
                fprintf(mFile,"\tsetAttr \".ccl.ccb\" %f;\n", ccb);
 
410
        }
 
411
        void setBorderColor(const float3& bcl)
 
412
        {
 
413
                fprintf(mFile,"\tsetAttr \".bcl\" -type \"float3\" ");
 
414
                bcl.write(mFile);
 
415
                fprintf(mFile,";\n");
 
416
        }
 
417
        void setBorderColorR(float bcr)
 
418
        {
 
419
                if(bcr == 0.0) return;
 
420
                fprintf(mFile,"\tsetAttr \".bcl.bcr\" %f;\n", bcr);
 
421
        }
 
422
        void setBorderColorG(float bcg)
 
423
        {
 
424
                if(bcg == 0.0) return;
 
425
                fprintf(mFile,"\tsetAttr \".bcl.bcg\" %f;\n", bcg);
 
426
        }
 
427
        void setBorderColorB(float bcb)
 
428
        {
 
429
                if(bcb == 0.0) return;
 
430
                fprintf(mFile,"\tsetAttr \".bcl.bcb\" %f;\n", bcb);
 
431
        }
 
432
        void setIntersectionColor(const float3& icl)
 
433
        {
 
434
                fprintf(mFile,"\tsetAttr \".icl\" -type \"float3\" ");
 
435
                icl.write(mFile);
 
436
                fprintf(mFile,";\n");
 
437
        }
 
438
        void setIntersectionColorR(float icr)
 
439
        {
 
440
                if(icr == 0.0) return;
 
441
                fprintf(mFile,"\tsetAttr \".icl.icr\" %f;\n", icr);
 
442
        }
 
443
        void setIntersectionColorG(float icg)
 
444
        {
 
445
                if(icg == 0.0) return;
 
446
                fprintf(mFile,"\tsetAttr \".icl.icg\" %f;\n", icg);
 
447
        }
 
448
        void setIntersectionColorB(float icb)
 
449
        {
 
450
                if(icb == 0.0) return;
 
451
                fprintf(mFile,"\tsetAttr \".icl.icb\" %f;\n", icb);
 
452
        }
 
453
        void getInputSurface(size_t ins_i)const
 
454
        {
 
455
                fprintf(mFile,"\"%s.ins[%i]\"",mName.c_str(),ins_i);
 
456
        }
 
457
        void getInputSurface()const
 
458
        {
 
459
 
 
460
                fprintf(mFile,"\"%s.ins\"",mName.c_str());
 
461
        }
 
462
        void getSurface(size_t ins_i)const
 
463
        {
 
464
                fprintf(mFile,"\"%s.ins[%i].srf\"",mName.c_str(),ins_i);
 
465
        }
 
466
        void getSurface()const
 
467
        {
 
468
 
 
469
                fprintf(mFile,"\"%s.ins.srf\"",mName.c_str());
 
470
        }
 
471
        void getInputWorldMatrix(size_t ins_i)const
 
472
        {
 
473
                fprintf(mFile,"\"%s.ins[%i].iwm\"",mName.c_str(),ins_i);
 
474
        }
 
475
        void getInputWorldMatrix()const
 
476
        {
 
477
 
 
478
                fprintf(mFile,"\"%s.ins.iwm\"",mName.c_str());
 
479
        }
 
480
        void getDisplayInViewport()const
 
481
        {
 
482
                fprintf(mFile,"\"%s.div\"",mName.c_str());
 
483
        }
 
484
        void getProfileLines()const
 
485
        {
 
486
                fprintf(mFile,"\"%s.pln\"",mName.c_str());
 
487
        }
 
488
        void getCreaseLines()const
 
489
        {
 
490
                fprintf(mFile,"\"%s.cln\"",mName.c_str());
 
491
        }
 
492
        void getBorderLines()const
 
493
        {
 
494
                fprintf(mFile,"\"%s.bln\"",mName.c_str());
 
495
        }
 
496
        void getIntersectionLines()const
 
497
        {
 
498
                fprintf(mFile,"\"%s.iln\"",mName.c_str());
 
499
        }
 
500
        void getSelfIntersect()const
 
501
        {
 
502
                fprintf(mFile,"\"%s.sei\"",mName.c_str());
 
503
        }
 
504
        void getLineWidth()const
 
505
        {
 
506
                fprintf(mFile,"\"%s.lwd\"",mName.c_str());
 
507
        }
 
508
        void getLineWidthMap()const
 
509
        {
 
510
                fprintf(mFile,"\"%s.lwm\"",mName.c_str());
 
511
        }
 
512
        void getLineOpacity()const
 
513
        {
 
514
                fprintf(mFile,"\"%s.lop\"",mName.c_str());
 
515
        }
 
516
        void getLineOpacityMap()const
 
517
        {
 
518
                fprintf(mFile,"\"%s.lpm\"",mName.c_str());
 
519
        }
 
520
        void getLocalOcclusion()const
 
521
        {
 
522
                fprintf(mFile,"\"%s.lcl\"",mName.c_str());
 
523
        }
 
524
        void getOcclusionTolerance()const
 
525
        {
 
526
                fprintf(mFile,"\"%s.otl\"",mName.c_str());
 
527
        }
 
528
        void getDepthBias()const
 
529
        {
 
530
                fprintf(mFile,"\"%s.dbs\"",mName.c_str());
 
531
        }
 
532
        void getProfileLineWidth()const
 
533
        {
 
534
                fprintf(mFile,"\"%s.plw\"",mName.c_str());
 
535
        }
 
536
        void getCreaseLineWidth()const
 
537
        {
 
538
                fprintf(mFile,"\"%s.clw\"",mName.c_str());
 
539
        }
 
540
        void getBorderLineWidth()const
 
541
        {
 
542
                fprintf(mFile,"\"%s.blw\"",mName.c_str());
 
543
        }
 
544
        void getIntersectionLineWidth()const
 
545
        {
 
546
                fprintf(mFile,"\"%s.ilw\"",mName.c_str());
 
547
        }
 
548
        void getLineOffset()const
 
549
        {
 
550
                fprintf(mFile,"\"%s.lof\"",mName.c_str());
 
551
        }
 
552
        void getLineOffsetMap()const
 
553
        {
 
554
                fprintf(mFile,"\"%s.lom\"",mName.c_str());
 
555
        }
 
556
        void getLightingBasedWidth()const
 
557
        {
 
558
                fprintf(mFile,"\"%s.lbw\"",mName.c_str());
 
559
        }
 
560
        void getOcclusionWidthScale()const
 
561
        {
 
562
                fprintf(mFile,"\"%s.ows\"",mName.c_str());
 
563
        }
 
564
        void getDepthOffset()const
 
565
        {
 
566
                fprintf(mFile,"\"%s.dff\"",mName.c_str());
 
567
        }
 
568
        void getCreaseAngleMin()const
 
569
        {
 
570
                fprintf(mFile,"\"%s.amn\"",mName.c_str());
 
571
        }
 
572
        void getCreaseAngleMax()const
 
573
        {
 
574
                fprintf(mFile,"\"%s.amx\"",mName.c_str());
 
575
        }
 
576
        void getHardCreasesOnly()const
 
577
        {
 
578
                fprintf(mFile,"\"%s.hco\"",mName.c_str());
 
579
        }
 
580
        void getBackfacingCreases()const
 
581
        {
 
582
                fprintf(mFile,"\"%s.bfc\"",mName.c_str());
 
583
        }
 
584
        void getIntersectionAngleMin()const
 
585
        {
 
586
                fprintf(mFile,"\"%s.imn\"",mName.c_str());
 
587
        }
 
588
        void getIntersectionAngleMax()const
 
589
        {
 
590
                fprintf(mFile,"\"%s.imx\"",mName.c_str());
 
591
        }
 
592
        void getSmoothProfile()const
 
593
        {
 
594
                fprintf(mFile,"\"%s.spf\"",mName.c_str());
 
595
        }
 
596
        void getTighterProfile()const
 
597
        {
 
598
                fprintf(mFile,"\"%s.tpf\"",mName.c_str());
 
599
        }
 
600
        void getCurvatureModulation()const
 
601
        {
 
602
                fprintf(mFile,"\"%s.cmo\"",mName.c_str());
 
603
        }
 
604
        void getCurvatureWidth(size_t cwd_i)const
 
605
        {
 
606
                fprintf(mFile,"\"%s.cwd[%i]\"",mName.c_str(),cwd_i);
 
607
        }
 
608
        void getCurvatureWidth()const
 
609
        {
 
610
 
 
611
                fprintf(mFile,"\"%s.cwd\"",mName.c_str());
 
612
        }
 
613
        void getCurvatureWidth_Position(size_t cwd_i)const
 
614
        {
 
615
                fprintf(mFile,"\"%s.cwd[%i].cwdp\"",mName.c_str(),cwd_i);
 
616
        }
 
617
        void getCurvatureWidth_Position()const
 
618
        {
 
619
 
 
620
                fprintf(mFile,"\"%s.cwd.cwdp\"",mName.c_str());
 
621
        }
 
622
        void getCurvatureWidth_FloatValue(size_t cwd_i)const
 
623
        {
 
624
                fprintf(mFile,"\"%s.cwd[%i].cwdfv\"",mName.c_str(),cwd_i);
 
625
        }
 
626
        void getCurvatureWidth_FloatValue()const
 
627
        {
 
628
 
 
629
                fprintf(mFile,"\"%s.cwd.cwdfv\"",mName.c_str());
 
630
        }
 
631
        void getCurvatureWidth_Interp(size_t cwd_i)const
 
632
        {
 
633
                fprintf(mFile,"\"%s.cwd[%i].cwdi\"",mName.c_str(),cwd_i);
 
634
        }
 
635
        void getCurvatureWidth_Interp()const
 
636
        {
 
637
 
 
638
                fprintf(mFile,"\"%s.cwd.cwdi\"",mName.c_str());
 
639
        }
 
640
        void getProfileWidthModulation()const
 
641
        {
 
642
                fprintf(mFile,"\"%s.pwm\"",mName.c_str());
 
643
        }
 
644
        void getCreaseWidthModulation()const
 
645
        {
 
646
                fprintf(mFile,"\"%s.cwm\"",mName.c_str());
 
647
        }
 
648
        void getBorderWidthModulation()const
 
649
        {
 
650
                fprintf(mFile,"\"%s.bwm\"",mName.c_str());
 
651
        }
 
652
        void getIntersectionWidthModulation()const
 
653
        {
 
654
                fprintf(mFile,"\"%s.imd\"",mName.c_str());
 
655
        }
 
656
        void getProfileBreakAngle()const
 
657
        {
 
658
                fprintf(mFile,"\"%s.pba\"",mName.c_str());
 
659
        }
 
660
        void getCreaseBreakAngle()const
 
661
        {
 
662
                fprintf(mFile,"\"%s.cba\"",mName.c_str());
 
663
        }
 
664
        void getBorderBreakAngle()const
 
665
        {
 
666
                fprintf(mFile,"\"%s.bba\"",mName.c_str());
 
667
        }
 
668
        void getIntersectionBreakAngle()const
 
669
        {
 
670
                fprintf(mFile,"\"%s.iba\"",mName.c_str());
 
671
        }
 
672
        void getRemoveFlushBorders()const
 
673
        {
 
674
                fprintf(mFile,"\"%s.rfb\"",mName.c_str());
 
675
        }
 
676
        void getFlushTolerance()const
 
677
        {
 
678
                fprintf(mFile,"\"%s.tfl\"",mName.c_str());
 
679
        }
 
680
        void getFlushAngleMax()const
 
681
        {
 
682
                fprintf(mFile,"\"%s.fmx\"",mName.c_str());
 
683
        }
 
684
        void getLineEndThinning()const
 
685
        {
 
686
                fprintf(mFile,"\"%s.let\"",mName.c_str());
 
687
        }
 
688
        void getLineExtend()const
 
689
        {
 
690
                fprintf(mFile,"\"%s.lex\"",mName.c_str());
 
691
        }
 
692
        void getResampleProfile()const
 
693
        {
 
694
                fprintf(mFile,"\"%s.rpf\"",mName.c_str());
 
695
        }
 
696
        void getResampleCrease()const
 
697
        {
 
698
                fprintf(mFile,"\"%s.rcr\"",mName.c_str());
 
699
        }
 
700
        void getResampleBorder()const
 
701
        {
 
702
                fprintf(mFile,"\"%s.rbd\"",mName.c_str());
 
703
        }
 
704
        void getResampleIntersection()const
 
705
        {
 
706
                fprintf(mFile,"\"%s.rin\"",mName.c_str());
 
707
        }
 
708
        void getMaxSegmentLength()const
 
709
        {
 
710
                fprintf(mFile,"\"%s.msl\"",mName.c_str());
 
711
        }
 
712
        void getMinSegmentLength()const
 
713
        {
 
714
                fprintf(mFile,"\"%s.mns\"",mName.c_str());
 
715
        }
 
716
        void getScreenSpaceResampling()const
 
717
        {
 
718
                fprintf(mFile,"\"%s.ssr\"",mName.c_str());
 
719
        }
 
720
        void getPfxRandomize()const
 
721
        {
 
722
                fprintf(mFile,"\"%s.prz\"",mName.c_str());
 
723
        }
 
724
        void getScreenspaceWidth()const
 
725
        {
 
726
                fprintf(mFile,"\"%s.spw\"",mName.c_str());
 
727
        }
 
728
        void getDistanceScaling()const
 
729
        {
 
730
                fprintf(mFile,"\"%s.dsl\"",mName.c_str());
 
731
        }
 
732
        void getMinPixelWidth()const
 
733
        {
 
734
                fprintf(mFile,"\"%s.mpw\"",mName.c_str());
 
735
        }
 
736
        void getMaxPixelWidth()const
 
737
        {
 
738
                fprintf(mFile,"\"%s.mxp\"",mName.c_str());
 
739
        }
 
740
        void getProfileColor()const
 
741
        {
 
742
                fprintf(mFile,"\"%s.pcl\"",mName.c_str());
 
743
        }
 
744
        void getProfileColorR()const
 
745
        {
 
746
                fprintf(mFile,"\"%s.pcl.pcr\"",mName.c_str());
 
747
        }
 
748
        void getProfileColorG()const
 
749
        {
 
750
                fprintf(mFile,"\"%s.pcl.pcg\"",mName.c_str());
 
751
        }
 
752
        void getProfileColorB()const
 
753
        {
 
754
                fprintf(mFile,"\"%s.pcl.pcb\"",mName.c_str());
 
755
        }
 
756
        void getCreaseColor()const
 
757
        {
 
758
                fprintf(mFile,"\"%s.ccl\"",mName.c_str());
 
759
        }
 
760
        void getCreaseColorR()const
 
761
        {
 
762
                fprintf(mFile,"\"%s.ccl.ccr\"",mName.c_str());
 
763
        }
 
764
        void getCreaseColorG()const
 
765
        {
 
766
                fprintf(mFile,"\"%s.ccl.ccg\"",mName.c_str());
 
767
        }
 
768
        void getCreaseColorB()const
 
769
        {
 
770
                fprintf(mFile,"\"%s.ccl.ccb\"",mName.c_str());
 
771
        }
 
772
        void getBorderColor()const
 
773
        {
 
774
                fprintf(mFile,"\"%s.bcl\"",mName.c_str());
 
775
        }
 
776
        void getBorderColorR()const
 
777
        {
 
778
                fprintf(mFile,"\"%s.bcl.bcr\"",mName.c_str());
 
779
        }
 
780
        void getBorderColorG()const
 
781
        {
 
782
                fprintf(mFile,"\"%s.bcl.bcg\"",mName.c_str());
 
783
        }
 
784
        void getBorderColorB()const
 
785
        {
 
786
                fprintf(mFile,"\"%s.bcl.bcb\"",mName.c_str());
 
787
        }
 
788
        void getIntersectionColor()const
 
789
        {
 
790
                fprintf(mFile,"\"%s.icl\"",mName.c_str());
 
791
        }
 
792
        void getIntersectionColorR()const
 
793
        {
 
794
                fprintf(mFile,"\"%s.icl.icr\"",mName.c_str());
 
795
        }
 
796
        void getIntersectionColorG()const
 
797
        {
 
798
                fprintf(mFile,"\"%s.icl.icg\"",mName.c_str());
 
799
        }
 
800
        void getIntersectionColorB()const
 
801
        {
 
802
                fprintf(mFile,"\"%s.icl.icb\"",mName.c_str());
 
803
        }
 
804
        void getOutColor()const
 
805
        {
 
806
                fprintf(mFile,"\"%s.ocl\"",mName.c_str());
 
807
        }
 
808
        void getOutColorR()const
 
809
        {
 
810
                fprintf(mFile,"\"%s.ocl.ocr\"",mName.c_str());
 
811
        }
 
812
        void getOutColorG()const
 
813
        {
 
814
                fprintf(mFile,"\"%s.ocl.ocg\"",mName.c_str());
 
815
        }
 
816
        void getOutColorB()const
 
817
        {
 
818
                fprintf(mFile,"\"%s.ocl.ocb\"",mName.c_str());
 
819
        }
 
820
        void getOutProfileMesh(size_t opm_i)const
 
821
        {
 
822
                fprintf(mFile,"\"%s.opm[%i]\"",mName.c_str(),opm_i);
 
823
        }
 
824
        void getOutProfileMesh()const
 
825
        {
 
826
 
 
827
                fprintf(mFile,"\"%s.opm\"",mName.c_str());
 
828
        }
 
829
protected:
 
830
        PfxToon(FILE* file,const std::string& name,const std::string& parent,const std::string& nodeType,bool shared=false,bool create=true)
 
831
                :PfxGeometry(file, name, parent, nodeType, shared, create) {}
 
832
 
 
833
};
 
834
}//namespace MayaDM
 
835
#endif//__MayaDM_PFXTOON_H__