← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Externals/MayaDataModel/include/MayaDMHairSystem.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/MayaDMHairSystem.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_HAIRSYSTEM_H__
 
11
#define __MayaDM_HAIRSYSTEM_H__
 
12
#include "MayaDMTypes.h"
 
13
#include "MayaDMConnectables.h"
 
14
#include "MayaDMShape.h"
 
15
namespace MayaDM
 
16
{
 
17
class HairSystem : public Shape
 
18
{
 
19
public:
 
20
        struct StiffnessScale{
 
21
                float stiffnessScale_Position;
 
22
                float stiffnessScale_FloatValue;
 
23
                unsigned int stiffnessScale_Interp;
 
24
                void write(FILE* file) const
 
25
                {
 
26
                        fprintf(file,"%f ", stiffnessScale_Position);
 
27
                        fprintf(file,"%f ", stiffnessScale_FloatValue);
 
28
                        fprintf(file,"%i", stiffnessScale_Interp);
 
29
                }
 
30
        };
 
31
        struct AttractionScale{
 
32
                float attractionScale_Position;
 
33
                float attractionScale_FloatValue;
 
34
                unsigned int attractionScale_Interp;
 
35
                void write(FILE* file) const
 
36
                {
 
37
                        fprintf(file,"%f ", attractionScale_Position);
 
38
                        fprintf(file,"%f ", attractionScale_FloatValue);
 
39
                        fprintf(file,"%i", attractionScale_Interp);
 
40
                }
 
41
        };
 
42
        struct ClumpWidthScale{
 
43
                float clumpWidthScale_Position;
 
44
                float clumpWidthScale_FloatValue;
 
45
                unsigned int clumpWidthScale_Interp;
 
46
                void write(FILE* file) const
 
47
                {
 
48
                        fprintf(file,"%f ", clumpWidthScale_Position);
 
49
                        fprintf(file,"%f ", clumpWidthScale_FloatValue);
 
50
                        fprintf(file,"%i", clumpWidthScale_Interp);
 
51
                }
 
52
        };
 
53
        struct ClumpCurl{
 
54
                float clumpCurl_Position;
 
55
                float clumpCurl_FloatValue;
 
56
                unsigned int clumpCurl_Interp;
 
57
                void write(FILE* file) const
 
58
                {
 
59
                        fprintf(file,"%f ", clumpCurl_Position);
 
60
                        fprintf(file,"%f ", clumpCurl_FloatValue);
 
61
                        fprintf(file,"%i", clumpCurl_Interp);
 
62
                }
 
63
        };
 
64
        struct ClumpFlatness{
 
65
                float clumpFlatness_Position;
 
66
                float clumpFlatness_FloatValue;
 
67
                unsigned int clumpFlatness_Interp;
 
68
                void write(FILE* file) const
 
69
                {
 
70
                        fprintf(file,"%f ", clumpFlatness_Position);
 
71
                        fprintf(file,"%f ", clumpFlatness_FloatValue);
 
72
                        fprintf(file,"%i", clumpFlatness_Interp);
 
73
                }
 
74
        };
 
75
        struct HairWidthScale{
 
76
                float hairWidthScale_Position;
 
77
                float hairWidthScale_FloatValue;
 
78
                unsigned int hairWidthScale_Interp;
 
79
                void write(FILE* file) const
 
80
                {
 
81
                        fprintf(file,"%f ", hairWidthScale_Position);
 
82
                        fprintf(file,"%f ", hairWidthScale_FloatValue);
 
83
                        fprintf(file,"%i", hairWidthScale_Interp);
 
84
                }
 
85
        };
 
86
        struct HairColorScale{
 
87
                float hairColorScale_Position;
 
88
                float3 hairColorScale_Color;
 
89
                unsigned int hairColorScale_Interp;
 
90
                void write(FILE* file) const
 
91
                {
 
92
                        fprintf(file,"%f ", hairColorScale_Position);
 
93
                        hairColorScale_Color.write(file);
 
94
                        fprintf(file, " ");
 
95
                        fprintf(file,"%i", hairColorScale_Interp);
 
96
                }
 
97
        };
 
98
        struct DisplacementScale{
 
99
                float displacementScale_Position;
 
100
                float displacementScale_FloatValue;
 
101
                unsigned int displacementScale_Interp;
 
102
                void write(FILE* file) const
 
103
                {
 
104
                        fprintf(file,"%f ", displacementScale_Position);
 
105
                        fprintf(file,"%f ", displacementScale_FloatValue);
 
106
                        fprintf(file,"%i", displacementScale_Interp);
 
107
                }
 
108
        };
 
109
        struct FieldData{
 
110
                void write(FILE* file) const
 
111
                {
 
112
                }
 
113
        };
 
114
        struct CollisionData{
 
115
                void write(FILE* file) const
 
116
                {
 
117
                }
 
118
        };
 
119
        struct MentalRayControls{
 
120
                bool miOverrideCaustics;
 
121
                short miCausticAccuracy;
 
122
                float miCausticRadius;
 
123
                bool miOverrideGlobalIllumination;
 
124
                short miGlobillumAccuracy;
 
125
                float miGlobillumRadius;
 
126
                bool miOverrideFinalGather;
 
127
                int miFinalGatherRays;
 
128
                float miFinalGatherMinRadius;
 
129
                float miFinalGatherMaxRadius;
 
130
                short miFinalGatherFilter;
 
131
                bool miFinalGatherView;
 
132
                bool miOverrideSamples;
 
133
                short miMinSamples;
 
134
                short miMaxSamples;
 
135
                bool miFinalGatherCast;
 
136
                bool miFinalGatherReceive;
 
137
                bool miTransparencyCast;
 
138
                bool miTransparencyReceive;
 
139
                void write(FILE* file) const
 
140
                {
 
141
                        fprintf(file,"%i ", miOverrideCaustics);
 
142
                        fprintf(file,"%i ", miCausticAccuracy);
 
143
                        fprintf(file,"%f ", miCausticRadius);
 
144
                        fprintf(file,"%i ", miOverrideGlobalIllumination);
 
145
                        fprintf(file,"%i ", miGlobillumAccuracy);
 
146
                        fprintf(file,"%f ", miGlobillumRadius);
 
147
                        fprintf(file,"%i ", miOverrideFinalGather);
 
148
                        fprintf(file,"%i ", miFinalGatherRays);
 
149
                        fprintf(file,"%f ", miFinalGatherMinRadius);
 
150
                        fprintf(file,"%f ", miFinalGatherMaxRadius);
 
151
                        fprintf(file,"%i ", miFinalGatherFilter);
 
152
                        fprintf(file,"%i ", miFinalGatherView);
 
153
                        fprintf(file,"%i ", miOverrideSamples);
 
154
                        fprintf(file,"%i ", miMinSamples);
 
155
                        fprintf(file,"%i ", miMaxSamples);
 
156
                        fprintf(file,"%i ", miFinalGatherCast);
 
157
                        fprintf(file,"%i ", miFinalGatherReceive);
 
158
                        fprintf(file,"%i ", miTransparencyCast);
 
159
                        fprintf(file,"%i", miTransparencyReceive);
 
160
                }
 
161
        };
 
162
public:
 
163
 
 
164
        HairSystem():Shape(){}
 
165
        HairSystem(FILE* file,const std::string& name,const std::string& parent="",bool shared=false,bool create=true)
 
166
                :Shape(file, name, parent, "hairSystem", shared, create){}
 
167
        virtual ~HairSystem(){}
 
168
 
 
169
        void setSimulationMethod(unsigned int sim)
 
170
        {
 
171
                if(sim == 3) return;
 
172
                fprintf(mFile,"\tsetAttr \".sim\" %i;\n", sim);
 
173
        }
 
174
        void setCollide(bool cld)
 
175
        {
 
176
                if(cld == true) return;
 
177
                fprintf(mFile,"\tsetAttr \".cld\" %i;\n", cld);
 
178
        }
 
179
        void setCollideOverSample(int cos)
 
180
        {
 
181
                if(cos == 0) return;
 
182
                fprintf(mFile,"\tsetAttr \".cos\" %i;\n", cos);
 
183
        }
 
184
        void setSelfCollide(bool scd)
 
185
        {
 
186
                if(scd == false) return;
 
187
                fprintf(mFile,"\tsetAttr \".scd\" %i;\n", scd);
 
188
        }
 
189
        void setCollideGround(bool cdg)
 
190
        {
 
191
                if(cdg == false) return;
 
192
                fprintf(mFile,"\tsetAttr \".cdg\" %i;\n", cdg);
 
193
        }
 
194
        void setGroundHeight(double ghe)
 
195
        {
 
196
                if(ghe == 0.0) return;
 
197
                fprintf(mFile,"\tsetAttr \".ghe\" %f;\n", ghe);
 
198
        }
 
199
        void setStiffness(double sfn)
 
200
        {
 
201
                if(sfn == 0.15) return;
 
202
                fprintf(mFile,"\tsetAttr \".sfn\" %f;\n", sfn);
 
203
        }
 
204
        void setStiffnessScale(size_t sts_i,const StiffnessScale& sts)
 
205
        {
 
206
                fprintf(mFile,"\tsetAttr \".sts[%i]\" ",sts_i);
 
207
                sts.write(mFile);
 
208
                fprintf(mFile,";\n");
 
209
        }
 
210
        void setStiffnessScale(size_t sts_start,size_t sts_end,StiffnessScale* sts)
 
211
        {
 
212
                fprintf(mFile,"\tsetAttr \".sts[%i:%i]\" ", sts_start,sts_end);
 
213
                size_t size = (sts_end-sts_start)*1+1;
 
214
                for(size_t i=0;i<size;++i)
 
215
                {
 
216
                        sts[i].write(mFile);
 
217
                        fprintf(mFile,"\n");
 
218
                }
 
219
                fprintf(mFile,";\n");
 
220
        }
 
221
        void startStiffnessScale(size_t sts_start,size_t sts_end)const
 
222
        {
 
223
                fprintf(mFile,"\tsetAttr \".sts[%i:%i]\"",sts_start,sts_end);
 
224
                fprintf(mFile," -type \"StiffnessScale\" ");
 
225
        }
 
226
        void appendStiffnessScale(const StiffnessScale& sts)const
 
227
        {
 
228
                fprintf(mFile," ");
 
229
                sts.write(mFile);
 
230
        }
 
231
        void endStiffnessScale()const
 
232
        {
 
233
                fprintf(mFile,";\n");
 
234
        }
 
235
        void setStiffnessScale_Position(size_t sts_i,float stsp)
 
236
        {
 
237
                if(stsp == 0.0) return;
 
238
                fprintf(mFile,"\tsetAttr \".sts[%i].stsp\" %f;\n", sts_i,stsp);
 
239
        }
 
240
        void setStiffnessScale_FloatValue(size_t sts_i,float stsfv)
 
241
        {
 
242
                if(stsfv == 0.0) return;
 
243
                fprintf(mFile,"\tsetAttr \".sts[%i].stsfv\" %f;\n", sts_i,stsfv);
 
244
        }
 
245
        void setStiffnessScale_Interp(size_t sts_i,unsigned int stsi)
 
246
        {
 
247
                if(stsi == 0) return;
 
248
                fprintf(mFile,"\tsetAttr \".sts[%i].stsi\" %i;\n", sts_i,stsi);
 
249
        }
 
250
        void setLengthFlex(double lfx)
 
251
        {
 
252
                if(lfx == 0.0) return;
 
253
                fprintf(mFile,"\tsetAttr \".lfx\" %f;\n", lfx);
 
254
        }
 
255
        void setDamp(double dmp)
 
256
        {
 
257
                if(dmp == 0.0) return;
 
258
                fprintf(mFile,"\tsetAttr \".dmp\" %f;\n", dmp);
 
259
        }
 
260
        void setDrag(double drg)
 
261
        {
 
262
                if(drg == 0.05) return;
 
263
                fprintf(mFile,"\tsetAttr \".drg\" %f;\n", drg);
 
264
        }
 
265
        void setFriction(double frc)
 
266
        {
 
267
                if(frc == 0.5) return;
 
268
                fprintf(mFile,"\tsetAttr \".frc\" %f;\n", frc);
 
269
        }
 
270
        void setMass(double mss)
 
271
        {
 
272
                if(mss == 1.0) return;
 
273
                fprintf(mFile,"\tsetAttr \".mss\" %f;\n", mss);
 
274
        }
 
275
        void setDynamicsWeight(double dw)
 
276
        {
 
277
                if(dw == 1.0) return;
 
278
                fprintf(mFile,"\tsetAttr \".dw\" %f;\n", dw);
 
279
        }
 
280
        void setCollideWidthOffset(double wid)
 
281
        {
 
282
                if(wid == 0.0) return;
 
283
                fprintf(mFile,"\tsetAttr \".wid\" %f;\n", wid);
 
284
        }
 
285
        void setStaticCling(double stc)
 
286
        {
 
287
                if(stc == 0.0) return;
 
288
                fprintf(mFile,"\tsetAttr \".stc\" %f;\n", stc);
 
289
        }
 
290
        void setRepulsion(double rpl)
 
291
        {
 
292
                if(rpl == 0.5) return;
 
293
                fprintf(mFile,"\tsetAttr \".rpl\" %f;\n", rpl);
 
294
        }
 
295
        void setNumCollideNeighbors(int ncn)
 
296
        {
 
297
                if(ncn == 4) return;
 
298
                fprintf(mFile,"\tsetAttr \".ncn\" %i;\n", ncn);
 
299
        }
 
300
        void setIterations(int itr)
 
301
        {
 
302
                if(itr == 4) return;
 
303
                fprintf(mFile,"\tsetAttr \".itr\" %i;\n", itr);
 
304
        }
 
305
        void setDrawCollideWidth(bool dwd)
 
306
        {
 
307
                if(dwd == false) return;
 
308
                fprintf(mFile,"\tsetAttr \".dwd\" %i;\n", dwd);
 
309
        }
 
310
        void setWidthDrawSkip(int wds)
 
311
        {
 
312
                if(wds == 2) return;
 
313
                fprintf(mFile,"\tsetAttr \".wds\" %i;\n", wds);
 
314
        }
 
315
        void setGravity(double grv)
 
316
        {
 
317
                if(grv == 0.98) return;
 
318
                fprintf(mFile,"\tsetAttr \".grv\" %f;\n", grv);
 
319
        }
 
320
        void setTurbulenceStrength(double tst)
 
321
        {
 
322
                if(tst == 0) return;
 
323
                fprintf(mFile,"\tsetAttr \".tst\" %f;\n", tst);
 
324
        }
 
325
        void setTurbulenceFrequency(double tfr)
 
326
        {
 
327
                if(tfr == 0.2) return;
 
328
                fprintf(mFile,"\tsetAttr \".tfr\" %f;\n", tfr);
 
329
        }
 
330
        void setTurbulenceSpeed(double tbs)
 
331
        {
 
332
                if(tbs == .2) return;
 
333
                fprintf(mFile,"\tsetAttr \".tbs\" %f;\n", tbs);
 
334
        }
 
335
        void setAttractionDamp(double ad)
 
336
        {
 
337
                if(ad == 0.0) return;
 
338
                fprintf(mFile,"\tsetAttr \".ad\" %f;\n", ad);
 
339
        }
 
340
        void setStartCurveAttract(double sct)
 
341
        {
 
342
                if(sct == 0.0) return;
 
343
                fprintf(mFile,"\tsetAttr \".sct\" %f;\n", sct);
 
344
        }
 
345
        void setAttractionScale(size_t ats_i,const AttractionScale& ats)
 
346
        {
 
347
                fprintf(mFile,"\tsetAttr \".ats[%i]\" ",ats_i);
 
348
                ats.write(mFile);
 
349
                fprintf(mFile,";\n");
 
350
        }
 
351
        void setAttractionScale(size_t ats_start,size_t ats_end,AttractionScale* ats)
 
352
        {
 
353
                fprintf(mFile,"\tsetAttr \".ats[%i:%i]\" ", ats_start,ats_end);
 
354
                size_t size = (ats_end-ats_start)*1+1;
 
355
                for(size_t i=0;i<size;++i)
 
356
                {
 
357
                        ats[i].write(mFile);
 
358
                        fprintf(mFile,"\n");
 
359
                }
 
360
                fprintf(mFile,";\n");
 
361
        }
 
362
        void startAttractionScale(size_t ats_start,size_t ats_end)const
 
363
        {
 
364
                fprintf(mFile,"\tsetAttr \".ats[%i:%i]\"",ats_start,ats_end);
 
365
                fprintf(mFile," -type \"AttractionScale\" ");
 
366
        }
 
367
        void appendAttractionScale(const AttractionScale& ats)const
 
368
        {
 
369
                fprintf(mFile," ");
 
370
                ats.write(mFile);
 
371
        }
 
372
        void endAttractionScale()const
 
373
        {
 
374
                fprintf(mFile,";\n");
 
375
        }
 
376
        void setAttractionScale_Position(size_t ats_i,float atsp)
 
377
        {
 
378
                if(atsp == 0.0) return;
 
379
                fprintf(mFile,"\tsetAttr \".ats[%i].atsp\" %f;\n", ats_i,atsp);
 
380
        }
 
381
        void setAttractionScale_FloatValue(size_t ats_i,float atsfv)
 
382
        {
 
383
                if(atsfv == 0.0) return;
 
384
                fprintf(mFile,"\tsetAttr \".ats[%i].atsfv\" %f;\n", ats_i,atsfv);
 
385
        }
 
386
        void setAttractionScale_Interp(size_t ats_i,unsigned int atsi)
 
387
        {
 
388
                if(atsi == 0) return;
 
389
                fprintf(mFile,"\tsetAttr \".ats[%i].atsi\" %i;\n", ats_i,atsi);
 
390
        }
 
391
        void setMotionDrag(double mdg)
 
392
        {
 
393
                if(mdg == 0.0) return;
 
394
                fprintf(mFile,"\tsetAttr \".mdg\" %f;\n", mdg);
 
395
        }
 
396
        void setDisplayQuality(double dpq)
 
397
        {
 
398
                if(dpq == 100.0) return;
 
399
                fprintf(mFile,"\tsetAttr \".dpq\" %f;\n", dpq);
 
400
        }
 
401
        void setNoStretch(bool nst)
 
402
        {
 
403
                if(nst == false) return;
 
404
                fprintf(mFile,"\tsetAttr \".nst\" %i;\n", nst);
 
405
        }
 
406
        void setSubSegments(int ssg)
 
407
        {
 
408
                if(ssg == 0) return;
 
409
                fprintf(mFile,"\tsetAttr \".ssg\" %i;\n", ssg);
 
410
        }
 
411
        void setClumpWidth(double cwd)
 
412
        {
 
413
                if(cwd == 0.3) return;
 
414
                fprintf(mFile,"\tsetAttr \".cwd\" %f;\n", cwd);
 
415
        }
 
416
        void setClumpWidthScale(size_t cws_i,const ClumpWidthScale& cws)
 
417
        {
 
418
                fprintf(mFile,"\tsetAttr \".cws[%i]\" ",cws_i);
 
419
                cws.write(mFile);
 
420
                fprintf(mFile,";\n");
 
421
        }
 
422
        void setClumpWidthScale(size_t cws_start,size_t cws_end,ClumpWidthScale* cws)
 
423
        {
 
424
                fprintf(mFile,"\tsetAttr \".cws[%i:%i]\" ", cws_start,cws_end);
 
425
                size_t size = (cws_end-cws_start)*1+1;
 
426
                for(size_t i=0;i<size;++i)
 
427
                {
 
428
                        cws[i].write(mFile);
 
429
                        fprintf(mFile,"\n");
 
430
                }
 
431
                fprintf(mFile,";\n");
 
432
        }
 
433
        void startClumpWidthScale(size_t cws_start,size_t cws_end)const
 
434
        {
 
435
                fprintf(mFile,"\tsetAttr \".cws[%i:%i]\"",cws_start,cws_end);
 
436
                fprintf(mFile," -type \"ClumpWidthScale\" ");
 
437
        }
 
438
        void appendClumpWidthScale(const ClumpWidthScale& cws)const
 
439
        {
 
440
                fprintf(mFile," ");
 
441
                cws.write(mFile);
 
442
        }
 
443
        void endClumpWidthScale()const
 
444
        {
 
445
                fprintf(mFile,";\n");
 
446
        }
 
447
        void setClumpWidthScale_Position(size_t cws_i,float cwsp)
 
448
        {
 
449
                if(cwsp == 0.0) return;
 
450
                fprintf(mFile,"\tsetAttr \".cws[%i].cwsp\" %f;\n", cws_i,cwsp);
 
451
        }
 
452
        void setClumpWidthScale_FloatValue(size_t cws_i,float cwsfv)
 
453
        {
 
454
                if(cwsfv == 0.0) return;
 
455
                fprintf(mFile,"\tsetAttr \".cws[%i].cwsfv\" %f;\n", cws_i,cwsfv);
 
456
        }
 
457
        void setClumpWidthScale_Interp(size_t cws_i,unsigned int cwsi)
 
458
        {
 
459
                if(cwsi == 0) return;
 
460
                fprintf(mFile,"\tsetAttr \".cws[%i].cwsi\" %i;\n", cws_i,cwsi);
 
461
        }
 
462
        void setClumpTwist(double ctw)
 
463
        {
 
464
                if(ctw == 0.0) return;
 
465
                fprintf(mFile,"\tsetAttr \".ctw\" %f;\n", ctw);
 
466
        }
 
467
        void setClumpCurl(size_t clc_i,const ClumpCurl& clc)
 
468
        {
 
469
                fprintf(mFile,"\tsetAttr \".clc[%i]\" ",clc_i);
 
470
                clc.write(mFile);
 
471
                fprintf(mFile,";\n");
 
472
        }
 
473
        void setClumpCurl(size_t clc_start,size_t clc_end,ClumpCurl* clc)
 
474
        {
 
475
                fprintf(mFile,"\tsetAttr \".clc[%i:%i]\" ", clc_start,clc_end);
 
476
                size_t size = (clc_end-clc_start)*1+1;
 
477
                for(size_t i=0;i<size;++i)
 
478
                {
 
479
                        clc[i].write(mFile);
 
480
                        fprintf(mFile,"\n");
 
481
                }
 
482
                fprintf(mFile,";\n");
 
483
        }
 
484
        void startClumpCurl(size_t clc_start,size_t clc_end)const
 
485
        {
 
486
                fprintf(mFile,"\tsetAttr \".clc[%i:%i]\"",clc_start,clc_end);
 
487
                fprintf(mFile," -type \"ClumpCurl\" ");
 
488
        }
 
489
        void appendClumpCurl(const ClumpCurl& clc)const
 
490
        {
 
491
                fprintf(mFile," ");
 
492
                clc.write(mFile);
 
493
        }
 
494
        void endClumpCurl()const
 
495
        {
 
496
                fprintf(mFile,";\n");
 
497
        }
 
498
        void setClumpCurl_Position(size_t clc_i,float clcp)
 
499
        {
 
500
                if(clcp == 0.0) return;
 
501
                fprintf(mFile,"\tsetAttr \".clc[%i].clcp\" %f;\n", clc_i,clcp);
 
502
        }
 
503
        void setClumpCurl_FloatValue(size_t clc_i,float clcfv)
 
504
        {
 
505
                if(clcfv == 0.0) return;
 
506
                fprintf(mFile,"\tsetAttr \".clc[%i].clcfv\" %f;\n", clc_i,clcfv);
 
507
        }
 
508
        void setClumpCurl_Interp(size_t clc_i,unsigned int clci)
 
509
        {
 
510
                if(clci == 0) return;
 
511
                fprintf(mFile,"\tsetAttr \".clc[%i].clci\" %i;\n", clc_i,clci);
 
512
        }
 
513
        void setClumpFlatness(size_t cfl_i,const ClumpFlatness& cfl)
 
514
        {
 
515
                fprintf(mFile,"\tsetAttr \".cfl[%i]\" ",cfl_i);
 
516
                cfl.write(mFile);
 
517
                fprintf(mFile,";\n");
 
518
        }
 
519
        void setClumpFlatness(size_t cfl_start,size_t cfl_end,ClumpFlatness* cfl)
 
520
        {
 
521
                fprintf(mFile,"\tsetAttr \".cfl[%i:%i]\" ", cfl_start,cfl_end);
 
522
                size_t size = (cfl_end-cfl_start)*1+1;
 
523
                for(size_t i=0;i<size;++i)
 
524
                {
 
525
                        cfl[i].write(mFile);
 
526
                        fprintf(mFile,"\n");
 
527
                }
 
528
                fprintf(mFile,";\n");
 
529
        }
 
530
        void startClumpFlatness(size_t cfl_start,size_t cfl_end)const
 
531
        {
 
532
                fprintf(mFile,"\tsetAttr \".cfl[%i:%i]\"",cfl_start,cfl_end);
 
533
                fprintf(mFile," -type \"ClumpFlatness\" ");
 
534
        }
 
535
        void appendClumpFlatness(const ClumpFlatness& cfl)const
 
536
        {
 
537
                fprintf(mFile," ");
 
538
                cfl.write(mFile);
 
539
        }
 
540
        void endClumpFlatness()const
 
541
        {
 
542
                fprintf(mFile,";\n");
 
543
        }
 
544
        void setClumpFlatness_Position(size_t cfl_i,float cflp)
 
545
        {
 
546
                if(cflp == 0.0) return;
 
547
                fprintf(mFile,"\tsetAttr \".cfl[%i].cflp\" %f;\n", cfl_i,cflp);
 
548
        }
 
549
        void setClumpFlatness_FloatValue(size_t cfl_i,float cflfv)
 
550
        {
 
551
                if(cflfv == 0.0) return;
 
552
                fprintf(mFile,"\tsetAttr \".cfl[%i].cflfv\" %f;\n", cfl_i,cflfv);
 
553
        }
 
554
        void setClumpFlatness_Interp(size_t cfl_i,unsigned int cfli)
 
555
        {
 
556
                if(cfli == 0) return;
 
557
                fprintf(mFile,"\tsetAttr \".cfl[%i].cfli\" %i;\n", cfl_i,cfli);
 
558
        }
 
559
        void setBendFollow(double bnf)
 
560
        {
 
561
                if(bnf == 1.0) return;
 
562
                fprintf(mFile,"\tsetAttr \".bnf\" %f;\n", bnf);
 
563
        }
 
564
        void setHairWidth(double hwd)
 
565
        {
 
566
                if(hwd == 0.01) return;
 
567
                fprintf(mFile,"\tsetAttr \".hwd\" %f;\n", hwd);
 
568
        }
 
569
        void setHairWidthScale(size_t hws_i,const HairWidthScale& hws)
 
570
        {
 
571
                fprintf(mFile,"\tsetAttr \".hws[%i]\" ",hws_i);
 
572
                hws.write(mFile);
 
573
                fprintf(mFile,";\n");
 
574
        }
 
575
        void setHairWidthScale(size_t hws_start,size_t hws_end,HairWidthScale* hws)
 
576
        {
 
577
                fprintf(mFile,"\tsetAttr \".hws[%i:%i]\" ", hws_start,hws_end);
 
578
                size_t size = (hws_end-hws_start)*1+1;
 
579
                for(size_t i=0;i<size;++i)
 
580
                {
 
581
                        hws[i].write(mFile);
 
582
                        fprintf(mFile,"\n");
 
583
                }
 
584
                fprintf(mFile,";\n");
 
585
        }
 
586
        void startHairWidthScale(size_t hws_start,size_t hws_end)const
 
587
        {
 
588
                fprintf(mFile,"\tsetAttr \".hws[%i:%i]\"",hws_start,hws_end);
 
589
                fprintf(mFile," -type \"HairWidthScale\" ");
 
590
        }
 
591
        void appendHairWidthScale(const HairWidthScale& hws)const
 
592
        {
 
593
                fprintf(mFile," ");
 
594
                hws.write(mFile);
 
595
        }
 
596
        void endHairWidthScale()const
 
597
        {
 
598
                fprintf(mFile,";\n");
 
599
        }
 
600
        void setHairWidthScale_Position(size_t hws_i,float hwsp)
 
601
        {
 
602
                if(hwsp == 0.0) return;
 
603
                fprintf(mFile,"\tsetAttr \".hws[%i].hwsp\" %f;\n", hws_i,hwsp);
 
604
        }
 
605
        void setHairWidthScale_FloatValue(size_t hws_i,float hwsfv)
 
606
        {
 
607
                if(hwsfv == 0.0) return;
 
608
                fprintf(mFile,"\tsetAttr \".hws[%i].hwsfv\" %f;\n", hws_i,hwsfv);
 
609
        }
 
610
        void setHairWidthScale_Interp(size_t hws_i,unsigned int hwsi)
 
611
        {
 
612
                if(hwsi == 0) return;
 
613
                fprintf(mFile,"\tsetAttr \".hws[%i].hwsi\" %i;\n", hws_i,hwsi);
 
614
        }
 
615
        void setBaldnessMap(double bmp)
 
616
        {
 
617
                if(bmp == 1.0) return;
 
618
                fprintf(mFile,"\tsetAttr \".bmp\" %f;\n", bmp);
 
619
        }
 
620
        void setOpacity(double opc)
 
621
        {
 
622
                if(opc == 1.0) return;
 
623
                fprintf(mFile,"\tsetAttr \".opc\" %f;\n", opc);
 
624
        }
 
625
        void setHairColor(const float3& hcl)
 
626
        {
 
627
                fprintf(mFile,"\tsetAttr \".hcl\" -type \"float3\" ");
 
628
                hcl.write(mFile);
 
629
                fprintf(mFile,";\n");
 
630
        }
 
631
        void setHairColorR(float hcr)
 
632
        {
 
633
                if(hcr == 0.3) return;
 
634
                fprintf(mFile,"\tsetAttr \".hcl.hcr\" %f;\n", hcr);
 
635
        }
 
636
        void setHairColorG(float hcg)
 
637
        {
 
638
                if(hcg == 0.25) return;
 
639
                fprintf(mFile,"\tsetAttr \".hcl.hcg\" %f;\n", hcg);
 
640
        }
 
641
        void setHairColorB(float hcb)
 
642
        {
 
643
                if(hcb == 0.15) return;
 
644
                fprintf(mFile,"\tsetAttr \".hcl.hcb\" %f;\n", hcb);
 
645
        }
 
646
        void setHairColorScale(size_t hcs_i,const HairColorScale& hcs)
 
647
        {
 
648
                fprintf(mFile,"\tsetAttr \".hcs[%i]\" ",hcs_i);
 
649
                hcs.write(mFile);
 
650
                fprintf(mFile,";\n");
 
651
        }
 
652
        void setHairColorScale(size_t hcs_start,size_t hcs_end,HairColorScale* hcs)
 
653
        {
 
654
                fprintf(mFile,"\tsetAttr \".hcs[%i:%i]\" ", hcs_start,hcs_end);
 
655
                size_t size = (hcs_end-hcs_start)*1+1;
 
656
                for(size_t i=0;i<size;++i)
 
657
                {
 
658
                        hcs[i].write(mFile);
 
659
                        fprintf(mFile,"\n");
 
660
                }
 
661
                fprintf(mFile,";\n");
 
662
        }
 
663
        void startHairColorScale(size_t hcs_start,size_t hcs_end)const
 
664
        {
 
665
                fprintf(mFile,"\tsetAttr \".hcs[%i:%i]\"",hcs_start,hcs_end);
 
666
                fprintf(mFile," -type \"HairColorScale\" ");
 
667
        }
 
668
        void appendHairColorScale(const HairColorScale& hcs)const
 
669
        {
 
670
                fprintf(mFile," ");
 
671
                hcs.write(mFile);
 
672
        }
 
673
        void endHairColorScale()const
 
674
        {
 
675
                fprintf(mFile,";\n");
 
676
        }
 
677
        void setHairColorScale_Position(size_t hcs_i,float hcsp)
 
678
        {
 
679
                if(hcsp == 0.0) return;
 
680
                fprintf(mFile,"\tsetAttr \".hcs[%i].hcsp\" %f;\n", hcs_i,hcsp);
 
681
        }
 
682
        void setHairColorScale_Color(size_t hcs_i,const float3& hcsc)
 
683
        {
 
684
                fprintf(mFile,"\tsetAttr \".hcs[%i].hcsc\" -type \"float3\" ",hcs_i);
 
685
                hcsc.write(mFile);
 
686
                fprintf(mFile,";\n");
 
687
        }
 
688
        void setHairColorScale_ColorR(size_t hcs_i,float hcscr)
 
689
        {
 
690
                if(hcscr == 0.0) return;
 
691
                fprintf(mFile,"\tsetAttr \".hcs[%i].hcsc.hcscr\" %f;\n", hcs_i,hcscr);
 
692
        }
 
693
        void setHairColorScale_ColorG(size_t hcs_i,float hcscg)
 
694
        {
 
695
                if(hcscg == 0.0) return;
 
696
                fprintf(mFile,"\tsetAttr \".hcs[%i].hcsc.hcscg\" %f;\n", hcs_i,hcscg);
 
697
        }
 
698
        void setHairColorScale_ColorB(size_t hcs_i,float hcscb)
 
699
        {
 
700
                if(hcscb == 0.0) return;
 
701
                fprintf(mFile,"\tsetAttr \".hcs[%i].hcsc.hcscb\" %f;\n", hcs_i,hcscb);
 
702
        }
 
703
        void setHairColorScale_Interp(size_t hcs_i,unsigned int hcsi)
 
704
        {
 
705
                if(hcsi == 0) return;
 
706
                fprintf(mFile,"\tsetAttr \".hcs[%i].hcsi\" %i;\n", hcs_i,hcsi);
 
707
        }
 
708
        void setHairsPerClump(int hpc)
 
709
        {
 
710
                if(hpc == 10) return;
 
711
                fprintf(mFile,"\tsetAttr \".hpc\" %i;\n", hpc);
 
712
        }
 
713
        void setThinning(double thn)
 
714
        {
 
715
                if(thn == 0.0) return;
 
716
                fprintf(mFile,"\tsetAttr \".thn\" %f;\n", thn);
 
717
        }
 
718
        void setTranslucence(double tlc)
 
719
        {
 
720
                if(tlc == 0.5) return;
 
721
                fprintf(mFile,"\tsetAttr \".tlc\" %f;\n", tlc);
 
722
        }
 
723
        void setSpecularColor(const float3& spc)
 
724
        {
 
725
                fprintf(mFile,"\tsetAttr \".spc\" -type \"float3\" ");
 
726
                spc.write(mFile);
 
727
                fprintf(mFile,";\n");
 
728
        }
 
729
        void setSpecularColorR(float spr)
 
730
        {
 
731
                if(spr == 0.35) return;
 
732
                fprintf(mFile,"\tsetAttr \".spc.spr\" %f;\n", spr);
 
733
        }
 
734
        void setSpecularColorG(float spg)
 
735
        {
 
736
                if(spg == 0.35) return;
 
737
                fprintf(mFile,"\tsetAttr \".spc.spg\" %f;\n", spg);
 
738
        }
 
739
        void setSpecularColorB(float spb)
 
740
        {
 
741
                if(spb == 0.3) return;
 
742
                fprintf(mFile,"\tsetAttr \".spc.spb\" %f;\n", spb);
 
743
        }
 
744
        void setSpecularPower(double spp)
 
745
        {
 
746
                if(spp == 3.0) return;
 
747
                fprintf(mFile,"\tsetAttr \".spp\" %f;\n", spp);
 
748
        }
 
749
        void setCastShadows(bool csd)
 
750
        {
 
751
                if(csd == true) return;
 
752
                fprintf(mFile,"\tsetAttr \".csd\" %i;\n", csd);
 
753
        }
 
754
        void setDiffuseRand(double dfr)
 
755
        {
 
756
                if(dfr == 0.2) return;
 
757
                fprintf(mFile,"\tsetAttr \".dfr\" %f;\n", dfr);
 
758
        }
 
759
        void setSpecularRand(double sra)
 
760
        {
 
761
                if(sra == 0.4) return;
 
762
                fprintf(mFile,"\tsetAttr \".sra\" %f;\n", sra);
 
763
        }
 
764
        void setHueRand(double chr)
 
765
        {
 
766
                if(chr == 0.0) return;
 
767
                fprintf(mFile,"\tsetAttr \".chr\" %f;\n", chr);
 
768
        }
 
769
        void setSatRand(double csr)
 
770
        {
 
771
                if(csr == 0.0) return;
 
772
                fprintf(mFile,"\tsetAttr \".csr\" %f;\n", csr);
 
773
        }
 
774
        void setValRand(double cvr)
 
775
        {
 
776
                if(cvr == 0.0) return;
 
777
                fprintf(mFile,"\tsetAttr \".cvr\" %f;\n", cvr);
 
778
        }
 
779
        void setMultiStreaks(int mst)
 
780
        {
 
781
                if(mst == 0) return;
 
782
                fprintf(mFile,"\tsetAttr \".mst\" %i;\n", mst);
 
783
        }
 
784
        void setMultiStreakSpread1(double ms1)
 
785
        {
 
786
                if(ms1 == 0.3) return;
 
787
                fprintf(mFile,"\tsetAttr \".ms1\" %f;\n", ms1);
 
788
        }
 
789
        void setMultiStreakSpread2(double ms2)
 
790
        {
 
791
                if(ms2 == 0.1) return;
 
792
                fprintf(mFile,"\tsetAttr \".ms2\" %f;\n", ms2);
 
793
        }
 
794
        void setLightEachHair(bool leh)
 
795
        {
 
796
                if(leh == false) return;
 
797
                fprintf(mFile,"\tsetAttr \".leh\" %i;\n", leh);
 
798
        }
 
799
        void setDisplacementScale(size_t dsc_i,const DisplacementScale& dsc)
 
800
        {
 
801
                fprintf(mFile,"\tsetAttr \".dsc[%i]\" ",dsc_i);
 
802
                dsc.write(mFile);
 
803
                fprintf(mFile,";\n");
 
804
        }
 
805
        void setDisplacementScale(size_t dsc_start,size_t dsc_end,DisplacementScale* dsc)
 
806
        {
 
807
                fprintf(mFile,"\tsetAttr \".dsc[%i:%i]\" ", dsc_start,dsc_end);
 
808
                size_t size = (dsc_end-dsc_start)*1+1;
 
809
                for(size_t i=0;i<size;++i)
 
810
                {
 
811
                        dsc[i].write(mFile);
 
812
                        fprintf(mFile,"\n");
 
813
                }
 
814
                fprintf(mFile,";\n");
 
815
        }
 
816
        void startDisplacementScale(size_t dsc_start,size_t dsc_end)const
 
817
        {
 
818
                fprintf(mFile,"\tsetAttr \".dsc[%i:%i]\"",dsc_start,dsc_end);
 
819
                fprintf(mFile," -type \"DisplacementScale\" ");
 
820
        }
 
821
        void appendDisplacementScale(const DisplacementScale& dsc)const
 
822
        {
 
823
                fprintf(mFile," ");
 
824
                dsc.write(mFile);
 
825
        }
 
826
        void endDisplacementScale()const
 
827
        {
 
828
                fprintf(mFile,";\n");
 
829
        }
 
830
        void setDisplacementScale_Position(size_t dsc_i,float dscp)
 
831
        {
 
832
                if(dscp == 0.0) return;
 
833
                fprintf(mFile,"\tsetAttr \".dsc[%i].dscp\" %f;\n", dsc_i,dscp);
 
834
        }
 
835
        void setDisplacementScale_FloatValue(size_t dsc_i,float dscfv)
 
836
        {
 
837
                if(dscfv == 0.0) return;
 
838
                fprintf(mFile,"\tsetAttr \".dsc[%i].dscfv\" %f;\n", dsc_i,dscfv);
 
839
        }
 
840
        void setDisplacementScale_Interp(size_t dsc_i,unsigned int dsci)
 
841
        {
 
842
                if(dsci == 0) return;
 
843
                fprintf(mFile,"\tsetAttr \".dsc[%i].dsci\" %i;\n", dsc_i,dsci);
 
844
        }
 
845
        void setCurl(double crl)
 
846
        {
 
847
                if(crl == 0.0) return;
 
848
                fprintf(mFile,"\tsetAttr \".crl\" %f;\n", crl);
 
849
        }
 
850
        void setCurlFrequency(double crf)
 
851
        {
 
852
                if(crf == 10) return;
 
853
                fprintf(mFile,"\tsetAttr \".crf\" %f;\n", crf);
 
854
        }
 
855
        void setNoiseMethod(unsigned int nmt)
 
856
        {
 
857
                if(nmt == 0) return;
 
858
                fprintf(mFile,"\tsetAttr \".nmt\" %i;\n", nmt);
 
859
        }
 
860
        void setNoise(double noi)
 
861
        {
 
862
                if(noi == 0.0) return;
 
863
                fprintf(mFile,"\tsetAttr \".noi\" %f;\n", noi);
 
864
        }
 
865
        void setDetailNoise(double dno)
 
866
        {
 
867
                if(dno == 0.0) return;
 
868
                fprintf(mFile,"\tsetAttr \".dno\" %f;\n", dno);
 
869
        }
 
870
        void setNoiseFrequency(double nof)
 
871
        {
 
872
                if(nof == 0.4) return;
 
873
                fprintf(mFile,"\tsetAttr \".nof\" %f;\n", nof);
 
874
        }
 
875
        void setNoiseFrequencyU(double nfu)
 
876
        {
 
877
                if(nfu == 1.0) return;
 
878
                fprintf(mFile,"\tsetAttr \".nfu\" %f;\n", nfu);
 
879
        }
 
880
        void setNoiseFrequencyV(double nfv)
 
881
        {
 
882
                if(nfv == 1.0) return;
 
883
                fprintf(mFile,"\tsetAttr \".nfv\" %f;\n", nfv);
 
884
        }
 
885
        void setNoiseFrequencyW(double nfw)
 
886
        {
 
887
                if(nfw == 1.0) return;
 
888
                fprintf(mFile,"\tsetAttr \".nfw\" %f;\n", nfw);
 
889
        }
 
890
        void setSubClumpMethod(unsigned int scm)
 
891
        {
 
892
                if(scm == 0) return;
 
893
                fprintf(mFile,"\tsetAttr \".scm\" %i;\n", scm);
 
894
        }
 
895
        void setSubClumping(double scp)
 
896
        {
 
897
                if(scp == 0.0) return;
 
898
                fprintf(mFile,"\tsetAttr \".scp\" %f;\n", scp);
 
899
        }
 
900
        void setSubClumpRand(double scr)
 
901
        {
 
902
                if(scr == 0.0) return;
 
903
                fprintf(mFile,"\tsetAttr \".scr\" %f;\n", scr);
 
904
        }
 
905
        void setNumUClumps(double nuc)
 
906
        {
 
907
                if(nuc == 15.0) return;
 
908
                fprintf(mFile,"\tsetAttr \".nuc\" %f;\n", nuc);
 
909
        }
 
910
        void setNumVClumps(double nvc)
 
911
        {
 
912
                if(nvc == 15.0) return;
 
913
                fprintf(mFile,"\tsetAttr \".nvc\" %f;\n", nvc);
 
914
        }
 
915
        void setClumpInterpolation(double cin)
 
916
        {
 
917
                if(cin == 0.0) return;
 
918
                fprintf(mFile,"\tsetAttr \".cin\" %f;\n", cin);
 
919
        }
 
920
        void setInterpolationRange(double inr)
 
921
        {
 
922
                if(inr == 8.0) return;
 
923
                fprintf(mFile,"\tsetAttr \".inr\" %f;\n", inr);
 
924
        }
 
925
        void setStartFrame(double stf)
 
926
        {
 
927
                if(stf == 1.0) return;
 
928
                fprintf(mFile,"\tsetAttr \".stf\" %f;\n", stf);
 
929
        }
 
930
        void setUsePre70ForceIntensity(bool upfi)
 
931
        {
 
932
                if(upfi == false) return;
 
933
                fprintf(mFile,"\tsetAttr \".upfi\" %i;\n", upfi);
 
934
        }
 
935
        void setReceiveShadows(bool rcsh)
 
936
        {
 
937
                if(rcsh == true) return;
 
938
                fprintf(mFile,"\tsetAttr \".rcsh\" %i;\n", rcsh);
 
939
        }
 
940
        void setVisibleInReflections(bool vir)
 
941
        {
 
942
                if(vir == false) return;
 
943
                fprintf(mFile,"\tsetAttr \".vir\" %i;\n", vir);
 
944
        }
 
945
        void setVisibleInRefractions(bool vif)
 
946
        {
 
947
                if(vif == false) return;
 
948
                fprintf(mFile,"\tsetAttr \".vif\" %i;\n", vif);
 
949
        }
 
950
        void setMentalRayControls(const MentalRayControls& mrc)
 
951
        {
 
952
                fprintf(mFile,"\tsetAttr \".mrc\" ");
 
953
                mrc.write(mFile);
 
954
                fprintf(mFile,";\n");
 
955
        }
 
956
        void setMiOverrideCaustics(bool oca)
 
957
        {
 
958
                if(oca == false) return;
 
959
                fprintf(mFile,"\tsetAttr \".mrc.oca\" %i;\n", oca);
 
960
        }
 
961
        void setMiCausticAccuracy(short caa)
 
962
        {
 
963
                if(caa == 64) return;
 
964
                fprintf(mFile,"\tsetAttr \".mrc.caa\" %i;\n", caa);
 
965
        }
 
966
        void setMiCausticRadius(float car)
 
967
        {
 
968
                if(car == 0) return;
 
969
                fprintf(mFile,"\tsetAttr \".mrc.car\" %f;\n", car);
 
970
        }
 
971
        void setMiOverrideGlobalIllumination(bool ogi)
 
972
        {
 
973
                if(ogi == false) return;
 
974
                fprintf(mFile,"\tsetAttr \".mrc.ogi\" %i;\n", ogi);
 
975
        }
 
976
        void setMiGlobillumAccuracy(short gia)
 
977
        {
 
978
                if(gia == 64) return;
 
979
                fprintf(mFile,"\tsetAttr \".mrc.gia\" %i;\n", gia);
 
980
        }
 
981
        void setMiGlobillumRadius(float gir)
 
982
        {
 
983
                if(gir == 0) return;
 
984
                fprintf(mFile,"\tsetAttr \".mrc.gir\" %f;\n", gir);
 
985
        }
 
986
        void setMiOverrideFinalGather(bool ofg)
 
987
        {
 
988
                if(ofg == false) return;
 
989
                fprintf(mFile,"\tsetAttr \".mrc.ofg\" %i;\n", ofg);
 
990
        }
 
991
        void setMiFinalGatherRays(int fry)
 
992
        {
 
993
                if(fry == 1000) return;
 
994
                fprintf(mFile,"\tsetAttr \".mrc.fry\" %i;\n", fry);
 
995
        }
 
996
        void setMiFinalGatherMinRadius(float fmn)
 
997
        {
 
998
                if(fmn == 0) return;
 
999
                fprintf(mFile,"\tsetAttr \".mrc.fmn\" %f;\n", fmn);
 
1000
        }
 
1001
        void setMiFinalGatherMaxRadius(float fmx)
 
1002
        {
 
1003
                if(fmx == 0) return;
 
1004
                fprintf(mFile,"\tsetAttr \".mrc.fmx\" %f;\n", fmx);
 
1005
        }
 
1006
        void setMiFinalGatherFilter(short ffi)
 
1007
        {
 
1008
                if(ffi == 1) return;
 
1009
                fprintf(mFile,"\tsetAttr \".mrc.ffi\" %i;\n", ffi);
 
1010
        }
 
1011
        void setMiFinalGatherView(bool fgv)
 
1012
        {
 
1013
                if(fgv == false) return;
 
1014
                fprintf(mFile,"\tsetAttr \".mrc.fgv\" %i;\n", fgv);
 
1015
        }
 
1016
        void setMiOverrideSamples(bool oos)
 
1017
        {
 
1018
                if(oos == false) return;
 
1019
                fprintf(mFile,"\tsetAttr \".mrc.oos\" %i;\n", oos);
 
1020
        }
 
1021
        void setMiMinSamples(short mins)
 
1022
        {
 
1023
                if(mins == 0) return;
 
1024
                fprintf(mFile,"\tsetAttr \".mrc.mins\" %i;\n", mins);
 
1025
        }
 
1026
        void setMiMaxSamples(short maxs)
 
1027
        {
 
1028
                if(maxs == 2) return;
 
1029
                fprintf(mFile,"\tsetAttr \".mrc.maxs\" %i;\n", maxs);
 
1030
        }
 
1031
        void setMiFinalGatherCast(bool fgc)
 
1032
        {
 
1033
                if(fgc == true) return;
 
1034
                fprintf(mFile,"\tsetAttr \".mrc.fgc\" %i;\n", fgc);
 
1035
        }
 
1036
        void setMiFinalGatherReceive(bool fge)
 
1037
        {
 
1038
                if(fge == true) return;
 
1039
                fprintf(mFile,"\tsetAttr \".mrc.fge\" %i;\n", fge);
 
1040
        }
 
1041
        void setMiTransparencyCast(bool tpc)
 
1042
        {
 
1043
                if(tpc == true) return;
 
1044
                fprintf(mFile,"\tsetAttr \".mrc.tpc\" %i;\n", tpc);
 
1045
        }
 
1046
        void setMiTransparencyReceive(bool tpr)
 
1047
        {
 
1048
                if(tpr == true) return;
 
1049
                fprintf(mFile,"\tsetAttr \".mrc.tpr\" %i;\n", tpr);
 
1050
        }
 
1051
        void setOutputHair(size_t oh_i,const vectorArray& oh)
 
1052
        {
 
1053
                if(oh.size == 0) return;
 
1054
                fprintf(mFile,"\tsetAttr \".oh[%i]\" -type \"vectorArray\" ",oh_i);
 
1055
                oh.write(mFile);
 
1056
                fprintf(mFile,";\n");
 
1057
        }
 
1058
        void setOutputHair(size_t oh_start,size_t oh_end,vectorArray* oh)
 
1059
        {
 
1060
                fprintf(mFile,"\tsetAttr \".oh[%i:%i]\" ", oh_start,oh_end);
 
1061
                size_t size = (oh_end-oh_start)*1+1;
 
1062
                for(size_t i=0;i<size;++i)
 
1063
                {
 
1064
                        oh[i].write(mFile);
 
1065
                        fprintf(mFile,"\n");
 
1066
                }
 
1067
                fprintf(mFile,";\n");
 
1068
        }
 
1069
        void startOutputHair(size_t oh_start,size_t oh_end)const
 
1070
        {
 
1071
                fprintf(mFile,"\tsetAttr \".oh[%i:%i]\"",oh_start,oh_end);
 
1072
                fprintf(mFile," -type \"vectorArray\" ");
 
1073
        }
 
1074
        void appendOutputHair(const vectorArray& oh)const
 
1075
        {
 
1076
                fprintf(mFile," ");
 
1077
                oh.write(mFile);
 
1078
        }
 
1079
        void endOutputHair()const
 
1080
        {
 
1081
                fprintf(mFile,";\n");
 
1082
        }
 
1083
        void getSimulationMethod()const
 
1084
        {
 
1085
                fprintf(mFile,"\"%s.sim\"",mName.c_str());
 
1086
        }
 
1087
        void getInputHair(size_t ih_i)const
 
1088
        {
 
1089
                fprintf(mFile,"\"%s.ih[%i]\"",mName.c_str(),ih_i);
 
1090
        }
 
1091
        void getInputHair()const
 
1092
        {
 
1093
 
 
1094
                fprintf(mFile,"\"%s.ih\"",mName.c_str());
 
1095
        }
 
1096
        void getInputHairPin(size_t ihp_i)const
 
1097
        {
 
1098
                fprintf(mFile,"\"%s.ihp[%i]\"",mName.c_str(),ihp_i);
 
1099
        }
 
1100
        void getInputHairPin()const
 
1101
        {
 
1102
 
 
1103
                fprintf(mFile,"\"%s.ihp\"",mName.c_str());
 
1104
        }
 
1105
        void getCollide()const
 
1106
        {
 
1107
                fprintf(mFile,"\"%s.cld\"",mName.c_str());
 
1108
        }
 
1109
        void getCollideOverSample()const
 
1110
        {
 
1111
                fprintf(mFile,"\"%s.cos\"",mName.c_str());
 
1112
        }
 
1113
        void getSelfCollide()const
 
1114
        {
 
1115
                fprintf(mFile,"\"%s.scd\"",mName.c_str());
 
1116
        }
 
1117
        void getCollideGround()const
 
1118
        {
 
1119
                fprintf(mFile,"\"%s.cdg\"",mName.c_str());
 
1120
        }
 
1121
        void getGroundHeight()const
 
1122
        {
 
1123
                fprintf(mFile,"\"%s.ghe\"",mName.c_str());
 
1124
        }
 
1125
        void getStiffness()const
 
1126
        {
 
1127
                fprintf(mFile,"\"%s.sfn\"",mName.c_str());
 
1128
        }
 
1129
        void getStiffnessScale(size_t sts_i)const
 
1130
        {
 
1131
                fprintf(mFile,"\"%s.sts[%i]\"",mName.c_str(),sts_i);
 
1132
        }
 
1133
        void getStiffnessScale()const
 
1134
        {
 
1135
 
 
1136
                fprintf(mFile,"\"%s.sts\"",mName.c_str());
 
1137
        }
 
1138
        void getStiffnessScale_Position(size_t sts_i)const
 
1139
        {
 
1140
                fprintf(mFile,"\"%s.sts[%i].stsp\"",mName.c_str(),sts_i);
 
1141
        }
 
1142
        void getStiffnessScale_Position()const
 
1143
        {
 
1144
 
 
1145
                fprintf(mFile,"\"%s.sts.stsp\"",mName.c_str());
 
1146
        }
 
1147
        void getStiffnessScale_FloatValue(size_t sts_i)const
 
1148
        {
 
1149
                fprintf(mFile,"\"%s.sts[%i].stsfv\"",mName.c_str(),sts_i);
 
1150
        }
 
1151
        void getStiffnessScale_FloatValue()const
 
1152
        {
 
1153
 
 
1154
                fprintf(mFile,"\"%s.sts.stsfv\"",mName.c_str());
 
1155
        }
 
1156
        void getStiffnessScale_Interp(size_t sts_i)const
 
1157
        {
 
1158
                fprintf(mFile,"\"%s.sts[%i].stsi\"",mName.c_str(),sts_i);
 
1159
        }
 
1160
        void getStiffnessScale_Interp()const
 
1161
        {
 
1162
 
 
1163
                fprintf(mFile,"\"%s.sts.stsi\"",mName.c_str());
 
1164
        }
 
1165
        void getLengthFlex()const
 
1166
        {
 
1167
                fprintf(mFile,"\"%s.lfx\"",mName.c_str());
 
1168
        }
 
1169
        void getDamp()const
 
1170
        {
 
1171
                fprintf(mFile,"\"%s.dmp\"",mName.c_str());
 
1172
        }
 
1173
        void getDrag()const
 
1174
        {
 
1175
                fprintf(mFile,"\"%s.drg\"",mName.c_str());
 
1176
        }
 
1177
        void getFriction()const
 
1178
        {
 
1179
                fprintf(mFile,"\"%s.frc\"",mName.c_str());
 
1180
        }
 
1181
        void getMass()const
 
1182
        {
 
1183
                fprintf(mFile,"\"%s.mss\"",mName.c_str());
 
1184
        }
 
1185
        void getDynamicsWeight()const
 
1186
        {
 
1187
                fprintf(mFile,"\"%s.dw\"",mName.c_str());
 
1188
        }
 
1189
        void getCollideWidthOffset()const
 
1190
        {
 
1191
                fprintf(mFile,"\"%s.wid\"",mName.c_str());
 
1192
        }
 
1193
        void getStaticCling()const
 
1194
        {
 
1195
                fprintf(mFile,"\"%s.stc\"",mName.c_str());
 
1196
        }
 
1197
        void getRepulsion()const
 
1198
        {
 
1199
                fprintf(mFile,"\"%s.rpl\"",mName.c_str());
 
1200
        }
 
1201
        void getNumCollideNeighbors()const
 
1202
        {
 
1203
                fprintf(mFile,"\"%s.ncn\"",mName.c_str());
 
1204
        }
 
1205
        void getIterations()const
 
1206
        {
 
1207
                fprintf(mFile,"\"%s.itr\"",mName.c_str());
 
1208
        }
 
1209
        void getDrawCollideWidth()const
 
1210
        {
 
1211
                fprintf(mFile,"\"%s.dwd\"",mName.c_str());
 
1212
        }
 
1213
        void getWidthDrawSkip()const
 
1214
        {
 
1215
                fprintf(mFile,"\"%s.wds\"",mName.c_str());
 
1216
        }
 
1217
        void getGravity()const
 
1218
        {
 
1219
                fprintf(mFile,"\"%s.grv\"",mName.c_str());
 
1220
        }
 
1221
        void getTurbulenceStrength()const
 
1222
        {
 
1223
                fprintf(mFile,"\"%s.tst\"",mName.c_str());
 
1224
        }
 
1225
        void getTurbulenceFrequency()const
 
1226
        {
 
1227
                fprintf(mFile,"\"%s.tfr\"",mName.c_str());
 
1228
        }
 
1229
        void getTurbulenceSpeed()const
 
1230
        {
 
1231
                fprintf(mFile,"\"%s.tbs\"",mName.c_str());
 
1232
        }
 
1233
        void getAttractionDamp()const
 
1234
        {
 
1235
                fprintf(mFile,"\"%s.ad\"",mName.c_str());
 
1236
        }
 
1237
        void getStartCurveAttract()const
 
1238
        {
 
1239
                fprintf(mFile,"\"%s.sct\"",mName.c_str());
 
1240
        }
 
1241
        void getAttractionScale(size_t ats_i)const
 
1242
        {
 
1243
                fprintf(mFile,"\"%s.ats[%i]\"",mName.c_str(),ats_i);
 
1244
        }
 
1245
        void getAttractionScale()const
 
1246
        {
 
1247
 
 
1248
                fprintf(mFile,"\"%s.ats\"",mName.c_str());
 
1249
        }
 
1250
        void getAttractionScale_Position(size_t ats_i)const
 
1251
        {
 
1252
                fprintf(mFile,"\"%s.ats[%i].atsp\"",mName.c_str(),ats_i);
 
1253
        }
 
1254
        void getAttractionScale_Position()const
 
1255
        {
 
1256
 
 
1257
                fprintf(mFile,"\"%s.ats.atsp\"",mName.c_str());
 
1258
        }
 
1259
        void getAttractionScale_FloatValue(size_t ats_i)const
 
1260
        {
 
1261
                fprintf(mFile,"\"%s.ats[%i].atsfv\"",mName.c_str(),ats_i);
 
1262
        }
 
1263
        void getAttractionScale_FloatValue()const
 
1264
        {
 
1265
 
 
1266
                fprintf(mFile,"\"%s.ats.atsfv\"",mName.c_str());
 
1267
        }
 
1268
        void getAttractionScale_Interp(size_t ats_i)const
 
1269
        {
 
1270
                fprintf(mFile,"\"%s.ats[%i].atsi\"",mName.c_str(),ats_i);
 
1271
        }
 
1272
        void getAttractionScale_Interp()const
 
1273
        {
 
1274
 
 
1275
                fprintf(mFile,"\"%s.ats.atsi\"",mName.c_str());
 
1276
        }
 
1277
        void getMotionDrag()const
 
1278
        {
 
1279
                fprintf(mFile,"\"%s.mdg\"",mName.c_str());
 
1280
        }
 
1281
        void getDisplayQuality()const
 
1282
        {
 
1283
                fprintf(mFile,"\"%s.dpq\"",mName.c_str());
 
1284
        }
 
1285
        void getNoStretch()const
 
1286
        {
 
1287
                fprintf(mFile,"\"%s.nst\"",mName.c_str());
 
1288
        }
 
1289
        void getSubSegments()const
 
1290
        {
 
1291
                fprintf(mFile,"\"%s.ssg\"",mName.c_str());
 
1292
        }
 
1293
        void getClumpWidth()const
 
1294
        {
 
1295
                fprintf(mFile,"\"%s.cwd\"",mName.c_str());
 
1296
        }
 
1297
        void getClumpWidthScale(size_t cws_i)const
 
1298
        {
 
1299
                fprintf(mFile,"\"%s.cws[%i]\"",mName.c_str(),cws_i);
 
1300
        }
 
1301
        void getClumpWidthScale()const
 
1302
        {
 
1303
 
 
1304
                fprintf(mFile,"\"%s.cws\"",mName.c_str());
 
1305
        }
 
1306
        void getClumpWidthScale_Position(size_t cws_i)const
 
1307
        {
 
1308
                fprintf(mFile,"\"%s.cws[%i].cwsp\"",mName.c_str(),cws_i);
 
1309
        }
 
1310
        void getClumpWidthScale_Position()const
 
1311
        {
 
1312
 
 
1313
                fprintf(mFile,"\"%s.cws.cwsp\"",mName.c_str());
 
1314
        }
 
1315
        void getClumpWidthScale_FloatValue(size_t cws_i)const
 
1316
        {
 
1317
                fprintf(mFile,"\"%s.cws[%i].cwsfv\"",mName.c_str(),cws_i);
 
1318
        }
 
1319
        void getClumpWidthScale_FloatValue()const
 
1320
        {
 
1321
 
 
1322
                fprintf(mFile,"\"%s.cws.cwsfv\"",mName.c_str());
 
1323
        }
 
1324
        void getClumpWidthScale_Interp(size_t cws_i)const
 
1325
        {
 
1326
                fprintf(mFile,"\"%s.cws[%i].cwsi\"",mName.c_str(),cws_i);
 
1327
        }
 
1328
        void getClumpWidthScale_Interp()const
 
1329
        {
 
1330
 
 
1331
                fprintf(mFile,"\"%s.cws.cwsi\"",mName.c_str());
 
1332
        }
 
1333
        void getClumpTwist()const
 
1334
        {
 
1335
                fprintf(mFile,"\"%s.ctw\"",mName.c_str());
 
1336
        }
 
1337
        void getClumpCurl(size_t clc_i)const
 
1338
        {
 
1339
                fprintf(mFile,"\"%s.clc[%i]\"",mName.c_str(),clc_i);
 
1340
        }
 
1341
        void getClumpCurl()const
 
1342
        {
 
1343
 
 
1344
                fprintf(mFile,"\"%s.clc\"",mName.c_str());
 
1345
        }
 
1346
        void getClumpCurl_Position(size_t clc_i)const
 
1347
        {
 
1348
                fprintf(mFile,"\"%s.clc[%i].clcp\"",mName.c_str(),clc_i);
 
1349
        }
 
1350
        void getClumpCurl_Position()const
 
1351
        {
 
1352
 
 
1353
                fprintf(mFile,"\"%s.clc.clcp\"",mName.c_str());
 
1354
        }
 
1355
        void getClumpCurl_FloatValue(size_t clc_i)const
 
1356
        {
 
1357
                fprintf(mFile,"\"%s.clc[%i].clcfv\"",mName.c_str(),clc_i);
 
1358
        }
 
1359
        void getClumpCurl_FloatValue()const
 
1360
        {
 
1361
 
 
1362
                fprintf(mFile,"\"%s.clc.clcfv\"",mName.c_str());
 
1363
        }
 
1364
        void getClumpCurl_Interp(size_t clc_i)const
 
1365
        {
 
1366
                fprintf(mFile,"\"%s.clc[%i].clci\"",mName.c_str(),clc_i);
 
1367
        }
 
1368
        void getClumpCurl_Interp()const
 
1369
        {
 
1370
 
 
1371
                fprintf(mFile,"\"%s.clc.clci\"",mName.c_str());
 
1372
        }
 
1373
        void getClumpFlatness(size_t cfl_i)const
 
1374
        {
 
1375
                fprintf(mFile,"\"%s.cfl[%i]\"",mName.c_str(),cfl_i);
 
1376
        }
 
1377
        void getClumpFlatness()const
 
1378
        {
 
1379
 
 
1380
                fprintf(mFile,"\"%s.cfl\"",mName.c_str());
 
1381
        }
 
1382
        void getClumpFlatness_Position(size_t cfl_i)const
 
1383
        {
 
1384
                fprintf(mFile,"\"%s.cfl[%i].cflp\"",mName.c_str(),cfl_i);
 
1385
        }
 
1386
        void getClumpFlatness_Position()const
 
1387
        {
 
1388
 
 
1389
                fprintf(mFile,"\"%s.cfl.cflp\"",mName.c_str());
 
1390
        }
 
1391
        void getClumpFlatness_FloatValue(size_t cfl_i)const
 
1392
        {
 
1393
                fprintf(mFile,"\"%s.cfl[%i].cflfv\"",mName.c_str(),cfl_i);
 
1394
        }
 
1395
        void getClumpFlatness_FloatValue()const
 
1396
        {
 
1397
 
 
1398
                fprintf(mFile,"\"%s.cfl.cflfv\"",mName.c_str());
 
1399
        }
 
1400
        void getClumpFlatness_Interp(size_t cfl_i)const
 
1401
        {
 
1402
                fprintf(mFile,"\"%s.cfl[%i].cfli\"",mName.c_str(),cfl_i);
 
1403
        }
 
1404
        void getClumpFlatness_Interp()const
 
1405
        {
 
1406
 
 
1407
                fprintf(mFile,"\"%s.cfl.cfli\"",mName.c_str());
 
1408
        }
 
1409
        void getBendFollow()const
 
1410
        {
 
1411
                fprintf(mFile,"\"%s.bnf\"",mName.c_str());
 
1412
        }
 
1413
        void getHairWidth()const
 
1414
        {
 
1415
                fprintf(mFile,"\"%s.hwd\"",mName.c_str());
 
1416
        }
 
1417
        void getHairWidthScale(size_t hws_i)const
 
1418
        {
 
1419
                fprintf(mFile,"\"%s.hws[%i]\"",mName.c_str(),hws_i);
 
1420
        }
 
1421
        void getHairWidthScale()const
 
1422
        {
 
1423
 
 
1424
                fprintf(mFile,"\"%s.hws\"",mName.c_str());
 
1425
        }
 
1426
        void getHairWidthScale_Position(size_t hws_i)const
 
1427
        {
 
1428
                fprintf(mFile,"\"%s.hws[%i].hwsp\"",mName.c_str(),hws_i);
 
1429
        }
 
1430
        void getHairWidthScale_Position()const
 
1431
        {
 
1432
 
 
1433
                fprintf(mFile,"\"%s.hws.hwsp\"",mName.c_str());
 
1434
        }
 
1435
        void getHairWidthScale_FloatValue(size_t hws_i)const
 
1436
        {
 
1437
                fprintf(mFile,"\"%s.hws[%i].hwsfv\"",mName.c_str(),hws_i);
 
1438
        }
 
1439
        void getHairWidthScale_FloatValue()const
 
1440
        {
 
1441
 
 
1442
                fprintf(mFile,"\"%s.hws.hwsfv\"",mName.c_str());
 
1443
        }
 
1444
        void getHairWidthScale_Interp(size_t hws_i)const
 
1445
        {
 
1446
                fprintf(mFile,"\"%s.hws[%i].hwsi\"",mName.c_str(),hws_i);
 
1447
        }
 
1448
        void getHairWidthScale_Interp()const
 
1449
        {
 
1450
 
 
1451
                fprintf(mFile,"\"%s.hws.hwsi\"",mName.c_str());
 
1452
        }
 
1453
        void getBaldnessMap()const
 
1454
        {
 
1455
                fprintf(mFile,"\"%s.bmp\"",mName.c_str());
 
1456
        }
 
1457
        void getOpacity()const
 
1458
        {
 
1459
                fprintf(mFile,"\"%s.opc\"",mName.c_str());
 
1460
        }
 
1461
        void getHairColor()const
 
1462
        {
 
1463
                fprintf(mFile,"\"%s.hcl\"",mName.c_str());
 
1464
        }
 
1465
        void getHairColorR()const
 
1466
        {
 
1467
                fprintf(mFile,"\"%s.hcl.hcr\"",mName.c_str());
 
1468
        }
 
1469
        void getHairColorG()const
 
1470
        {
 
1471
                fprintf(mFile,"\"%s.hcl.hcg\"",mName.c_str());
 
1472
        }
 
1473
        void getHairColorB()const
 
1474
        {
 
1475
                fprintf(mFile,"\"%s.hcl.hcb\"",mName.c_str());
 
1476
        }
 
1477
        void getHairColorScale(size_t hcs_i)const
 
1478
        {
 
1479
                fprintf(mFile,"\"%s.hcs[%i]\"",mName.c_str(),hcs_i);
 
1480
        }
 
1481
        void getHairColorScale()const
 
1482
        {
 
1483
 
 
1484
                fprintf(mFile,"\"%s.hcs\"",mName.c_str());
 
1485
        }
 
1486
        void getHairColorScale_Position(size_t hcs_i)const
 
1487
        {
 
1488
                fprintf(mFile,"\"%s.hcs[%i].hcsp\"",mName.c_str(),hcs_i);
 
1489
        }
 
1490
        void getHairColorScale_Position()const
 
1491
        {
 
1492
 
 
1493
                fprintf(mFile,"\"%s.hcs.hcsp\"",mName.c_str());
 
1494
        }
 
1495
        void getHairColorScale_Color(size_t hcs_i)const
 
1496
        {
 
1497
                fprintf(mFile,"\"%s.hcs[%i].hcsc\"",mName.c_str(),hcs_i);
 
1498
        }
 
1499
        void getHairColorScale_Color()const
 
1500
        {
 
1501
 
 
1502
                fprintf(mFile,"\"%s.hcs.hcsc\"",mName.c_str());
 
1503
        }
 
1504
        void getHairColorScale_ColorR(size_t hcs_i)const
 
1505
        {
 
1506
                fprintf(mFile,"\"%s.hcs[%i].hcsc.hcscr\"",mName.c_str(),hcs_i);
 
1507
        }
 
1508
        void getHairColorScale_ColorR()const
 
1509
        {
 
1510
 
 
1511
                fprintf(mFile,"\"%s.hcs.hcsc.hcscr\"",mName.c_str());
 
1512
        }
 
1513
        void getHairColorScale_ColorG(size_t hcs_i)const
 
1514
        {
 
1515
                fprintf(mFile,"\"%s.hcs[%i].hcsc.hcscg\"",mName.c_str(),hcs_i);
 
1516
        }
 
1517
        void getHairColorScale_ColorG()const
 
1518
        {
 
1519
 
 
1520
                fprintf(mFile,"\"%s.hcs.hcsc.hcscg\"",mName.c_str());
 
1521
        }
 
1522
        void getHairColorScale_ColorB(size_t hcs_i)const
 
1523
        {
 
1524
                fprintf(mFile,"\"%s.hcs[%i].hcsc.hcscb\"",mName.c_str(),hcs_i);
 
1525
        }
 
1526
        void getHairColorScale_ColorB()const
 
1527
        {
 
1528
 
 
1529
                fprintf(mFile,"\"%s.hcs.hcsc.hcscb\"",mName.c_str());
 
1530
        }
 
1531
        void getHairColorScale_Interp(size_t hcs_i)const
 
1532
        {
 
1533
                fprintf(mFile,"\"%s.hcs[%i].hcsi\"",mName.c_str(),hcs_i);
 
1534
        }
 
1535
        void getHairColorScale_Interp()const
 
1536
        {
 
1537
 
 
1538
                fprintf(mFile,"\"%s.hcs.hcsi\"",mName.c_str());
 
1539
        }
 
1540
        void getHairsPerClump()const
 
1541
        {
 
1542
                fprintf(mFile,"\"%s.hpc\"",mName.c_str());
 
1543
        }
 
1544
        void getThinning()const
 
1545
        {
 
1546
                fprintf(mFile,"\"%s.thn\"",mName.c_str());
 
1547
        }
 
1548
        void getTranslucence()const
 
1549
        {
 
1550
                fprintf(mFile,"\"%s.tlc\"",mName.c_str());
 
1551
        }
 
1552
        void getSpecularColor()const
 
1553
        {
 
1554
                fprintf(mFile,"\"%s.spc\"",mName.c_str());
 
1555
        }
 
1556
        void getSpecularColorR()const
 
1557
        {
 
1558
                fprintf(mFile,"\"%s.spc.spr\"",mName.c_str());
 
1559
        }
 
1560
        void getSpecularColorG()const
 
1561
        {
 
1562
                fprintf(mFile,"\"%s.spc.spg\"",mName.c_str());
 
1563
        }
 
1564
        void getSpecularColorB()const
 
1565
        {
 
1566
                fprintf(mFile,"\"%s.spc.spb\"",mName.c_str());
 
1567
        }
 
1568
        void getSpecularPower()const
 
1569
        {
 
1570
                fprintf(mFile,"\"%s.spp\"",mName.c_str());
 
1571
        }
 
1572
        void getCastShadows()const
 
1573
        {
 
1574
                fprintf(mFile,"\"%s.csd\"",mName.c_str());
 
1575
        }
 
1576
        void getDiffuseRand()const
 
1577
        {
 
1578
                fprintf(mFile,"\"%s.dfr\"",mName.c_str());
 
1579
        }
 
1580
        void getSpecularRand()const
 
1581
        {
 
1582
                fprintf(mFile,"\"%s.sra\"",mName.c_str());
 
1583
        }
 
1584
        void getHueRand()const
 
1585
        {
 
1586
                fprintf(mFile,"\"%s.chr\"",mName.c_str());
 
1587
        }
 
1588
        void getSatRand()const
 
1589
        {
 
1590
                fprintf(mFile,"\"%s.csr\"",mName.c_str());
 
1591
        }
 
1592
        void getValRand()const
 
1593
        {
 
1594
                fprintf(mFile,"\"%s.cvr\"",mName.c_str());
 
1595
        }
 
1596
        void getMultiStreaks()const
 
1597
        {
 
1598
                fprintf(mFile,"\"%s.mst\"",mName.c_str());
 
1599
        }
 
1600
        void getMultiStreakSpread1()const
 
1601
        {
 
1602
                fprintf(mFile,"\"%s.ms1\"",mName.c_str());
 
1603
        }
 
1604
        void getMultiStreakSpread2()const
 
1605
        {
 
1606
                fprintf(mFile,"\"%s.ms2\"",mName.c_str());
 
1607
        }
 
1608
        void getLightEachHair()const
 
1609
        {
 
1610
                fprintf(mFile,"\"%s.leh\"",mName.c_str());
 
1611
        }
 
1612
        void getDisplacementScale(size_t dsc_i)const
 
1613
        {
 
1614
                fprintf(mFile,"\"%s.dsc[%i]\"",mName.c_str(),dsc_i);
 
1615
        }
 
1616
        void getDisplacementScale()const
 
1617
        {
 
1618
 
 
1619
                fprintf(mFile,"\"%s.dsc\"",mName.c_str());
 
1620
        }
 
1621
        void getDisplacementScale_Position(size_t dsc_i)const
 
1622
        {
 
1623
                fprintf(mFile,"\"%s.dsc[%i].dscp\"",mName.c_str(),dsc_i);
 
1624
        }
 
1625
        void getDisplacementScale_Position()const
 
1626
        {
 
1627
 
 
1628
                fprintf(mFile,"\"%s.dsc.dscp\"",mName.c_str());
 
1629
        }
 
1630
        void getDisplacementScale_FloatValue(size_t dsc_i)const
 
1631
        {
 
1632
                fprintf(mFile,"\"%s.dsc[%i].dscfv\"",mName.c_str(),dsc_i);
 
1633
        }
 
1634
        void getDisplacementScale_FloatValue()const
 
1635
        {
 
1636
 
 
1637
                fprintf(mFile,"\"%s.dsc.dscfv\"",mName.c_str());
 
1638
        }
 
1639
        void getDisplacementScale_Interp(size_t dsc_i)const
 
1640
        {
 
1641
                fprintf(mFile,"\"%s.dsc[%i].dsci\"",mName.c_str(),dsc_i);
 
1642
        }
 
1643
        void getDisplacementScale_Interp()const
 
1644
        {
 
1645
 
 
1646
                fprintf(mFile,"\"%s.dsc.dsci\"",mName.c_str());
 
1647
        }
 
1648
        void getCurl()const
 
1649
        {
 
1650
                fprintf(mFile,"\"%s.crl\"",mName.c_str());
 
1651
        }
 
1652
        void getCurlFrequency()const
 
1653
        {
 
1654
                fprintf(mFile,"\"%s.crf\"",mName.c_str());
 
1655
        }
 
1656
        void getNoiseMethod()const
 
1657
        {
 
1658
                fprintf(mFile,"\"%s.nmt\"",mName.c_str());
 
1659
        }
 
1660
        void getNoise()const
 
1661
        {
 
1662
                fprintf(mFile,"\"%s.noi\"",mName.c_str());
 
1663
        }
 
1664
        void getDetailNoise()const
 
1665
        {
 
1666
                fprintf(mFile,"\"%s.dno\"",mName.c_str());
 
1667
        }
 
1668
        void getNoiseFrequency()const
 
1669
        {
 
1670
                fprintf(mFile,"\"%s.nof\"",mName.c_str());
 
1671
        }
 
1672
        void getNoiseFrequencyU()const
 
1673
        {
 
1674
                fprintf(mFile,"\"%s.nfu\"",mName.c_str());
 
1675
        }
 
1676
        void getNoiseFrequencyV()const
 
1677
        {
 
1678
                fprintf(mFile,"\"%s.nfv\"",mName.c_str());
 
1679
        }
 
1680
        void getNoiseFrequencyW()const
 
1681
        {
 
1682
                fprintf(mFile,"\"%s.nfw\"",mName.c_str());
 
1683
        }
 
1684
        void getSubClumpMethod()const
 
1685
        {
 
1686
                fprintf(mFile,"\"%s.scm\"",mName.c_str());
 
1687
        }
 
1688
        void getSubClumping()const
 
1689
        {
 
1690
                fprintf(mFile,"\"%s.scp\"",mName.c_str());
 
1691
        }
 
1692
        void getSubClumpRand()const
 
1693
        {
 
1694
                fprintf(mFile,"\"%s.scr\"",mName.c_str());
 
1695
        }
 
1696
        void getNumUClumps()const
 
1697
        {
 
1698
                fprintf(mFile,"\"%s.nuc\"",mName.c_str());
 
1699
        }
 
1700
        void getNumVClumps()const
 
1701
        {
 
1702
                fprintf(mFile,"\"%s.nvc\"",mName.c_str());
 
1703
        }
 
1704
        void getClumpInterpolation()const
 
1705
        {
 
1706
                fprintf(mFile,"\"%s.cin\"",mName.c_str());
 
1707
        }
 
1708
        void getInterpolationRange()const
 
1709
        {
 
1710
                fprintf(mFile,"\"%s.inr\"",mName.c_str());
 
1711
        }
 
1712
        void getCurrentTime()const
 
1713
        {
 
1714
                fprintf(mFile,"\"%s.cti\"",mName.c_str());
 
1715
        }
 
1716
        void getStartTime()const
 
1717
        {
 
1718
                fprintf(mFile,"\"%s.sti\"",mName.c_str());
 
1719
        }
 
1720
        void getStartFrame()const
 
1721
        {
 
1722
                fprintf(mFile,"\"%s.stf\"",mName.c_str());
 
1723
        }
 
1724
        void getInputForce(size_t ifc_i)const
 
1725
        {
 
1726
                fprintf(mFile,"\"%s.ifc[%i]\"",mName.c_str(),ifc_i);
 
1727
        }
 
1728
        void getInputForce()const
 
1729
        {
 
1730
 
 
1731
                fprintf(mFile,"\"%s.ifc\"",mName.c_str());
 
1732
        }
 
1733
        void getFieldData()const
 
1734
        {
 
1735
                fprintf(mFile,"\"%s.fd\"",mName.c_str());
 
1736
        }
 
1737
        void getFieldDataPosition()const
 
1738
        {
 
1739
                fprintf(mFile,"\"%s.fd.fdp\"",mName.c_str());
 
1740
        }
 
1741
        void getFieldDataVelocity()const
 
1742
        {
 
1743
                fprintf(mFile,"\"%s.fd.fdv\"",mName.c_str());
 
1744
        }
 
1745
        void getFieldDataMass()const
 
1746
        {
 
1747
                fprintf(mFile,"\"%s.fd.fdm\"",mName.c_str());
 
1748
        }
 
1749
        void getFieldDataDeltaTime()const
 
1750
        {
 
1751
                fprintf(mFile,"\"%s.fd.fdt\"",mName.c_str());
 
1752
        }
 
1753
        void getUsePre70ForceIntensity()const
 
1754
        {
 
1755
                fprintf(mFile,"\"%s.upfi\"",mName.c_str());
 
1756
        }
 
1757
        void getCollisionData()const
 
1758
        {
 
1759
                fprintf(mFile,"\"%s.cda\"",mName.c_str());
 
1760
        }
 
1761
        void getCollisionGeometry(size_t cge_i)const
 
1762
        {
 
1763
                fprintf(mFile,"\"%s.cda.cge[%i]\"",mName.c_str(),cge_i);
 
1764
        }
 
1765
        void getCollisionResilience(size_t crs_i)const
 
1766
        {
 
1767
                fprintf(mFile,"\"%s.cda.crs[%i]\"",mName.c_str(),crs_i);
 
1768
        }
 
1769
        void getCollisionFriction(size_t cfr_i)const
 
1770
        {
 
1771
                fprintf(mFile,"\"%s.cda.cfr[%i]\"",mName.c_str(),cfr_i);
 
1772
        }
 
1773
        void getDiskCache()const
 
1774
        {
 
1775
                fprintf(mFile,"\"%s.dc\"",mName.c_str());
 
1776
        }
 
1777
        void getReceiveShadows()const
 
1778
        {
 
1779
                fprintf(mFile,"\"%s.rcsh\"",mName.c_str());
 
1780
        }
 
1781
        void getVisibleInReflections()const
 
1782
        {
 
1783
                fprintf(mFile,"\"%s.vir\"",mName.c_str());
 
1784
        }
 
1785
        void getVisibleInRefractions()const
 
1786
        {
 
1787
                fprintf(mFile,"\"%s.vif\"",mName.c_str());
 
1788
        }
 
1789
        void getMentalRayControls()const
 
1790
        {
 
1791
                fprintf(mFile,"\"%s.mrc\"",mName.c_str());
 
1792
        }
 
1793
        void getMiOverrideCaustics()const
 
1794
        {
 
1795
                fprintf(mFile,"\"%s.mrc.oca\"",mName.c_str());
 
1796
        }
 
1797
        void getMiCausticAccuracy()const
 
1798
        {
 
1799
                fprintf(mFile,"\"%s.mrc.caa\"",mName.c_str());
 
1800
        }
 
1801
        void getMiCausticRadius()const
 
1802
        {
 
1803
                fprintf(mFile,"\"%s.mrc.car\"",mName.c_str());
 
1804
        }
 
1805
        void getMiOverrideGlobalIllumination()const
 
1806
        {
 
1807
                fprintf(mFile,"\"%s.mrc.ogi\"",mName.c_str());
 
1808
        }
 
1809
        void getMiGlobillumAccuracy()const
 
1810
        {
 
1811
                fprintf(mFile,"\"%s.mrc.gia\"",mName.c_str());
 
1812
        }
 
1813
        void getMiGlobillumRadius()const
 
1814
        {
 
1815
                fprintf(mFile,"\"%s.mrc.gir\"",mName.c_str());
 
1816
        }
 
1817
        void getMiOverrideFinalGather()const
 
1818
        {
 
1819
                fprintf(mFile,"\"%s.mrc.ofg\"",mName.c_str());
 
1820
        }
 
1821
        void getMiFinalGatherRays()const
 
1822
        {
 
1823
                fprintf(mFile,"\"%s.mrc.fry\"",mName.c_str());
 
1824
        }
 
1825
        void getMiFinalGatherMinRadius()const
 
1826
        {
 
1827
                fprintf(mFile,"\"%s.mrc.fmn\"",mName.c_str());
 
1828
        }
 
1829
        void getMiFinalGatherMaxRadius()const
 
1830
        {
 
1831
                fprintf(mFile,"\"%s.mrc.fmx\"",mName.c_str());
 
1832
        }
 
1833
        void getMiFinalGatherFilter()const
 
1834
        {
 
1835
                fprintf(mFile,"\"%s.mrc.ffi\"",mName.c_str());
 
1836
        }
 
1837
        void getMiFinalGatherView()const
 
1838
        {
 
1839
                fprintf(mFile,"\"%s.mrc.fgv\"",mName.c_str());
 
1840
        }
 
1841
        void getMiOverrideSamples()const
 
1842
        {
 
1843
                fprintf(mFile,"\"%s.mrc.oos\"",mName.c_str());
 
1844
        }
 
1845
        void getMiMinSamples()const
 
1846
        {
 
1847
                fprintf(mFile,"\"%s.mrc.mins\"",mName.c_str());
 
1848
        }
 
1849
        void getMiMaxSamples()const
 
1850
        {
 
1851
                fprintf(mFile,"\"%s.mrc.maxs\"",mName.c_str());
 
1852
        }
 
1853
        void getMiFinalGatherCast()const
 
1854
        {
 
1855
                fprintf(mFile,"\"%s.mrc.fgc\"",mName.c_str());
 
1856
        }
 
1857
        void getMiFinalGatherReceive()const
 
1858
        {
 
1859
                fprintf(mFile,"\"%s.mrc.fge\"",mName.c_str());
 
1860
        }
 
1861
        void getMiTransparencyCast()const
 
1862
        {
 
1863
                fprintf(mFile,"\"%s.mrc.tpc\"",mName.c_str());
 
1864
        }
 
1865
        void getMiTransparencyReceive()const
 
1866
        {
 
1867
                fprintf(mFile,"\"%s.mrc.tpr\"",mName.c_str());
 
1868
        }
 
1869
        void getOutputHair(size_t oh_i)const
 
1870
        {
 
1871
                fprintf(mFile,"\"%s.oh[%i]\"",mName.c_str(),oh_i);
 
1872
        }
 
1873
        void getOutputHair()const
 
1874
        {
 
1875
 
 
1876
                fprintf(mFile,"\"%s.oh\"",mName.c_str());
 
1877
        }
 
1878
        void getOutputRenderHairs()const
 
1879
        {
 
1880
                fprintf(mFile,"\"%s.orh\"",mName.c_str());
 
1881
        }
 
1882
protected:
 
1883
        HairSystem(FILE* file,const std::string& name,const std::string& parent,const std::string& nodeType,bool shared=false,bool create=true)
 
1884
                :Shape(file, name, parent, nodeType, shared, create) {}
 
1885
 
 
1886
};
 
1887
}//namespace MayaDM
 
1888
#endif//__MayaDM_HAIRSYSTEM_H__