← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Externals/MayaDataModel/include/MayaDMEnvFog.h

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2015-05-14 17:23:27 UTC
  • Revision ID: package-import@ubuntu.com-20150514172327-f862u8envms01fra
Tags: upstream-0.1.0~20140703.ddf8f47+dfsg1
Import upstream version 0.1.0~20140703.ddf8f47+dfsg1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Externals/MayaDataModel/include/MayaDMEnvFog.h
 
1
/*
 
2
    Copyright (c) 2008-2009 NetAllied Systems GmbH
 
3
 
 
4
    This file is part of MayaDataModel.
 
5
 
 
6
    Licensed under the MIT Open Source License,
 
7
    for details please see LICENSE file or the website
 
8
    http://www.opensource.org/licenses/mit-license.php
 
9
*/
 
10
#ifndef __MayaDM_ENVFOG_H__
 
11
#define __MayaDM_ENVFOG_H__
 
12
#include "MayaDMTypes.h"
 
13
#include "MayaDMConnectables.h"
 
14
#include "MayaDMLightFog.h"
 
15
namespace MayaDM
 
16
{
 
17
class EnvFog : public LightFog
 
18
{
 
19
public:
 
20
public:
 
21
 
 
22
        EnvFog():LightFog(){}
 
23
        EnvFog(FILE* file,const std::string& name,const std::string& parent="",bool shared=false,bool create=true)
 
24
                :LightFog(file, name, parent, "envFog", shared, create){}
 
25
        virtual ~EnvFog(){}
 
26
 
 
27
        void setDistanceClipPlanes(unsigned int dcp)
 
28
        {
 
29
                if(dcp == 1) return;
 
30
                fprintf(mFile,"\tsetAttr \".dcp\" %i;\n", dcp);
 
31
        }
 
32
        void setUseLayer(bool ul)
 
33
        {
 
34
                if(ul == false) return;
 
35
                fprintf(mFile,"\tsetAttr \".ul\" %i;\n", ul);
 
36
        }
 
37
        void setUseHeight(bool uh)
 
38
        {
 
39
                if(uh == false) return;
 
40
                fprintf(mFile,"\tsetAttr \".uh\" %i;\n", uh);
 
41
        }
 
42
        void setBlendRange(float br)
 
43
        {
 
44
                if(br == 1.0) return;
 
45
                fprintf(mFile,"\tsetAttr \".br\" %f;\n", br);
 
46
        }
 
47
        void setSaturationDistance(float sdt)
 
48
        {
 
49
                if(sdt == 100.0) return;
 
50
                fprintf(mFile,"\tsetAttr \".sdt\" %f;\n", sdt);
 
51
        }
 
52
        void setFogNearDistance(float fnd)
 
53
        {
 
54
                if(fnd == 0.0) return;
 
55
                fprintf(mFile,"\tsetAttr \".fnd\" %f;\n", fnd);
 
56
        }
 
57
        void setFogFarDistance(float ffd)
 
58
        {
 
59
                if(ffd == 200.0) return;
 
60
                fprintf(mFile,"\tsetAttr \".ffd\" %f;\n", ffd);
 
61
        }
 
62
        void setLayer(float l)
 
63
        {
 
64
                if(l == 1.0) return;
 
65
                fprintf(mFile,"\tsetAttr \".l\" %f;\n", l);
 
66
        }
 
67
        void setMinHeight(float mnh)
 
68
        {
 
69
                if(mnh == -1.0) return;
 
70
                fprintf(mFile,"\tsetAttr \".mnh\" %f;\n", mnh);
 
71
        }
 
72
        void setMaxHeight(float mxh)
 
73
        {
 
74
                if(mxh == 1.0) return;
 
75
                fprintf(mFile,"\tsetAttr \".mxh\" %f;\n", mxh);
 
76
        }
 
77
        void setUseDistance(bool ud)
 
78
        {
 
79
                if(ud == false) return;
 
80
                fprintf(mFile,"\tsetAttr \".ud\" %i;\n", ud);
 
81
        }
 
82
        void setStartDistance(float sd)
 
83
        {
 
84
                if(sd == 0.0) return;
 
85
                fprintf(mFile,"\tsetAttr \".sd\" %f;\n", sd);
 
86
        }
 
87
        void setEndDistance(float ed)
 
88
        {
 
89
                if(ed == -1.0) return;
 
90
                fprintf(mFile,"\tsetAttr \".ed\" %f;\n", ed);
 
91
        }
 
92
        void setPhysicalFog(bool sff)
 
93
        {
 
94
                if(sff == false) return;
 
95
                fprintf(mFile,"\tsetAttr \".sff\" %i;\n", sff);
 
96
        }
 
97
        void setFogType(unsigned int ftp)
 
98
        {
 
99
                if(ftp == 0) return;
 
100
                fprintf(mFile,"\tsetAttr \".ftp\" %i;\n", ftp);
 
101
        }
 
102
        void setFogDensity(double fdn)
 
103
        {
 
104
                if(fdn == 0.4) return;
 
105
                fprintf(mFile,"\tsetAttr \".fdn\" %f;\n", fdn);
 
106
        }
 
107
        void setFogColor(const float3& fcl)
 
108
        {
 
109
                fprintf(mFile,"\tsetAttr \".fcl\" -type \"float3\" ");
 
110
                fcl.write(mFile);
 
111
                fprintf(mFile,";\n");
 
112
        }
 
113
        void setFogColorR(float fcr)
 
114
        {
 
115
                if(fcr == 1.0) return;
 
116
                fprintf(mFile,"\tsetAttr \".fcl.fcr\" %f;\n", fcr);
 
117
        }
 
118
        void setFogColorG(float fcg)
 
119
        {
 
120
                if(fcg == 1.0) return;
 
121
                fprintf(mFile,"\tsetAttr \".fcl.fcg\" %f;\n", fcg);
 
122
        }
 
123
        void setFogColorB(float fcb)
 
124
        {
 
125
                if(fcb == 1.0) return;
 
126
                fprintf(mFile,"\tsetAttr \".fcl.fcb\" %f;\n", fcb);
 
127
        }
 
128
        void setFogOpacity(const float3& fop)
 
129
        {
 
130
                fprintf(mFile,"\tsetAttr \".fop\" -type \"float3\" ");
 
131
                fop.write(mFile);
 
132
                fprintf(mFile,";\n");
 
133
        }
 
134
        void setFogOpacityR(float for_)
 
135
        {
 
136
                if(for_ == 0.5) return;
 
137
                fprintf(mFile,"\tsetAttr \".fop.for\" %f;\n", for_);
 
138
        }
 
139
        void setFogOpacityG(float fog)
 
140
        {
 
141
                if(fog == 0.5) return;
 
142
                fprintf(mFile,"\tsetAttr \".fop.fog\" %f;\n", fog);
 
143
        }
 
144
        void setFogOpacityB(float fob)
 
145
        {
 
146
                if(fob == 0.5) return;
 
147
                fprintf(mFile,"\tsetAttr \".fop.fob\" %f;\n", fob);
 
148
        }
 
149
        void setFogMinHeight(double fmh)
 
150
        {
 
151
                if(fmh == 0.0) return;
 
152
                fprintf(mFile,"\tsetAttr \".fmh\" %f;\n", fmh);
 
153
        }
 
154
        void setFogMaxHeight(double fxh)
 
155
        {
 
156
                if(fxh == 1.0) return;
 
157
                fprintf(mFile,"\tsetAttr \".fxh\" %f;\n", fxh);
 
158
        }
 
159
        void setFogDecay(double fdc)
 
160
        {
 
161
                if(fdc == 0.2) return;
 
162
                fprintf(mFile,"\tsetAttr \".fdc\" %f;\n", fdc);
 
163
        }
 
164
        void setFogLightScatter(double flc)
 
165
        {
 
166
                if(flc == 1.0) return;
 
167
                fprintf(mFile,"\tsetAttr \".flc\" %f;\n", flc);
 
168
        }
 
169
        void setAirDensity(double adn)
 
170
        {
 
171
                if(adn == 0.0) return;
 
172
                fprintf(mFile,"\tsetAttr \".adn\" %f;\n", adn);
 
173
        }
 
174
        void setAirColor(const float3& acl)
 
175
        {
 
176
                fprintf(mFile,"\tsetAttr \".acl\" -type \"float3\" ");
 
177
                acl.write(mFile);
 
178
                fprintf(mFile,";\n");
 
179
        }
 
180
        void setAirColorR(float acr)
 
181
        {
 
182
                if(acr == 0.6) return;
 
183
                fprintf(mFile,"\tsetAttr \".acl.acr\" %f;\n", acr);
 
184
        }
 
185
        void setAirColorG(float acg)
 
186
        {
 
187
                if(acg == 0.8) return;
 
188
                fprintf(mFile,"\tsetAttr \".acl.acg\" %f;\n", acg);
 
189
        }
 
190
        void setAirColorB(float acb)
 
191
        {
 
192
                if(acb == 1.0) return;
 
193
                fprintf(mFile,"\tsetAttr \".acl.acb\" %f;\n", acb);
 
194
        }
 
195
        void setAirOpacity(const float3& aop)
 
196
        {
 
197
                fprintf(mFile,"\tsetAttr \".aop\" -type \"float3\" ");
 
198
                aop.write(mFile);
 
199
                fprintf(mFile,";\n");
 
200
        }
 
201
        void setAirOpacityR(float aor)
 
202
        {
 
203
                if(aor == 0.37) return;
 
204
                fprintf(mFile,"\tsetAttr \".aop.aor\" %f;\n", aor);
 
205
        }
 
206
        void setAirOpacityG(float aog)
 
207
        {
 
208
                if(aog == 0.47) return;
 
209
                fprintf(mFile,"\tsetAttr \".aop.aog\" %f;\n", aog);
 
210
        }
 
211
        void setAirOpacityB(float aob)
 
212
        {
 
213
                if(aob == 0.9) return;
 
214
                fprintf(mFile,"\tsetAttr \".aop.aob\" %f;\n", aob);
 
215
        }
 
216
        void setAirMinHeight(double amh)
 
217
        {
 
218
                if(amh == 0.0) return;
 
219
                fprintf(mFile,"\tsetAttr \".amh\" %f;\n", amh);
 
220
        }
 
221
        void setAirMaxHeight(double axh)
 
222
        {
 
223
                if(axh == 50.0) return;
 
224
                fprintf(mFile,"\tsetAttr \".axh\" %f;\n", axh);
 
225
        }
 
226
        void setAirDecay(double adc)
 
227
        {
 
228
                if(adc == 0.1) return;
 
229
                fprintf(mFile,"\tsetAttr \".adc\" %f;\n", adc);
 
230
        }
 
231
        void setAirLightScatter(double alc)
 
232
        {
 
233
                if(alc == 1.0) return;
 
234
                fprintf(mFile,"\tsetAttr \".alc\" %f;\n", alc);
 
235
        }
 
236
        void setWaterDensity(double wdn)
 
237
        {
 
238
                if(wdn == 0.0) return;
 
239
                fprintf(mFile,"\tsetAttr \".wdn\" %f;\n", wdn);
 
240
        }
 
241
        void setWaterColor(const float3& wcl)
 
242
        {
 
243
                fprintf(mFile,"\tsetAttr \".wcl\" -type \"float3\" ");
 
244
                wcl.write(mFile);
 
245
                fprintf(mFile,";\n");
 
246
        }
 
247
        void setWaterColorR(float wcr)
 
248
        {
 
249
                if(wcr == 0.6) return;
 
250
                fprintf(mFile,"\tsetAttr \".wcl.wcr\" %f;\n", wcr);
 
251
        }
 
252
        void setWaterColorG(float wcg)
 
253
        {
 
254
                if(wcg == 0.8) return;
 
255
                fprintf(mFile,"\tsetAttr \".wcl.wcg\" %f;\n", wcg);
 
256
        }
 
257
        void setWaterColorB(float wcb)
 
258
        {
 
259
                if(wcb == 1.0) return;
 
260
                fprintf(mFile,"\tsetAttr \".wcl.wcb\" %f;\n", wcb);
 
261
        }
 
262
        void setWaterOpacity(const float3& wop)
 
263
        {
 
264
                fprintf(mFile,"\tsetAttr \".wop\" -type \"float3\" ");
 
265
                wop.write(mFile);
 
266
                fprintf(mFile,";\n");
 
267
        }
 
268
        void setWaterOpacityR(float wor)
 
269
        {
 
270
                if(wor == 0.37) return;
 
271
                fprintf(mFile,"\tsetAttr \".wop.wor\" %f;\n", wor);
 
272
        }
 
273
        void setWaterOpacityG(float wog)
 
274
        {
 
275
                if(wog == 0.47) return;
 
276
                fprintf(mFile,"\tsetAttr \".wop.wog\" %f;\n", wog);
 
277
        }
 
278
        void setWaterOpacityB(float wob)
 
279
        {
 
280
                if(wob == 0.9) return;
 
281
                fprintf(mFile,"\tsetAttr \".wop.wob\" %f;\n", wob);
 
282
        }
 
283
        void setWaterLevel(double wlv)
 
284
        {
 
285
                if(wlv == 0.0) return;
 
286
                fprintf(mFile,"\tsetAttr \".wlv\" %f;\n", wlv);
 
287
        }
 
288
        void setWaterDepth(double wdp)
 
289
        {
 
290
                if(wdp == 50.0) return;
 
291
                fprintf(mFile,"\tsetAttr \".wdp\" %f;\n", wdp);
 
292
        }
 
293
        void setWaterLightDecay(double wdc)
 
294
        {
 
295
                if(wdc == 2.0) return;
 
296
                fprintf(mFile,"\tsetAttr \".wdc\" %f;\n", wdc);
 
297
        }
 
298
        void setWaterLightScatter(double wlc)
 
299
        {
 
300
                if(wlc == 1.0) return;
 
301
                fprintf(mFile,"\tsetAttr \".wlc\" %f;\n", wlc);
 
302
        }
 
303
        void setPlanetRadius(double prd)
 
304
        {
 
305
                if(prd == 1000.0) return;
 
306
                fprintf(mFile,"\tsetAttr \".prd\" %f;\n", prd);
 
307
        }
 
308
        void setFogAxis(unsigned int fax)
 
309
        {
 
310
                if(fax == 0) return;
 
311
                fprintf(mFile,"\tsetAttr \".fax\" %i;\n", fax);
 
312
        }
 
313
        void setSunIntensity(double sin)
 
314
        {
 
315
                if(sin == 1.0) return;
 
316
                fprintf(mFile,"\tsetAttr \".sin\" %f;\n", sin);
 
317
        }
 
318
        void setSunAzimuth(double saz)
 
319
        {
 
320
                if(saz == 0.0) return;
 
321
                fprintf(mFile,"\tsetAttr \".saz\" %f;\n", saz);
 
322
        }
 
323
        void setSunElevation(double sel)
 
324
        {
 
325
                if(sel == 45.0) return;
 
326
                fprintf(mFile,"\tsetAttr \".sel\" %f;\n", sel);
 
327
        }
 
328
        void setSunColor(const float3& snc)
 
329
        {
 
330
                fprintf(mFile,"\tsetAttr \".snc\" -type \"float3\" ");
 
331
                snc.write(mFile);
 
332
                fprintf(mFile,";\n");
 
333
        }
 
334
        void setSunColorR(float snr)
 
335
        {
 
336
                if(snr == 1.0) return;
 
337
                fprintf(mFile,"\tsetAttr \".snc.snr\" %f;\n", snr);
 
338
        }
 
339
        void setSunColorG(float sng)
 
340
        {
 
341
                if(sng == 1.0) return;
 
342
                fprintf(mFile,"\tsetAttr \".snc.sng\" %f;\n", sng);
 
343
        }
 
344
        void setSunColorB(float snb)
 
345
        {
 
346
                if(snb == 1.0) return;
 
347
                fprintf(mFile,"\tsetAttr \".snc.snb\" %f;\n", snb);
 
348
        }
 
349
        void getMatrixEyeToWorld()const
 
350
        {
 
351
                fprintf(mFile,"\"%s.e2w\"",mName.c_str());
 
352
        }
 
353
        void getPointCamera()const
 
354
        {
 
355
                fprintf(mFile,"\"%s.p\"",mName.c_str());
 
356
        }
 
357
        void getPointCameraX()const
 
358
        {
 
359
                fprintf(mFile,"\"%s.p.px\"",mName.c_str());
 
360
        }
 
361
        void getPointCameraY()const
 
362
        {
 
363
                fprintf(mFile,"\"%s.p.py\"",mName.c_str());
 
364
        }
 
365
        void getPointCameraZ()const
 
366
        {
 
367
                fprintf(mFile,"\"%s.p.pz\"",mName.c_str());
 
368
        }
 
369
        void getPointWorld()const
 
370
        {
 
371
                fprintf(mFile,"\"%s.pw\"",mName.c_str());
 
372
        }
 
373
        void getPointWorldX()const
 
374
        {
 
375
                fprintf(mFile,"\"%s.pw.pwx\"",mName.c_str());
 
376
        }
 
377
        void getPointWorldY()const
 
378
        {
 
379
                fprintf(mFile,"\"%s.pw.pwy\"",mName.c_str());
 
380
        }
 
381
        void getPointWorldZ()const
 
382
        {
 
383
                fprintf(mFile,"\"%s.pw.pwz\"",mName.c_str());
 
384
        }
 
385
        void getRayDirection()const
 
386
        {
 
387
                fprintf(mFile,"\"%s.r\"",mName.c_str());
 
388
        }
 
389
        void getRayDirectionX()const
 
390
        {
 
391
                fprintf(mFile,"\"%s.r.rx\"",mName.c_str());
 
392
        }
 
393
        void getRayDirectionY()const
 
394
        {
 
395
                fprintf(mFile,"\"%s.r.ry\"",mName.c_str());
 
396
        }
 
397
        void getRayDirectionZ()const
 
398
        {
 
399
                fprintf(mFile,"\"%s.r.rz\"",mName.c_str());
 
400
        }
 
401
        void getDistanceClipPlanes()const
 
402
        {
 
403
                fprintf(mFile,"\"%s.dcp\"",mName.c_str());
 
404
        }
 
405
        void getUseLayer()const
 
406
        {
 
407
                fprintf(mFile,"\"%s.ul\"",mName.c_str());
 
408
        }
 
409
        void getUseHeight()const
 
410
        {
 
411
                fprintf(mFile,"\"%s.uh\"",mName.c_str());
 
412
        }
 
413
        void getBlendRange()const
 
414
        {
 
415
                fprintf(mFile,"\"%s.br\"",mName.c_str());
 
416
        }
 
417
        void getSaturationDistance()const
 
418
        {
 
419
                fprintf(mFile,"\"%s.sdt\"",mName.c_str());
 
420
        }
 
421
        void getFogNearDistance()const
 
422
        {
 
423
                fprintf(mFile,"\"%s.fnd\"",mName.c_str());
 
424
        }
 
425
        void getFogFarDistance()const
 
426
        {
 
427
                fprintf(mFile,"\"%s.ffd\"",mName.c_str());
 
428
        }
 
429
        void getLayer()const
 
430
        {
 
431
                fprintf(mFile,"\"%s.l\"",mName.c_str());
 
432
        }
 
433
        void getMinHeight()const
 
434
        {
 
435
                fprintf(mFile,"\"%s.mnh\"",mName.c_str());
 
436
        }
 
437
        void getMaxHeight()const
 
438
        {
 
439
                fprintf(mFile,"\"%s.mxh\"",mName.c_str());
 
440
        }
 
441
        void getUseDistance()const
 
442
        {
 
443
                fprintf(mFile,"\"%s.ud\"",mName.c_str());
 
444
        }
 
445
        void getStartDistance()const
 
446
        {
 
447
                fprintf(mFile,"\"%s.sd\"",mName.c_str());
 
448
        }
 
449
        void getEndDistance()const
 
450
        {
 
451
                fprintf(mFile,"\"%s.ed\"",mName.c_str());
 
452
        }
 
453
        void getPhysicalFog()const
 
454
        {
 
455
                fprintf(mFile,"\"%s.sff\"",mName.c_str());
 
456
        }
 
457
        void getFogType()const
 
458
        {
 
459
                fprintf(mFile,"\"%s.ftp\"",mName.c_str());
 
460
        }
 
461
        void getFogDensity()const
 
462
        {
 
463
                fprintf(mFile,"\"%s.fdn\"",mName.c_str());
 
464
        }
 
465
        void getFogColor()const
 
466
        {
 
467
                fprintf(mFile,"\"%s.fcl\"",mName.c_str());
 
468
        }
 
469
        void getFogColorR()const
 
470
        {
 
471
                fprintf(mFile,"\"%s.fcl.fcr\"",mName.c_str());
 
472
        }
 
473
        void getFogColorG()const
 
474
        {
 
475
                fprintf(mFile,"\"%s.fcl.fcg\"",mName.c_str());
 
476
        }
 
477
        void getFogColorB()const
 
478
        {
 
479
                fprintf(mFile,"\"%s.fcl.fcb\"",mName.c_str());
 
480
        }
 
481
        void getFogOpacity()const
 
482
        {
 
483
                fprintf(mFile,"\"%s.fop\"",mName.c_str());
 
484
        }
 
485
        void getFogOpacityR()const
 
486
        {
 
487
                fprintf(mFile,"\"%s.fop.for\"",mName.c_str());
 
488
        }
 
489
        void getFogOpacityG()const
 
490
        {
 
491
                fprintf(mFile,"\"%s.fop.fog\"",mName.c_str());
 
492
        }
 
493
        void getFogOpacityB()const
 
494
        {
 
495
                fprintf(mFile,"\"%s.fop.fob\"",mName.c_str());
 
496
        }
 
497
        void getFogMinHeight()const
 
498
        {
 
499
                fprintf(mFile,"\"%s.fmh\"",mName.c_str());
 
500
        }
 
501
        void getFogMaxHeight()const
 
502
        {
 
503
                fprintf(mFile,"\"%s.fxh\"",mName.c_str());
 
504
        }
 
505
        void getFogDecay()const
 
506
        {
 
507
                fprintf(mFile,"\"%s.fdc\"",mName.c_str());
 
508
        }
 
509
        void getFogLightScatter()const
 
510
        {
 
511
                fprintf(mFile,"\"%s.flc\"",mName.c_str());
 
512
        }
 
513
        void getAirDensity()const
 
514
        {
 
515
                fprintf(mFile,"\"%s.adn\"",mName.c_str());
 
516
        }
 
517
        void getAirColor()const
 
518
        {
 
519
                fprintf(mFile,"\"%s.acl\"",mName.c_str());
 
520
        }
 
521
        void getAirColorR()const
 
522
        {
 
523
                fprintf(mFile,"\"%s.acl.acr\"",mName.c_str());
 
524
        }
 
525
        void getAirColorG()const
 
526
        {
 
527
                fprintf(mFile,"\"%s.acl.acg\"",mName.c_str());
 
528
        }
 
529
        void getAirColorB()const
 
530
        {
 
531
                fprintf(mFile,"\"%s.acl.acb\"",mName.c_str());
 
532
        }
 
533
        void getAirOpacity()const
 
534
        {
 
535
                fprintf(mFile,"\"%s.aop\"",mName.c_str());
 
536
        }
 
537
        void getAirOpacityR()const
 
538
        {
 
539
                fprintf(mFile,"\"%s.aop.aor\"",mName.c_str());
 
540
        }
 
541
        void getAirOpacityG()const
 
542
        {
 
543
                fprintf(mFile,"\"%s.aop.aog\"",mName.c_str());
 
544
        }
 
545
        void getAirOpacityB()const
 
546
        {
 
547
                fprintf(mFile,"\"%s.aop.aob\"",mName.c_str());
 
548
        }
 
549
        void getAirMinHeight()const
 
550
        {
 
551
                fprintf(mFile,"\"%s.amh\"",mName.c_str());
 
552
        }
 
553
        void getAirMaxHeight()const
 
554
        {
 
555
                fprintf(mFile,"\"%s.axh\"",mName.c_str());
 
556
        }
 
557
        void getAirDecay()const
 
558
        {
 
559
                fprintf(mFile,"\"%s.adc\"",mName.c_str());
 
560
        }
 
561
        void getAirLightScatter()const
 
562
        {
 
563
                fprintf(mFile,"\"%s.alc\"",mName.c_str());
 
564
        }
 
565
        void getWaterDensity()const
 
566
        {
 
567
                fprintf(mFile,"\"%s.wdn\"",mName.c_str());
 
568
        }
 
569
        void getWaterColor()const
 
570
        {
 
571
                fprintf(mFile,"\"%s.wcl\"",mName.c_str());
 
572
        }
 
573
        void getWaterColorR()const
 
574
        {
 
575
                fprintf(mFile,"\"%s.wcl.wcr\"",mName.c_str());
 
576
        }
 
577
        void getWaterColorG()const
 
578
        {
 
579
                fprintf(mFile,"\"%s.wcl.wcg\"",mName.c_str());
 
580
        }
 
581
        void getWaterColorB()const
 
582
        {
 
583
                fprintf(mFile,"\"%s.wcl.wcb\"",mName.c_str());
 
584
        }
 
585
        void getWaterOpacity()const
 
586
        {
 
587
                fprintf(mFile,"\"%s.wop\"",mName.c_str());
 
588
        }
 
589
        void getWaterOpacityR()const
 
590
        {
 
591
                fprintf(mFile,"\"%s.wop.wor\"",mName.c_str());
 
592
        }
 
593
        void getWaterOpacityG()const
 
594
        {
 
595
                fprintf(mFile,"\"%s.wop.wog\"",mName.c_str());
 
596
        }
 
597
        void getWaterOpacityB()const
 
598
        {
 
599
                fprintf(mFile,"\"%s.wop.wob\"",mName.c_str());
 
600
        }
 
601
        void getWaterLevel()const
 
602
        {
 
603
                fprintf(mFile,"\"%s.wlv\"",mName.c_str());
 
604
        }
 
605
        void getWaterDepth()const
 
606
        {
 
607
                fprintf(mFile,"\"%s.wdp\"",mName.c_str());
 
608
        }
 
609
        void getWaterLightDecay()const
 
610
        {
 
611
                fprintf(mFile,"\"%s.wdc\"",mName.c_str());
 
612
        }
 
613
        void getWaterLightScatter()const
 
614
        {
 
615
                fprintf(mFile,"\"%s.wlc\"",mName.c_str());
 
616
        }
 
617
        void getPlanetRadius()const
 
618
        {
 
619
                fprintf(mFile,"\"%s.prd\"",mName.c_str());
 
620
        }
 
621
        void getFogAxis()const
 
622
        {
 
623
                fprintf(mFile,"\"%s.fax\"",mName.c_str());
 
624
        }
 
625
        void getSunIntensity()const
 
626
        {
 
627
                fprintf(mFile,"\"%s.sin\"",mName.c_str());
 
628
        }
 
629
        void getSunAzimuth()const
 
630
        {
 
631
                fprintf(mFile,"\"%s.saz\"",mName.c_str());
 
632
        }
 
633
        void getSunElevation()const
 
634
        {
 
635
                fprintf(mFile,"\"%s.sel\"",mName.c_str());
 
636
        }
 
637
        void getSunColor()const
 
638
        {
 
639
                fprintf(mFile,"\"%s.snc\"",mName.c_str());
 
640
        }
 
641
        void getSunColorR()const
 
642
        {
 
643
                fprintf(mFile,"\"%s.snc.snr\"",mName.c_str());
 
644
        }
 
645
        void getSunColorG()const
 
646
        {
 
647
                fprintf(mFile,"\"%s.snc.sng\"",mName.c_str());
 
648
        }
 
649
        void getSunColorB()const
 
650
        {
 
651
                fprintf(mFile,"\"%s.snc.snb\"",mName.c_str());
 
652
        }
 
653
protected:
 
654
        EnvFog(FILE* file,const std::string& name,const std::string& parent,const std::string& nodeType,bool shared=false,bool create=true)
 
655
                :LightFog(file, name, parent, nodeType, shared, create) {}
 
656
 
 
657
};
 
658
}//namespace MayaDM
 
659
#endif//__MayaDM_ENVFOG_H__