← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Externals/MayaDataModel/include/MayaDMFurFeedback.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/MayaDMFurFeedback.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_FURFEEDBACK_H__
 
11
#define __MayaDM_FURFEEDBACK_H__
 
12
#include "MayaDMTypes.h"
 
13
#include "MayaDMConnectables.h"
 
14
#include "MayaDMLocator.h"
 
15
namespace MayaDM
 
16
{
 
17
class FurFeedback : public Locator
 
18
{
 
19
public:
 
20
        struct Attractors{
 
21
        };
 
22
        struct MentalRayControls{
 
23
                bool miOverrideCaustics;
 
24
                short miCausticAccuracy;
 
25
                float miCausticRadius;
 
26
                bool miOverrideGlobalIllumination;
 
27
                short miGlobillumAccuracy;
 
28
                float miGlobillumRadius;
 
29
                bool miOverrideFinalGather;
 
30
                int miFinalGatherRays;
 
31
                float miFinalGatherMinRadius;
 
32
                float miFinalGatherMaxRadius;
 
33
                short miFinalGatherFilter;
 
34
                bool miFinalGatherView;
 
35
                bool miOverrideSamples;
 
36
                short miMinSamples;
 
37
                short miMaxSamples;
 
38
                bool miFinalGatherCast;
 
39
                bool miFinalGatherReceive;
 
40
                bool miTransparencyCast;
 
41
                bool miTransparencyReceive;
 
42
                void write(FILE* file) const
 
43
                {
 
44
                        fprintf(file,"%i ", miOverrideCaustics);
 
45
                        fprintf(file,"%i ", miCausticAccuracy);
 
46
                        fprintf(file,"%f ", miCausticRadius);
 
47
                        fprintf(file,"%i ", miOverrideGlobalIllumination);
 
48
                        fprintf(file,"%i ", miGlobillumAccuracy);
 
49
                        fprintf(file,"%f ", miGlobillumRadius);
 
50
                        fprintf(file,"%i ", miOverrideFinalGather);
 
51
                        fprintf(file,"%i ", miFinalGatherRays);
 
52
                        fprintf(file,"%f ", miFinalGatherMinRadius);
 
53
                        fprintf(file,"%f ", miFinalGatherMaxRadius);
 
54
                        fprintf(file,"%i ", miFinalGatherFilter);
 
55
                        fprintf(file,"%i ", miFinalGatherView);
 
56
                        fprintf(file,"%i ", miOverrideSamples);
 
57
                        fprintf(file,"%i ", miMinSamples);
 
58
                        fprintf(file,"%i ", miMaxSamples);
 
59
                        fprintf(file,"%i ", miFinalGatherCast);
 
60
                        fprintf(file,"%i ", miFinalGatherReceive);
 
61
                        fprintf(file,"%i ", miTransparencyCast);
 
62
                        fprintf(file,"%i", miTransparencyReceive);
 
63
                }
 
64
        };
 
65
public:
 
66
 
 
67
        FurFeedback():Locator(){}
 
68
        FurFeedback(FILE* file,const std::string& name,const std::string& parent="",bool shared=false,bool create=true)
 
69
                :Locator(file, name, parent, "FurFeedback", shared, create){}
 
70
        virtual ~FurFeedback(){}
 
71
 
 
72
        void setInputSurface(const nurbsSurface& is)
 
73
        {
 
74
                fprintf(mFile,"\tsetAttr \".is\" -type \"nurbsSurface\" ");
 
75
                is.write(mFile);
 
76
                fprintf(mFile,";\n");
 
77
        }
 
78
        void setInputMesh(const mesh& imsh)
 
79
        {
 
80
                fprintf(mFile,"\tsetAttr \".imsh\" -type \"mesh\" ");
 
81
                imsh.write(mFile);
 
82
                fprintf(mFile,";\n");
 
83
        }
 
84
        void setRealUSamples(int rus)
 
85
        {
 
86
                if(rus == 32) return;
 
87
                fprintf(mFile,"\tsetAttr \".rus\" %i;\n", rus);
 
88
        }
 
89
        void setRealVSamples(int rvs)
 
90
        {
 
91
                if(rvs == 32) return;
 
92
                fprintf(mFile,"\tsetAttr \".rvs\" %i;\n", rvs);
 
93
        }
 
94
        void setUSamples(int us)
 
95
        {
 
96
                if(us == 32) return;
 
97
                fprintf(mFile,"\tsetAttr \".us\" %i;\n", us);
 
98
        }
 
99
        void setVSamples(int vs)
 
100
        {
 
101
                if(vs == 32) return;
 
102
                fprintf(mFile,"\tsetAttr \".vs\" %i;\n", vs);
 
103
        }
 
104
        void setFlipNormals(bool fn)
 
105
        {
 
106
                if(fn == false) return;
 
107
                fprintf(mFile,"\tsetAttr \".fn\" %i;\n", fn);
 
108
        }
 
109
        void setHairs(const pointArray& h)
 
110
        {
 
111
                fprintf(mFile,"\tsetAttr \".h\" -type \"pointArray\" ");
 
112
                h.write(mFile);
 
113
                fprintf(mFile,";\n");
 
114
        }
 
115
        void setFurAccuracy(float ha)
 
116
        {
 
117
                if(ha == 0.0) return;
 
118
                fprintf(mFile,"\tsetAttr \".ha\" %f;\n", ha);
 
119
        }
 
120
        void setFurGlobalScale(float fgs)
 
121
        {
 
122
                if(fgs == 1.0) return;
 
123
                fprintf(mFile,"\tsetAttr \".fgs\" %f;\n", fgs);
 
124
        }
 
125
        void setAttractorGlobalScale(float ags)
 
126
        {
 
127
                if(ags == 1.0) return;
 
128
                fprintf(mFile,"\tsetAttr \".ags\" %f;\n", ags);
 
129
        }
 
130
        void setExportAttr(const string& ea)
 
131
        {
 
132
                if(ea == "n/a") return;
 
133
                fprintf(mFile,"\tsetAttr \".ea\" -type \"string\" ");
 
134
                ea.write(mFile);
 
135
                fprintf(mFile,";\n");
 
136
        }
 
137
        void setExportFile(const string& ef)
 
138
        {
 
139
                if(ef == "n/a") return;
 
140
                fprintf(mFile,"\tsetAttr \".ef\" -type \"string\" ");
 
141
                ef.write(mFile);
 
142
                fprintf(mFile,";\n");
 
143
        }
 
144
        void setExportWidth(int ew)
 
145
        {
 
146
                if(ew == 256) return;
 
147
                fprintf(mFile,"\tsetAttr \".ew\" %i;\n", ew);
 
148
        }
 
149
        void setExportHeight(int eh)
 
150
        {
 
151
                if(eh == 256) return;
 
152
                fprintf(mFile,"\tsetAttr \".eh\" %i;\n", eh);
 
153
        }
 
154
        void setColorFeedbackEnabled(bool cfe)
 
155
        {
 
156
                if(cfe == false) return;
 
157
                fprintf(mFile,"\tsetAttr \".cfe\" %i;\n", cfe);
 
158
        }
 
159
        void setAttractorModel(unsigned int amd)
 
160
        {
 
161
                if(amd == 0) return;
 
162
                fprintf(mFile,"\tsetAttr \".amd\" %i;\n", amd);
 
163
        }
 
164
        void setAttractorsPerHair(int aph)
 
165
        {
 
166
                if(aph == 1) return;
 
167
                fprintf(mFile,"\tsetAttr \".aph\" %i;\n", aph);
 
168
        }
 
169
        void setDrawAttractors(bool drat)
 
170
        {
 
171
                if(drat == false) return;
 
172
                fprintf(mFile,"\tsetAttr \".drat\" %i;\n", drat);
 
173
        }
 
174
        void setLength(double dl)
 
175
        {
 
176
                if(dl == 1) return;
 
177
                fprintf(mFile,"\tsetAttr \".dl\" %f;\n", dl);
 
178
        }
 
179
        void setLengthSamples(size_t ls_i,double ls)
 
180
        {
 
181
                if(ls == 0.0) return;
 
182
                fprintf(mFile,"\tsetAttr \".ls[%i]\" %f;\n", ls_i,ls);
 
183
        }
 
184
        void setLengthSamples(size_t ls_start,size_t ls_end,double* ls)
 
185
        {
 
186
                fprintf(mFile,"\tsetAttr \".ls[%i:%i]\" ", ls_start,ls_end);
 
187
                size_t size = (ls_end-ls_start)*1+1;
 
188
                for(size_t i=0;i<size;++i)
 
189
                {
 
190
                        fprintf(mFile,"%f",ls[i]);
 
191
                        if(i+1<size) fprintf(mFile," ");
 
192
                }
 
193
                fprintf(mFile,";\n");
 
194
        }
 
195
        void startLengthSamples(size_t ls_start,size_t ls_end)const
 
196
        {
 
197
                fprintf(mFile,"\tsetAttr \".ls[%i:%i]\"",ls_start,ls_end);
 
198
        }
 
199
        void appendLengthSamples(double ls)const
 
200
        {
 
201
                fprintf(mFile," %f",ls);
 
202
        }
 
203
        void endLengthSamples()const
 
204
        {
 
205
                fprintf(mFile,";\n");
 
206
        }
 
207
        void setLengthMap(const string& lm)
 
208
        {
 
209
                if(lm == "n/a") return;
 
210
                fprintf(mFile,"\tsetAttr \".lm\" -type \"string\" ");
 
211
                lm.write(mFile);
 
212
                fprintf(mFile,";\n");
 
213
        }
 
214
        void setLengthMapOffset(double lmo)
 
215
        {
 
216
                if(lmo == 0) return;
 
217
                fprintf(mFile,"\tsetAttr \".lmo\" %f;\n", lmo);
 
218
        }
 
219
        void setLengthMapMult(double lmm)
 
220
        {
 
221
                if(lmm == 1) return;
 
222
                fprintf(mFile,"\tsetAttr \".lmm\" %f;\n", lmm);
 
223
        }
 
224
        void setLengthNoise(double ln)
 
225
        {
 
226
                if(ln == 0) return;
 
227
                fprintf(mFile,"\tsetAttr \".ln\" %f;\n", ln);
 
228
        }
 
229
        void setLengthNoiseFreq(float lnf)
 
230
        {
 
231
                if(lnf == 10.0) return;
 
232
                fprintf(mFile,"\tsetAttr \".lnf\" %f;\n", lnf);
 
233
        }
 
234
        void setLengthSamplesDirty(int lsd)
 
235
        {
 
236
                if(lsd == 0.0) return;
 
237
                fprintf(mFile,"\tsetAttr \".lsd\" %i;\n", lsd);
 
238
        }
 
239
        void setLengthMapDirty(int lmd)
 
240
        {
 
241
                if(lmd == 0.0) return;
 
242
                fprintf(mFile,"\tsetAttr \".lmd\" %i;\n", lmd);
 
243
        }
 
244
        void setInclination(float din)
 
245
        {
 
246
                if(din == 0.0) return;
 
247
                fprintf(mFile,"\tsetAttr \".din\" %f;\n", din);
 
248
        }
 
249
        void setInclinationSamples(size_t ins_i,double ins)
 
250
        {
 
251
                if(ins == 0.0) return;
 
252
                fprintf(mFile,"\tsetAttr \".ins[%i]\" %f;\n", ins_i,ins);
 
253
        }
 
254
        void setInclinationSamples(size_t ins_start,size_t ins_end,double* ins)
 
255
        {
 
256
                fprintf(mFile,"\tsetAttr \".ins[%i:%i]\" ", ins_start,ins_end);
 
257
                size_t size = (ins_end-ins_start)*1+1;
 
258
                for(size_t i=0;i<size;++i)
 
259
                {
 
260
                        fprintf(mFile,"%f",ins[i]);
 
261
                        if(i+1<size) fprintf(mFile," ");
 
262
                }
 
263
                fprintf(mFile,";\n");
 
264
        }
 
265
        void startInclinationSamples(size_t ins_start,size_t ins_end)const
 
266
        {
 
267
                fprintf(mFile,"\tsetAttr \".ins[%i:%i]\"",ins_start,ins_end);
 
268
        }
 
269
        void appendInclinationSamples(double ins)const
 
270
        {
 
271
                fprintf(mFile," %f",ins);
 
272
        }
 
273
        void endInclinationSamples()const
 
274
        {
 
275
                fprintf(mFile,";\n");
 
276
        }
 
277
        void setInclinationMap(const string& inm)
 
278
        {
 
279
                if(inm == "n/a") return;
 
280
                fprintf(mFile,"\tsetAttr \".inm\" -type \"string\" ");
 
281
                inm.write(mFile);
 
282
                fprintf(mFile,";\n");
 
283
        }
 
284
        void setInclinationMapOffset(float inmo)
 
285
        {
 
286
                if(inmo == 0.0) return;
 
287
                fprintf(mFile,"\tsetAttr \".inmo\" %f;\n", inmo);
 
288
        }
 
289
        void setInclinationMapMult(float inmm)
 
290
        {
 
291
                if(inmm == 1.0) return;
 
292
                fprintf(mFile,"\tsetAttr \".inmm\" %f;\n", inmm);
 
293
        }
 
294
        void setInclinationNoise(float inn)
 
295
        {
 
296
                if(inn == 0.0) return;
 
297
                fprintf(mFile,"\tsetAttr \".inn\" %f;\n", inn);
 
298
        }
 
299
        void setInclinationNoiseFreq(float innf)
 
300
        {
 
301
                if(innf == 10.0) return;
 
302
                fprintf(mFile,"\tsetAttr \".innf\" %f;\n", innf);
 
303
        }
 
304
        void setInclinationSamplesDirty(int insd)
 
305
        {
 
306
                if(insd == 0.0) return;
 
307
                fprintf(mFile,"\tsetAttr \".insd\" %i;\n", insd);
 
308
        }
 
309
        void setInclinationMapDirty(int inmd)
 
310
        {
 
311
                if(inmd == 0.0) return;
 
312
                fprintf(mFile,"\tsetAttr \".inmd\" %i;\n", inmd);
 
313
        }
 
314
        void setRoll(float drl)
 
315
        {
 
316
                if(drl == 0.5) return;
 
317
                fprintf(mFile,"\tsetAttr \".drl\" %f;\n", drl);
 
318
        }
 
319
        void setRollSamples(size_t rls_i,double rls)
 
320
        {
 
321
                if(rls == 0.0) return;
 
322
                fprintf(mFile,"\tsetAttr \".rls[%i]\" %f;\n", rls_i,rls);
 
323
        }
 
324
        void setRollSamples(size_t rls_start,size_t rls_end,double* rls)
 
325
        {
 
326
                fprintf(mFile,"\tsetAttr \".rls[%i:%i]\" ", rls_start,rls_end);
 
327
                size_t size = (rls_end-rls_start)*1+1;
 
328
                for(size_t i=0;i<size;++i)
 
329
                {
 
330
                        fprintf(mFile,"%f",rls[i]);
 
331
                        if(i+1<size) fprintf(mFile," ");
 
332
                }
 
333
                fprintf(mFile,";\n");
 
334
        }
 
335
        void startRollSamples(size_t rls_start,size_t rls_end)const
 
336
        {
 
337
                fprintf(mFile,"\tsetAttr \".rls[%i:%i]\"",rls_start,rls_end);
 
338
        }
 
339
        void appendRollSamples(double rls)const
 
340
        {
 
341
                fprintf(mFile," %f",rls);
 
342
        }
 
343
        void endRollSamples()const
 
344
        {
 
345
                fprintf(mFile,";\n");
 
346
        }
 
347
        void setRollMap(const string& rlm)
 
348
        {
 
349
                if(rlm == "n/a") return;
 
350
                fprintf(mFile,"\tsetAttr \".rlm\" -type \"string\" ");
 
351
                rlm.write(mFile);
 
352
                fprintf(mFile,";\n");
 
353
        }
 
354
        void setRollMapOffset(float rlmo)
 
355
        {
 
356
                if(rlmo == 0.0) return;
 
357
                fprintf(mFile,"\tsetAttr \".rlmo\" %f;\n", rlmo);
 
358
        }
 
359
        void setRollMapMult(float rlmm)
 
360
        {
 
361
                if(rlmm == 1.0) return;
 
362
                fprintf(mFile,"\tsetAttr \".rlmm\" %f;\n", rlmm);
 
363
        }
 
364
        void setRollNoise(float rln)
 
365
        {
 
366
                if(rln == 0.0) return;
 
367
                fprintf(mFile,"\tsetAttr \".rln\" %f;\n", rln);
 
368
        }
 
369
        void setRollNoiseFreq(float rlnf)
 
370
        {
 
371
                if(rlnf == 10.0) return;
 
372
                fprintf(mFile,"\tsetAttr \".rlnf\" %f;\n", rlnf);
 
373
        }
 
374
        void setRollSamplesDirty(int rlsd)
 
375
        {
 
376
                if(rlsd == 0.0) return;
 
377
                fprintf(mFile,"\tsetAttr \".rlsd\" %i;\n", rlsd);
 
378
        }
 
379
        void setRollMapDirty(int rlmd)
 
380
        {
 
381
                if(rlmd == 0.0) return;
 
382
                fprintf(mFile,"\tsetAttr \".rlmd\" %i;\n", rlmd);
 
383
        }
 
384
        void setPolar(float dpo)
 
385
        {
 
386
                if(dpo == 0.5) return;
 
387
                fprintf(mFile,"\tsetAttr \".dpo\" %f;\n", dpo);
 
388
        }
 
389
        void setPolarSamples(size_t pos_i,double pos)
 
390
        {
 
391
                if(pos == 0.0) return;
 
392
                fprintf(mFile,"\tsetAttr \".pos[%i]\" %f;\n", pos_i,pos);
 
393
        }
 
394
        void setPolarSamples(size_t pos_start,size_t pos_end,double* pos)
 
395
        {
 
396
                fprintf(mFile,"\tsetAttr \".pos[%i:%i]\" ", pos_start,pos_end);
 
397
                size_t size = (pos_end-pos_start)*1+1;
 
398
                for(size_t i=0;i<size;++i)
 
399
                {
 
400
                        fprintf(mFile,"%f",pos[i]);
 
401
                        if(i+1<size) fprintf(mFile," ");
 
402
                }
 
403
                fprintf(mFile,";\n");
 
404
        }
 
405
        void startPolarSamples(size_t pos_start,size_t pos_end)const
 
406
        {
 
407
                fprintf(mFile,"\tsetAttr \".pos[%i:%i]\"",pos_start,pos_end);
 
408
        }
 
409
        void appendPolarSamples(double pos)const
 
410
        {
 
411
                fprintf(mFile," %f",pos);
 
412
        }
 
413
        void endPolarSamples()const
 
414
        {
 
415
                fprintf(mFile,";\n");
 
416
        }
 
417
        void setPolarMap(const string& pom)
 
418
        {
 
419
                if(pom == "n/a") return;
 
420
                fprintf(mFile,"\tsetAttr \".pom\" -type \"string\" ");
 
421
                pom.write(mFile);
 
422
                fprintf(mFile,";\n");
 
423
        }
 
424
        void setPolarMapOffset(float pomo)
 
425
        {
 
426
                if(pomo == 0.0) return;
 
427
                fprintf(mFile,"\tsetAttr \".pomo\" %f;\n", pomo);
 
428
        }
 
429
        void setPolarMapMult(float pomm)
 
430
        {
 
431
                if(pomm == 1.0) return;
 
432
                fprintf(mFile,"\tsetAttr \".pomm\" %f;\n", pomm);
 
433
        }
 
434
        void setPolarNoise(float pon)
 
435
        {
 
436
                if(pon == 0.0) return;
 
437
                fprintf(mFile,"\tsetAttr \".pon\" %f;\n", pon);
 
438
        }
 
439
        void setPolarNoiseFreq(float ponf)
 
440
        {
 
441
                if(ponf == 10.0) return;
 
442
                fprintf(mFile,"\tsetAttr \".ponf\" %f;\n", ponf);
 
443
        }
 
444
        void setPolarSamplesDirty(int posd)
 
445
        {
 
446
                if(posd == 0.0) return;
 
447
                fprintf(mFile,"\tsetAttr \".posd\" %i;\n", posd);
 
448
        }
 
449
        void setPolarMapDirty(int pomd)
 
450
        {
 
451
                if(pomd == 0.0) return;
 
452
                fprintf(mFile,"\tsetAttr \".pomd\" %i;\n", pomd);
 
453
        }
 
454
        void setBaldness(float db)
 
455
        {
 
456
                if(db == 1.0) return;
 
457
                fprintf(mFile,"\tsetAttr \".db\" %f;\n", db);
 
458
        }
 
459
        void setBaldnessSamples(size_t bs_i,double bs)
 
460
        {
 
461
                if(bs == 0.0) return;
 
462
                fprintf(mFile,"\tsetAttr \".bs[%i]\" %f;\n", bs_i,bs);
 
463
        }
 
464
        void setBaldnessSamples(size_t bs_start,size_t bs_end,double* bs)
 
465
        {
 
466
                fprintf(mFile,"\tsetAttr \".bs[%i:%i]\" ", bs_start,bs_end);
 
467
                size_t size = (bs_end-bs_start)*1+1;
 
468
                for(size_t i=0;i<size;++i)
 
469
                {
 
470
                        fprintf(mFile,"%f",bs[i]);
 
471
                        if(i+1<size) fprintf(mFile," ");
 
472
                }
 
473
                fprintf(mFile,";\n");
 
474
        }
 
475
        void startBaldnessSamples(size_t bs_start,size_t bs_end)const
 
476
        {
 
477
                fprintf(mFile,"\tsetAttr \".bs[%i:%i]\"",bs_start,bs_end);
 
478
        }
 
479
        void appendBaldnessSamples(double bs)const
 
480
        {
 
481
                fprintf(mFile," %f",bs);
 
482
        }
 
483
        void endBaldnessSamples()const
 
484
        {
 
485
                fprintf(mFile,";\n");
 
486
        }
 
487
        void setBaldnessMap(const string& bm)
 
488
        {
 
489
                if(bm == "n/a") return;
 
490
                fprintf(mFile,"\tsetAttr \".bm\" -type \"string\" ");
 
491
                bm.write(mFile);
 
492
                fprintf(mFile,";\n");
 
493
        }
 
494
        void setBaldnessMapOffset(float bmo)
 
495
        {
 
496
                if(bmo == 0.0) return;
 
497
                fprintf(mFile,"\tsetAttr \".bmo\" %f;\n", bmo);
 
498
        }
 
499
        void setBaldnessMapMult(float bmm)
 
500
        {
 
501
                if(bmm == 1.0) return;
 
502
                fprintf(mFile,"\tsetAttr \".bmm\" %f;\n", bmm);
 
503
        }
 
504
        void setBaldnessNoise(float bn)
 
505
        {
 
506
                if(bn == 0.0) return;
 
507
                fprintf(mFile,"\tsetAttr \".bn\" %f;\n", bn);
 
508
        }
 
509
        void setBaldnessNoiseFreq(float bnf)
 
510
        {
 
511
                if(bnf == 10.0) return;
 
512
                fprintf(mFile,"\tsetAttr \".bnf\" %f;\n", bnf);
 
513
        }
 
514
        void setBaldnessSamplesDirty(int bsd)
 
515
        {
 
516
                if(bsd == 0.0) return;
 
517
                fprintf(mFile,"\tsetAttr \".bsd\" %i;\n", bsd);
 
518
        }
 
519
        void setBaldnessMapDirty(int bmd)
 
520
        {
 
521
                if(bmd == 0.0) return;
 
522
                fprintf(mFile,"\tsetAttr \".bmd\" %i;\n", bmd);
 
523
        }
 
524
        void setBaseOpacity(float dbo)
 
525
        {
 
526
                if(dbo == 1.0) return;
 
527
                fprintf(mFile,"\tsetAttr \".dbo\" %f;\n", dbo);
 
528
        }
 
529
        void setBaseOpacitySamples(size_t bos_i,double bos)
 
530
        {
 
531
                if(bos == 0.0) return;
 
532
                fprintf(mFile,"\tsetAttr \".bos[%i]\" %f;\n", bos_i,bos);
 
533
        }
 
534
        void setBaseOpacitySamples(size_t bos_start,size_t bos_end,double* bos)
 
535
        {
 
536
                fprintf(mFile,"\tsetAttr \".bos[%i:%i]\" ", bos_start,bos_end);
 
537
                size_t size = (bos_end-bos_start)*1+1;
 
538
                for(size_t i=0;i<size;++i)
 
539
                {
 
540
                        fprintf(mFile,"%f",bos[i]);
 
541
                        if(i+1<size) fprintf(mFile," ");
 
542
                }
 
543
                fprintf(mFile,";\n");
 
544
        }
 
545
        void startBaseOpacitySamples(size_t bos_start,size_t bos_end)const
 
546
        {
 
547
                fprintf(mFile,"\tsetAttr \".bos[%i:%i]\"",bos_start,bos_end);
 
548
        }
 
549
        void appendBaseOpacitySamples(double bos)const
 
550
        {
 
551
                fprintf(mFile," %f",bos);
 
552
        }
 
553
        void endBaseOpacitySamples()const
 
554
        {
 
555
                fprintf(mFile,";\n");
 
556
        }
 
557
        void setBaseOpacityMap(const string& bom)
 
558
        {
 
559
                if(bom == "n/a") return;
 
560
                fprintf(mFile,"\tsetAttr \".bom\" -type \"string\" ");
 
561
                bom.write(mFile);
 
562
                fprintf(mFile,";\n");
 
563
        }
 
564
        void setBaseOpacityMapOffset(float bomo)
 
565
        {
 
566
                if(bomo == 0.0) return;
 
567
                fprintf(mFile,"\tsetAttr \".bomo\" %f;\n", bomo);
 
568
        }
 
569
        void setBaseOpacityMapMult(float bomm)
 
570
        {
 
571
                if(bomm == 1.0) return;
 
572
                fprintf(mFile,"\tsetAttr \".bomm\" %f;\n", bomm);
 
573
        }
 
574
        void setBaseOpacityNoise(float bon)
 
575
        {
 
576
                if(bon == 0.0) return;
 
577
                fprintf(mFile,"\tsetAttr \".bon\" %f;\n", bon);
 
578
        }
 
579
        void setBaseOpacityNoiseFreq(float bonf)
 
580
        {
 
581
                if(bonf == 10.0) return;
 
582
                fprintf(mFile,"\tsetAttr \".bonf\" %f;\n", bonf);
 
583
        }
 
584
        void setBaseOpacitySamplesDirty(int bosd)
 
585
        {
 
586
                if(bosd == 0.0) return;
 
587
                fprintf(mFile,"\tsetAttr \".bosd\" %i;\n", bosd);
 
588
        }
 
589
        void setBaseOpacityMapDirty(int bomd)
 
590
        {
 
591
                if(bomd == 0.0) return;
 
592
                fprintf(mFile,"\tsetAttr \".bomd\" %i;\n", bomd);
 
593
        }
 
594
        void setTipOpacity(float dto)
 
595
        {
 
596
                if(dto == 1.0) return;
 
597
                fprintf(mFile,"\tsetAttr \".dto\" %f;\n", dto);
 
598
        }
 
599
        void setTipOpacitySamples(size_t tos_i,double tos)
 
600
        {
 
601
                if(tos == 0.0) return;
 
602
                fprintf(mFile,"\tsetAttr \".tos[%i]\" %f;\n", tos_i,tos);
 
603
        }
 
604
        void setTipOpacitySamples(size_t tos_start,size_t tos_end,double* tos)
 
605
        {
 
606
                fprintf(mFile,"\tsetAttr \".tos[%i:%i]\" ", tos_start,tos_end);
 
607
                size_t size = (tos_end-tos_start)*1+1;
 
608
                for(size_t i=0;i<size;++i)
 
609
                {
 
610
                        fprintf(mFile,"%f",tos[i]);
 
611
                        if(i+1<size) fprintf(mFile," ");
 
612
                }
 
613
                fprintf(mFile,";\n");
 
614
        }
 
615
        void startTipOpacitySamples(size_t tos_start,size_t tos_end)const
 
616
        {
 
617
                fprintf(mFile,"\tsetAttr \".tos[%i:%i]\"",tos_start,tos_end);
 
618
        }
 
619
        void appendTipOpacitySamples(double tos)const
 
620
        {
 
621
                fprintf(mFile," %f",tos);
 
622
        }
 
623
        void endTipOpacitySamples()const
 
624
        {
 
625
                fprintf(mFile,";\n");
 
626
        }
 
627
        void setTipOpacityMap(const string& tom)
 
628
        {
 
629
                if(tom == "n/a") return;
 
630
                fprintf(mFile,"\tsetAttr \".tom\" -type \"string\" ");
 
631
                tom.write(mFile);
 
632
                fprintf(mFile,";\n");
 
633
        }
 
634
        void setTipOpacityMapOffset(float tomo)
 
635
        {
 
636
                if(tomo == 0.0) return;
 
637
                fprintf(mFile,"\tsetAttr \".tomo\" %f;\n", tomo);
 
638
        }
 
639
        void setTipOpacityMapMult(float tomm)
 
640
        {
 
641
                if(tomm == 1.0) return;
 
642
                fprintf(mFile,"\tsetAttr \".tomm\" %f;\n", tomm);
 
643
        }
 
644
        void setTipOpacityNoise(float ton)
 
645
        {
 
646
                if(ton == 0.0) return;
 
647
                fprintf(mFile,"\tsetAttr \".ton\" %f;\n", ton);
 
648
        }
 
649
        void setTipOpacityNoiseFreq(float tonf)
 
650
        {
 
651
                if(tonf == 10.0) return;
 
652
                fprintf(mFile,"\tsetAttr \".tonf\" %f;\n", tonf);
 
653
        }
 
654
        void setTipOpacitySamplesDirty(int tosd)
 
655
        {
 
656
                if(tosd == 0.0) return;
 
657
                fprintf(mFile,"\tsetAttr \".tosd\" %i;\n", tosd);
 
658
        }
 
659
        void setTipOpacityMapDirty(int tomd)
 
660
        {
 
661
                if(tomd == 0.0) return;
 
662
                fprintf(mFile,"\tsetAttr \".tomd\" %i;\n", tomd);
 
663
        }
 
664
        void setBaseCurl(float dbcl)
 
665
        {
 
666
                if(dbcl == 0.50) return;
 
667
                fprintf(mFile,"\tsetAttr \".dbcl\" %f;\n", dbcl);
 
668
        }
 
669
        void setBaseCurlSamples(size_t bcls_i,double bcls)
 
670
        {
 
671
                if(bcls == 0.0) return;
 
672
                fprintf(mFile,"\tsetAttr \".bcls[%i]\" %f;\n", bcls_i,bcls);
 
673
        }
 
674
        void setBaseCurlSamples(size_t bcls_start,size_t bcls_end,double* bcls)
 
675
        {
 
676
                fprintf(mFile,"\tsetAttr \".bcls[%i:%i]\" ", bcls_start,bcls_end);
 
677
                size_t size = (bcls_end-bcls_start)*1+1;
 
678
                for(size_t i=0;i<size;++i)
 
679
                {
 
680
                        fprintf(mFile,"%f",bcls[i]);
 
681
                        if(i+1<size) fprintf(mFile," ");
 
682
                }
 
683
                fprintf(mFile,";\n");
 
684
        }
 
685
        void startBaseCurlSamples(size_t bcls_start,size_t bcls_end)const
 
686
        {
 
687
                fprintf(mFile,"\tsetAttr \".bcls[%i:%i]\"",bcls_start,bcls_end);
 
688
        }
 
689
        void appendBaseCurlSamples(double bcls)const
 
690
        {
 
691
                fprintf(mFile," %f",bcls);
 
692
        }
 
693
        void endBaseCurlSamples()const
 
694
        {
 
695
                fprintf(mFile,";\n");
 
696
        }
 
697
        void setBaseCurlMap(const string& bclm)
 
698
        {
 
699
                if(bclm == "n/a") return;
 
700
                fprintf(mFile,"\tsetAttr \".bclm\" -type \"string\" ");
 
701
                bclm.write(mFile);
 
702
                fprintf(mFile,";\n");
 
703
        }
 
704
        void setBaseCurlMapOffset(float bclmo)
 
705
        {
 
706
                if(bclmo == 0.0) return;
 
707
                fprintf(mFile,"\tsetAttr \".bclmo\" %f;\n", bclmo);
 
708
        }
 
709
        void setBaseCurlMapMult(float bclmm)
 
710
        {
 
711
                if(bclmm == 1.0) return;
 
712
                fprintf(mFile,"\tsetAttr \".bclmm\" %f;\n", bclmm);
 
713
        }
 
714
        void setBaseCurlNoise(float bcln)
 
715
        {
 
716
                if(bcln == 0.0) return;
 
717
                fprintf(mFile,"\tsetAttr \".bcln\" %f;\n", bcln);
 
718
        }
 
719
        void setBaseCurlNoiseFreq(float bclnf)
 
720
        {
 
721
                if(bclnf == 10.0) return;
 
722
                fprintf(mFile,"\tsetAttr \".bclnf\" %f;\n", bclnf);
 
723
        }
 
724
        void setBaseCurlSamplesDirty(int bclsd)
 
725
        {
 
726
                if(bclsd == 0.0) return;
 
727
                fprintf(mFile,"\tsetAttr \".bclsd\" %i;\n", bclsd);
 
728
        }
 
729
        void setBaseCurlMapDirty(int bclmd)
 
730
        {
 
731
                if(bclmd == 0.0) return;
 
732
                fprintf(mFile,"\tsetAttr \".bclmd\" %i;\n", bclmd);
 
733
        }
 
734
        void setTipCurl(float dtcl)
 
735
        {
 
736
                if(dtcl == 0.5) return;
 
737
                fprintf(mFile,"\tsetAttr \".dtcl\" %f;\n", dtcl);
 
738
        }
 
739
        void setTipCurlSamples(size_t tcls_i,double tcls)
 
740
        {
 
741
                if(tcls == 0.0) return;
 
742
                fprintf(mFile,"\tsetAttr \".tcls[%i]\" %f;\n", tcls_i,tcls);
 
743
        }
 
744
        void setTipCurlSamples(size_t tcls_start,size_t tcls_end,double* tcls)
 
745
        {
 
746
                fprintf(mFile,"\tsetAttr \".tcls[%i:%i]\" ", tcls_start,tcls_end);
 
747
                size_t size = (tcls_end-tcls_start)*1+1;
 
748
                for(size_t i=0;i<size;++i)
 
749
                {
 
750
                        fprintf(mFile,"%f",tcls[i]);
 
751
                        if(i+1<size) fprintf(mFile," ");
 
752
                }
 
753
                fprintf(mFile,";\n");
 
754
        }
 
755
        void startTipCurlSamples(size_t tcls_start,size_t tcls_end)const
 
756
        {
 
757
                fprintf(mFile,"\tsetAttr \".tcls[%i:%i]\"",tcls_start,tcls_end);
 
758
        }
 
759
        void appendTipCurlSamples(double tcls)const
 
760
        {
 
761
                fprintf(mFile," %f",tcls);
 
762
        }
 
763
        void endTipCurlSamples()const
 
764
        {
 
765
                fprintf(mFile,";\n");
 
766
        }
 
767
        void setTipCurlMap(const string& tclm)
 
768
        {
 
769
                if(tclm == "n/a") return;
 
770
                fprintf(mFile,"\tsetAttr \".tclm\" -type \"string\" ");
 
771
                tclm.write(mFile);
 
772
                fprintf(mFile,";\n");
 
773
        }
 
774
        void setTipCurlMapOffset(float tclmo)
 
775
        {
 
776
                if(tclmo == 0.0) return;
 
777
                fprintf(mFile,"\tsetAttr \".tclmo\" %f;\n", tclmo);
 
778
        }
 
779
        void setTipCurlMapMult(float tclmm)
 
780
        {
 
781
                if(tclmm == 1.0) return;
 
782
                fprintf(mFile,"\tsetAttr \".tclmm\" %f;\n", tclmm);
 
783
        }
 
784
        void setTipCurlNoise(float tcln)
 
785
        {
 
786
                if(tcln == 0.0) return;
 
787
                fprintf(mFile,"\tsetAttr \".tcln\" %f;\n", tcln);
 
788
        }
 
789
        void setTipCurlNoiseFreq(float tclnf)
 
790
        {
 
791
                if(tclnf == 10.0) return;
 
792
                fprintf(mFile,"\tsetAttr \".tclnf\" %f;\n", tclnf);
 
793
        }
 
794
        void setTipCurlSamplesDirty(int tclsd)
 
795
        {
 
796
                if(tclsd == 0.0) return;
 
797
                fprintf(mFile,"\tsetAttr \".tclsd\" %i;\n", tclsd);
 
798
        }
 
799
        void setTipCurlMapDirty(int tclmd)
 
800
        {
 
801
                if(tclmd == 0.0) return;
 
802
                fprintf(mFile,"\tsetAttr \".tclmd\" %i;\n", tclmd);
 
803
        }
 
804
        void setBaseWidth(double dbw)
 
805
        {
 
806
                if(dbw == 0) return;
 
807
                fprintf(mFile,"\tsetAttr \".dbw\" %f;\n", dbw);
 
808
        }
 
809
        void setBaseWidthSamples(size_t bws_i,double bws)
 
810
        {
 
811
                if(bws == 0.0) return;
 
812
                fprintf(mFile,"\tsetAttr \".bws[%i]\" %f;\n", bws_i,bws);
 
813
        }
 
814
        void setBaseWidthSamples(size_t bws_start,size_t bws_end,double* bws)
 
815
        {
 
816
                fprintf(mFile,"\tsetAttr \".bws[%i:%i]\" ", bws_start,bws_end);
 
817
                size_t size = (bws_end-bws_start)*1+1;
 
818
                for(size_t i=0;i<size;++i)
 
819
                {
 
820
                        fprintf(mFile,"%f",bws[i]);
 
821
                        if(i+1<size) fprintf(mFile," ");
 
822
                }
 
823
                fprintf(mFile,";\n");
 
824
        }
 
825
        void startBaseWidthSamples(size_t bws_start,size_t bws_end)const
 
826
        {
 
827
                fprintf(mFile,"\tsetAttr \".bws[%i:%i]\"",bws_start,bws_end);
 
828
        }
 
829
        void appendBaseWidthSamples(double bws)const
 
830
        {
 
831
                fprintf(mFile," %f",bws);
 
832
        }
 
833
        void endBaseWidthSamples()const
 
834
        {
 
835
                fprintf(mFile,";\n");
 
836
        }
 
837
        void setBaseWidthMap(const string& bwm)
 
838
        {
 
839
                if(bwm == "n/a") return;
 
840
                fprintf(mFile,"\tsetAttr \".bwm\" -type \"string\" ");
 
841
                bwm.write(mFile);
 
842
                fprintf(mFile,";\n");
 
843
        }
 
844
        void setBaseWidthMapOffset(double bwmo)
 
845
        {
 
846
                if(bwmo == 0) return;
 
847
                fprintf(mFile,"\tsetAttr \".bwmo\" %f;\n", bwmo);
 
848
        }
 
849
        void setBaseWidthMapMult(double bwmm)
 
850
        {
 
851
                if(bwmm == 1) return;
 
852
                fprintf(mFile,"\tsetAttr \".bwmm\" %f;\n", bwmm);
 
853
        }
 
854
        void setBaseWidthNoise(double bwn)
 
855
        {
 
856
                if(bwn == 0) return;
 
857
                fprintf(mFile,"\tsetAttr \".bwn\" %f;\n", bwn);
 
858
        }
 
859
        void setBaseWidthNoiseFreq(float bwnf)
 
860
        {
 
861
                if(bwnf == 10.0) return;
 
862
                fprintf(mFile,"\tsetAttr \".bwnf\" %f;\n", bwnf);
 
863
        }
 
864
        void setBaseWidthSamplesDirty(int bwsd)
 
865
        {
 
866
                if(bwsd == 0.0) return;
 
867
                fprintf(mFile,"\tsetAttr \".bwsd\" %i;\n", bwsd);
 
868
        }
 
869
        void setBaseWidthMapDirty(int bwmd)
 
870
        {
 
871
                if(bwmd == 0.0) return;
 
872
                fprintf(mFile,"\tsetAttr \".bwmd\" %i;\n", bwmd);
 
873
        }
 
874
        void setTipWidth(double dtw)
 
875
        {
 
876
                if(dtw == 0) return;
 
877
                fprintf(mFile,"\tsetAttr \".dtw\" %f;\n", dtw);
 
878
        }
 
879
        void setTipWidthSamples(size_t tws_i,double tws)
 
880
        {
 
881
                if(tws == 0.0) return;
 
882
                fprintf(mFile,"\tsetAttr \".tws[%i]\" %f;\n", tws_i,tws);
 
883
        }
 
884
        void setTipWidthSamples(size_t tws_start,size_t tws_end,double* tws)
 
885
        {
 
886
                fprintf(mFile,"\tsetAttr \".tws[%i:%i]\" ", tws_start,tws_end);
 
887
                size_t size = (tws_end-tws_start)*1+1;
 
888
                for(size_t i=0;i<size;++i)
 
889
                {
 
890
                        fprintf(mFile,"%f",tws[i]);
 
891
                        if(i+1<size) fprintf(mFile," ");
 
892
                }
 
893
                fprintf(mFile,";\n");
 
894
        }
 
895
        void startTipWidthSamples(size_t tws_start,size_t tws_end)const
 
896
        {
 
897
                fprintf(mFile,"\tsetAttr \".tws[%i:%i]\"",tws_start,tws_end);
 
898
        }
 
899
        void appendTipWidthSamples(double tws)const
 
900
        {
 
901
                fprintf(mFile," %f",tws);
 
902
        }
 
903
        void endTipWidthSamples()const
 
904
        {
 
905
                fprintf(mFile,";\n");
 
906
        }
 
907
        void setTipWidthMap(const string& twm)
 
908
        {
 
909
                if(twm == "n/a") return;
 
910
                fprintf(mFile,"\tsetAttr \".twm\" -type \"string\" ");
 
911
                twm.write(mFile);
 
912
                fprintf(mFile,";\n");
 
913
        }
 
914
        void setTipWidthMapOffset(double twmo)
 
915
        {
 
916
                if(twmo == 0) return;
 
917
                fprintf(mFile,"\tsetAttr \".twmo\" %f;\n", twmo);
 
918
        }
 
919
        void setTipWidthMapMult(double twmm)
 
920
        {
 
921
                if(twmm == 1) return;
 
922
                fprintf(mFile,"\tsetAttr \".twmm\" %f;\n", twmm);
 
923
        }
 
924
        void setTipWidthNoise(double twn)
 
925
        {
 
926
                if(twn == 0) return;
 
927
                fprintf(mFile,"\tsetAttr \".twn\" %f;\n", twn);
 
928
        }
 
929
        void setTipWidthNoiseFreq(float twnf)
 
930
        {
 
931
                if(twnf == 10.0) return;
 
932
                fprintf(mFile,"\tsetAttr \".twnf\" %f;\n", twnf);
 
933
        }
 
934
        void setTipWidthSamplesDirty(int twsd)
 
935
        {
 
936
                if(twsd == 0.0) return;
 
937
                fprintf(mFile,"\tsetAttr \".twsd\" %i;\n", twsd);
 
938
        }
 
939
        void setTipWidthMapDirty(int twmd)
 
940
        {
 
941
                if(twmd == 0.0) return;
 
942
                fprintf(mFile,"\tsetAttr \".twmd\" %i;\n", twmd);
 
943
        }
 
944
        void setScraggle(float ds)
 
945
        {
 
946
                if(ds == 0.0) return;
 
947
                fprintf(mFile,"\tsetAttr \".ds\" %f;\n", ds);
 
948
        }
 
949
        void setScraggleSamples(size_t ss_i,double ss)
 
950
        {
 
951
                if(ss == 0.0) return;
 
952
                fprintf(mFile,"\tsetAttr \".ss[%i]\" %f;\n", ss_i,ss);
 
953
        }
 
954
        void setScraggleSamples(size_t ss_start,size_t ss_end,double* ss)
 
955
        {
 
956
                fprintf(mFile,"\tsetAttr \".ss[%i:%i]\" ", ss_start,ss_end);
 
957
                size_t size = (ss_end-ss_start)*1+1;
 
958
                for(size_t i=0;i<size;++i)
 
959
                {
 
960
                        fprintf(mFile,"%f",ss[i]);
 
961
                        if(i+1<size) fprintf(mFile," ");
 
962
                }
 
963
                fprintf(mFile,";\n");
 
964
        }
 
965
        void startScraggleSamples(size_t ss_start,size_t ss_end)const
 
966
        {
 
967
                fprintf(mFile,"\tsetAttr \".ss[%i:%i]\"",ss_start,ss_end);
 
968
        }
 
969
        void appendScraggleSamples(double ss)const
 
970
        {
 
971
                fprintf(mFile," %f",ss);
 
972
        }
 
973
        void endScraggleSamples()const
 
974
        {
 
975
                fprintf(mFile,";\n");
 
976
        }
 
977
        void setScraggleMap(const string& sm)
 
978
        {
 
979
                if(sm == "n/a") return;
 
980
                fprintf(mFile,"\tsetAttr \".sm\" -type \"string\" ");
 
981
                sm.write(mFile);
 
982
                fprintf(mFile,";\n");
 
983
        }
 
984
        void setScraggleMapOffset(float smo)
 
985
        {
 
986
                if(smo == 0.0) return;
 
987
                fprintf(mFile,"\tsetAttr \".smo\" %f;\n", smo);
 
988
        }
 
989
        void setScraggleMapMult(float smm)
 
990
        {
 
991
                if(smm == 1.0) return;
 
992
                fprintf(mFile,"\tsetAttr \".smm\" %f;\n", smm);
 
993
        }
 
994
        void setScraggleNoise(float sn)
 
995
        {
 
996
                if(sn == 0.0) return;
 
997
                fprintf(mFile,"\tsetAttr \".sn\" %f;\n", sn);
 
998
        }
 
999
        void setScraggleNoiseFreq(float snf)
 
1000
        {
 
1001
                if(snf == 10.0) return;
 
1002
                fprintf(mFile,"\tsetAttr \".snf\" %f;\n", snf);
 
1003
        }
 
1004
        void setScraggleSamplesDirty(int ssd)
 
1005
        {
 
1006
                if(ssd == 0.0) return;
 
1007
                fprintf(mFile,"\tsetAttr \".ssd\" %i;\n", ssd);
 
1008
        }
 
1009
        void setScraggleMapDirty(int smd)
 
1010
        {
 
1011
                if(smd == 0.0) return;
 
1012
                fprintf(mFile,"\tsetAttr \".smd\" %i;\n", smd);
 
1013
        }
 
1014
        void setScraggleCorrelation(float dsco)
 
1015
        {
 
1016
                if(dsco == 0.0) return;
 
1017
                fprintf(mFile,"\tsetAttr \".dsco\" %f;\n", dsco);
 
1018
        }
 
1019
        void setScraggleCorrelationSamples(size_t scos_i,double scos)
 
1020
        {
 
1021
                if(scos == 0.0) return;
 
1022
                fprintf(mFile,"\tsetAttr \".scos[%i]\" %f;\n", scos_i,scos);
 
1023
        }
 
1024
        void setScraggleCorrelationSamples(size_t scos_start,size_t scos_end,double* scos)
 
1025
        {
 
1026
                fprintf(mFile,"\tsetAttr \".scos[%i:%i]\" ", scos_start,scos_end);
 
1027
                size_t size = (scos_end-scos_start)*1+1;
 
1028
                for(size_t i=0;i<size;++i)
 
1029
                {
 
1030
                        fprintf(mFile,"%f",scos[i]);
 
1031
                        if(i+1<size) fprintf(mFile," ");
 
1032
                }
 
1033
                fprintf(mFile,";\n");
 
1034
        }
 
1035
        void startScraggleCorrelationSamples(size_t scos_start,size_t scos_end)const
 
1036
        {
 
1037
                fprintf(mFile,"\tsetAttr \".scos[%i:%i]\"",scos_start,scos_end);
 
1038
        }
 
1039
        void appendScraggleCorrelationSamples(double scos)const
 
1040
        {
 
1041
                fprintf(mFile," %f",scos);
 
1042
        }
 
1043
        void endScraggleCorrelationSamples()const
 
1044
        {
 
1045
                fprintf(mFile,";\n");
 
1046
        }
 
1047
        void setScraggleCorrelationMap(const string& scom)
 
1048
        {
 
1049
                if(scom == "n/a") return;
 
1050
                fprintf(mFile,"\tsetAttr \".scom\" -type \"string\" ");
 
1051
                scom.write(mFile);
 
1052
                fprintf(mFile,";\n");
 
1053
        }
 
1054
        void setScraggleCorrelationMapOffset(float scomo)
 
1055
        {
 
1056
                if(scomo == 0.0) return;
 
1057
                fprintf(mFile,"\tsetAttr \".scomo\" %f;\n", scomo);
 
1058
        }
 
1059
        void setScraggleCorrelationMapMult(float scomm)
 
1060
        {
 
1061
                if(scomm == 1.0) return;
 
1062
                fprintf(mFile,"\tsetAttr \".scomm\" %f;\n", scomm);
 
1063
        }
 
1064
        void setScraggleCorrelationNoise(float scon)
 
1065
        {
 
1066
                if(scon == 0.0) return;
 
1067
                fprintf(mFile,"\tsetAttr \".scon\" %f;\n", scon);
 
1068
        }
 
1069
        void setScraggleCorrelationNoiseFreq(float sconf)
 
1070
        {
 
1071
                if(sconf == 10.0) return;
 
1072
                fprintf(mFile,"\tsetAttr \".sconf\" %f;\n", sconf);
 
1073
        }
 
1074
        void setScraggleCorrelationSamplesDirty(int scosd)
 
1075
        {
 
1076
                if(scosd == 0.0) return;
 
1077
                fprintf(mFile,"\tsetAttr \".scosd\" %i;\n", scosd);
 
1078
        }
 
1079
        void setScraggleCorrelationMapDirty(int scomd)
 
1080
        {
 
1081
                if(scomd == 0.0) return;
 
1082
                fprintf(mFile,"\tsetAttr \".scomd\" %i;\n", scomd);
 
1083
        }
 
1084
        void setScraggleFrequency(float dscf)
 
1085
        {
 
1086
                if(dscf == 5.0) return;
 
1087
                fprintf(mFile,"\tsetAttr \".dscf\" %f;\n", dscf);
 
1088
        }
 
1089
        void setScraggleFrequencySamples(size_t scfs_i,double scfs)
 
1090
        {
 
1091
                if(scfs == 0.0) return;
 
1092
                fprintf(mFile,"\tsetAttr \".scfs[%i]\" %f;\n", scfs_i,scfs);
 
1093
        }
 
1094
        void setScraggleFrequencySamples(size_t scfs_start,size_t scfs_end,double* scfs)
 
1095
        {
 
1096
                fprintf(mFile,"\tsetAttr \".scfs[%i:%i]\" ", scfs_start,scfs_end);
 
1097
                size_t size = (scfs_end-scfs_start)*1+1;
 
1098
                for(size_t i=0;i<size;++i)
 
1099
                {
 
1100
                        fprintf(mFile,"%f",scfs[i]);
 
1101
                        if(i+1<size) fprintf(mFile," ");
 
1102
                }
 
1103
                fprintf(mFile,";\n");
 
1104
        }
 
1105
        void startScraggleFrequencySamples(size_t scfs_start,size_t scfs_end)const
 
1106
        {
 
1107
                fprintf(mFile,"\tsetAttr \".scfs[%i:%i]\"",scfs_start,scfs_end);
 
1108
        }
 
1109
        void appendScraggleFrequencySamples(double scfs)const
 
1110
        {
 
1111
                fprintf(mFile," %f",scfs);
 
1112
        }
 
1113
        void endScraggleFrequencySamples()const
 
1114
        {
 
1115
                fprintf(mFile,";\n");
 
1116
        }
 
1117
        void setScraggleFrequencyMap(const string& scfm)
 
1118
        {
 
1119
                if(scfm == "n/a") return;
 
1120
                fprintf(mFile,"\tsetAttr \".scfm\" -type \"string\" ");
 
1121
                scfm.write(mFile);
 
1122
                fprintf(mFile,";\n");
 
1123
        }
 
1124
        void setScraggleFrequencyMapOffset(float scfmo)
 
1125
        {
 
1126
                if(scfmo == 0.0) return;
 
1127
                fprintf(mFile,"\tsetAttr \".scfmo\" %f;\n", scfmo);
 
1128
        }
 
1129
        void setScraggleFrequencyMapMult(float scfmm)
 
1130
        {
 
1131
                if(scfmm == 1.0) return;
 
1132
                fprintf(mFile,"\tsetAttr \".scfmm\" %f;\n", scfmm);
 
1133
        }
 
1134
        void setScraggleFrequencyNoise(float scfn)
 
1135
        {
 
1136
                if(scfn == 0.0) return;
 
1137
                fprintf(mFile,"\tsetAttr \".scfn\" %f;\n", scfn);
 
1138
        }
 
1139
        void setScraggleFrequencyNoiseFreq(float scfnf)
 
1140
        {
 
1141
                if(scfnf == 10.0) return;
 
1142
                fprintf(mFile,"\tsetAttr \".scfnf\" %f;\n", scfnf);
 
1143
        }
 
1144
        void setScraggleFrequencySamplesDirty(int scfsd)
 
1145
        {
 
1146
                if(scfsd == 0.0) return;
 
1147
                fprintf(mFile,"\tsetAttr \".scfsd\" %i;\n", scfsd);
 
1148
        }
 
1149
        void setScraggleFrequencyMapDirty(int scfmd)
 
1150
        {
 
1151
                if(scfmd == 0.0) return;
 
1152
                fprintf(mFile,"\tsetAttr \".scfmd\" %i;\n", scfmd);
 
1153
        }
 
1154
        void setSegments(float dseg)
 
1155
        {
 
1156
                if(dseg == 10) return;
 
1157
                fprintf(mFile,"\tsetAttr \".dseg\" %f;\n", dseg);
 
1158
        }
 
1159
        void setSegmentsSamples(size_t segs_i,double segs)
 
1160
        {
 
1161
                if(segs == 0.0) return;
 
1162
                fprintf(mFile,"\tsetAttr \".segs[%i]\" %f;\n", segs_i,segs);
 
1163
        }
 
1164
        void setSegmentsSamples(size_t segs_start,size_t segs_end,double* segs)
 
1165
        {
 
1166
                fprintf(mFile,"\tsetAttr \".segs[%i:%i]\" ", segs_start,segs_end);
 
1167
                size_t size = (segs_end-segs_start)*1+1;
 
1168
                for(size_t i=0;i<size;++i)
 
1169
                {
 
1170
                        fprintf(mFile,"%f",segs[i]);
 
1171
                        if(i+1<size) fprintf(mFile," ");
 
1172
                }
 
1173
                fprintf(mFile,";\n");
 
1174
        }
 
1175
        void startSegmentsSamples(size_t segs_start,size_t segs_end)const
 
1176
        {
 
1177
                fprintf(mFile,"\tsetAttr \".segs[%i:%i]\"",segs_start,segs_end);
 
1178
        }
 
1179
        void appendSegmentsSamples(double segs)const
 
1180
        {
 
1181
                fprintf(mFile," %f",segs);
 
1182
        }
 
1183
        void endSegmentsSamples()const
 
1184
        {
 
1185
                fprintf(mFile,";\n");
 
1186
        }
 
1187
        void setSegmentsMap(const string& segm)
 
1188
        {
 
1189
                if(segm == "n/a") return;
 
1190
                fprintf(mFile,"\tsetAttr \".segm\" -type \"string\" ");
 
1191
                segm.write(mFile);
 
1192
                fprintf(mFile,";\n");
 
1193
        }
 
1194
        void setSegmentsMapOffset(float segmo)
 
1195
        {
 
1196
                if(segmo == 0.0) return;
 
1197
                fprintf(mFile,"\tsetAttr \".segmo\" %f;\n", segmo);
 
1198
        }
 
1199
        void setSegmentsMapMult(float segmm)
 
1200
        {
 
1201
                if(segmm == 1.0) return;
 
1202
                fprintf(mFile,"\tsetAttr \".segmm\" %f;\n", segmm);
 
1203
        }
 
1204
        void setSegmentsNoise(float segn)
 
1205
        {
 
1206
                if(segn == 0.0) return;
 
1207
                fprintf(mFile,"\tsetAttr \".segn\" %f;\n", segn);
 
1208
        }
 
1209
        void setSegmentsNoiseFreq(float segnf)
 
1210
        {
 
1211
                if(segnf == 10.0) return;
 
1212
                fprintf(mFile,"\tsetAttr \".segnf\" %f;\n", segnf);
 
1213
        }
 
1214
        void setSegmentsSamplesDirty(int segsd)
 
1215
        {
 
1216
                if(segsd == 0.0) return;
 
1217
                fprintf(mFile,"\tsetAttr \".segsd\" %i;\n", segsd);
 
1218
        }
 
1219
        void setSegmentsMapDirty(int segmd)
 
1220
        {
 
1221
                if(segmd == 0.0) return;
 
1222
                fprintf(mFile,"\tsetAttr \".segmd\" %i;\n", segmd);
 
1223
        }
 
1224
        void setAttraction(float dat)
 
1225
        {
 
1226
                if(dat == 1.0) return;
 
1227
                fprintf(mFile,"\tsetAttr \".dat\" %f;\n", dat);
 
1228
        }
 
1229
        void setAttractionSamples(size_t ats_i,double ats)
 
1230
        {
 
1231
                if(ats == 0.0) return;
 
1232
                fprintf(mFile,"\tsetAttr \".ats[%i]\" %f;\n", ats_i,ats);
 
1233
        }
 
1234
        void setAttractionSamples(size_t ats_start,size_t ats_end,double* ats)
 
1235
        {
 
1236
                fprintf(mFile,"\tsetAttr \".ats[%i:%i]\" ", ats_start,ats_end);
 
1237
                size_t size = (ats_end-ats_start)*1+1;
 
1238
                for(size_t i=0;i<size;++i)
 
1239
                {
 
1240
                        fprintf(mFile,"%f",ats[i]);
 
1241
                        if(i+1<size) fprintf(mFile," ");
 
1242
                }
 
1243
                fprintf(mFile,";\n");
 
1244
        }
 
1245
        void startAttractionSamples(size_t ats_start,size_t ats_end)const
 
1246
        {
 
1247
                fprintf(mFile,"\tsetAttr \".ats[%i:%i]\"",ats_start,ats_end);
 
1248
        }
 
1249
        void appendAttractionSamples(double ats)const
 
1250
        {
 
1251
                fprintf(mFile," %f",ats);
 
1252
        }
 
1253
        void endAttractionSamples()const
 
1254
        {
 
1255
                fprintf(mFile,";\n");
 
1256
        }
 
1257
        void setAttractionMap(const string& atm)
 
1258
        {
 
1259
                if(atm == "n/a") return;
 
1260
                fprintf(mFile,"\tsetAttr \".atm\" -type \"string\" ");
 
1261
                atm.write(mFile);
 
1262
                fprintf(mFile,";\n");
 
1263
        }
 
1264
        void setAttractionMapOffset(float atmo)
 
1265
        {
 
1266
                if(atmo == 0.0) return;
 
1267
                fprintf(mFile,"\tsetAttr \".atmo\" %f;\n", atmo);
 
1268
        }
 
1269
        void setAttractionMapMult(float atmm)
 
1270
        {
 
1271
                if(atmm == 1.0) return;
 
1272
                fprintf(mFile,"\tsetAttr \".atmm\" %f;\n", atmm);
 
1273
        }
 
1274
        void setAttractionNoise(float atn)
 
1275
        {
 
1276
                if(atn == 0.0) return;
 
1277
                fprintf(mFile,"\tsetAttr \".atn\" %f;\n", atn);
 
1278
        }
 
1279
        void setAttractionNoiseFreq(float atnf)
 
1280
        {
 
1281
                if(atnf == 10.0) return;
 
1282
                fprintf(mFile,"\tsetAttr \".atnf\" %f;\n", atnf);
 
1283
        }
 
1284
        void setAttractionSamplesDirty(int atsd)
 
1285
        {
 
1286
                if(atsd == 0.0) return;
 
1287
                fprintf(mFile,"\tsetAttr \".atsd\" %i;\n", atsd);
 
1288
        }
 
1289
        void setAttractionMapDirty(int atmd)
 
1290
        {
 
1291
                if(atmd == 0.0) return;
 
1292
                fprintf(mFile,"\tsetAttr \".atmd\" %i;\n", atmd);
 
1293
        }
 
1294
        void setOffset(double dofs)
 
1295
        {
 
1296
                if(dofs == 0) return;
 
1297
                fprintf(mFile,"\tsetAttr \".dofs\" %f;\n", dofs);
 
1298
        }
 
1299
        void setOffsetSamples(size_t ofss_i,double ofss)
 
1300
        {
 
1301
                if(ofss == 0.0) return;
 
1302
                fprintf(mFile,"\tsetAttr \".ofss[%i]\" %f;\n", ofss_i,ofss);
 
1303
        }
 
1304
        void setOffsetSamples(size_t ofss_start,size_t ofss_end,double* ofss)
 
1305
        {
 
1306
                fprintf(mFile,"\tsetAttr \".ofss[%i:%i]\" ", ofss_start,ofss_end);
 
1307
                size_t size = (ofss_end-ofss_start)*1+1;
 
1308
                for(size_t i=0;i<size;++i)
 
1309
                {
 
1310
                        fprintf(mFile,"%f",ofss[i]);
 
1311
                        if(i+1<size) fprintf(mFile," ");
 
1312
                }
 
1313
                fprintf(mFile,";\n");
 
1314
        }
 
1315
        void startOffsetSamples(size_t ofss_start,size_t ofss_end)const
 
1316
        {
 
1317
                fprintf(mFile,"\tsetAttr \".ofss[%i:%i]\"",ofss_start,ofss_end);
 
1318
        }
 
1319
        void appendOffsetSamples(double ofss)const
 
1320
        {
 
1321
                fprintf(mFile," %f",ofss);
 
1322
        }
 
1323
        void endOffsetSamples()const
 
1324
        {
 
1325
                fprintf(mFile,";\n");
 
1326
        }
 
1327
        void setOffsetMap(const string& ofsm)
 
1328
        {
 
1329
                if(ofsm == "n/a") return;
 
1330
                fprintf(mFile,"\tsetAttr \".ofsm\" -type \"string\" ");
 
1331
                ofsm.write(mFile);
 
1332
                fprintf(mFile,";\n");
 
1333
        }
 
1334
        void setOffsetMapOffset(double ofsmo)
 
1335
        {
 
1336
                if(ofsmo == 0) return;
 
1337
                fprintf(mFile,"\tsetAttr \".ofsmo\" %f;\n", ofsmo);
 
1338
        }
 
1339
        void setOffsetMapMult(double ofsmm)
 
1340
        {
 
1341
                if(ofsmm == 1) return;
 
1342
                fprintf(mFile,"\tsetAttr \".ofsmm\" %f;\n", ofsmm);
 
1343
        }
 
1344
        void setOffsetNoise(double ofsn)
 
1345
        {
 
1346
                if(ofsn == 0) return;
 
1347
                fprintf(mFile,"\tsetAttr \".ofsn\" %f;\n", ofsn);
 
1348
        }
 
1349
        void setOffsetNoiseFreq(float ofsnf)
 
1350
        {
 
1351
                if(ofsnf == 10.0) return;
 
1352
                fprintf(mFile,"\tsetAttr \".ofsnf\" %f;\n", ofsnf);
 
1353
        }
 
1354
        void setOffsetSamplesDirty(int ofssd)
 
1355
        {
 
1356
                if(ofssd == 0.0) return;
 
1357
                fprintf(mFile,"\tsetAttr \".ofssd\" %i;\n", ofssd);
 
1358
        }
 
1359
        void setOffsetMapDirty(int ofsmd)
 
1360
        {
 
1361
                if(ofsmd == 0.0) return;
 
1362
                fprintf(mFile,"\tsetAttr \".ofsmd\" %i;\n", ofsmd);
 
1363
        }
 
1364
        void setClumping(float dc)
 
1365
        {
 
1366
                if(dc == 0.0) return;
 
1367
                fprintf(mFile,"\tsetAttr \".dc\" %f;\n", dc);
 
1368
        }
 
1369
        void setClumpingSamples(size_t cs_i,double cs)
 
1370
        {
 
1371
                if(cs == 0.0) return;
 
1372
                fprintf(mFile,"\tsetAttr \".cs[%i]\" %f;\n", cs_i,cs);
 
1373
        }
 
1374
        void setClumpingSamples(size_t cs_start,size_t cs_end,double* cs)
 
1375
        {
 
1376
                fprintf(mFile,"\tsetAttr \".cs[%i:%i]\" ", cs_start,cs_end);
 
1377
                size_t size = (cs_end-cs_start)*1+1;
 
1378
                for(size_t i=0;i<size;++i)
 
1379
                {
 
1380
                        fprintf(mFile,"%f",cs[i]);
 
1381
                        if(i+1<size) fprintf(mFile," ");
 
1382
                }
 
1383
                fprintf(mFile,";\n");
 
1384
        }
 
1385
        void startClumpingSamples(size_t cs_start,size_t cs_end)const
 
1386
        {
 
1387
                fprintf(mFile,"\tsetAttr \".cs[%i:%i]\"",cs_start,cs_end);
 
1388
        }
 
1389
        void appendClumpingSamples(double cs)const
 
1390
        {
 
1391
                fprintf(mFile," %f",cs);
 
1392
        }
 
1393
        void endClumpingSamples()const
 
1394
        {
 
1395
                fprintf(mFile,";\n");
 
1396
        }
 
1397
        void setClumpingMap(const string& cm)
 
1398
        {
 
1399
                if(cm == "n/a") return;
 
1400
                fprintf(mFile,"\tsetAttr \".cm\" -type \"string\" ");
 
1401
                cm.write(mFile);
 
1402
                fprintf(mFile,";\n");
 
1403
        }
 
1404
        void setClumpingMapOffset(float cmo)
 
1405
        {
 
1406
                if(cmo == 0.0) return;
 
1407
                fprintf(mFile,"\tsetAttr \".cmo\" %f;\n", cmo);
 
1408
        }
 
1409
        void setClumpingMapMult(float cmm)
 
1410
        {
 
1411
                if(cmm == 0.0) return;
 
1412
                fprintf(mFile,"\tsetAttr \".cmm\" %f;\n", cmm);
 
1413
        }
 
1414
        void setClumpingNoise(float cn)
 
1415
        {
 
1416
                if(cn == 0.0) return;
 
1417
                fprintf(mFile,"\tsetAttr \".cn\" %f;\n", cn);
 
1418
        }
 
1419
        void setClumpingNoiseFreq(float cnf)
 
1420
        {
 
1421
                if(cnf == 0.0) return;
 
1422
                fprintf(mFile,"\tsetAttr \".cnf\" %f;\n", cnf);
 
1423
        }
 
1424
        void setClumpingSamplesDirty(int csd)
 
1425
        {
 
1426
                if(csd == 0.0) return;
 
1427
                fprintf(mFile,"\tsetAttr \".csd\" %i;\n", csd);
 
1428
        }
 
1429
        void setClumpingMapDirty(int cmd)
 
1430
        {
 
1431
                if(cmd == 0.0) return;
 
1432
                fprintf(mFile,"\tsetAttr \".cmd\" %i;\n", cmd);
 
1433
        }
 
1434
        void setClumpingFrequency(float dcf)
 
1435
        {
 
1436
                if(dcf == 0.0) return;
 
1437
                fprintf(mFile,"\tsetAttr \".dcf\" %f;\n", dcf);
 
1438
        }
 
1439
        void setClumpingFrequencySamples(size_t cfs_i,double cfs)
 
1440
        {
 
1441
                if(cfs == 0.0) return;
 
1442
                fprintf(mFile,"\tsetAttr \".cfs[%i]\" %f;\n", cfs_i,cfs);
 
1443
        }
 
1444
        void setClumpingFrequencySamples(size_t cfs_start,size_t cfs_end,double* cfs)
 
1445
        {
 
1446
                fprintf(mFile,"\tsetAttr \".cfs[%i:%i]\" ", cfs_start,cfs_end);
 
1447
                size_t size = (cfs_end-cfs_start)*1+1;
 
1448
                for(size_t i=0;i<size;++i)
 
1449
                {
 
1450
                        fprintf(mFile,"%f",cfs[i]);
 
1451
                        if(i+1<size) fprintf(mFile," ");
 
1452
                }
 
1453
                fprintf(mFile,";\n");
 
1454
        }
 
1455
        void startClumpingFrequencySamples(size_t cfs_start,size_t cfs_end)const
 
1456
        {
 
1457
                fprintf(mFile,"\tsetAttr \".cfs[%i:%i]\"",cfs_start,cfs_end);
 
1458
        }
 
1459
        void appendClumpingFrequencySamples(double cfs)const
 
1460
        {
 
1461
                fprintf(mFile," %f",cfs);
 
1462
        }
 
1463
        void endClumpingFrequencySamples()const
 
1464
        {
 
1465
                fprintf(mFile,";\n");
 
1466
        }
 
1467
        void setClumpingFrequencyMap(const string& cfm)
 
1468
        {
 
1469
                if(cfm == "n/a") return;
 
1470
                fprintf(mFile,"\tsetAttr \".cfm\" -type \"string\" ");
 
1471
                cfm.write(mFile);
 
1472
                fprintf(mFile,";\n");
 
1473
        }
 
1474
        void setClumpingFrequencyMapOffset(float cfmo)
 
1475
        {
 
1476
                if(cfmo == 0.0) return;
 
1477
                fprintf(mFile,"\tsetAttr \".cfmo\" %f;\n", cfmo);
 
1478
        }
 
1479
        void setClumpingFrequencyMapMult(float cfmm)
 
1480
        {
 
1481
                if(cfmm == 0.0) return;
 
1482
                fprintf(mFile,"\tsetAttr \".cfmm\" %f;\n", cfmm);
 
1483
        }
 
1484
        void setClumpingFrequencyNoise(float cfn)
 
1485
        {
 
1486
                if(cfn == 0.0) return;
 
1487
                fprintf(mFile,"\tsetAttr \".cfn\" %f;\n", cfn);
 
1488
        }
 
1489
        void setClumpingFrequencyNoiseFreq(float cfnf)
 
1490
        {
 
1491
                if(cfnf == 0.0) return;
 
1492
                fprintf(mFile,"\tsetAttr \".cfnf\" %f;\n", cfnf);
 
1493
        }
 
1494
        void setClumpingFrequencySamplesDirty(int cfsd)
 
1495
        {
 
1496
                if(cfsd == 0.0) return;
 
1497
                fprintf(mFile,"\tsetAttr \".cfsd\" %i;\n", cfsd);
 
1498
        }
 
1499
        void setClumpingFrequencyMapDirty(int cfmd)
 
1500
        {
 
1501
                if(cfmd == 0.0) return;
 
1502
                fprintf(mFile,"\tsetAttr \".cfmd\" %i;\n", cfmd);
 
1503
        }
 
1504
        void setClumpingShape(float dcs)
 
1505
        {
 
1506
                if(dcs == 0.0) return;
 
1507
                fprintf(mFile,"\tsetAttr \".dcs\" %f;\n", dcs);
 
1508
        }
 
1509
        void setClumpingShapeSamples(size_t css_i,double css)
 
1510
        {
 
1511
                if(css == 0.0) return;
 
1512
                fprintf(mFile,"\tsetAttr \".css[%i]\" %f;\n", css_i,css);
 
1513
        }
 
1514
        void setClumpingShapeSamples(size_t css_start,size_t css_end,double* css)
 
1515
        {
 
1516
                fprintf(mFile,"\tsetAttr \".css[%i:%i]\" ", css_start,css_end);
 
1517
                size_t size = (css_end-css_start)*1+1;
 
1518
                for(size_t i=0;i<size;++i)
 
1519
                {
 
1520
                        fprintf(mFile,"%f",css[i]);
 
1521
                        if(i+1<size) fprintf(mFile," ");
 
1522
                }
 
1523
                fprintf(mFile,";\n");
 
1524
        }
 
1525
        void startClumpingShapeSamples(size_t css_start,size_t css_end)const
 
1526
        {
 
1527
                fprintf(mFile,"\tsetAttr \".css[%i:%i]\"",css_start,css_end);
 
1528
        }
 
1529
        void appendClumpingShapeSamples(double css)const
 
1530
        {
 
1531
                fprintf(mFile," %f",css);
 
1532
        }
 
1533
        void endClumpingShapeSamples()const
 
1534
        {
 
1535
                fprintf(mFile,";\n");
 
1536
        }
 
1537
        void setClumpingShapeMap(const string& csm)
 
1538
        {
 
1539
                if(csm == "n/a") return;
 
1540
                fprintf(mFile,"\tsetAttr \".csm\" -type \"string\" ");
 
1541
                csm.write(mFile);
 
1542
                fprintf(mFile,";\n");
 
1543
        }
 
1544
        void setClumpingShapeMapOffset(float csmo)
 
1545
        {
 
1546
                if(csmo == 0.0) return;
 
1547
                fprintf(mFile,"\tsetAttr \".csmo\" %f;\n", csmo);
 
1548
        }
 
1549
        void setClumpingShapeMapMult(float csmm)
 
1550
        {
 
1551
                if(csmm == 0.0) return;
 
1552
                fprintf(mFile,"\tsetAttr \".csmm\" %f;\n", csmm);
 
1553
        }
 
1554
        void setClumpingShapeNoise(float csn)
 
1555
        {
 
1556
                if(csn == 0.0) return;
 
1557
                fprintf(mFile,"\tsetAttr \".csn\" %f;\n", csn);
 
1558
        }
 
1559
        void setClumpingShapeNoiseFreq(float csnf)
 
1560
        {
 
1561
                if(csnf == 0.0) return;
 
1562
                fprintf(mFile,"\tsetAttr \".csnf\" %f;\n", csnf);
 
1563
        }
 
1564
        void setClumpingShapeSamplesDirty(int cssd)
 
1565
        {
 
1566
                if(cssd == 0.0) return;
 
1567
                fprintf(mFile,"\tsetAttr \".cssd\" %i;\n", cssd);
 
1568
        }
 
1569
        void setClumpingShapeMapDirty(int csmd)
 
1570
        {
 
1571
                if(csmd == 0.0) return;
 
1572
                fprintf(mFile,"\tsetAttr \".csmd\" %i;\n", csmd);
 
1573
        }
 
1574
        void setBaseColor(const float3& dbc)
 
1575
        {
 
1576
                if(dbc == float3(1.0f,1.0f,1.0f)) return;
 
1577
                fprintf(mFile,"\tsetAttr \".dbc\" -type \"float3\" ");
 
1578
                dbc.write(mFile);
 
1579
                fprintf(mFile,";\n");
 
1580
        }
 
1581
        void setBaseColorR(float dbcr)
 
1582
        {
 
1583
                if(dbcr == 1.0) return;
 
1584
                fprintf(mFile,"\tsetAttr \".dbcr\" %f;\n", dbcr);
 
1585
        }
 
1586
        void setBaseColorG(float dbcg)
 
1587
        {
 
1588
                if(dbcg == 1.0) return;
 
1589
                fprintf(mFile,"\tsetAttr \".dbcg\" %f;\n", dbcg);
 
1590
        }
 
1591
        void setBaseColorB(float dbcb)
 
1592
        {
 
1593
                if(dbcb == 1.0) return;
 
1594
                fprintf(mFile,"\tsetAttr \".dbcb\" %f;\n", dbcb);
 
1595
        }
 
1596
        void setBaseColorSamples(size_t bcs_i,double bcs)
 
1597
        {
 
1598
                if(bcs == 0.0) return;
 
1599
                fprintf(mFile,"\tsetAttr \".bcs[%i]\" %f;\n", bcs_i,bcs);
 
1600
        }
 
1601
        void setBaseColorSamples(size_t bcs_start,size_t bcs_end,double* bcs)
 
1602
        {
 
1603
                fprintf(mFile,"\tsetAttr \".bcs[%i:%i]\" ", bcs_start,bcs_end);
 
1604
                size_t size = (bcs_end-bcs_start)*1+1;
 
1605
                for(size_t i=0;i<size;++i)
 
1606
                {
 
1607
                        fprintf(mFile,"%f",bcs[i]);
 
1608
                        if(i+1<size) fprintf(mFile," ");
 
1609
                }
 
1610
                fprintf(mFile,";\n");
 
1611
        }
 
1612
        void startBaseColorSamples(size_t bcs_start,size_t bcs_end)const
 
1613
        {
 
1614
                fprintf(mFile,"\tsetAttr \".bcs[%i:%i]\"",bcs_start,bcs_end);
 
1615
        }
 
1616
        void appendBaseColorSamples(double bcs)const
 
1617
        {
 
1618
                fprintf(mFile," %f",bcs);
 
1619
        }
 
1620
        void endBaseColorSamples()const
 
1621
        {
 
1622
                fprintf(mFile,";\n");
 
1623
        }
 
1624
        void setBaseColorMap(const string& bcm)
 
1625
        {
 
1626
                if(bcm == "n/a") return;
 
1627
                fprintf(mFile,"\tsetAttr \".bcm\" -type \"string\" ");
 
1628
                bcm.write(mFile);
 
1629
                fprintf(mFile,";\n");
 
1630
        }
 
1631
        void setBaseColorNoise(float bcn)
 
1632
        {
 
1633
                if(bcn == 0.0) return;
 
1634
                fprintf(mFile,"\tsetAttr \".bcn\" %f;\n", bcn);
 
1635
        }
 
1636
        void setBaseColorNoiseFreq(float bcnf)
 
1637
        {
 
1638
                if(bcnf == 10.0) return;
 
1639
                fprintf(mFile,"\tsetAttr \".bcnf\" %f;\n", bcnf);
 
1640
        }
 
1641
        void setBaseColorSamplesDirty(int bcsd)
 
1642
        {
 
1643
                if(bcsd == 0.0) return;
 
1644
                fprintf(mFile,"\tsetAttr \".bcsd\" %i;\n", bcsd);
 
1645
        }
 
1646
        void setBaseColorMapDirty(int bcmd)
 
1647
        {
 
1648
                if(bcmd == 0.0) return;
 
1649
                fprintf(mFile,"\tsetAttr \".bcmd\" %i;\n", bcmd);
 
1650
        }
 
1651
        void setTipColor(const float3& dtc)
 
1652
        {
 
1653
                if(dtc == float3(1.0f,1.0f,1.0f)) return;
 
1654
                fprintf(mFile,"\tsetAttr \".dtc\" -type \"float3\" ");
 
1655
                dtc.write(mFile);
 
1656
                fprintf(mFile,";\n");
 
1657
        }
 
1658
        void setTipColorR(float dtcr)
 
1659
        {
 
1660
                if(dtcr == 1.0) return;
 
1661
                fprintf(mFile,"\tsetAttr \".dtcr\" %f;\n", dtcr);
 
1662
        }
 
1663
        void setTipColorG(float dtcg)
 
1664
        {
 
1665
                if(dtcg == 1.0) return;
 
1666
                fprintf(mFile,"\tsetAttr \".dtcg\" %f;\n", dtcg);
 
1667
        }
 
1668
        void setTipColorB(float dtcb)
 
1669
        {
 
1670
                if(dtcb == 1.0) return;
 
1671
                fprintf(mFile,"\tsetAttr \".dtcb\" %f;\n", dtcb);
 
1672
        }
 
1673
        void setTipColorSamples(size_t tcs_i,double tcs)
 
1674
        {
 
1675
                if(tcs == 0.0) return;
 
1676
                fprintf(mFile,"\tsetAttr \".tcs[%i]\" %f;\n", tcs_i,tcs);
 
1677
        }
 
1678
        void setTipColorSamples(size_t tcs_start,size_t tcs_end,double* tcs)
 
1679
        {
 
1680
                fprintf(mFile,"\tsetAttr \".tcs[%i:%i]\" ", tcs_start,tcs_end);
 
1681
                size_t size = (tcs_end-tcs_start)*1+1;
 
1682
                for(size_t i=0;i<size;++i)
 
1683
                {
 
1684
                        fprintf(mFile,"%f",tcs[i]);
 
1685
                        if(i+1<size) fprintf(mFile," ");
 
1686
                }
 
1687
                fprintf(mFile,";\n");
 
1688
        }
 
1689
        void startTipColorSamples(size_t tcs_start,size_t tcs_end)const
 
1690
        {
 
1691
                fprintf(mFile,"\tsetAttr \".tcs[%i:%i]\"",tcs_start,tcs_end);
 
1692
        }
 
1693
        void appendTipColorSamples(double tcs)const
 
1694
        {
 
1695
                fprintf(mFile," %f",tcs);
 
1696
        }
 
1697
        void endTipColorSamples()const
 
1698
        {
 
1699
                fprintf(mFile,";\n");
 
1700
        }
 
1701
        void setTipColorMap(const string& tcm)
 
1702
        {
 
1703
                if(tcm == "n/a") return;
 
1704
                fprintf(mFile,"\tsetAttr \".tcm\" -type \"string\" ");
 
1705
                tcm.write(mFile);
 
1706
                fprintf(mFile,";\n");
 
1707
        }
 
1708
        void setTipColorNoise(float tcn)
 
1709
        {
 
1710
                if(tcn == 0.0) return;
 
1711
                fprintf(mFile,"\tsetAttr \".tcn\" %f;\n", tcn);
 
1712
        }
 
1713
        void setTipColorNoiseFreq(float tcnf)
 
1714
        {
 
1715
                if(tcnf == 10.0) return;
 
1716
                fprintf(mFile,"\tsetAttr \".tcnf\" %f;\n", tcnf);
 
1717
        }
 
1718
        void setTipColorSamplesDirty(int tcsd)
 
1719
        {
 
1720
                if(tcsd == 0.0) return;
 
1721
                fprintf(mFile,"\tsetAttr \".tcsd\" %i;\n", tcsd);
 
1722
        }
 
1723
        void setTipColorMapDirty(int tcmd)
 
1724
        {
 
1725
                if(tcmd == 0.0) return;
 
1726
                fprintf(mFile,"\tsetAttr \".tcmd\" %i;\n", tcmd);
 
1727
        }
 
1728
        void setRadius(double dar)
 
1729
        {
 
1730
                if(dar == 1) return;
 
1731
                fprintf(mFile,"\tsetAttr \".dar\" %f;\n", dar);
 
1732
        }
 
1733
        void setRadiusSamples(size_t ars_i,double ars)
 
1734
        {
 
1735
                if(ars == 0.0) return;
 
1736
                fprintf(mFile,"\tsetAttr \".ars[%i]\" %f;\n", ars_i,ars);
 
1737
        }
 
1738
        void setRadiusSamples(size_t ars_start,size_t ars_end,double* ars)
 
1739
        {
 
1740
                fprintf(mFile,"\tsetAttr \".ars[%i:%i]\" ", ars_start,ars_end);
 
1741
                size_t size = (ars_end-ars_start)*1+1;
 
1742
                for(size_t i=0;i<size;++i)
 
1743
                {
 
1744
                        fprintf(mFile,"%f",ars[i]);
 
1745
                        if(i+1<size) fprintf(mFile," ");
 
1746
                }
 
1747
                fprintf(mFile,";\n");
 
1748
        }
 
1749
        void startRadiusSamples(size_t ars_start,size_t ars_end)const
 
1750
        {
 
1751
                fprintf(mFile,"\tsetAttr \".ars[%i:%i]\"",ars_start,ars_end);
 
1752
        }
 
1753
        void appendRadiusSamples(double ars)const
 
1754
        {
 
1755
                fprintf(mFile," %f",ars);
 
1756
        }
 
1757
        void endRadiusSamples()const
 
1758
        {
 
1759
                fprintf(mFile,";\n");
 
1760
        }
 
1761
        void setRadiusMap(const string& arm)
 
1762
        {
 
1763
                if(arm == "n/a") return;
 
1764
                fprintf(mFile,"\tsetAttr \".arm\" -type \"string\" ");
 
1765
                arm.write(mFile);
 
1766
                fprintf(mFile,";\n");
 
1767
        }
 
1768
        void setRadiusMapOffset(double armo)
 
1769
        {
 
1770
                if(armo == 0) return;
 
1771
                fprintf(mFile,"\tsetAttr \".armo\" %f;\n", armo);
 
1772
        }
 
1773
        void setRadiusMapMult(double armm)
 
1774
        {
 
1775
                if(armm == 1) return;
 
1776
                fprintf(mFile,"\tsetAttr \".armm\" %f;\n", armm);
 
1777
        }
 
1778
        void setRadiusNoise(double arn)
 
1779
        {
 
1780
                if(arn == 0) return;
 
1781
                fprintf(mFile,"\tsetAttr \".arn\" %f;\n", arn);
 
1782
        }
 
1783
        void setRadiusNoiseFreq(float arnf)
 
1784
        {
 
1785
                if(arnf == 10.0) return;
 
1786
                fprintf(mFile,"\tsetAttr \".arnf\" %f;\n", arnf);
 
1787
        }
 
1788
        void setRadiusSamplesDirty(int arsd)
 
1789
        {
 
1790
                if(arsd == 0.0) return;
 
1791
                fprintf(mFile,"\tsetAttr \".arsd\" %i;\n", arsd);
 
1792
        }
 
1793
        void setRadiusMapDirty(int armd)
 
1794
        {
 
1795
                if(armd == 0.0) return;
 
1796
                fprintf(mFile,"\tsetAttr \".armd\" %i;\n", armd);
 
1797
        }
 
1798
        void setPower(float dap)
 
1799
        {
 
1800
                if(dap == 1.0) return;
 
1801
                fprintf(mFile,"\tsetAttr \".dap\" %f;\n", dap);
 
1802
        }
 
1803
        void setPowerSamples(size_t aps_i,double aps)
 
1804
        {
 
1805
                if(aps == 0.0) return;
 
1806
                fprintf(mFile,"\tsetAttr \".aps[%i]\" %f;\n", aps_i,aps);
 
1807
        }
 
1808
        void setPowerSamples(size_t aps_start,size_t aps_end,double* aps)
 
1809
        {
 
1810
                fprintf(mFile,"\tsetAttr \".aps[%i:%i]\" ", aps_start,aps_end);
 
1811
                size_t size = (aps_end-aps_start)*1+1;
 
1812
                for(size_t i=0;i<size;++i)
 
1813
                {
 
1814
                        fprintf(mFile,"%f",aps[i]);
 
1815
                        if(i+1<size) fprintf(mFile," ");
 
1816
                }
 
1817
                fprintf(mFile,";\n");
 
1818
        }
 
1819
        void startPowerSamples(size_t aps_start,size_t aps_end)const
 
1820
        {
 
1821
                fprintf(mFile,"\tsetAttr \".aps[%i:%i]\"",aps_start,aps_end);
 
1822
        }
 
1823
        void appendPowerSamples(double aps)const
 
1824
        {
 
1825
                fprintf(mFile," %f",aps);
 
1826
        }
 
1827
        void endPowerSamples()const
 
1828
        {
 
1829
                fprintf(mFile,";\n");
 
1830
        }
 
1831
        void setPowerMap(const string& apm)
 
1832
        {
 
1833
                if(apm == "n/a") return;
 
1834
                fprintf(mFile,"\tsetAttr \".apm\" -type \"string\" ");
 
1835
                apm.write(mFile);
 
1836
                fprintf(mFile,";\n");
 
1837
        }
 
1838
        void setPowerMapOffset(float apmo)
 
1839
        {
 
1840
                if(apmo == 0.0) return;
 
1841
                fprintf(mFile,"\tsetAttr \".apmo\" %f;\n", apmo);
 
1842
        }
 
1843
        void setPowerMapMult(float apmm)
 
1844
        {
 
1845
                if(apmm == 1.0) return;
 
1846
                fprintf(mFile,"\tsetAttr \".apmm\" %f;\n", apmm);
 
1847
        }
 
1848
        void setPowerNoise(float apn)
 
1849
        {
 
1850
                if(apn == 0.0) return;
 
1851
                fprintf(mFile,"\tsetAttr \".apn\" %f;\n", apn);
 
1852
        }
 
1853
        void setPowerNoiseFreq(float apnf)
 
1854
        {
 
1855
                if(apnf == 10.0) return;
 
1856
                fprintf(mFile,"\tsetAttr \".apnf\" %f;\n", apnf);
 
1857
        }
 
1858
        void setPowerSamplesDirty(int apsd)
 
1859
        {
 
1860
                if(apsd == 0.0) return;
 
1861
                fprintf(mFile,"\tsetAttr \".apsd\" %i;\n", apsd);
 
1862
        }
 
1863
        void setPowerMapDirty(int apmd)
 
1864
        {
 
1865
                if(apmd == 0.0) return;
 
1866
                fprintf(mFile,"\tsetAttr \".apmd\" %i;\n", apmd);
 
1867
        }
 
1868
        void setInfluence(float dai)
 
1869
        {
 
1870
                if(dai == 1.0) return;
 
1871
                fprintf(mFile,"\tsetAttr \".dai\" %f;\n", dai);
 
1872
        }
 
1873
        void setInfluenceSamples(size_t ais_i,double ais)
 
1874
        {
 
1875
                if(ais == 0.0) return;
 
1876
                fprintf(mFile,"\tsetAttr \".ais[%i]\" %f;\n", ais_i,ais);
 
1877
        }
 
1878
        void setInfluenceSamples(size_t ais_start,size_t ais_end,double* ais)
 
1879
        {
 
1880
                fprintf(mFile,"\tsetAttr \".ais[%i:%i]\" ", ais_start,ais_end);
 
1881
                size_t size = (ais_end-ais_start)*1+1;
 
1882
                for(size_t i=0;i<size;++i)
 
1883
                {
 
1884
                        fprintf(mFile,"%f",ais[i]);
 
1885
                        if(i+1<size) fprintf(mFile," ");
 
1886
                }
 
1887
                fprintf(mFile,";\n");
 
1888
        }
 
1889
        void startInfluenceSamples(size_t ais_start,size_t ais_end)const
 
1890
        {
 
1891
                fprintf(mFile,"\tsetAttr \".ais[%i:%i]\"",ais_start,ais_end);
 
1892
        }
 
1893
        void appendInfluenceSamples(double ais)const
 
1894
        {
 
1895
                fprintf(mFile," %f",ais);
 
1896
        }
 
1897
        void endInfluenceSamples()const
 
1898
        {
 
1899
                fprintf(mFile,";\n");
 
1900
        }
 
1901
        void setInfluenceMap(const string& aim)
 
1902
        {
 
1903
                if(aim == "n/a") return;
 
1904
                fprintf(mFile,"\tsetAttr \".aim\" -type \"string\" ");
 
1905
                aim.write(mFile);
 
1906
                fprintf(mFile,";\n");
 
1907
        }
 
1908
        void setInfluenceMapOffset(float aimo)
 
1909
        {
 
1910
                if(aimo == 0.0) return;
 
1911
                fprintf(mFile,"\tsetAttr \".aimo\" %f;\n", aimo);
 
1912
        }
 
1913
        void setInfluenceMapMult(float aimm)
 
1914
        {
 
1915
                if(aimm == 1.0) return;
 
1916
                fprintf(mFile,"\tsetAttr \".aimm\" %f;\n", aimm);
 
1917
        }
 
1918
        void setInfluenceNoise(float ain)
 
1919
        {
 
1920
                if(ain == 0.0) return;
 
1921
                fprintf(mFile,"\tsetAttr \".ain\" %f;\n", ain);
 
1922
        }
 
1923
        void setInfluenceNoiseFreq(float ainf)
 
1924
        {
 
1925
                if(ainf == 10.0) return;
 
1926
                fprintf(mFile,"\tsetAttr \".ainf\" %f;\n", ainf);
 
1927
        }
 
1928
        void setInfluenceSamplesDirty(int aisd)
 
1929
        {
 
1930
                if(aisd == 0.0) return;
 
1931
                fprintf(mFile,"\tsetAttr \".aisd\" %i;\n", aisd);
 
1932
        }
 
1933
        void setInfluenceMapDirty(int aimd)
 
1934
        {
 
1935
                if(aimd == 0.0) return;
 
1936
                fprintf(mFile,"\tsetAttr \".aimd\" %i;\n", aimd);
 
1937
        }
 
1938
        void setStartLength(double dasl)
 
1939
        {
 
1940
                if(dasl == 0) return;
 
1941
                fprintf(mFile,"\tsetAttr \".dasl\" %f;\n", dasl);
 
1942
        }
 
1943
        void setStartLengthSamples(size_t asls_i,double asls)
 
1944
        {
 
1945
                if(asls == 0.0) return;
 
1946
                fprintf(mFile,"\tsetAttr \".asls[%i]\" %f;\n", asls_i,asls);
 
1947
        }
 
1948
        void setStartLengthSamples(size_t asls_start,size_t asls_end,double* asls)
 
1949
        {
 
1950
                fprintf(mFile,"\tsetAttr \".asls[%i:%i]\" ", asls_start,asls_end);
 
1951
                size_t size = (asls_end-asls_start)*1+1;
 
1952
                for(size_t i=0;i<size;++i)
 
1953
                {
 
1954
                        fprintf(mFile,"%f",asls[i]);
 
1955
                        if(i+1<size) fprintf(mFile," ");
 
1956
                }
 
1957
                fprintf(mFile,";\n");
 
1958
        }
 
1959
        void startStartLengthSamples(size_t asls_start,size_t asls_end)const
 
1960
        {
 
1961
                fprintf(mFile,"\tsetAttr \".asls[%i:%i]\"",asls_start,asls_end);
 
1962
        }
 
1963
        void appendStartLengthSamples(double asls)const
 
1964
        {
 
1965
                fprintf(mFile," %f",asls);
 
1966
        }
 
1967
        void endStartLengthSamples()const
 
1968
        {
 
1969
                fprintf(mFile,";\n");
 
1970
        }
 
1971
        void setStartLengthMap(const string& aslm)
 
1972
        {
 
1973
                if(aslm == "n/a") return;
 
1974
                fprintf(mFile,"\tsetAttr \".aslm\" -type \"string\" ");
 
1975
                aslm.write(mFile);
 
1976
                fprintf(mFile,";\n");
 
1977
        }
 
1978
        void setStartLengthMapOffset(double aslmo)
 
1979
        {
 
1980
                if(aslmo == 0) return;
 
1981
                fprintf(mFile,"\tsetAttr \".aslmo\" %f;\n", aslmo);
 
1982
        }
 
1983
        void setStartLengthMapMult(double aslmm)
 
1984
        {
 
1985
                if(aslmm == 1) return;
 
1986
                fprintf(mFile,"\tsetAttr \".aslmm\" %f;\n", aslmm);
 
1987
        }
 
1988
        void setStartLengthNoise(double asln)
 
1989
        {
 
1990
                if(asln == 0) return;
 
1991
                fprintf(mFile,"\tsetAttr \".asln\" %f;\n", asln);
 
1992
        }
 
1993
        void setStartLengthNoiseFreq(float aslnf)
 
1994
        {
 
1995
                if(aslnf == 10.0) return;
 
1996
                fprintf(mFile,"\tsetAttr \".aslnf\" %f;\n", aslnf);
 
1997
        }
 
1998
        void setStartLengthSamplesDirty(int aslsd)
 
1999
        {
 
2000
                if(aslsd == 0.0) return;
 
2001
                fprintf(mFile,"\tsetAttr \".aslsd\" %i;\n", aslsd);
 
2002
        }
 
2003
        void setStartLengthMapDirty(int aslmd)
 
2004
        {
 
2005
                if(aslmd == 0.0) return;
 
2006
                fprintf(mFile,"\tsetAttr \".aslmd\" %i;\n", aslmd);
 
2007
        }
 
2008
        void setEndLength(double dael)
 
2009
        {
 
2010
                if(dael == 5) return;
 
2011
                fprintf(mFile,"\tsetAttr \".dael\" %f;\n", dael);
 
2012
        }
 
2013
        void setEndLengthSamples(size_t aels_i,double aels)
 
2014
        {
 
2015
                if(aels == 0.0) return;
 
2016
                fprintf(mFile,"\tsetAttr \".aels[%i]\" %f;\n", aels_i,aels);
 
2017
        }
 
2018
        void setEndLengthSamples(size_t aels_start,size_t aels_end,double* aels)
 
2019
        {
 
2020
                fprintf(mFile,"\tsetAttr \".aels[%i:%i]\" ", aels_start,aels_end);
 
2021
                size_t size = (aels_end-aels_start)*1+1;
 
2022
                for(size_t i=0;i<size;++i)
 
2023
                {
 
2024
                        fprintf(mFile,"%f",aels[i]);
 
2025
                        if(i+1<size) fprintf(mFile," ");
 
2026
                }
 
2027
                fprintf(mFile,";\n");
 
2028
        }
 
2029
        void startEndLengthSamples(size_t aels_start,size_t aels_end)const
 
2030
        {
 
2031
                fprintf(mFile,"\tsetAttr \".aels[%i:%i]\"",aels_start,aels_end);
 
2032
        }
 
2033
        void appendEndLengthSamples(double aels)const
 
2034
        {
 
2035
                fprintf(mFile," %f",aels);
 
2036
        }
 
2037
        void endEndLengthSamples()const
 
2038
        {
 
2039
                fprintf(mFile,";\n");
 
2040
        }
 
2041
        void setEndLengthMap(const string& aelm)
 
2042
        {
 
2043
                if(aelm == "n/a") return;
 
2044
                fprintf(mFile,"\tsetAttr \".aelm\" -type \"string\" ");
 
2045
                aelm.write(mFile);
 
2046
                fprintf(mFile,";\n");
 
2047
        }
 
2048
        void setEndLengthMapOffset(double aelmo)
 
2049
        {
 
2050
                if(aelmo == 0) return;
 
2051
                fprintf(mFile,"\tsetAttr \".aelmo\" %f;\n", aelmo);
 
2052
        }
 
2053
        void setEndLengthMapMult(double aelmm)
 
2054
        {
 
2055
                if(aelmm == 1) return;
 
2056
                fprintf(mFile,"\tsetAttr \".aelmm\" %f;\n", aelmm);
 
2057
        }
 
2058
        void setEndLengthNoise(double aeln)
 
2059
        {
 
2060
                if(aeln == 0) return;
 
2061
                fprintf(mFile,"\tsetAttr \".aeln\" %f;\n", aeln);
 
2062
        }
 
2063
        void setEndLengthNoiseFreq(float aelnf)
 
2064
        {
 
2065
                if(aelnf == 10.0) return;
 
2066
                fprintf(mFile,"\tsetAttr \".aelnf\" %f;\n", aelnf);
 
2067
        }
 
2068
        void setEndLengthSamplesDirty(int aelsd)
 
2069
        {
 
2070
                if(aelsd == 0.0) return;
 
2071
                fprintf(mFile,"\tsetAttr \".aelsd\" %i;\n", aelsd);
 
2072
        }
 
2073
        void setEndLengthMapDirty(int aelmd)
 
2074
        {
 
2075
                if(aelmd == 0.0) return;
 
2076
                fprintf(mFile,"\tsetAttr \".aelmd\" %i;\n", aelmd);
 
2077
        }
 
2078
        void setThresholdLength(double datl)
 
2079
        {
 
2080
                if(datl == 0) return;
 
2081
                fprintf(mFile,"\tsetAttr \".datl\" %f;\n", datl);
 
2082
        }
 
2083
        void setThresholdLengthSamples(size_t atls_i,double atls)
 
2084
        {
 
2085
                if(atls == 0.0) return;
 
2086
                fprintf(mFile,"\tsetAttr \".atls[%i]\" %f;\n", atls_i,atls);
 
2087
        }
 
2088
        void setThresholdLengthSamples(size_t atls_start,size_t atls_end,double* atls)
 
2089
        {
 
2090
                fprintf(mFile,"\tsetAttr \".atls[%i:%i]\" ", atls_start,atls_end);
 
2091
                size_t size = (atls_end-atls_start)*1+1;
 
2092
                for(size_t i=0;i<size;++i)
 
2093
                {
 
2094
                        fprintf(mFile,"%f",atls[i]);
 
2095
                        if(i+1<size) fprintf(mFile," ");
 
2096
                }
 
2097
                fprintf(mFile,";\n");
 
2098
        }
 
2099
        void startThresholdLengthSamples(size_t atls_start,size_t atls_end)const
 
2100
        {
 
2101
                fprintf(mFile,"\tsetAttr \".atls[%i:%i]\"",atls_start,atls_end);
 
2102
        }
 
2103
        void appendThresholdLengthSamples(double atls)const
 
2104
        {
 
2105
                fprintf(mFile," %f",atls);
 
2106
        }
 
2107
        void endThresholdLengthSamples()const
 
2108
        {
 
2109
                fprintf(mFile,";\n");
 
2110
        }
 
2111
        void setThresholdLengthMap(const string& atlm)
 
2112
        {
 
2113
                if(atlm == "n/a") return;
 
2114
                fprintf(mFile,"\tsetAttr \".atlm\" -type \"string\" ");
 
2115
                atlm.write(mFile);
 
2116
                fprintf(mFile,";\n");
 
2117
        }
 
2118
        void setThresholdLengthMapOffset(double atlmo)
 
2119
        {
 
2120
                if(atlmo == 0) return;
 
2121
                fprintf(mFile,"\tsetAttr \".atlmo\" %f;\n", atlmo);
 
2122
        }
 
2123
        void setThresholdLengthMapMult(double atlmm)
 
2124
        {
 
2125
                if(atlmm == 1) return;
 
2126
                fprintf(mFile,"\tsetAttr \".atlmm\" %f;\n", atlmm);
 
2127
        }
 
2128
        void setThresholdLengthNoise(double atln)
 
2129
        {
 
2130
                if(atln == 0) return;
 
2131
                fprintf(mFile,"\tsetAttr \".atln\" %f;\n", atln);
 
2132
        }
 
2133
        void setThresholdLengthNoiseFreq(float atlnf)
 
2134
        {
 
2135
                if(atlnf == 10.0) return;
 
2136
                fprintf(mFile,"\tsetAttr \".atlnf\" %f;\n", atlnf);
 
2137
        }
 
2138
        void setThresholdLengthSamplesDirty(int atlsd)
 
2139
        {
 
2140
                if(atlsd == 0.0) return;
 
2141
                fprintf(mFile,"\tsetAttr \".atlsd\" %i;\n", atlsd);
 
2142
        }
 
2143
        void setThresholdLengthMapDirty(int atlmd)
 
2144
        {
 
2145
                if(atlmd == 0.0) return;
 
2146
                fprintf(mFile,"\tsetAttr \".atlmd\" %i;\n", atlmd);
 
2147
        }
 
2148
        void setUnused(float dun)
 
2149
        {
 
2150
                if(dun == 1.0) return;
 
2151
                fprintf(mFile,"\tsetAttr \".dun\" %f;\n", dun);
 
2152
        }
 
2153
        void setUnusedSamples(size_t uns_i,double uns)
 
2154
        {
 
2155
                if(uns == 0.0) return;
 
2156
                fprintf(mFile,"\tsetAttr \".uns[%i]\" %f;\n", uns_i,uns);
 
2157
        }
 
2158
        void setUnusedSamples(size_t uns_start,size_t uns_end,double* uns)
 
2159
        {
 
2160
                fprintf(mFile,"\tsetAttr \".uns[%i:%i]\" ", uns_start,uns_end);
 
2161
                size_t size = (uns_end-uns_start)*1+1;
 
2162
                for(size_t i=0;i<size;++i)
 
2163
                {
 
2164
                        fprintf(mFile,"%f",uns[i]);
 
2165
                        if(i+1<size) fprintf(mFile," ");
 
2166
                }
 
2167
                fprintf(mFile,";\n");
 
2168
        }
 
2169
        void startUnusedSamples(size_t uns_start,size_t uns_end)const
 
2170
        {
 
2171
                fprintf(mFile,"\tsetAttr \".uns[%i:%i]\"",uns_start,uns_end);
 
2172
        }
 
2173
        void appendUnusedSamples(double uns)const
 
2174
        {
 
2175
                fprintf(mFile," %f",uns);
 
2176
        }
 
2177
        void endUnusedSamples()const
 
2178
        {
 
2179
                fprintf(mFile,";\n");
 
2180
        }
 
2181
        void setUnusedMap(const string& unm)
 
2182
        {
 
2183
                if(unm == "n/a") return;
 
2184
                fprintf(mFile,"\tsetAttr \".unm\" -type \"string\" ");
 
2185
                unm.write(mFile);
 
2186
                fprintf(mFile,";\n");
 
2187
        }
 
2188
        void setUnusedMapOffset(float unmo)
 
2189
        {
 
2190
                if(unmo == 0.0) return;
 
2191
                fprintf(mFile,"\tsetAttr \".unmo\" %f;\n", unmo);
 
2192
        }
 
2193
        void setUnusedMapMult(float unmm)
 
2194
        {
 
2195
                if(unmm == 1.0) return;
 
2196
                fprintf(mFile,"\tsetAttr \".unmm\" %f;\n", unmm);
 
2197
        }
 
2198
        void setUnusedNoise(float unn)
 
2199
        {
 
2200
                if(unn == 0.0) return;
 
2201
                fprintf(mFile,"\tsetAttr \".unn\" %f;\n", unn);
 
2202
        }
 
2203
        void setUnusedNoiseFreq(float unnf)
 
2204
        {
 
2205
                if(unnf == 10.0) return;
 
2206
                fprintf(mFile,"\tsetAttr \".unnf\" %f;\n", unnf);
 
2207
        }
 
2208
        void setUnusedSamplesDirty(int unsd)
 
2209
        {
 
2210
                if(unsd == 0.0) return;
 
2211
                fprintf(mFile,"\tsetAttr \".unsd\" %i;\n", unsd);
 
2212
        }
 
2213
        void setUnusedMapDirty(int unmd)
 
2214
        {
 
2215
                if(unmd == 0.0) return;
 
2216
                fprintf(mFile,"\tsetAttr \".unmd\" %i;\n", unmd);
 
2217
        }
 
2218
        void setEqualizer(float dem)
 
2219
        {
 
2220
                if(dem == 1.0) return;
 
2221
                fprintf(mFile,"\tsetAttr \".dem\" %f;\n", dem);
 
2222
        }
 
2223
        void setEqualizerSamples(size_t ems_i,double ems)
 
2224
        {
 
2225
                if(ems == 0.0) return;
 
2226
                fprintf(mFile,"\tsetAttr \".ems[%i]\" %f;\n", ems_i,ems);
 
2227
        }
 
2228
        void setEqualizerSamples(size_t ems_start,size_t ems_end,double* ems)
 
2229
        {
 
2230
                fprintf(mFile,"\tsetAttr \".ems[%i:%i]\" ", ems_start,ems_end);
 
2231
                size_t size = (ems_end-ems_start)*1+1;
 
2232
                for(size_t i=0;i<size;++i)
 
2233
                {
 
2234
                        fprintf(mFile,"%f",ems[i]);
 
2235
                        if(i+1<size) fprintf(mFile," ");
 
2236
                }
 
2237
                fprintf(mFile,";\n");
 
2238
        }
 
2239
        void startEqualizerSamples(size_t ems_start,size_t ems_end)const
 
2240
        {
 
2241
                fprintf(mFile,"\tsetAttr \".ems[%i:%i]\"",ems_start,ems_end);
 
2242
        }
 
2243
        void appendEqualizerSamples(double ems)const
 
2244
        {
 
2245
                fprintf(mFile," %f",ems);
 
2246
        }
 
2247
        void endEqualizerSamples()const
 
2248
        {
 
2249
                fprintf(mFile,";\n");
 
2250
        }
 
2251
        void setEqualizerMap(const string& emm)
 
2252
        {
 
2253
                if(emm == "n/a") return;
 
2254
                fprintf(mFile,"\tsetAttr \".emm\" -type \"string\" ");
 
2255
                emm.write(mFile);
 
2256
                fprintf(mFile,";\n");
 
2257
        }
 
2258
        void setEqualizerMapOffset(float emmo)
 
2259
        {
 
2260
                if(emmo == 0.0) return;
 
2261
                fprintf(mFile,"\tsetAttr \".emmo\" %f;\n", emmo);
 
2262
        }
 
2263
        void setEqualizerMapMult(float emmm)
 
2264
        {
 
2265
                if(emmm == 1.0) return;
 
2266
                fprintf(mFile,"\tsetAttr \".emmm\" %f;\n", emmm);
 
2267
        }
 
2268
        void setEqualizerNoise(float emn)
 
2269
        {
 
2270
                if(emn == 0.0) return;
 
2271
                fprintf(mFile,"\tsetAttr \".emn\" %f;\n", emn);
 
2272
        }
 
2273
        void setEqualizerNoiseFreq(float emnf)
 
2274
        {
 
2275
                if(emnf == 10.0) return;
 
2276
                fprintf(mFile,"\tsetAttr \".emnf\" %f;\n", emnf);
 
2277
        }
 
2278
        void setEqualizerSamplesDirty(int emsd)
 
2279
        {
 
2280
                if(emsd == 0.0) return;
 
2281
                fprintf(mFile,"\tsetAttr \".emsd\" %i;\n", emsd);
 
2282
        }
 
2283
        void setEqualizerMapDirty(int emmd)
 
2284
        {
 
2285
                if(emmd == 0.0) return;
 
2286
                fprintf(mFile,"\tsetAttr \".emmd\" %i;\n", emmd);
 
2287
        }
 
2288
        void setMentalRayControls(const MentalRayControls& mrc)
 
2289
        {
 
2290
                fprintf(mFile,"\tsetAttr \".mrc\" ");
 
2291
                mrc.write(mFile);
 
2292
                fprintf(mFile,";\n");
 
2293
        }
 
2294
        void setMiOverrideCaustics(bool oca)
 
2295
        {
 
2296
                if(oca == false) return;
 
2297
                fprintf(mFile,"\tsetAttr \".mrc.oca\" %i;\n", oca);
 
2298
        }
 
2299
        void setMiCausticAccuracy(short caa)
 
2300
        {
 
2301
                if(caa == 64) return;
 
2302
                fprintf(mFile,"\tsetAttr \".mrc.caa\" %i;\n", caa);
 
2303
        }
 
2304
        void setMiCausticRadius(float car)
 
2305
        {
 
2306
                if(car == 0) return;
 
2307
                fprintf(mFile,"\tsetAttr \".mrc.car\" %f;\n", car);
 
2308
        }
 
2309
        void setMiOverrideGlobalIllumination(bool ogi)
 
2310
        {
 
2311
                if(ogi == false) return;
 
2312
                fprintf(mFile,"\tsetAttr \".mrc.ogi\" %i;\n", ogi);
 
2313
        }
 
2314
        void setMiGlobillumAccuracy(short gia)
 
2315
        {
 
2316
                if(gia == 64) return;
 
2317
                fprintf(mFile,"\tsetAttr \".mrc.gia\" %i;\n", gia);
 
2318
        }
 
2319
        void setMiGlobillumRadius(float gir)
 
2320
        {
 
2321
                if(gir == 0) return;
 
2322
                fprintf(mFile,"\tsetAttr \".mrc.gir\" %f;\n", gir);
 
2323
        }
 
2324
        void setMiOverrideFinalGather(bool ofg)
 
2325
        {
 
2326
                if(ofg == false) return;
 
2327
                fprintf(mFile,"\tsetAttr \".mrc.ofg\" %i;\n", ofg);
 
2328
        }
 
2329
        void setMiFinalGatherRays(int fry)
 
2330
        {
 
2331
                if(fry == 1000) return;
 
2332
                fprintf(mFile,"\tsetAttr \".mrc.fry\" %i;\n", fry);
 
2333
        }
 
2334
        void setMiFinalGatherMinRadius(float fmn)
 
2335
        {
 
2336
                if(fmn == 0) return;
 
2337
                fprintf(mFile,"\tsetAttr \".mrc.fmn\" %f;\n", fmn);
 
2338
        }
 
2339
        void setMiFinalGatherMaxRadius(float fmx)
 
2340
        {
 
2341
                if(fmx == 0) return;
 
2342
                fprintf(mFile,"\tsetAttr \".mrc.fmx\" %f;\n", fmx);
 
2343
        }
 
2344
        void setMiFinalGatherFilter(short ffi)
 
2345
        {
 
2346
                if(ffi == 1) return;
 
2347
                fprintf(mFile,"\tsetAttr \".mrc.ffi\" %i;\n", ffi);
 
2348
        }
 
2349
        void setMiFinalGatherView(bool fgv)
 
2350
        {
 
2351
                if(fgv == false) return;
 
2352
                fprintf(mFile,"\tsetAttr \".mrc.fgv\" %i;\n", fgv);
 
2353
        }
 
2354
        void setMiOverrideSamples(bool oos)
 
2355
        {
 
2356
                if(oos == false) return;
 
2357
                fprintf(mFile,"\tsetAttr \".mrc.oos\" %i;\n", oos);
 
2358
        }
 
2359
        void setMiMinSamples(short mins)
 
2360
        {
 
2361
                if(mins == -2) return;
 
2362
                fprintf(mFile,"\tsetAttr \".mrc.mins\" %i;\n", mins);
 
2363
        }
 
2364
        void setMiMaxSamples(short maxs)
 
2365
        {
 
2366
                if(maxs == 0) return;
 
2367
                fprintf(mFile,"\tsetAttr \".mrc.maxs\" %i;\n", maxs);
 
2368
        }
 
2369
        void setMiFinalGatherCast(bool fgc)
 
2370
        {
 
2371
                if(fgc == true) return;
 
2372
                fprintf(mFile,"\tsetAttr \".mrc.fgc\" %i;\n", fgc);
 
2373
        }
 
2374
        void setMiFinalGatherReceive(bool fge)
 
2375
        {
 
2376
                if(fge == true) return;
 
2377
                fprintf(mFile,"\tsetAttr \".mrc.fge\" %i;\n", fge);
 
2378
        }
 
2379
        void setMiTransparencyCast(bool tpc)
 
2380
        {
 
2381
                if(tpc == true) return;
 
2382
                fprintf(mFile,"\tsetAttr \".mrc.tpc\" %i;\n", tpc);
 
2383
        }
 
2384
        void setMiTransparencyReceive(bool tpr)
 
2385
        {
 
2386
                if(tpr == true) return;
 
2387
                fprintf(mFile,"\tsetAttr \".mrc.tpr\" %i;\n", tpr);
 
2388
        }
 
2389
        void getInputSurface()const
 
2390
        {
 
2391
                fprintf(mFile,"\"%s.is\"",mName.c_str());
 
2392
        }
 
2393
        void getInputMesh()const
 
2394
        {
 
2395
                fprintf(mFile,"\"%s.imsh\"",mName.c_str());
 
2396
        }
 
2397
        void getRealUSamples()const
 
2398
        {
 
2399
                fprintf(mFile,"\"%s.rus\"",mName.c_str());
 
2400
        }
 
2401
        void getRealVSamples()const
 
2402
        {
 
2403
                fprintf(mFile,"\"%s.rvs\"",mName.c_str());
 
2404
        }
 
2405
        void getUSamples()const
 
2406
        {
 
2407
                fprintf(mFile,"\"%s.us\"",mName.c_str());
 
2408
        }
 
2409
        void getVSamples()const
 
2410
        {
 
2411
                fprintf(mFile,"\"%s.vs\"",mName.c_str());
 
2412
        }
 
2413
        void getFlipNormals()const
 
2414
        {
 
2415
                fprintf(mFile,"\"%s.fn\"",mName.c_str());
 
2416
        }
 
2417
        void getHairs()const
 
2418
        {
 
2419
                fprintf(mFile,"\"%s.h\"",mName.c_str());
 
2420
        }
 
2421
        void getFurAccuracy()const
 
2422
        {
 
2423
                fprintf(mFile,"\"%s.ha\"",mName.c_str());
 
2424
        }
 
2425
        void getFurGlobalScale()const
 
2426
        {
 
2427
                fprintf(mFile,"\"%s.fgs\"",mName.c_str());
 
2428
        }
 
2429
        void getAttractorGlobalScale()const
 
2430
        {
 
2431
                fprintf(mFile,"\"%s.ags\"",mName.c_str());
 
2432
        }
 
2433
        void getExportAttr()const
 
2434
        {
 
2435
                fprintf(mFile,"\"%s.ea\"",mName.c_str());
 
2436
        }
 
2437
        void getExportFile()const
 
2438
        {
 
2439
                fprintf(mFile,"\"%s.ef\"",mName.c_str());
 
2440
        }
 
2441
        void getExportWidth()const
 
2442
        {
 
2443
                fprintf(mFile,"\"%s.ew\"",mName.c_str());
 
2444
        }
 
2445
        void getExportHeight()const
 
2446
        {
 
2447
                fprintf(mFile,"\"%s.eh\"",mName.c_str());
 
2448
        }
 
2449
        void getColorFeedbackEnabled()const
 
2450
        {
 
2451
                fprintf(mFile,"\"%s.cfe\"",mName.c_str());
 
2452
        }
 
2453
        void getAttractors()const
 
2454
        {
 
2455
                fprintf(mFile,"\"%s.atr\"",mName.c_str());
 
2456
        }
 
2457
        void getAttractorModel()const
 
2458
        {
 
2459
                fprintf(mFile,"\"%s.amd\"",mName.c_str());
 
2460
        }
 
2461
        void getAttractorsPerHair()const
 
2462
        {
 
2463
                fprintf(mFile,"\"%s.aph\"",mName.c_str());
 
2464
        }
 
2465
        void getDrawAttractors()const
 
2466
        {
 
2467
                fprintf(mFile,"\"%s.drat\"",mName.c_str());
 
2468
        }
 
2469
        void getLength()const
 
2470
        {
 
2471
                fprintf(mFile,"\"%s.dl\"",mName.c_str());
 
2472
        }
 
2473
        void getLengthSamples(size_t ls_i)const
 
2474
        {
 
2475
                fprintf(mFile,"\"%s.ls[%i]\"",mName.c_str(),ls_i);
 
2476
        }
 
2477
        void getLengthSamples()const
 
2478
        {
 
2479
 
 
2480
                fprintf(mFile,"\"%s.ls\"",mName.c_str());
 
2481
        }
 
2482
        void getLengthMap()const
 
2483
        {
 
2484
                fprintf(mFile,"\"%s.lm\"",mName.c_str());
 
2485
        }
 
2486
        void getLengthMapOffset()const
 
2487
        {
 
2488
                fprintf(mFile,"\"%s.lmo\"",mName.c_str());
 
2489
        }
 
2490
        void getLengthMapMult()const
 
2491
        {
 
2492
                fprintf(mFile,"\"%s.lmm\"",mName.c_str());
 
2493
        }
 
2494
        void getLengthNoise()const
 
2495
        {
 
2496
                fprintf(mFile,"\"%s.ln\"",mName.c_str());
 
2497
        }
 
2498
        void getLengthNoiseFreq()const
 
2499
        {
 
2500
                fprintf(mFile,"\"%s.lnf\"",mName.c_str());
 
2501
        }
 
2502
        void getLengthSamplesDirty()const
 
2503
        {
 
2504
                fprintf(mFile,"\"%s.lsd\"",mName.c_str());
 
2505
        }
 
2506
        void getLengthMapDirty()const
 
2507
        {
 
2508
                fprintf(mFile,"\"%s.lmd\"",mName.c_str());
 
2509
        }
 
2510
        void getInclination()const
 
2511
        {
 
2512
                fprintf(mFile,"\"%s.din\"",mName.c_str());
 
2513
        }
 
2514
        void getInclinationSamples(size_t ins_i)const
 
2515
        {
 
2516
                fprintf(mFile,"\"%s.ins[%i]\"",mName.c_str(),ins_i);
 
2517
        }
 
2518
        void getInclinationSamples()const
 
2519
        {
 
2520
 
 
2521
                fprintf(mFile,"\"%s.ins\"",mName.c_str());
 
2522
        }
 
2523
        void getInclinationMap()const
 
2524
        {
 
2525
                fprintf(mFile,"\"%s.inm\"",mName.c_str());
 
2526
        }
 
2527
        void getInclinationMapOffset()const
 
2528
        {
 
2529
                fprintf(mFile,"\"%s.inmo\"",mName.c_str());
 
2530
        }
 
2531
        void getInclinationMapMult()const
 
2532
        {
 
2533
                fprintf(mFile,"\"%s.inmm\"",mName.c_str());
 
2534
        }
 
2535
        void getInclinationNoise()const
 
2536
        {
 
2537
                fprintf(mFile,"\"%s.inn\"",mName.c_str());
 
2538
        }
 
2539
        void getInclinationNoiseFreq()const
 
2540
        {
 
2541
                fprintf(mFile,"\"%s.innf\"",mName.c_str());
 
2542
        }
 
2543
        void getInclinationSamplesDirty()const
 
2544
        {
 
2545
                fprintf(mFile,"\"%s.insd\"",mName.c_str());
 
2546
        }
 
2547
        void getInclinationMapDirty()const
 
2548
        {
 
2549
                fprintf(mFile,"\"%s.inmd\"",mName.c_str());
 
2550
        }
 
2551
        void getRoll()const
 
2552
        {
 
2553
                fprintf(mFile,"\"%s.drl\"",mName.c_str());
 
2554
        }
 
2555
        void getRollSamples(size_t rls_i)const
 
2556
        {
 
2557
                fprintf(mFile,"\"%s.rls[%i]\"",mName.c_str(),rls_i);
 
2558
        }
 
2559
        void getRollSamples()const
 
2560
        {
 
2561
 
 
2562
                fprintf(mFile,"\"%s.rls\"",mName.c_str());
 
2563
        }
 
2564
        void getRollMap()const
 
2565
        {
 
2566
                fprintf(mFile,"\"%s.rlm\"",mName.c_str());
 
2567
        }
 
2568
        void getRollMapOffset()const
 
2569
        {
 
2570
                fprintf(mFile,"\"%s.rlmo\"",mName.c_str());
 
2571
        }
 
2572
        void getRollMapMult()const
 
2573
        {
 
2574
                fprintf(mFile,"\"%s.rlmm\"",mName.c_str());
 
2575
        }
 
2576
        void getRollNoise()const
 
2577
        {
 
2578
                fprintf(mFile,"\"%s.rln\"",mName.c_str());
 
2579
        }
 
2580
        void getRollNoiseFreq()const
 
2581
        {
 
2582
                fprintf(mFile,"\"%s.rlnf\"",mName.c_str());
 
2583
        }
 
2584
        void getRollSamplesDirty()const
 
2585
        {
 
2586
                fprintf(mFile,"\"%s.rlsd\"",mName.c_str());
 
2587
        }
 
2588
        void getRollMapDirty()const
 
2589
        {
 
2590
                fprintf(mFile,"\"%s.rlmd\"",mName.c_str());
 
2591
        }
 
2592
        void getPolar()const
 
2593
        {
 
2594
                fprintf(mFile,"\"%s.dpo\"",mName.c_str());
 
2595
        }
 
2596
        void getPolarSamples(size_t pos_i)const
 
2597
        {
 
2598
                fprintf(mFile,"\"%s.pos[%i]\"",mName.c_str(),pos_i);
 
2599
        }
 
2600
        void getPolarSamples()const
 
2601
        {
 
2602
 
 
2603
                fprintf(mFile,"\"%s.pos\"",mName.c_str());
 
2604
        }
 
2605
        void getPolarMap()const
 
2606
        {
 
2607
                fprintf(mFile,"\"%s.pom\"",mName.c_str());
 
2608
        }
 
2609
        void getPolarMapOffset()const
 
2610
        {
 
2611
                fprintf(mFile,"\"%s.pomo\"",mName.c_str());
 
2612
        }
 
2613
        void getPolarMapMult()const
 
2614
        {
 
2615
                fprintf(mFile,"\"%s.pomm\"",mName.c_str());
 
2616
        }
 
2617
        void getPolarNoise()const
 
2618
        {
 
2619
                fprintf(mFile,"\"%s.pon\"",mName.c_str());
 
2620
        }
 
2621
        void getPolarNoiseFreq()const
 
2622
        {
 
2623
                fprintf(mFile,"\"%s.ponf\"",mName.c_str());
 
2624
        }
 
2625
        void getPolarSamplesDirty()const
 
2626
        {
 
2627
                fprintf(mFile,"\"%s.posd\"",mName.c_str());
 
2628
        }
 
2629
        void getPolarMapDirty()const
 
2630
        {
 
2631
                fprintf(mFile,"\"%s.pomd\"",mName.c_str());
 
2632
        }
 
2633
        void getBaldness()const
 
2634
        {
 
2635
                fprintf(mFile,"\"%s.db\"",mName.c_str());
 
2636
        }
 
2637
        void getBaldnessSamples(size_t bs_i)const
 
2638
        {
 
2639
                fprintf(mFile,"\"%s.bs[%i]\"",mName.c_str(),bs_i);
 
2640
        }
 
2641
        void getBaldnessSamples()const
 
2642
        {
 
2643
 
 
2644
                fprintf(mFile,"\"%s.bs\"",mName.c_str());
 
2645
        }
 
2646
        void getBaldnessMap()const
 
2647
        {
 
2648
                fprintf(mFile,"\"%s.bm\"",mName.c_str());
 
2649
        }
 
2650
        void getBaldnessMapOffset()const
 
2651
        {
 
2652
                fprintf(mFile,"\"%s.bmo\"",mName.c_str());
 
2653
        }
 
2654
        void getBaldnessMapMult()const
 
2655
        {
 
2656
                fprintf(mFile,"\"%s.bmm\"",mName.c_str());
 
2657
        }
 
2658
        void getBaldnessNoise()const
 
2659
        {
 
2660
                fprintf(mFile,"\"%s.bn\"",mName.c_str());
 
2661
        }
 
2662
        void getBaldnessNoiseFreq()const
 
2663
        {
 
2664
                fprintf(mFile,"\"%s.bnf\"",mName.c_str());
 
2665
        }
 
2666
        void getBaldnessSamplesDirty()const
 
2667
        {
 
2668
                fprintf(mFile,"\"%s.bsd\"",mName.c_str());
 
2669
        }
 
2670
        void getBaldnessMapDirty()const
 
2671
        {
 
2672
                fprintf(mFile,"\"%s.bmd\"",mName.c_str());
 
2673
        }
 
2674
        void getBaseOpacity()const
 
2675
        {
 
2676
                fprintf(mFile,"\"%s.dbo\"",mName.c_str());
 
2677
        }
 
2678
        void getBaseOpacitySamples(size_t bos_i)const
 
2679
        {
 
2680
                fprintf(mFile,"\"%s.bos[%i]\"",mName.c_str(),bos_i);
 
2681
        }
 
2682
        void getBaseOpacitySamples()const
 
2683
        {
 
2684
 
 
2685
                fprintf(mFile,"\"%s.bos\"",mName.c_str());
 
2686
        }
 
2687
        void getBaseOpacityMap()const
 
2688
        {
 
2689
                fprintf(mFile,"\"%s.bom\"",mName.c_str());
 
2690
        }
 
2691
        void getBaseOpacityMapOffset()const
 
2692
        {
 
2693
                fprintf(mFile,"\"%s.bomo\"",mName.c_str());
 
2694
        }
 
2695
        void getBaseOpacityMapMult()const
 
2696
        {
 
2697
                fprintf(mFile,"\"%s.bomm\"",mName.c_str());
 
2698
        }
 
2699
        void getBaseOpacityNoise()const
 
2700
        {
 
2701
                fprintf(mFile,"\"%s.bon\"",mName.c_str());
 
2702
        }
 
2703
        void getBaseOpacityNoiseFreq()const
 
2704
        {
 
2705
                fprintf(mFile,"\"%s.bonf\"",mName.c_str());
 
2706
        }
 
2707
        void getBaseOpacitySamplesDirty()const
 
2708
        {
 
2709
                fprintf(mFile,"\"%s.bosd\"",mName.c_str());
 
2710
        }
 
2711
        void getBaseOpacityMapDirty()const
 
2712
        {
 
2713
                fprintf(mFile,"\"%s.bomd\"",mName.c_str());
 
2714
        }
 
2715
        void getTipOpacity()const
 
2716
        {
 
2717
                fprintf(mFile,"\"%s.dto\"",mName.c_str());
 
2718
        }
 
2719
        void getTipOpacitySamples(size_t tos_i)const
 
2720
        {
 
2721
                fprintf(mFile,"\"%s.tos[%i]\"",mName.c_str(),tos_i);
 
2722
        }
 
2723
        void getTipOpacitySamples()const
 
2724
        {
 
2725
 
 
2726
                fprintf(mFile,"\"%s.tos\"",mName.c_str());
 
2727
        }
 
2728
        void getTipOpacityMap()const
 
2729
        {
 
2730
                fprintf(mFile,"\"%s.tom\"",mName.c_str());
 
2731
        }
 
2732
        void getTipOpacityMapOffset()const
 
2733
        {
 
2734
                fprintf(mFile,"\"%s.tomo\"",mName.c_str());
 
2735
        }
 
2736
        void getTipOpacityMapMult()const
 
2737
        {
 
2738
                fprintf(mFile,"\"%s.tomm\"",mName.c_str());
 
2739
        }
 
2740
        void getTipOpacityNoise()const
 
2741
        {
 
2742
                fprintf(mFile,"\"%s.ton\"",mName.c_str());
 
2743
        }
 
2744
        void getTipOpacityNoiseFreq()const
 
2745
        {
 
2746
                fprintf(mFile,"\"%s.tonf\"",mName.c_str());
 
2747
        }
 
2748
        void getTipOpacitySamplesDirty()const
 
2749
        {
 
2750
                fprintf(mFile,"\"%s.tosd\"",mName.c_str());
 
2751
        }
 
2752
        void getTipOpacityMapDirty()const
 
2753
        {
 
2754
                fprintf(mFile,"\"%s.tomd\"",mName.c_str());
 
2755
        }
 
2756
        void getBaseCurl()const
 
2757
        {
 
2758
                fprintf(mFile,"\"%s.dbcl\"",mName.c_str());
 
2759
        }
 
2760
        void getBaseCurlSamples(size_t bcls_i)const
 
2761
        {
 
2762
                fprintf(mFile,"\"%s.bcls[%i]\"",mName.c_str(),bcls_i);
 
2763
        }
 
2764
        void getBaseCurlSamples()const
 
2765
        {
 
2766
 
 
2767
                fprintf(mFile,"\"%s.bcls\"",mName.c_str());
 
2768
        }
 
2769
        void getBaseCurlMap()const
 
2770
        {
 
2771
                fprintf(mFile,"\"%s.bclm\"",mName.c_str());
 
2772
        }
 
2773
        void getBaseCurlMapOffset()const
 
2774
        {
 
2775
                fprintf(mFile,"\"%s.bclmo\"",mName.c_str());
 
2776
        }
 
2777
        void getBaseCurlMapMult()const
 
2778
        {
 
2779
                fprintf(mFile,"\"%s.bclmm\"",mName.c_str());
 
2780
        }
 
2781
        void getBaseCurlNoise()const
 
2782
        {
 
2783
                fprintf(mFile,"\"%s.bcln\"",mName.c_str());
 
2784
        }
 
2785
        void getBaseCurlNoiseFreq()const
 
2786
        {
 
2787
                fprintf(mFile,"\"%s.bclnf\"",mName.c_str());
 
2788
        }
 
2789
        void getBaseCurlSamplesDirty()const
 
2790
        {
 
2791
                fprintf(mFile,"\"%s.bclsd\"",mName.c_str());
 
2792
        }
 
2793
        void getBaseCurlMapDirty()const
 
2794
        {
 
2795
                fprintf(mFile,"\"%s.bclmd\"",mName.c_str());
 
2796
        }
 
2797
        void getTipCurl()const
 
2798
        {
 
2799
                fprintf(mFile,"\"%s.dtcl\"",mName.c_str());
 
2800
        }
 
2801
        void getTipCurlSamples(size_t tcls_i)const
 
2802
        {
 
2803
                fprintf(mFile,"\"%s.tcls[%i]\"",mName.c_str(),tcls_i);
 
2804
        }
 
2805
        void getTipCurlSamples()const
 
2806
        {
 
2807
 
 
2808
                fprintf(mFile,"\"%s.tcls\"",mName.c_str());
 
2809
        }
 
2810
        void getTipCurlMap()const
 
2811
        {
 
2812
                fprintf(mFile,"\"%s.tclm\"",mName.c_str());
 
2813
        }
 
2814
        void getTipCurlMapOffset()const
 
2815
        {
 
2816
                fprintf(mFile,"\"%s.tclmo\"",mName.c_str());
 
2817
        }
 
2818
        void getTipCurlMapMult()const
 
2819
        {
 
2820
                fprintf(mFile,"\"%s.tclmm\"",mName.c_str());
 
2821
        }
 
2822
        void getTipCurlNoise()const
 
2823
        {
 
2824
                fprintf(mFile,"\"%s.tcln\"",mName.c_str());
 
2825
        }
 
2826
        void getTipCurlNoiseFreq()const
 
2827
        {
 
2828
                fprintf(mFile,"\"%s.tclnf\"",mName.c_str());
 
2829
        }
 
2830
        void getTipCurlSamplesDirty()const
 
2831
        {
 
2832
                fprintf(mFile,"\"%s.tclsd\"",mName.c_str());
 
2833
        }
 
2834
        void getTipCurlMapDirty()const
 
2835
        {
 
2836
                fprintf(mFile,"\"%s.tclmd\"",mName.c_str());
 
2837
        }
 
2838
        void getBaseWidth()const
 
2839
        {
 
2840
                fprintf(mFile,"\"%s.dbw\"",mName.c_str());
 
2841
        }
 
2842
        void getBaseWidthSamples(size_t bws_i)const
 
2843
        {
 
2844
                fprintf(mFile,"\"%s.bws[%i]\"",mName.c_str(),bws_i);
 
2845
        }
 
2846
        void getBaseWidthSamples()const
 
2847
        {
 
2848
 
 
2849
                fprintf(mFile,"\"%s.bws\"",mName.c_str());
 
2850
        }
 
2851
        void getBaseWidthMap()const
 
2852
        {
 
2853
                fprintf(mFile,"\"%s.bwm\"",mName.c_str());
 
2854
        }
 
2855
        void getBaseWidthMapOffset()const
 
2856
        {
 
2857
                fprintf(mFile,"\"%s.bwmo\"",mName.c_str());
 
2858
        }
 
2859
        void getBaseWidthMapMult()const
 
2860
        {
 
2861
                fprintf(mFile,"\"%s.bwmm\"",mName.c_str());
 
2862
        }
 
2863
        void getBaseWidthNoise()const
 
2864
        {
 
2865
                fprintf(mFile,"\"%s.bwn\"",mName.c_str());
 
2866
        }
 
2867
        void getBaseWidthNoiseFreq()const
 
2868
        {
 
2869
                fprintf(mFile,"\"%s.bwnf\"",mName.c_str());
 
2870
        }
 
2871
        void getBaseWidthSamplesDirty()const
 
2872
        {
 
2873
                fprintf(mFile,"\"%s.bwsd\"",mName.c_str());
 
2874
        }
 
2875
        void getBaseWidthMapDirty()const
 
2876
        {
 
2877
                fprintf(mFile,"\"%s.bwmd\"",mName.c_str());
 
2878
        }
 
2879
        void getTipWidth()const
 
2880
        {
 
2881
                fprintf(mFile,"\"%s.dtw\"",mName.c_str());
 
2882
        }
 
2883
        void getTipWidthSamples(size_t tws_i)const
 
2884
        {
 
2885
                fprintf(mFile,"\"%s.tws[%i]\"",mName.c_str(),tws_i);
 
2886
        }
 
2887
        void getTipWidthSamples()const
 
2888
        {
 
2889
 
 
2890
                fprintf(mFile,"\"%s.tws\"",mName.c_str());
 
2891
        }
 
2892
        void getTipWidthMap()const
 
2893
        {
 
2894
                fprintf(mFile,"\"%s.twm\"",mName.c_str());
 
2895
        }
 
2896
        void getTipWidthMapOffset()const
 
2897
        {
 
2898
                fprintf(mFile,"\"%s.twmo\"",mName.c_str());
 
2899
        }
 
2900
        void getTipWidthMapMult()const
 
2901
        {
 
2902
                fprintf(mFile,"\"%s.twmm\"",mName.c_str());
 
2903
        }
 
2904
        void getTipWidthNoise()const
 
2905
        {
 
2906
                fprintf(mFile,"\"%s.twn\"",mName.c_str());
 
2907
        }
 
2908
        void getTipWidthNoiseFreq()const
 
2909
        {
 
2910
                fprintf(mFile,"\"%s.twnf\"",mName.c_str());
 
2911
        }
 
2912
        void getTipWidthSamplesDirty()const
 
2913
        {
 
2914
                fprintf(mFile,"\"%s.twsd\"",mName.c_str());
 
2915
        }
 
2916
        void getTipWidthMapDirty()const
 
2917
        {
 
2918
                fprintf(mFile,"\"%s.twmd\"",mName.c_str());
 
2919
        }
 
2920
        void getScraggle()const
 
2921
        {
 
2922
                fprintf(mFile,"\"%s.ds\"",mName.c_str());
 
2923
        }
 
2924
        void getScraggleSamples(size_t ss_i)const
 
2925
        {
 
2926
                fprintf(mFile,"\"%s.ss[%i]\"",mName.c_str(),ss_i);
 
2927
        }
 
2928
        void getScraggleSamples()const
 
2929
        {
 
2930
 
 
2931
                fprintf(mFile,"\"%s.ss\"",mName.c_str());
 
2932
        }
 
2933
        void getScraggleMap()const
 
2934
        {
 
2935
                fprintf(mFile,"\"%s.sm\"",mName.c_str());
 
2936
        }
 
2937
        void getScraggleMapOffset()const
 
2938
        {
 
2939
                fprintf(mFile,"\"%s.smo\"",mName.c_str());
 
2940
        }
 
2941
        void getScraggleMapMult()const
 
2942
        {
 
2943
                fprintf(mFile,"\"%s.smm\"",mName.c_str());
 
2944
        }
 
2945
        void getScraggleNoise()const
 
2946
        {
 
2947
                fprintf(mFile,"\"%s.sn\"",mName.c_str());
 
2948
        }
 
2949
        void getScraggleNoiseFreq()const
 
2950
        {
 
2951
                fprintf(mFile,"\"%s.snf\"",mName.c_str());
 
2952
        }
 
2953
        void getScraggleSamplesDirty()const
 
2954
        {
 
2955
                fprintf(mFile,"\"%s.ssd\"",mName.c_str());
 
2956
        }
 
2957
        void getScraggleMapDirty()const
 
2958
        {
 
2959
                fprintf(mFile,"\"%s.smd\"",mName.c_str());
 
2960
        }
 
2961
        void getScraggleCorrelation()const
 
2962
        {
 
2963
                fprintf(mFile,"\"%s.dsco\"",mName.c_str());
 
2964
        }
 
2965
        void getScraggleCorrelationSamples(size_t scos_i)const
 
2966
        {
 
2967
                fprintf(mFile,"\"%s.scos[%i]\"",mName.c_str(),scos_i);
 
2968
        }
 
2969
        void getScraggleCorrelationSamples()const
 
2970
        {
 
2971
 
 
2972
                fprintf(mFile,"\"%s.scos\"",mName.c_str());
 
2973
        }
 
2974
        void getScraggleCorrelationMap()const
 
2975
        {
 
2976
                fprintf(mFile,"\"%s.scom\"",mName.c_str());
 
2977
        }
 
2978
        void getScraggleCorrelationMapOffset()const
 
2979
        {
 
2980
                fprintf(mFile,"\"%s.scomo\"",mName.c_str());
 
2981
        }
 
2982
        void getScraggleCorrelationMapMult()const
 
2983
        {
 
2984
                fprintf(mFile,"\"%s.scomm\"",mName.c_str());
 
2985
        }
 
2986
        void getScraggleCorrelationNoise()const
 
2987
        {
 
2988
                fprintf(mFile,"\"%s.scon\"",mName.c_str());
 
2989
        }
 
2990
        void getScraggleCorrelationNoiseFreq()const
 
2991
        {
 
2992
                fprintf(mFile,"\"%s.sconf\"",mName.c_str());
 
2993
        }
 
2994
        void getScraggleCorrelationSamplesDirty()const
 
2995
        {
 
2996
                fprintf(mFile,"\"%s.scosd\"",mName.c_str());
 
2997
        }
 
2998
        void getScraggleCorrelationMapDirty()const
 
2999
        {
 
3000
                fprintf(mFile,"\"%s.scomd\"",mName.c_str());
 
3001
        }
 
3002
        void getScraggleFrequency()const
 
3003
        {
 
3004
                fprintf(mFile,"\"%s.dscf\"",mName.c_str());
 
3005
        }
 
3006
        void getScraggleFrequencySamples(size_t scfs_i)const
 
3007
        {
 
3008
                fprintf(mFile,"\"%s.scfs[%i]\"",mName.c_str(),scfs_i);
 
3009
        }
 
3010
        void getScraggleFrequencySamples()const
 
3011
        {
 
3012
 
 
3013
                fprintf(mFile,"\"%s.scfs\"",mName.c_str());
 
3014
        }
 
3015
        void getScraggleFrequencyMap()const
 
3016
        {
 
3017
                fprintf(mFile,"\"%s.scfm\"",mName.c_str());
 
3018
        }
 
3019
        void getScraggleFrequencyMapOffset()const
 
3020
        {
 
3021
                fprintf(mFile,"\"%s.scfmo\"",mName.c_str());
 
3022
        }
 
3023
        void getScraggleFrequencyMapMult()const
 
3024
        {
 
3025
                fprintf(mFile,"\"%s.scfmm\"",mName.c_str());
 
3026
        }
 
3027
        void getScraggleFrequencyNoise()const
 
3028
        {
 
3029
                fprintf(mFile,"\"%s.scfn\"",mName.c_str());
 
3030
        }
 
3031
        void getScraggleFrequencyNoiseFreq()const
 
3032
        {
 
3033
                fprintf(mFile,"\"%s.scfnf\"",mName.c_str());
 
3034
        }
 
3035
        void getScraggleFrequencySamplesDirty()const
 
3036
        {
 
3037
                fprintf(mFile,"\"%s.scfsd\"",mName.c_str());
 
3038
        }
 
3039
        void getScraggleFrequencyMapDirty()const
 
3040
        {
 
3041
                fprintf(mFile,"\"%s.scfmd\"",mName.c_str());
 
3042
        }
 
3043
        void getSegments()const
 
3044
        {
 
3045
                fprintf(mFile,"\"%s.dseg\"",mName.c_str());
 
3046
        }
 
3047
        void getSegmentsSamples(size_t segs_i)const
 
3048
        {
 
3049
                fprintf(mFile,"\"%s.segs[%i]\"",mName.c_str(),segs_i);
 
3050
        }
 
3051
        void getSegmentsSamples()const
 
3052
        {
 
3053
 
 
3054
                fprintf(mFile,"\"%s.segs\"",mName.c_str());
 
3055
        }
 
3056
        void getSegmentsMap()const
 
3057
        {
 
3058
                fprintf(mFile,"\"%s.segm\"",mName.c_str());
 
3059
        }
 
3060
        void getSegmentsMapOffset()const
 
3061
        {
 
3062
                fprintf(mFile,"\"%s.segmo\"",mName.c_str());
 
3063
        }
 
3064
        void getSegmentsMapMult()const
 
3065
        {
 
3066
                fprintf(mFile,"\"%s.segmm\"",mName.c_str());
 
3067
        }
 
3068
        void getSegmentsNoise()const
 
3069
        {
 
3070
                fprintf(mFile,"\"%s.segn\"",mName.c_str());
 
3071
        }
 
3072
        void getSegmentsNoiseFreq()const
 
3073
        {
 
3074
                fprintf(mFile,"\"%s.segnf\"",mName.c_str());
 
3075
        }
 
3076
        void getSegmentsSamplesDirty()const
 
3077
        {
 
3078
                fprintf(mFile,"\"%s.segsd\"",mName.c_str());
 
3079
        }
 
3080
        void getSegmentsMapDirty()const
 
3081
        {
 
3082
                fprintf(mFile,"\"%s.segmd\"",mName.c_str());
 
3083
        }
 
3084
        void getAttraction()const
 
3085
        {
 
3086
                fprintf(mFile,"\"%s.dat\"",mName.c_str());
 
3087
        }
 
3088
        void getAttractionSamples(size_t ats_i)const
 
3089
        {
 
3090
                fprintf(mFile,"\"%s.ats[%i]\"",mName.c_str(),ats_i);
 
3091
        }
 
3092
        void getAttractionSamples()const
 
3093
        {
 
3094
 
 
3095
                fprintf(mFile,"\"%s.ats\"",mName.c_str());
 
3096
        }
 
3097
        void getAttractionMap()const
 
3098
        {
 
3099
                fprintf(mFile,"\"%s.atm\"",mName.c_str());
 
3100
        }
 
3101
        void getAttractionMapOffset()const
 
3102
        {
 
3103
                fprintf(mFile,"\"%s.atmo\"",mName.c_str());
 
3104
        }
 
3105
        void getAttractionMapMult()const
 
3106
        {
 
3107
                fprintf(mFile,"\"%s.atmm\"",mName.c_str());
 
3108
        }
 
3109
        void getAttractionNoise()const
 
3110
        {
 
3111
                fprintf(mFile,"\"%s.atn\"",mName.c_str());
 
3112
        }
 
3113
        void getAttractionNoiseFreq()const
 
3114
        {
 
3115
                fprintf(mFile,"\"%s.atnf\"",mName.c_str());
 
3116
        }
 
3117
        void getAttractionSamplesDirty()const
 
3118
        {
 
3119
                fprintf(mFile,"\"%s.atsd\"",mName.c_str());
 
3120
        }
 
3121
        void getAttractionMapDirty()const
 
3122
        {
 
3123
                fprintf(mFile,"\"%s.atmd\"",mName.c_str());
 
3124
        }
 
3125
        void getOffset()const
 
3126
        {
 
3127
                fprintf(mFile,"\"%s.dofs\"",mName.c_str());
 
3128
        }
 
3129
        void getOffsetSamples(size_t ofss_i)const
 
3130
        {
 
3131
                fprintf(mFile,"\"%s.ofss[%i]\"",mName.c_str(),ofss_i);
 
3132
        }
 
3133
        void getOffsetSamples()const
 
3134
        {
 
3135
 
 
3136
                fprintf(mFile,"\"%s.ofss\"",mName.c_str());
 
3137
        }
 
3138
        void getOffsetMap()const
 
3139
        {
 
3140
                fprintf(mFile,"\"%s.ofsm\"",mName.c_str());
 
3141
        }
 
3142
        void getOffsetMapOffset()const
 
3143
        {
 
3144
                fprintf(mFile,"\"%s.ofsmo\"",mName.c_str());
 
3145
        }
 
3146
        void getOffsetMapMult()const
 
3147
        {
 
3148
                fprintf(mFile,"\"%s.ofsmm\"",mName.c_str());
 
3149
        }
 
3150
        void getOffsetNoise()const
 
3151
        {
 
3152
                fprintf(mFile,"\"%s.ofsn\"",mName.c_str());
 
3153
        }
 
3154
        void getOffsetNoiseFreq()const
 
3155
        {
 
3156
                fprintf(mFile,"\"%s.ofsnf\"",mName.c_str());
 
3157
        }
 
3158
        void getOffsetSamplesDirty()const
 
3159
        {
 
3160
                fprintf(mFile,"\"%s.ofssd\"",mName.c_str());
 
3161
        }
 
3162
        void getOffsetMapDirty()const
 
3163
        {
 
3164
                fprintf(mFile,"\"%s.ofsmd\"",mName.c_str());
 
3165
        }
 
3166
        void getClumping()const
 
3167
        {
 
3168
                fprintf(mFile,"\"%s.dc\"",mName.c_str());
 
3169
        }
 
3170
        void getClumpingSamples(size_t cs_i)const
 
3171
        {
 
3172
                fprintf(mFile,"\"%s.cs[%i]\"",mName.c_str(),cs_i);
 
3173
        }
 
3174
        void getClumpingSamples()const
 
3175
        {
 
3176
 
 
3177
                fprintf(mFile,"\"%s.cs\"",mName.c_str());
 
3178
        }
 
3179
        void getClumpingMap()const
 
3180
        {
 
3181
                fprintf(mFile,"\"%s.cm\"",mName.c_str());
 
3182
        }
 
3183
        void getClumpingMapOffset()const
 
3184
        {
 
3185
                fprintf(mFile,"\"%s.cmo\"",mName.c_str());
 
3186
        }
 
3187
        void getClumpingMapMult()const
 
3188
        {
 
3189
                fprintf(mFile,"\"%s.cmm\"",mName.c_str());
 
3190
        }
 
3191
        void getClumpingNoise()const
 
3192
        {
 
3193
                fprintf(mFile,"\"%s.cn\"",mName.c_str());
 
3194
        }
 
3195
        void getClumpingNoiseFreq()const
 
3196
        {
 
3197
                fprintf(mFile,"\"%s.cnf\"",mName.c_str());
 
3198
        }
 
3199
        void getClumpingSamplesDirty()const
 
3200
        {
 
3201
                fprintf(mFile,"\"%s.csd\"",mName.c_str());
 
3202
        }
 
3203
        void getClumpingMapDirty()const
 
3204
        {
 
3205
                fprintf(mFile,"\"%s.cmd\"",mName.c_str());
 
3206
        }
 
3207
        void getClumpingFrequency()const
 
3208
        {
 
3209
                fprintf(mFile,"\"%s.dcf\"",mName.c_str());
 
3210
        }
 
3211
        void getClumpingFrequencySamples(size_t cfs_i)const
 
3212
        {
 
3213
                fprintf(mFile,"\"%s.cfs[%i]\"",mName.c_str(),cfs_i);
 
3214
        }
 
3215
        void getClumpingFrequencySamples()const
 
3216
        {
 
3217
 
 
3218
                fprintf(mFile,"\"%s.cfs\"",mName.c_str());
 
3219
        }
 
3220
        void getClumpingFrequencyMap()const
 
3221
        {
 
3222
                fprintf(mFile,"\"%s.cfm\"",mName.c_str());
 
3223
        }
 
3224
        void getClumpingFrequencyMapOffset()const
 
3225
        {
 
3226
                fprintf(mFile,"\"%s.cfmo\"",mName.c_str());
 
3227
        }
 
3228
        void getClumpingFrequencyMapMult()const
 
3229
        {
 
3230
                fprintf(mFile,"\"%s.cfmm\"",mName.c_str());
 
3231
        }
 
3232
        void getClumpingFrequencyNoise()const
 
3233
        {
 
3234
                fprintf(mFile,"\"%s.cfn\"",mName.c_str());
 
3235
        }
 
3236
        void getClumpingFrequencyNoiseFreq()const
 
3237
        {
 
3238
                fprintf(mFile,"\"%s.cfnf\"",mName.c_str());
 
3239
        }
 
3240
        void getClumpingFrequencySamplesDirty()const
 
3241
        {
 
3242
                fprintf(mFile,"\"%s.cfsd\"",mName.c_str());
 
3243
        }
 
3244
        void getClumpingFrequencyMapDirty()const
 
3245
        {
 
3246
                fprintf(mFile,"\"%s.cfmd\"",mName.c_str());
 
3247
        }
 
3248
        void getClumpingShape()const
 
3249
        {
 
3250
                fprintf(mFile,"\"%s.dcs\"",mName.c_str());
 
3251
        }
 
3252
        void getClumpingShapeSamples(size_t css_i)const
 
3253
        {
 
3254
                fprintf(mFile,"\"%s.css[%i]\"",mName.c_str(),css_i);
 
3255
        }
 
3256
        void getClumpingShapeSamples()const
 
3257
        {
 
3258
 
 
3259
                fprintf(mFile,"\"%s.css\"",mName.c_str());
 
3260
        }
 
3261
        void getClumpingShapeMap()const
 
3262
        {
 
3263
                fprintf(mFile,"\"%s.csm\"",mName.c_str());
 
3264
        }
 
3265
        void getClumpingShapeMapOffset()const
 
3266
        {
 
3267
                fprintf(mFile,"\"%s.csmo\"",mName.c_str());
 
3268
        }
 
3269
        void getClumpingShapeMapMult()const
 
3270
        {
 
3271
                fprintf(mFile,"\"%s.csmm\"",mName.c_str());
 
3272
        }
 
3273
        void getClumpingShapeNoise()const
 
3274
        {
 
3275
                fprintf(mFile,"\"%s.csn\"",mName.c_str());
 
3276
        }
 
3277
        void getClumpingShapeNoiseFreq()const
 
3278
        {
 
3279
                fprintf(mFile,"\"%s.csnf\"",mName.c_str());
 
3280
        }
 
3281
        void getClumpingShapeSamplesDirty()const
 
3282
        {
 
3283
                fprintf(mFile,"\"%s.cssd\"",mName.c_str());
 
3284
        }
 
3285
        void getClumpingShapeMapDirty()const
 
3286
        {
 
3287
                fprintf(mFile,"\"%s.csmd\"",mName.c_str());
 
3288
        }
 
3289
        void getBaseColor()const
 
3290
        {
 
3291
                fprintf(mFile,"\"%s.dbc\"",mName.c_str());
 
3292
        }
 
3293
        void getBaseColorR()const
 
3294
        {
 
3295
                fprintf(mFile,"\"%s.dbcr\"",mName.c_str());
 
3296
        }
 
3297
        void getBaseColorG()const
 
3298
        {
 
3299
                fprintf(mFile,"\"%s.dbcg\"",mName.c_str());
 
3300
        }
 
3301
        void getBaseColorB()const
 
3302
        {
 
3303
                fprintf(mFile,"\"%s.dbcb\"",mName.c_str());
 
3304
        }
 
3305
        void getBaseColorSamples(size_t bcs_i)const
 
3306
        {
 
3307
                fprintf(mFile,"\"%s.bcs[%i]\"",mName.c_str(),bcs_i);
 
3308
        }
 
3309
        void getBaseColorSamples()const
 
3310
        {
 
3311
 
 
3312
                fprintf(mFile,"\"%s.bcs\"",mName.c_str());
 
3313
        }
 
3314
        void getBaseColorMap()const
 
3315
        {
 
3316
                fprintf(mFile,"\"%s.bcm\"",mName.c_str());
 
3317
        }
 
3318
        void getBaseColorNoise()const
 
3319
        {
 
3320
                fprintf(mFile,"\"%s.bcn\"",mName.c_str());
 
3321
        }
 
3322
        void getBaseColorNoiseFreq()const
 
3323
        {
 
3324
                fprintf(mFile,"\"%s.bcnf\"",mName.c_str());
 
3325
        }
 
3326
        void getBaseColorSamplesDirty()const
 
3327
        {
 
3328
                fprintf(mFile,"\"%s.bcsd\"",mName.c_str());
 
3329
        }
 
3330
        void getBaseColorMapDirty()const
 
3331
        {
 
3332
                fprintf(mFile,"\"%s.bcmd\"",mName.c_str());
 
3333
        }
 
3334
        void getTipColor()const
 
3335
        {
 
3336
                fprintf(mFile,"\"%s.dtc\"",mName.c_str());
 
3337
        }
 
3338
        void getTipColorR()const
 
3339
        {
 
3340
                fprintf(mFile,"\"%s.dtcr\"",mName.c_str());
 
3341
        }
 
3342
        void getTipColorG()const
 
3343
        {
 
3344
                fprintf(mFile,"\"%s.dtcg\"",mName.c_str());
 
3345
        }
 
3346
        void getTipColorB()const
 
3347
        {
 
3348
                fprintf(mFile,"\"%s.dtcb\"",mName.c_str());
 
3349
        }
 
3350
        void getTipColorSamples(size_t tcs_i)const
 
3351
        {
 
3352
                fprintf(mFile,"\"%s.tcs[%i]\"",mName.c_str(),tcs_i);
 
3353
        }
 
3354
        void getTipColorSamples()const
 
3355
        {
 
3356
 
 
3357
                fprintf(mFile,"\"%s.tcs\"",mName.c_str());
 
3358
        }
 
3359
        void getTipColorMap()const
 
3360
        {
 
3361
                fprintf(mFile,"\"%s.tcm\"",mName.c_str());
 
3362
        }
 
3363
        void getTipColorNoise()const
 
3364
        {
 
3365
                fprintf(mFile,"\"%s.tcn\"",mName.c_str());
 
3366
        }
 
3367
        void getTipColorNoiseFreq()const
 
3368
        {
 
3369
                fprintf(mFile,"\"%s.tcnf\"",mName.c_str());
 
3370
        }
 
3371
        void getTipColorSamplesDirty()const
 
3372
        {
 
3373
                fprintf(mFile,"\"%s.tcsd\"",mName.c_str());
 
3374
        }
 
3375
        void getTipColorMapDirty()const
 
3376
        {
 
3377
                fprintf(mFile,"\"%s.tcmd\"",mName.c_str());
 
3378
        }
 
3379
        void getRadius()const
 
3380
        {
 
3381
                fprintf(mFile,"\"%s.dar\"",mName.c_str());
 
3382
        }
 
3383
        void getRadiusSamples(size_t ars_i)const
 
3384
        {
 
3385
                fprintf(mFile,"\"%s.ars[%i]\"",mName.c_str(),ars_i);
 
3386
        }
 
3387
        void getRadiusSamples()const
 
3388
        {
 
3389
 
 
3390
                fprintf(mFile,"\"%s.ars\"",mName.c_str());
 
3391
        }
 
3392
        void getRadiusMap()const
 
3393
        {
 
3394
                fprintf(mFile,"\"%s.arm\"",mName.c_str());
 
3395
        }
 
3396
        void getRadiusMapOffset()const
 
3397
        {
 
3398
                fprintf(mFile,"\"%s.armo\"",mName.c_str());
 
3399
        }
 
3400
        void getRadiusMapMult()const
 
3401
        {
 
3402
                fprintf(mFile,"\"%s.armm\"",mName.c_str());
 
3403
        }
 
3404
        void getRadiusNoise()const
 
3405
        {
 
3406
                fprintf(mFile,"\"%s.arn\"",mName.c_str());
 
3407
        }
 
3408
        void getRadiusNoiseFreq()const
 
3409
        {
 
3410
                fprintf(mFile,"\"%s.arnf\"",mName.c_str());
 
3411
        }
 
3412
        void getRadiusSamplesDirty()const
 
3413
        {
 
3414
                fprintf(mFile,"\"%s.arsd\"",mName.c_str());
 
3415
        }
 
3416
        void getRadiusMapDirty()const
 
3417
        {
 
3418
                fprintf(mFile,"\"%s.armd\"",mName.c_str());
 
3419
        }
 
3420
        void getPower()const
 
3421
        {
 
3422
                fprintf(mFile,"\"%s.dap\"",mName.c_str());
 
3423
        }
 
3424
        void getPowerSamples(size_t aps_i)const
 
3425
        {
 
3426
                fprintf(mFile,"\"%s.aps[%i]\"",mName.c_str(),aps_i);
 
3427
        }
 
3428
        void getPowerSamples()const
 
3429
        {
 
3430
 
 
3431
                fprintf(mFile,"\"%s.aps\"",mName.c_str());
 
3432
        }
 
3433
        void getPowerMap()const
 
3434
        {
 
3435
                fprintf(mFile,"\"%s.apm\"",mName.c_str());
 
3436
        }
 
3437
        void getPowerMapOffset()const
 
3438
        {
 
3439
                fprintf(mFile,"\"%s.apmo\"",mName.c_str());
 
3440
        }
 
3441
        void getPowerMapMult()const
 
3442
        {
 
3443
                fprintf(mFile,"\"%s.apmm\"",mName.c_str());
 
3444
        }
 
3445
        void getPowerNoise()const
 
3446
        {
 
3447
                fprintf(mFile,"\"%s.apn\"",mName.c_str());
 
3448
        }
 
3449
        void getPowerNoiseFreq()const
 
3450
        {
 
3451
                fprintf(mFile,"\"%s.apnf\"",mName.c_str());
 
3452
        }
 
3453
        void getPowerSamplesDirty()const
 
3454
        {
 
3455
                fprintf(mFile,"\"%s.apsd\"",mName.c_str());
 
3456
        }
 
3457
        void getPowerMapDirty()const
 
3458
        {
 
3459
                fprintf(mFile,"\"%s.apmd\"",mName.c_str());
 
3460
        }
 
3461
        void getInfluence()const
 
3462
        {
 
3463
                fprintf(mFile,"\"%s.dai\"",mName.c_str());
 
3464
        }
 
3465
        void getInfluenceSamples(size_t ais_i)const
 
3466
        {
 
3467
                fprintf(mFile,"\"%s.ais[%i]\"",mName.c_str(),ais_i);
 
3468
        }
 
3469
        void getInfluenceSamples()const
 
3470
        {
 
3471
 
 
3472
                fprintf(mFile,"\"%s.ais\"",mName.c_str());
 
3473
        }
 
3474
        void getInfluenceMap()const
 
3475
        {
 
3476
                fprintf(mFile,"\"%s.aim\"",mName.c_str());
 
3477
        }
 
3478
        void getInfluenceMapOffset()const
 
3479
        {
 
3480
                fprintf(mFile,"\"%s.aimo\"",mName.c_str());
 
3481
        }
 
3482
        void getInfluenceMapMult()const
 
3483
        {
 
3484
                fprintf(mFile,"\"%s.aimm\"",mName.c_str());
 
3485
        }
 
3486
        void getInfluenceNoise()const
 
3487
        {
 
3488
                fprintf(mFile,"\"%s.ain\"",mName.c_str());
 
3489
        }
 
3490
        void getInfluenceNoiseFreq()const
 
3491
        {
 
3492
                fprintf(mFile,"\"%s.ainf\"",mName.c_str());
 
3493
        }
 
3494
        void getInfluenceSamplesDirty()const
 
3495
        {
 
3496
                fprintf(mFile,"\"%s.aisd\"",mName.c_str());
 
3497
        }
 
3498
        void getInfluenceMapDirty()const
 
3499
        {
 
3500
                fprintf(mFile,"\"%s.aimd\"",mName.c_str());
 
3501
        }
 
3502
        void getStartLength()const
 
3503
        {
 
3504
                fprintf(mFile,"\"%s.dasl\"",mName.c_str());
 
3505
        }
 
3506
        void getStartLengthSamples(size_t asls_i)const
 
3507
        {
 
3508
                fprintf(mFile,"\"%s.asls[%i]\"",mName.c_str(),asls_i);
 
3509
        }
 
3510
        void getStartLengthSamples()const
 
3511
        {
 
3512
 
 
3513
                fprintf(mFile,"\"%s.asls\"",mName.c_str());
 
3514
        }
 
3515
        void getStartLengthMap()const
 
3516
        {
 
3517
                fprintf(mFile,"\"%s.aslm\"",mName.c_str());
 
3518
        }
 
3519
        void getStartLengthMapOffset()const
 
3520
        {
 
3521
                fprintf(mFile,"\"%s.aslmo\"",mName.c_str());
 
3522
        }
 
3523
        void getStartLengthMapMult()const
 
3524
        {
 
3525
                fprintf(mFile,"\"%s.aslmm\"",mName.c_str());
 
3526
        }
 
3527
        void getStartLengthNoise()const
 
3528
        {
 
3529
                fprintf(mFile,"\"%s.asln\"",mName.c_str());
 
3530
        }
 
3531
        void getStartLengthNoiseFreq()const
 
3532
        {
 
3533
                fprintf(mFile,"\"%s.aslnf\"",mName.c_str());
 
3534
        }
 
3535
        void getStartLengthSamplesDirty()const
 
3536
        {
 
3537
                fprintf(mFile,"\"%s.aslsd\"",mName.c_str());
 
3538
        }
 
3539
        void getStartLengthMapDirty()const
 
3540
        {
 
3541
                fprintf(mFile,"\"%s.aslmd\"",mName.c_str());
 
3542
        }
 
3543
        void getEndLength()const
 
3544
        {
 
3545
                fprintf(mFile,"\"%s.dael\"",mName.c_str());
 
3546
        }
 
3547
        void getEndLengthSamples(size_t aels_i)const
 
3548
        {
 
3549
                fprintf(mFile,"\"%s.aels[%i]\"",mName.c_str(),aels_i);
 
3550
        }
 
3551
        void getEndLengthSamples()const
 
3552
        {
 
3553
 
 
3554
                fprintf(mFile,"\"%s.aels\"",mName.c_str());
 
3555
        }
 
3556
        void getEndLengthMap()const
 
3557
        {
 
3558
                fprintf(mFile,"\"%s.aelm\"",mName.c_str());
 
3559
        }
 
3560
        void getEndLengthMapOffset()const
 
3561
        {
 
3562
                fprintf(mFile,"\"%s.aelmo\"",mName.c_str());
 
3563
        }
 
3564
        void getEndLengthMapMult()const
 
3565
        {
 
3566
                fprintf(mFile,"\"%s.aelmm\"",mName.c_str());
 
3567
        }
 
3568
        void getEndLengthNoise()const
 
3569
        {
 
3570
                fprintf(mFile,"\"%s.aeln\"",mName.c_str());
 
3571
        }
 
3572
        void getEndLengthNoiseFreq()const
 
3573
        {
 
3574
                fprintf(mFile,"\"%s.aelnf\"",mName.c_str());
 
3575
        }
 
3576
        void getEndLengthSamplesDirty()const
 
3577
        {
 
3578
                fprintf(mFile,"\"%s.aelsd\"",mName.c_str());
 
3579
        }
 
3580
        void getEndLengthMapDirty()const
 
3581
        {
 
3582
                fprintf(mFile,"\"%s.aelmd\"",mName.c_str());
 
3583
        }
 
3584
        void getThresholdLength()const
 
3585
        {
 
3586
                fprintf(mFile,"\"%s.datl\"",mName.c_str());
 
3587
        }
 
3588
        void getThresholdLengthSamples(size_t atls_i)const
 
3589
        {
 
3590
                fprintf(mFile,"\"%s.atls[%i]\"",mName.c_str(),atls_i);
 
3591
        }
 
3592
        void getThresholdLengthSamples()const
 
3593
        {
 
3594
 
 
3595
                fprintf(mFile,"\"%s.atls\"",mName.c_str());
 
3596
        }
 
3597
        void getThresholdLengthMap()const
 
3598
        {
 
3599
                fprintf(mFile,"\"%s.atlm\"",mName.c_str());
 
3600
        }
 
3601
        void getThresholdLengthMapOffset()const
 
3602
        {
 
3603
                fprintf(mFile,"\"%s.atlmo\"",mName.c_str());
 
3604
        }
 
3605
        void getThresholdLengthMapMult()const
 
3606
        {
 
3607
                fprintf(mFile,"\"%s.atlmm\"",mName.c_str());
 
3608
        }
 
3609
        void getThresholdLengthNoise()const
 
3610
        {
 
3611
                fprintf(mFile,"\"%s.atln\"",mName.c_str());
 
3612
        }
 
3613
        void getThresholdLengthNoiseFreq()const
 
3614
        {
 
3615
                fprintf(mFile,"\"%s.atlnf\"",mName.c_str());
 
3616
        }
 
3617
        void getThresholdLengthSamplesDirty()const
 
3618
        {
 
3619
                fprintf(mFile,"\"%s.atlsd\"",mName.c_str());
 
3620
        }
 
3621
        void getThresholdLengthMapDirty()const
 
3622
        {
 
3623
                fprintf(mFile,"\"%s.atlmd\"",mName.c_str());
 
3624
        }
 
3625
        void getUnused()const
 
3626
        {
 
3627
                fprintf(mFile,"\"%s.dun\"",mName.c_str());
 
3628
        }
 
3629
        void getUnusedSamples(size_t uns_i)const
 
3630
        {
 
3631
                fprintf(mFile,"\"%s.uns[%i]\"",mName.c_str(),uns_i);
 
3632
        }
 
3633
        void getUnusedSamples()const
 
3634
        {
 
3635
 
 
3636
                fprintf(mFile,"\"%s.uns\"",mName.c_str());
 
3637
        }
 
3638
        void getUnusedMap()const
 
3639
        {
 
3640
                fprintf(mFile,"\"%s.unm\"",mName.c_str());
 
3641
        }
 
3642
        void getUnusedMapOffset()const
 
3643
        {
 
3644
                fprintf(mFile,"\"%s.unmo\"",mName.c_str());
 
3645
        }
 
3646
        void getUnusedMapMult()const
 
3647
        {
 
3648
                fprintf(mFile,"\"%s.unmm\"",mName.c_str());
 
3649
        }
 
3650
        void getUnusedNoise()const
 
3651
        {
 
3652
                fprintf(mFile,"\"%s.unn\"",mName.c_str());
 
3653
        }
 
3654
        void getUnusedSamplesDirty()const
 
3655
        {
 
3656
                fprintf(mFile,"\"%s.unsd\"",mName.c_str());
 
3657
        }
 
3658
        void getUnusedMapDirty()const
 
3659
        {
 
3660
                fprintf(mFile,"\"%s.unmd\"",mName.c_str());
 
3661
        }
 
3662
        void getEqualizer()const
 
3663
        {
 
3664
                fprintf(mFile,"\"%s.dem\"",mName.c_str());
 
3665
        }
 
3666
        void getEqualizerSamples(size_t ems_i)const
 
3667
        {
 
3668
                fprintf(mFile,"\"%s.ems[%i]\"",mName.c_str(),ems_i);
 
3669
        }
 
3670
        void getEqualizerSamples()const
 
3671
        {
 
3672
 
 
3673
                fprintf(mFile,"\"%s.ems\"",mName.c_str());
 
3674
        }
 
3675
        void getEqualizerMap()const
 
3676
        {
 
3677
                fprintf(mFile,"\"%s.emm\"",mName.c_str());
 
3678
        }
 
3679
        void getEqualizerMapOffset()const
 
3680
        {
 
3681
                fprintf(mFile,"\"%s.emmo\"",mName.c_str());
 
3682
        }
 
3683
        void getEqualizerMapMult()const
 
3684
        {
 
3685
                fprintf(mFile,"\"%s.emmm\"",mName.c_str());
 
3686
        }
 
3687
        void getEqualizerNoise()const
 
3688
        {
 
3689
                fprintf(mFile,"\"%s.emn\"",mName.c_str());
 
3690
        }
 
3691
        void getEqualizerNoiseFreq()const
 
3692
        {
 
3693
                fprintf(mFile,"\"%s.emnf\"",mName.c_str());
 
3694
        }
 
3695
        void getEqualizerSamplesDirty()const
 
3696
        {
 
3697
                fprintf(mFile,"\"%s.emsd\"",mName.c_str());
 
3698
        }
 
3699
        void getEqualizerMapDirty()const
 
3700
        {
 
3701
                fprintf(mFile,"\"%s.emmd\"",mName.c_str());
 
3702
        }
 
3703
        void getMentalRayControls()const
 
3704
        {
 
3705
                fprintf(mFile,"\"%s.mrc\"",mName.c_str());
 
3706
        }
 
3707
        void getMiOverrideCaustics()const
 
3708
        {
 
3709
                fprintf(mFile,"\"%s.mrc.oca\"",mName.c_str());
 
3710
        }
 
3711
        void getMiCausticAccuracy()const
 
3712
        {
 
3713
                fprintf(mFile,"\"%s.mrc.caa\"",mName.c_str());
 
3714
        }
 
3715
        void getMiCausticRadius()const
 
3716
        {
 
3717
                fprintf(mFile,"\"%s.mrc.car\"",mName.c_str());
 
3718
        }
 
3719
        void getMiOverrideGlobalIllumination()const
 
3720
        {
 
3721
                fprintf(mFile,"\"%s.mrc.ogi\"",mName.c_str());
 
3722
        }
 
3723
        void getMiGlobillumAccuracy()const
 
3724
        {
 
3725
                fprintf(mFile,"\"%s.mrc.gia\"",mName.c_str());
 
3726
        }
 
3727
        void getMiGlobillumRadius()const
 
3728
        {
 
3729
                fprintf(mFile,"\"%s.mrc.gir\"",mName.c_str());
 
3730
        }
 
3731
        void getMiOverrideFinalGather()const
 
3732
        {
 
3733
                fprintf(mFile,"\"%s.mrc.ofg\"",mName.c_str());
 
3734
        }
 
3735
        void getMiFinalGatherRays()const
 
3736
        {
 
3737
                fprintf(mFile,"\"%s.mrc.fry\"",mName.c_str());
 
3738
        }
 
3739
        void getMiFinalGatherMinRadius()const
 
3740
        {
 
3741
                fprintf(mFile,"\"%s.mrc.fmn\"",mName.c_str());
 
3742
        }
 
3743
        void getMiFinalGatherMaxRadius()const
 
3744
        {
 
3745
                fprintf(mFile,"\"%s.mrc.fmx\"",mName.c_str());
 
3746
        }
 
3747
        void getMiFinalGatherFilter()const
 
3748
        {
 
3749
                fprintf(mFile,"\"%s.mrc.ffi\"",mName.c_str());
 
3750
        }
 
3751
        void getMiFinalGatherView()const
 
3752
        {
 
3753
                fprintf(mFile,"\"%s.mrc.fgv\"",mName.c_str());
 
3754
        }
 
3755
        void getMiOverrideSamples()const
 
3756
        {
 
3757
                fprintf(mFile,"\"%s.mrc.oos\"",mName.c_str());
 
3758
        }
 
3759
        void getMiMinSamples()const
 
3760
        {
 
3761
                fprintf(mFile,"\"%s.mrc.mins\"",mName.c_str());
 
3762
        }
 
3763
        void getMiMaxSamples()const
 
3764
        {
 
3765
                fprintf(mFile,"\"%s.mrc.maxs\"",mName.c_str());
 
3766
        }
 
3767
        void getMiFinalGatherCast()const
 
3768
        {
 
3769
                fprintf(mFile,"\"%s.mrc.fgc\"",mName.c_str());
 
3770
        }
 
3771
        void getMiFinalGatherReceive()const
 
3772
        {
 
3773
                fprintf(mFile,"\"%s.mrc.fge\"",mName.c_str());
 
3774
        }
 
3775
        void getMiTransparencyCast()const
 
3776
        {
 
3777
                fprintf(mFile,"\"%s.mrc.tpc\"",mName.c_str());
 
3778
        }
 
3779
        void getMiTransparencyReceive()const
 
3780
        {
 
3781
                fprintf(mFile,"\"%s.mrc.tpr\"",mName.c_str());
 
3782
        }
 
3783
protected:
 
3784
        FurFeedback(FILE* file,const std::string& name,const std::string& parent,const std::string& nodeType,bool shared=false,bool create=true)
 
3785
                :Locator(file, name, parent, nodeType, shared, create) {}
 
3786
 
 
3787
};
 
3788
}//namespace MayaDM
 
3789
#endif//__MayaDM_FURFEEDBACK_H__