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