← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Externals/MayaDataModel/include/MayaDMRenderGlobals.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/MayaDMRenderGlobals.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_RENDERGLOBALS_H__
 
11
#define __MayaDM_RENDERGLOBALS_H__
 
12
#include "MayaDMTypes.h"
 
13
#include "MayaDMConnectables.h"
 
14
#include "MayaDMDependNode.h"
 
15
namespace MayaDM
 
16
{
 
17
class RenderGlobals : public DependNode
 
18
{
 
19
public:
 
20
public:
 
21
 
 
22
        RenderGlobals():DependNode(){}
 
23
        RenderGlobals(FILE* file,const std::string& name,const std::string& parent="",bool shared=false,bool create=true)
 
24
                :DependNode(file, name, parent, "renderGlobals", shared, create){}
 
25
        virtual ~RenderGlobals(){}
 
26
 
 
27
        void setMacCodec(int macc)
 
28
        {
 
29
                if(macc == 1919706400) return;
 
30
                fprintf(mFile,"\tsetAttr \".macc\" %i;\n", macc);
 
31
        }
 
32
        void setMacDepth(int macd)
 
33
        {
 
34
                if(macd == 32) return;
 
35
                fprintf(mFile,"\tsetAttr \".macd\" %i;\n", macd);
 
36
        }
 
37
        void setMacQual(int macq)
 
38
        {
 
39
                if(macq == 1024) return;
 
40
                fprintf(mFile,"\tsetAttr \".macq\" %i;\n", macq);
 
41
        }
 
42
        void setComFrrt(int mcfr)
 
43
        {
 
44
                if(mcfr == 24) return;
 
45
                fprintf(mFile,"\tsetAttr \".mcfr\" %i;\n", mcfr);
 
46
        }
 
47
        void setIgnoreFilmGate(bool ifg)
 
48
        {
 
49
                if(ifg == true) return;
 
50
                fprintf(mFile,"\tsetAttr \".ifg\" %i;\n", ifg);
 
51
        }
 
52
        void setClipFinalShadedColor(bool clip)
 
53
        {
 
54
                if(clip == true) return;
 
55
                fprintf(mFile,"\tsetAttr \".clip\" %i;\n", clip);
 
56
        }
 
57
        void setEnableDepthMaps(bool edm)
 
58
        {
 
59
                if(edm == true) return;
 
60
                fprintf(mFile,"\tsetAttr \".edm\" %i;\n", edm);
 
61
        }
 
62
        void setEnableDefaultLight(bool edl)
 
63
        {
 
64
                if(edl == true) return;
 
65
                fprintf(mFile,"\tsetAttr \".edl\" %i;\n", edl);
 
66
        }
 
67
        void setCurrentRenderer(const string& ren)
 
68
        {
 
69
                if(ren == "mayaSoftware") return;
 
70
                fprintf(mFile,"\tsetAttr \".ren\" -type \"string\" ");
 
71
                ren.write(mFile);
 
72
                fprintf(mFile,";\n");
 
73
        }
 
74
        void setEnableStrokeRender(bool esr)
 
75
        {
 
76
                if(esr == true) return;
 
77
                fprintf(mFile,"\tsetAttr \".esr\" %i;\n", esr);
 
78
        }
 
79
        void setOnlyRenderStrokes(bool ors)
 
80
        {
 
81
                if(ors == false) return;
 
82
                fprintf(mFile,"\tsetAttr \".ors\" %i;\n", ors);
 
83
        }
 
84
        void setStrokesDepthFile(const string& sdf)
 
85
        {
 
86
                if(sdf == "NULL") return;
 
87
                fprintf(mFile,"\tsetAttr \".sdf\" -type \"string\" ");
 
88
                sdf.write(mFile);
 
89
                fprintf(mFile,";\n");
 
90
        }
 
91
        void setImageFormat(unsigned int outf)
 
92
        {
 
93
                if(outf == 7) return;
 
94
                fprintf(mFile,"\tsetAttr \".outf\" %i;\n", outf);
 
95
        }
 
96
        void setImfPluginKey(const string& imfkey)
 
97
        {
 
98
                if(imfkey == "") return;
 
99
                fprintf(mFile,"\tsetAttr \".imfkey\" -type \"string\" ");
 
100
                imfkey.write(mFile);
 
101
                fprintf(mFile,";\n");
 
102
        }
 
103
        void setGammaCorrection(float gama)
 
104
        {
 
105
                if(gama == 1.0) return;
 
106
                fprintf(mFile,"\tsetAttr \".gama\" %f;\n", gama);
 
107
        }
 
108
        void setAnimation(bool an)
 
109
        {
 
110
                if(an == false) return;
 
111
                fprintf(mFile,"\tsetAttr \".an\" %i;\n", an);
 
112
        }
 
113
        void setAnimationRange(unsigned int ar)
 
114
        {
 
115
                if(ar == 1) return;
 
116
                fprintf(mFile,"\tsetAttr \".ar\" %i;\n", ar);
 
117
        }
 
118
        void setStartFrame(double fs)
 
119
        {
 
120
                if(fs == 1) return;
 
121
                fprintf(mFile,"\tsetAttr \".fs\" %f;\n", fs);
 
122
        }
 
123
        void setEndFrame(double ef)
 
124
        {
 
125
                if(ef == 1) return;
 
126
                fprintf(mFile,"\tsetAttr \".ef\" %f;\n", ef);
 
127
        }
 
128
        void setByFrameStep(float bfs)
 
129
        {
 
130
                if(bfs == 1.0) return;
 
131
                fprintf(mFile,"\tsetAttr \".bfs\" %f;\n", bfs);
 
132
        }
 
133
        void setModifyExtension(bool me)
 
134
        {
 
135
                if(me == false) return;
 
136
                fprintf(mFile,"\tsetAttr \".me\" %i;\n", me);
 
137
        }
 
138
        void setStartExtension(float se)
 
139
        {
 
140
                if(se == 1.0) return;
 
141
                fprintf(mFile,"\tsetAttr \".se\" %f;\n", se);
 
142
        }
 
143
        void setByExtension(float be)
 
144
        {
 
145
                if(be == 1.0) return;
 
146
                fprintf(mFile,"\tsetAttr \".be\" %f;\n", be);
 
147
        }
 
148
        void setExtensionPadding(int ep)
 
149
        {
 
150
                if(ep == 1) return;
 
151
                fprintf(mFile,"\tsetAttr \".ep\" %i;\n", ep);
 
152
        }
 
153
        void setFieldExtControl(unsigned int fec)
 
154
        {
 
155
                if(fec == 0) return;
 
156
                fprintf(mFile,"\tsetAttr \".fec\" %i;\n", fec);
 
157
        }
 
158
        void setOutFormatControl(unsigned int ofc)
 
159
        {
 
160
                if(ofc == 0) return;
 
161
                fprintf(mFile,"\tsetAttr \".ofc\" %i;\n", ofc);
 
162
        }
 
163
        void setOddFieldExt(const string& ofe)
 
164
        {
 
165
                if(ofe == "NULL") return;
 
166
                fprintf(mFile,"\tsetAttr \".ofe\" -type \"string\" ");
 
167
                ofe.write(mFile);
 
168
                fprintf(mFile,";\n");
 
169
        }
 
170
        void setEvenFieldExt(const string& efe)
 
171
        {
 
172
                if(efe == "NULL") return;
 
173
                fprintf(mFile,"\tsetAttr \".efe\" -type \"string\" ");
 
174
                efe.write(mFile);
 
175
                fprintf(mFile,";\n");
 
176
        }
 
177
        void setOutFormatExt(const string& oft)
 
178
        {
 
179
                if(oft == "NULL") return;
 
180
                fprintf(mFile,"\tsetAttr \".oft\" -type \"string\" ");
 
181
                oft.write(mFile);
 
182
                fprintf(mFile,";\n");
 
183
        }
 
184
        void setUseMayaFileName(bool umfn)
 
185
        {
 
186
                if(umfn == true) return;
 
187
                fprintf(mFile,"\tsetAttr \".umfn\" %i;\n", umfn);
 
188
        }
 
189
        void setUseFrameExt(bool ufe)
 
190
        {
 
191
                if(ufe == false) return;
 
192
                fprintf(mFile,"\tsetAttr \".ufe\" %i;\n", ufe);
 
193
        }
 
194
        void setPutFrameBeforeExt(bool pff)
 
195
        {
 
196
                if(pff == false) return;
 
197
                fprintf(mFile,"\tsetAttr \".pff\" %i;\n", pff);
 
198
        }
 
199
        void setPeriodInExt(unsigned int peie)
 
200
        {
 
201
                if(peie == 1) return;
 
202
                fprintf(mFile,"\tsetAttr \".peie\" %i;\n", peie);
 
203
        }
 
204
        void setImageFilePrefix(const string& ifp)
 
205
        {
 
206
                if(ifp == "NULL") return;
 
207
                fprintf(mFile,"\tsetAttr \".ifp\" -type \"string\" ");
 
208
                ifp.write(mFile);
 
209
                fprintf(mFile,";\n");
 
210
        }
 
211
        void setRenderVersion(const string& rv)
 
212
        {
 
213
                if(rv == "NULL") return;
 
214
                fprintf(mFile,"\tsetAttr \".rv\" -type \"string\" ");
 
215
                rv.write(mFile);
 
216
                fprintf(mFile,";\n");
 
217
        }
 
218
        void setComposite(bool comp)
 
219
        {
 
220
                if(comp == false) return;
 
221
                fprintf(mFile,"\tsetAttr \".comp\" %i;\n", comp);
 
222
        }
 
223
        void setCompositeThreshold(float cth)
 
224
        {
 
225
                if(cth == 0.0) return;
 
226
                fprintf(mFile,"\tsetAttr \".cth\" %f;\n", cth);
 
227
        }
 
228
        void setShadowsObeyLightLinking(bool soll)
 
229
        {
 
230
                if(soll == true) return;
 
231
                fprintf(mFile,"\tsetAttr \".soll\" %i;\n", soll);
 
232
        }
 
233
        void setShadowsObeyShadowLinking(bool sosl)
 
234
        {
 
235
                if(sosl == false) return;
 
236
                fprintf(mFile,"\tsetAttr \".sosl\" %i;\n", sosl);
 
237
        }
 
238
        void setRecursionDepth(int rd)
 
239
        {
 
240
                if(rd == 2) return;
 
241
                fprintf(mFile,"\tsetAttr \".rd\" %i;\n", rd);
 
242
        }
 
243
        void setLeafPrimitives(int lp)
 
244
        {
 
245
                if(lp == 200) return;
 
246
                fprintf(mFile,"\tsetAttr \".lp\" %i;\n", lp);
 
247
        }
 
248
        void setSubdivisionPower(float sp)
 
249
        {
 
250
                if(sp == 0.25) return;
 
251
                fprintf(mFile,"\tsetAttr \".sp\" %f;\n", sp);
 
252
        }
 
253
        void setSubdivisionHashSize(int shs)
 
254
        {
 
255
                if(shs == 5) return;
 
256
                fprintf(mFile,"\tsetAttr \".shs\" %i;\n", shs);
 
257
        }
 
258
        void setLogRenderPerformance(bool lpr)
 
259
        {
 
260
                if(lpr == false) return;
 
261
                fprintf(mFile,"\tsetAttr \".lpr\" %i;\n", lpr);
 
262
        }
 
263
        void setGeometryVector(int gv)
 
264
        {
 
265
                if(gv == 20) return;
 
266
                fprintf(mFile,"\tsetAttr \".gv\" %i;\n", gv);
 
267
        }
 
268
        void setShadingVector(int sv)
 
269
        {
 
270
                if(sv == 60) return;
 
271
                fprintf(mFile,"\tsetAttr \".sv\" %i;\n", sv);
 
272
        }
 
273
        void setMaximumMemory(int mm)
 
274
        {
 
275
                if(mm == 48) return;
 
276
                fprintf(mFile,"\tsetAttr \".mm\" %i;\n", mm);
 
277
        }
 
278
        void setNumCpusToUse(int npu)
 
279
        {
 
280
                if(npu == 0) return;
 
281
                fprintf(mFile,"\tsetAttr \".npu\" %i;\n", npu);
 
282
        }
 
283
        void setInterruptFrequency(int itf)
 
284
        {
 
285
                if(itf == 1) return;
 
286
                fprintf(mFile,"\tsetAttr \".itf\" %i;\n", itf);
 
287
        }
 
288
        void setShadowPass(bool shp)
 
289
        {
 
290
                if(shp == false) return;
 
291
                fprintf(mFile,"\tsetAttr \".shp\" %i;\n", shp);
 
292
        }
 
293
        void setIprShadowPass(bool isp)
 
294
        {
 
295
                if(isp == false) return;
 
296
                fprintf(mFile,"\tsetAttr \".isp\" %i;\n", isp);
 
297
        }
 
298
        void setUseFileCache(bool uf)
 
299
        {
 
300
                if(uf == true) return;
 
301
                fprintf(mFile,"\tsetAttr \".uf\" %i;\n", uf);
 
302
        }
 
303
        void setOptimizeInstances(bool oi)
 
304
        {
 
305
                if(oi == true) return;
 
306
                fprintf(mFile,"\tsetAttr \".oi\" %i;\n", oi);
 
307
        }
 
308
        void setReuseTessellations(bool rut)
 
309
        {
 
310
                if(rut == true) return;
 
311
                fprintf(mFile,"\tsetAttr \".rut\" %i;\n", rut);
 
312
        }
 
313
        void setMatteOpacityUsesTransparency(bool mot)
 
314
        {
 
315
                if(mot == true) return;
 
316
                fprintf(mFile,"\tsetAttr \".mot\" %i;\n", mot);
 
317
        }
 
318
        void setMotionBlur(bool mb)
 
319
        {
 
320
                if(mb == false) return;
 
321
                fprintf(mFile,"\tsetAttr \".mb\" %i;\n", mb);
 
322
        }
 
323
        void setMotionBlurByFrame(float mbf)
 
324
        {
 
325
                if(mbf == 1.0) return;
 
326
                fprintf(mFile,"\tsetAttr \".mbf\" %f;\n", mbf);
 
327
        }
 
328
        void setApplyFogInPost(bool afp)
 
329
        {
 
330
                if(afp == false) return;
 
331
                fprintf(mFile,"\tsetAttr \".afp\" %i;\n", afp);
 
332
        }
 
333
        void setPostFogBlur(int pfb)
 
334
        {
 
335
                if(pfb == 1) return;
 
336
                fprintf(mFile,"\tsetAttr \".pfb\" %i;\n", pfb);
 
337
        }
 
338
        void setPreMel(const string& pram)
 
339
        {
 
340
                if(pram == "NULL") return;
 
341
                fprintf(mFile,"\tsetAttr \".pram\" -type \"string\" ");
 
342
                pram.write(mFile);
 
343
                fprintf(mFile,";\n");
 
344
        }
 
345
        void setPostMel(const string& poam)
 
346
        {
 
347
                if(poam == "NULL") return;
 
348
                fprintf(mFile,"\tsetAttr \".poam\" -type \"string\" ");
 
349
                poam.write(mFile);
 
350
                fprintf(mFile,";\n");
 
351
        }
 
352
        void setPreRenderLayerMel(const string& prlm)
 
353
        {
 
354
                if(prlm == "NULL") return;
 
355
                fprintf(mFile,"\tsetAttr \".prlm\" -type \"string\" ");
 
356
                prlm.write(mFile);
 
357
                fprintf(mFile,";\n");
 
358
        }
 
359
        void setPostRenderLayerMel(const string& polm)
 
360
        {
 
361
                if(polm == "NULL") return;
 
362
                fprintf(mFile,"\tsetAttr \".polm\" -type \"string\" ");
 
363
                polm.write(mFile);
 
364
                fprintf(mFile,";\n");
 
365
        }
 
366
        void setPreRenderMel(const string& prm)
 
367
        {
 
368
                if(prm == "NULL") return;
 
369
                fprintf(mFile,"\tsetAttr \".prm\" -type \"string\" ");
 
370
                prm.write(mFile);
 
371
                fprintf(mFile,";\n");
 
372
        }
 
373
        void setPostRenderMel(const string& pom)
 
374
        {
 
375
                if(pom == "NULL") return;
 
376
                fprintf(mFile,"\tsetAttr \".pom\" -type \"string\" ");
 
377
                pom.write(mFile);
 
378
                fprintf(mFile,";\n");
 
379
        }
 
380
        void setPreFurRenderMel(const string& pfrm)
 
381
        {
 
382
                if(pfrm == "NULL") return;
 
383
                fprintf(mFile,"\tsetAttr \".pfrm\" -type \"string\" ");
 
384
                pfrm.write(mFile);
 
385
                fprintf(mFile,";\n");
 
386
        }
 
387
        void setPostFurRenderMel(const string& pfom)
 
388
        {
 
389
                if(pfom == "NULL") return;
 
390
                fprintf(mFile,"\tsetAttr \".pfom\" -type \"string\" ");
 
391
                pfom.write(mFile);
 
392
                fprintf(mFile,";\n");
 
393
        }
 
394
        void setBlurLength(float bll)
 
395
        {
 
396
                if(bll == 1.0) return;
 
397
                fprintf(mFile,"\tsetAttr \".bll\" %f;\n", bll);
 
398
        }
 
399
        void setBlurSharpness(float bls)
 
400
        {
 
401
                if(bls == 1.0) return;
 
402
                fprintf(mFile,"\tsetAttr \".bls\" %f;\n", bls);
 
403
        }
 
404
        void setSmoothValue(int smv)
 
405
        {
 
406
                if(smv == 2) return;
 
407
                fprintf(mFile,"\tsetAttr \".smv\" %i;\n", smv);
 
408
        }
 
409
        void setUseBlur2DMemoryCap(bool ubc)
 
410
        {
 
411
                if(ubc == true) return;
 
412
                fprintf(mFile,"\tsetAttr \".ubc\" %i;\n", ubc);
 
413
        }
 
414
        void setBlur2DMemoryCap(float mbc)
 
415
        {
 
416
                if(mbc == 200.0) return;
 
417
                fprintf(mFile,"\tsetAttr \".mbc\" %f;\n", mbc);
 
418
        }
 
419
        void setMotionBlurType(unsigned int mbt)
 
420
        {
 
421
                if(mbt == 1) return;
 
422
                fprintf(mFile,"\tsetAttr \".mbt\" %i;\n", mbt);
 
423
        }
 
424
        void setUseDisplacementBoundingBox(bool udbx)
 
425
        {
 
426
                if(udbx == true) return;
 
427
                fprintf(mFile,"\tsetAttr \".udbx\" %i;\n", udbx);
 
428
        }
 
429
        void setSmoothColor(bool smc)
 
430
        {
 
431
                if(smc == false) return;
 
432
                fprintf(mFile,"\tsetAttr \".smc\" %i;\n", smc);
 
433
        }
 
434
        void setKeepMotionVector(bool kmv)
 
435
        {
 
436
                if(kmv == false) return;
 
437
                fprintf(mFile,"\tsetAttr \".kmv\" %i;\n", kmv);
 
438
        }
 
439
        void setIprRenderShading(bool isl)
 
440
        {
 
441
                if(isl == true) return;
 
442
                fprintf(mFile,"\tsetAttr \".isl\" %i;\n", isl);
 
443
        }
 
444
        void setIprRenderShadowMaps(bool ism)
 
445
        {
 
446
                if(ism == true) return;
 
447
                fprintf(mFile,"\tsetAttr \".ism\" %i;\n", ism);
 
448
        }
 
449
        void setIprRenderMotionBlur(bool imb)
 
450
        {
 
451
                if(imb == true) return;
 
452
                fprintf(mFile,"\tsetAttr \".imb\" %i;\n", imb);
 
453
        }
 
454
        void setRenderLayerEnable(bool rlen)
 
455
        {
 
456
                if(rlen == false) return;
 
457
                fprintf(mFile,"\tsetAttr \".rlen\" %i;\n", rlen);
 
458
        }
 
459
        void setForceTileSize(bool frts)
 
460
        {
 
461
                if(frts == false) return;
 
462
                fprintf(mFile,"\tsetAttr \".frts\" %i;\n", frts);
 
463
        }
 
464
        void setTileWidth(short tlwd)
 
465
        {
 
466
                if(tlwd == 64) return;
 
467
                fprintf(mFile,"\tsetAttr \".tlwd\" %i;\n", tlwd);
 
468
        }
 
469
        void setTileHeight(short tlht)
 
470
        {
 
471
                if(tlht == 64) return;
 
472
                fprintf(mFile,"\tsetAttr \".tlht\" %i;\n", tlht);
 
473
        }
 
474
        void setJitterFinalColor(bool jfc)
 
475
        {
 
476
                if(jfc == true) return;
 
477
                fprintf(mFile,"\tsetAttr \".jfc\" %i;\n", jfc);
 
478
        }
 
479
        void setRaysSeeBackground(bool rsb)
 
480
        {
 
481
                if(rsb == true) return;
 
482
                fprintf(mFile,"\tsetAttr \".rsb\" %i;\n", rsb);
 
483
        }
 
484
        void setOversamplePaintEffects(bool ope)
 
485
        {
 
486
                if(ope == false) return;
 
487
                fprintf(mFile,"\tsetAttr \".ope\" %i;\n", ope);
 
488
        }
 
489
        void setOversamplePfxPostFilter(bool oppf)
 
490
        {
 
491
                if(oppf == false) return;
 
492
                fprintf(mFile,"\tsetAttr \".oppf\" %i;\n", oppf);
 
493
        }
 
494
        void setHyperShadeBinList(const string& hbl)
 
495
        {
 
496
                if(hbl == "NULL") return;
 
497
                fprintf(mFile,"\tsetAttr \".hbl\" -type \"string\" ");
 
498
                hbl.write(mFile);
 
499
                fprintf(mFile,";\n");
 
500
        }
 
501
        void getMacCodec()const
 
502
        {
 
503
                fprintf(mFile,"\"%s.macc\"",mName.c_str());
 
504
        }
 
505
        void getMacDepth()const
 
506
        {
 
507
                fprintf(mFile,"\"%s.macd\"",mName.c_str());
 
508
        }
 
509
        void getMacQual()const
 
510
        {
 
511
                fprintf(mFile,"\"%s.macq\"",mName.c_str());
 
512
        }
 
513
        void getComFrrt()const
 
514
        {
 
515
                fprintf(mFile,"\"%s.mcfr\"",mName.c_str());
 
516
        }
 
517
        void getRenderAll()const
 
518
        {
 
519
                fprintf(mFile,"\"%s.ra\"",mName.c_str());
 
520
        }
 
521
        void getQuality()const
 
522
        {
 
523
                fprintf(mFile,"\"%s.qual\"",mName.c_str());
 
524
        }
 
525
        void getResolution()const
 
526
        {
 
527
                fprintf(mFile,"\"%s.res\"",mName.c_str());
 
528
        }
 
529
        void getClipFinalShadedColor()const
 
530
        {
 
531
                fprintf(mFile,"\"%s.clip\"",mName.c_str());
 
532
        }
 
533
        void getEnableDepthMaps()const
 
534
        {
 
535
                fprintf(mFile,"\"%s.edm\"",mName.c_str());
 
536
        }
 
537
        void getEnableDefaultLight()const
 
538
        {
 
539
                fprintf(mFile,"\"%s.edl\"",mName.c_str());
 
540
        }
 
541
        void getEnableStrokeRender()const
 
542
        {
 
543
                fprintf(mFile,"\"%s.esr\"",mName.c_str());
 
544
        }
 
545
        void getOnlyRenderStrokes()const
 
546
        {
 
547
                fprintf(mFile,"\"%s.ors\"",mName.c_str());
 
548
        }
 
549
        void getStrokesDepthFile()const
 
550
        {
 
551
                fprintf(mFile,"\"%s.sdf\"",mName.c_str());
 
552
        }
 
553
        void getImageFormat()const
 
554
        {
 
555
                fprintf(mFile,"\"%s.outf\"",mName.c_str());
 
556
        }
 
557
        void getImfPluginKey()const
 
558
        {
 
559
                fprintf(mFile,"\"%s.imfkey\"",mName.c_str());
 
560
        }
 
561
        void getGammaCorrection()const
 
562
        {
 
563
                fprintf(mFile,"\"%s.gama\"",mName.c_str());
 
564
        }
 
565
        void getTopRegion()const
 
566
        {
 
567
                fprintf(mFile,"\"%s.top\"",mName.c_str());
 
568
        }
 
569
        void getLeftRegion()const
 
570
        {
 
571
                fprintf(mFile,"\"%s.left\"",mName.c_str());
 
572
        }
 
573
        void getBottomRegion()const
 
574
        {
 
575
                fprintf(mFile,"\"%s.bot\"",mName.c_str());
 
576
        }
 
577
        void getRightRegion()const
 
578
        {
 
579
                fprintf(mFile,"\"%s.rght\"",mName.c_str());
 
580
        }
 
581
        void getUseRenderRegion()const
 
582
        {
 
583
                fprintf(mFile,"\"%s.urr\"",mName.c_str());
 
584
        }
 
585
        void getByFrame()const
 
586
        {
 
587
                fprintf(mFile,"\"%s.bf\"",mName.c_str());
 
588
        }
 
589
        void getByFrameStep()const
 
590
        {
 
591
                fprintf(mFile,"\"%s.bfs\"",mName.c_str());
 
592
        }
 
593
        void getByExtension()const
 
594
        {
 
595
                fprintf(mFile,"\"%s.be\"",mName.c_str());
 
596
        }
 
597
        void getFieldExtControl()const
 
598
        {
 
599
                fprintf(mFile,"\"%s.fec\"",mName.c_str());
 
600
        }
 
601
        void getOutFormatControl()const
 
602
        {
 
603
                fprintf(mFile,"\"%s.ofc\"",mName.c_str());
 
604
        }
 
605
        void getOddFieldExt()const
 
606
        {
 
607
                fprintf(mFile,"\"%s.ofe\"",mName.c_str());
 
608
        }
 
609
        void getEvenFieldExt()const
 
610
        {
 
611
                fprintf(mFile,"\"%s.efe\"",mName.c_str());
 
612
        }
 
613
        void getOutFormatExt()const
 
614
        {
 
615
                fprintf(mFile,"\"%s.oft\"",mName.c_str());
 
616
        }
 
617
        void getComposite()const
 
618
        {
 
619
                fprintf(mFile,"\"%s.comp\"",mName.c_str());
 
620
        }
 
621
        void getCompositeThreshold()const
 
622
        {
 
623
                fprintf(mFile,"\"%s.cth\"",mName.c_str());
 
624
        }
 
625
        void getShadowsObeyLightLinking()const
 
626
        {
 
627
                fprintf(mFile,"\"%s.soll\"",mName.c_str());
 
628
        }
 
629
        void getShadowsObeyShadowLinking()const
 
630
        {
 
631
                fprintf(mFile,"\"%s.sosl\"",mName.c_str());
 
632
        }
 
633
        void getRecursionDepth()const
 
634
        {
 
635
                fprintf(mFile,"\"%s.rd\"",mName.c_str());
 
636
        }
 
637
        void getLeafPrimitives()const
 
638
        {
 
639
                fprintf(mFile,"\"%s.lp\"",mName.c_str());
 
640
        }
 
641
        void getSubdivisionPower()const
 
642
        {
 
643
                fprintf(mFile,"\"%s.sp\"",mName.c_str());
 
644
        }
 
645
        void getSubdivisionHashSize()const
 
646
        {
 
647
                fprintf(mFile,"\"%s.shs\"",mName.c_str());
 
648
        }
 
649
        void getLogRenderPerformance()const
 
650
        {
 
651
                fprintf(mFile,"\"%s.lpr\"",mName.c_str());
 
652
        }
 
653
        void getGeometryVector()const
 
654
        {
 
655
                fprintf(mFile,"\"%s.gv\"",mName.c_str());
 
656
        }
 
657
        void getShadingVector()const
 
658
        {
 
659
                fprintf(mFile,"\"%s.sv\"",mName.c_str());
 
660
        }
 
661
        void getMaximumMemory()const
 
662
        {
 
663
                fprintf(mFile,"\"%s.mm\"",mName.c_str());
 
664
        }
 
665
        void getNumCpusToUse()const
 
666
        {
 
667
                fprintf(mFile,"\"%s.npu\"",mName.c_str());
 
668
        }
 
669
        void getInterruptFrequency()const
 
670
        {
 
671
                fprintf(mFile,"\"%s.itf\"",mName.c_str());
 
672
        }
 
673
        void getShadowPass()const
 
674
        {
 
675
                fprintf(mFile,"\"%s.shp\"",mName.c_str());
 
676
        }
 
677
        void getIprShadowPass()const
 
678
        {
 
679
                fprintf(mFile,"\"%s.isp\"",mName.c_str());
 
680
        }
 
681
        void getUseFileCache()const
 
682
        {
 
683
                fprintf(mFile,"\"%s.uf\"",mName.c_str());
 
684
        }
 
685
        void getOptimizeInstances()const
 
686
        {
 
687
                fprintf(mFile,"\"%s.oi\"",mName.c_str());
 
688
        }
 
689
        void getReuseTessellations()const
 
690
        {
 
691
                fprintf(mFile,"\"%s.rut\"",mName.c_str());
 
692
        }
 
693
        void getMatteOpacityUsesTransparency()const
 
694
        {
 
695
                fprintf(mFile,"\"%s.mot\"",mName.c_str());
 
696
        }
 
697
        void getMotionBlurByFrame()const
 
698
        {
 
699
                fprintf(mFile,"\"%s.mbf\"",mName.c_str());
 
700
        }
 
701
        void getFogGeometry()const
 
702
        {
 
703
                fprintf(mFile,"\"%s.fg\"",mName.c_str());
 
704
        }
 
705
        void getApplyFogInPost()const
 
706
        {
 
707
                fprintf(mFile,"\"%s.afp\"",mName.c_str());
 
708
        }
 
709
        void getPostFogBlur()const
 
710
        {
 
711
                fprintf(mFile,"\"%s.pfb\"",mName.c_str());
 
712
        }
 
713
        void getPreMel()const
 
714
        {
 
715
                fprintf(mFile,"\"%s.pram\"",mName.c_str());
 
716
        }
 
717
        void getPostMel()const
 
718
        {
 
719
                fprintf(mFile,"\"%s.poam\"",mName.c_str());
 
720
        }
 
721
        void getPreRenderLayerMel()const
 
722
        {
 
723
                fprintf(mFile,"\"%s.prlm\"",mName.c_str());
 
724
        }
 
725
        void getPostRenderLayerMel()const
 
726
        {
 
727
                fprintf(mFile,"\"%s.polm\"",mName.c_str());
 
728
        }
 
729
        void getPreRenderMel()const
 
730
        {
 
731
                fprintf(mFile,"\"%s.prm\"",mName.c_str());
 
732
        }
 
733
        void getPostRenderMel()const
 
734
        {
 
735
                fprintf(mFile,"\"%s.pom\"",mName.c_str());
 
736
        }
 
737
        void getPreFurRenderMel()const
 
738
        {
 
739
                fprintf(mFile,"\"%s.pfrm\"",mName.c_str());
 
740
        }
 
741
        void getPostFurRenderMel()const
 
742
        {
 
743
                fprintf(mFile,"\"%s.pfom\"",mName.c_str());
 
744
        }
 
745
        void getCreateIprFile()const
 
746
        {
 
747
                fprintf(mFile,"\"%s.cif\"",mName.c_str());
 
748
        }
 
749
        void getBlurLength()const
 
750
        {
 
751
                fprintf(mFile,"\"%s.bll\"",mName.c_str());
 
752
        }
 
753
        void getBlurSharpness()const
 
754
        {
 
755
                fprintf(mFile,"\"%s.bls\"",mName.c_str());
 
756
        }
 
757
        void getSmoothValue()const
 
758
        {
 
759
                fprintf(mFile,"\"%s.smv\"",mName.c_str());
 
760
        }
 
761
        void getUseBlur2DMemoryCap()const
 
762
        {
 
763
                fprintf(mFile,"\"%s.ubc\"",mName.c_str());
 
764
        }
 
765
        void getBlur2DMemoryCap()const
 
766
        {
 
767
                fprintf(mFile,"\"%s.mbc\"",mName.c_str());
 
768
        }
 
769
        void getUseDisplacementBoundingBox()const
 
770
        {
 
771
                fprintf(mFile,"\"%s.udbx\"",mName.c_str());
 
772
        }
 
773
        void getSmoothColor()const
 
774
        {
 
775
                fprintf(mFile,"\"%s.smc\"",mName.c_str());
 
776
        }
 
777
        void getKeepMotionVector()const
 
778
        {
 
779
                fprintf(mFile,"\"%s.kmv\"",mName.c_str());
 
780
        }
 
781
        void getIprRenderShading()const
 
782
        {
 
783
                fprintf(mFile,"\"%s.isl\"",mName.c_str());
 
784
        }
 
785
        void getIprRenderShadowMaps()const
 
786
        {
 
787
                fprintf(mFile,"\"%s.ism\"",mName.c_str());
 
788
        }
 
789
        void getIprRenderMotionBlur()const
 
790
        {
 
791
                fprintf(mFile,"\"%s.imb\"",mName.c_str());
 
792
        }
 
793
        void getRendercallback()const
 
794
        {
 
795
                fprintf(mFile,"\"%s.rcb\"",mName.c_str());
 
796
        }
 
797
        void getRenderLayerEnable()const
 
798
        {
 
799
                fprintf(mFile,"\"%s.rlen\"",mName.c_str());
 
800
        }
 
801
        void getForceTileSize()const
 
802
        {
 
803
                fprintf(mFile,"\"%s.frts\"",mName.c_str());
 
804
        }
 
805
        void getTileWidth()const
 
806
        {
 
807
                fprintf(mFile,"\"%s.tlwd\"",mName.c_str());
 
808
        }
 
809
        void getTileHeight()const
 
810
        {
 
811
                fprintf(mFile,"\"%s.tlht\"",mName.c_str());
 
812
        }
 
813
        void getJitterFinalColor()const
 
814
        {
 
815
                fprintf(mFile,"\"%s.jfc\"",mName.c_str());
 
816
        }
 
817
        void getRaysSeeBackground()const
 
818
        {
 
819
                fprintf(mFile,"\"%s.rsb\"",mName.c_str());
 
820
        }
 
821
        void getOversamplePaintEffects()const
 
822
        {
 
823
                fprintf(mFile,"\"%s.ope\"",mName.c_str());
 
824
        }
 
825
        void getOversamplePfxPostFilter()const
 
826
        {
 
827
                fprintf(mFile,"\"%s.oppf\"",mName.c_str());
 
828
        }
 
829
protected:
 
830
        RenderGlobals(FILE* file,const std::string& name,const std::string& parent,const std::string& nodeType,bool shared=false,bool create=true)
 
831
                :DependNode(file, name, parent, nodeType, shared, create) {}
 
832
 
 
833
};
 
834
}//namespace MayaDM
 
835
#endif//__MayaDM_RENDERGLOBALS_H__