← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Externals/MayaDataModel/include/MayaDMPointLight.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/MayaDMPointLight.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_POINTLIGHT_H__
 
11
#define __MayaDM_POINTLIGHT_H__
 
12
#include "MayaDMTypes.h"
 
13
#include "MayaDMConnectables.h"
 
14
#include "MayaDMNonExtendedLightShapeNode.h"
 
15
namespace MayaDM
 
16
{
 
17
class PointLight : public NonExtendedLightShapeNode
 
18
{
 
19
public:
 
20
        struct MentalRayControls{
 
21
                bool miExportMrLight;
 
22
                bool emitPhotons;
 
23
                float3 energy;
 
24
                float photonIntensity;
 
25
                float exponent;
 
26
                int causticPhotons;
 
27
                int globIllPhotons;
 
28
                bool shadowMap;
 
29
                int smapResolution;
 
30
                short smapSamples;
 
31
                float smapSoftness;
 
32
                float smapBias;
 
33
                string smapFilename;
 
34
                bool smapLightName;
 
35
                bool smapSceneName;
 
36
                bool smapFrameExt;
 
37
                bool smapDetail;
 
38
                short smapDetailSamples;
 
39
                float smapDetailAccuracy;
 
40
                bool smapDetailAlpha;
 
41
                bool areaLight;
 
42
                unsigned int areaType;
 
43
                float3 areaNormal;
 
44
                float3 areaEdge;
 
45
                float areaRadius;
 
46
                short2 areaSampling;
 
47
                short areaLowLevel;
 
48
                short2 areaLowSampling;
 
49
                bool areaVisible;
 
50
                void write(FILE* file) const
 
51
                {
 
52
                        fprintf(file,"%i ", miExportMrLight);
 
53
                        fprintf(file,"%i ", emitPhotons);
 
54
                        energy.write(file);
 
55
                        fprintf(file, " ");
 
56
                        fprintf(file,"%f ", photonIntensity);
 
57
                        fprintf(file,"%f ", exponent);
 
58
                        fprintf(file,"%i ", causticPhotons);
 
59
                        fprintf(file,"%i ", globIllPhotons);
 
60
                        fprintf(file,"%i ", shadowMap);
 
61
                        fprintf(file,"%i ", smapResolution);
 
62
                        fprintf(file,"%i ", smapSamples);
 
63
                        fprintf(file,"%f ", smapSoftness);
 
64
                        fprintf(file,"%f ", smapBias);
 
65
                        smapFilename.write(file);
 
66
                        fprintf(file, " ");
 
67
                        fprintf(file,"%i ", smapLightName);
 
68
                        fprintf(file,"%i ", smapSceneName);
 
69
                        fprintf(file,"%i ", smapFrameExt);
 
70
                        fprintf(file,"%i ", smapDetail);
 
71
                        fprintf(file,"%i ", smapDetailSamples);
 
72
                        fprintf(file,"%f ", smapDetailAccuracy);
 
73
                        fprintf(file,"%i ", smapDetailAlpha);
 
74
                        fprintf(file,"%i ", areaLight);
 
75
                        fprintf(file,"%i ", areaType);
 
76
                        areaNormal.write(file);
 
77
                        fprintf(file, " ");
 
78
                        areaEdge.write(file);
 
79
                        fprintf(file, " ");
 
80
                        fprintf(file,"%f ", areaRadius);
 
81
                        areaSampling.write(file);
 
82
                        fprintf(file, " ");
 
83
                        fprintf(file,"%i ", areaLowLevel);
 
84
                        areaLowSampling.write(file);
 
85
                        fprintf(file, " ");
 
86
                        fprintf(file,"%i ", areaVisible);
 
87
                }
 
88
        };
 
89
public:
 
90
 
 
91
        PointLight():NonExtendedLightShapeNode(){}
 
92
        PointLight(FILE* file,const std::string& name,const std::string& parent="",bool shared=false,bool create=true)
 
93
                :NonExtendedLightShapeNode(file, name, parent, "pointLight", shared, create){}
 
94
        virtual ~PointLight(){}
 
95
 
 
96
        void setFogRadius(float fr)
 
97
        {
 
98
                if(fr == 1.0) return;
 
99
                fprintf(mFile,"\tsetAttr \".fr\" %f;\n", fr);
 
100
        }
 
101
        void setObjectType(char ot)
 
102
        {
 
103
                if(ot == 1) return;
 
104
                fprintf(mFile,"\tsetAttr \".ot\" %;\n", ot);
 
105
        }
 
106
        void setFogType(unsigned int ft)
 
107
        {
 
108
                if(ft == 0) return;
 
109
                fprintf(mFile,"\tsetAttr \".ft\" %i;\n", ft);
 
110
        }
 
111
        void setPointWorld(const float3& pw)
 
112
        {
 
113
                if(pw == float3(1.0f,1.0f,1.0f)) return;
 
114
                fprintf(mFile,"\tsetAttr \".pw\" -type \"float3\" ");
 
115
                pw.write(mFile);
 
116
                fprintf(mFile,";\n");
 
117
        }
 
118
        void setPointWorldX(float tx)
 
119
        {
 
120
                if(tx == 0.0) return;
 
121
                fprintf(mFile,"\tsetAttr \".pw.tx\" %f;\n", tx);
 
122
        }
 
123
        void setPointWorldY(float ty)
 
124
        {
 
125
                if(ty == 0.0) return;
 
126
                fprintf(mFile,"\tsetAttr \".pw.ty\" %f;\n", ty);
 
127
        }
 
128
        void setPointWorldZ(float tz)
 
129
        {
 
130
                if(tz == 0.0) return;
 
131
                fprintf(mFile,"\tsetAttr \".pw.tz\" %f;\n", tz);
 
132
        }
 
133
        void setFarPointWorld(const float3& fw)
 
134
        {
 
135
                if(fw == float3(1.0f,1.0f,1.0f)) return;
 
136
                fprintf(mFile,"\tsetAttr \".fw\" -type \"float3\" ");
 
137
                fw.write(mFile);
 
138
                fprintf(mFile,";\n");
 
139
        }
 
140
        void setFarPointWorldX(float fwx)
 
141
        {
 
142
                if(fwx == 0.0) return;
 
143
                fprintf(mFile,"\tsetAttr \".fw.fwx\" %f;\n", fwx);
 
144
        }
 
145
        void setFarPointWorldY(float fwy)
 
146
        {
 
147
                if(fwy == 0.0) return;
 
148
                fprintf(mFile,"\tsetAttr \".fw.fwy\" %f;\n", fwy);
 
149
        }
 
150
        void setFarPointWorldZ(float fwz)
 
151
        {
 
152
                if(fwz == 0.0) return;
 
153
                fprintf(mFile,"\tsetAttr \".fw.fwz\" %f;\n", fwz);
 
154
        }
 
155
        void setFogIntensity(float fin)
 
156
        {
 
157
                if(fin == 1.0) return;
 
158
                fprintf(mFile,"\tsetAttr \".fin\" %f;\n", fin);
 
159
        }
 
160
        void setMentalRayControls(const MentalRayControls& mrc)
 
161
        {
 
162
                fprintf(mFile,"\tsetAttr \".mrc\" ");
 
163
                mrc.write(mFile);
 
164
                fprintf(mFile,";\n");
 
165
        }
 
166
        void setMiExportMrLight(bool milt)
 
167
        {
 
168
                if(milt == false) return;
 
169
                fprintf(mFile,"\tsetAttr \".mrc.milt\" %i;\n", milt);
 
170
        }
 
171
        void setEmitPhotons(bool phot)
 
172
        {
 
173
                if(phot == false) return;
 
174
                fprintf(mFile,"\tsetAttr \".mrc.phot\" %i;\n", phot);
 
175
        }
 
176
        void setEnergy(const float3& eng)
 
177
        {
 
178
                fprintf(mFile,"\tsetAttr \".mrc.eng\" -type \"float3\" ");
 
179
                eng.write(mFile);
 
180
                fprintf(mFile,";\n");
 
181
        }
 
182
        void setEnergyR(float engr)
 
183
        {
 
184
                if(engr == 8000) return;
 
185
                fprintf(mFile,"\tsetAttr \".mrc.eng.engr\" %f;\n", engr);
 
186
        }
 
187
        void setEnergyG(float engg)
 
188
        {
 
189
                if(engg == 8000) return;
 
190
                fprintf(mFile,"\tsetAttr \".mrc.eng.engg\" %f;\n", engg);
 
191
        }
 
192
        void setEnergyB(float engb)
 
193
        {
 
194
                if(engb == 8000) return;
 
195
                fprintf(mFile,"\tsetAttr \".mrc.eng.engb\" %f;\n", engb);
 
196
        }
 
197
        void setPhotonIntensity(float phi)
 
198
        {
 
199
                if(phi == 1) return;
 
200
                fprintf(mFile,"\tsetAttr \".mrc.phi\" %f;\n", phi);
 
201
        }
 
202
        void setExponent(float exp)
 
203
        {
 
204
                if(exp == 2) return;
 
205
                fprintf(mFile,"\tsetAttr \".mrc.exp\" %f;\n", exp);
 
206
        }
 
207
        void setCausticPhotons(int cph)
 
208
        {
 
209
                if(cph == 10000) return;
 
210
                fprintf(mFile,"\tsetAttr \".mrc.cph\" %i;\n", cph);
 
211
        }
 
212
        void setGlobIllPhotons(int gph)
 
213
        {
 
214
                if(gph == 10000) return;
 
215
                fprintf(mFile,"\tsetAttr \".mrc.gph\" %i;\n", gph);
 
216
        }
 
217
        void setShadowMap(bool usm)
 
218
        {
 
219
                if(usm == false) return;
 
220
                fprintf(mFile,"\tsetAttr \".mrc.usm\" %i;\n", usm);
 
221
        }
 
222
        void setSmapResolution(int smr)
 
223
        {
 
224
                if(smr == 256) return;
 
225
                fprintf(mFile,"\tsetAttr \".mrc.smr\" %i;\n", smr);
 
226
        }
 
227
        void setSmapSamples(short smsa)
 
228
        {
 
229
                if(smsa == 1) return;
 
230
                fprintf(mFile,"\tsetAttr \".mrc.smsa\" %i;\n", smsa);
 
231
        }
 
232
        void setSmapSoftness(float smso)
 
233
        {
 
234
                if(smso == 0) return;
 
235
                fprintf(mFile,"\tsetAttr \".mrc.smso\" %f;\n", smso);
 
236
        }
 
237
        void setSmapBias(float smb)
 
238
        {
 
239
                if(smb == 0) return;
 
240
                fprintf(mFile,"\tsetAttr \".mrc.smb\" %f;\n", smb);
 
241
        }
 
242
        void setSmapFilename(const string& smf)
 
243
        {
 
244
                if(smf == "NULL") return;
 
245
                fprintf(mFile,"\tsetAttr \".mrc.smf\" -type \"string\" ");
 
246
                smf.write(mFile);
 
247
                fprintf(mFile,";\n");
 
248
        }
 
249
        void setSmapLightName(bool smln)
 
250
        {
 
251
                if(smln == 0) return;
 
252
                fprintf(mFile,"\tsetAttr \".mrc.smln\" %i;\n", smln);
 
253
        }
 
254
        void setSmapSceneName(bool smsn)
 
255
        {
 
256
                if(smsn == 0) return;
 
257
                fprintf(mFile,"\tsetAttr \".mrc.smsn\" %i;\n", smsn);
 
258
        }
 
259
        void setSmapFrameExt(bool smfe)
 
260
        {
 
261
                if(smfe == 0) return;
 
262
                fprintf(mFile,"\tsetAttr \".mrc.smfe\" %i;\n", smfe);
 
263
        }
 
264
        void setSmapDetail(bool smd)
 
265
        {
 
266
                if(smd == 0) return;
 
267
                fprintf(mFile,"\tsetAttr \".mrc.smd\" %i;\n", smd);
 
268
        }
 
269
        void setSmapDetailSamples(short sds)
 
270
        {
 
271
                if(sds == 0) return;
 
272
                fprintf(mFile,"\tsetAttr \".mrc.sds\" %i;\n", sds);
 
273
        }
 
274
        void setSmapDetailAccuracy(float sdac)
 
275
        {
 
276
                if(sdac == 0) return;
 
277
                fprintf(mFile,"\tsetAttr \".mrc.sdac\" %f;\n", sdac);
 
278
        }
 
279
        void setSmapDetailAlpha(bool sdal)
 
280
        {
 
281
                if(sdal == 0) return;
 
282
                fprintf(mFile,"\tsetAttr \".mrc.sdal\" %i;\n", sdal);
 
283
        }
 
284
        void setAreaLight(bool algt)
 
285
        {
 
286
                if(algt == false) return;
 
287
                fprintf(mFile,"\tsetAttr \".mrc.algt\" %i;\n", algt);
 
288
        }
 
289
        void setAreaType(unsigned int atyp)
 
290
        {
 
291
                if(atyp == 0) return;
 
292
                fprintf(mFile,"\tsetAttr \".mrc.atyp\" %i;\n", atyp);
 
293
        }
 
294
        void setAreaNormal(const float3& ano)
 
295
        {
 
296
                fprintf(mFile,"\tsetAttr \".mrc.ano\" -type \"float3\" ");
 
297
                ano.write(mFile);
 
298
                fprintf(mFile,";\n");
 
299
        }
 
300
        void setAreaNormalX(float anox)
 
301
        {
 
302
                if(anox == 0) return;
 
303
                fprintf(mFile,"\tsetAttr \".mrc.ano.anox\" %f;\n", anox);
 
304
        }
 
305
        void setAreaNormalY(float anoy)
 
306
        {
 
307
                if(anoy == 2) return;
 
308
                fprintf(mFile,"\tsetAttr \".mrc.ano.anoy\" %f;\n", anoy);
 
309
        }
 
310
        void setAreaNormalZ(float anoz)
 
311
        {
 
312
                if(anoz == 0) return;
 
313
                fprintf(mFile,"\tsetAttr \".mrc.ano.anoz\" %f;\n", anoz);
 
314
        }
 
315
        void setAreaEdge(const float3& aed)
 
316
        {
 
317
                fprintf(mFile,"\tsetAttr \".mrc.aed\" -type \"float3\" ");
 
318
                aed.write(mFile);
 
319
                fprintf(mFile,";\n");
 
320
        }
 
321
        void setAreaEdgeX(float aedx)
 
322
        {
 
323
                if(aedx == 2) return;
 
324
                fprintf(mFile,"\tsetAttr \".mrc.aed.aedx\" %f;\n", aedx);
 
325
        }
 
326
        void setAreaEdgeY(float aedy)
 
327
        {
 
328
                if(aedy == 0) return;
 
329
                fprintf(mFile,"\tsetAttr \".mrc.aed.aedy\" %f;\n", aedy);
 
330
        }
 
331
        void setAreaEdgeZ(float aedz)
 
332
        {
 
333
                if(aedz == 0) return;
 
334
                fprintf(mFile,"\tsetAttr \".mrc.aed.aedz\" %f;\n", aedz);
 
335
        }
 
336
        void setAreaRadius(float arad)
 
337
        {
 
338
                if(arad == 2) return;
 
339
                fprintf(mFile,"\tsetAttr \".mrc.arad\" %f;\n", arad);
 
340
        }
 
341
        void setAreaSampling(const short2& asa)
 
342
        {
 
343
                fprintf(mFile,"\tsetAttr \".mrc.asa\" -type \"short2\" ");
 
344
                asa.write(mFile);
 
345
                fprintf(mFile,";\n");
 
346
        }
 
347
        void setAreaSamplingU(short asau)
 
348
        {
 
349
                if(asau == 3) return;
 
350
                fprintf(mFile,"\tsetAttr \".mrc.asa.asau\" %i;\n", asau);
 
351
        }
 
352
        void setAreaSamplingV(short asav)
 
353
        {
 
354
                if(asav == 3) return;
 
355
                fprintf(mFile,"\tsetAttr \".mrc.asa.asav\" %i;\n", asav);
 
356
        }
 
357
        void setAreaLowLevel(short alev)
 
358
        {
 
359
                if(alev == 0) return;
 
360
                fprintf(mFile,"\tsetAttr \".mrc.alev\" %i;\n", alev);
 
361
        }
 
362
        void setAreaLowSampling(const short2& alo)
 
363
        {
 
364
                fprintf(mFile,"\tsetAttr \".mrc.alo\" -type \"short2\" ");
 
365
                alo.write(mFile);
 
366
                fprintf(mFile,";\n");
 
367
        }
 
368
        void setAreaLowSamplingU(short alou)
 
369
        {
 
370
                if(alou == 2) return;
 
371
                fprintf(mFile,"\tsetAttr \".mrc.alo.alou\" %i;\n", alou);
 
372
        }
 
373
        void setAreaLowSamplingV(short alov)
 
374
        {
 
375
                if(alov == 2) return;
 
376
                fprintf(mFile,"\tsetAttr \".mrc.alo.alov\" %i;\n", alov);
 
377
        }
 
378
        void setAreaVisible(bool avis)
 
379
        {
 
380
                if(avis == false) return;
 
381
                fprintf(mFile,"\tsetAttr \".mrc.avis\" %i;\n", avis);
 
382
        }
 
383
        void getFogGeometry()const
 
384
        {
 
385
                fprintf(mFile,"\"%s.fg\"",mName.c_str());
 
386
        }
 
387
        void getFogRadius()const
 
388
        {
 
389
                fprintf(mFile,"\"%s.fr\"",mName.c_str());
 
390
        }
 
391
        void getLightGlow()const
 
392
        {
 
393
                fprintf(mFile,"\"%s.lg\"",mName.c_str());
 
394
        }
 
395
        void getObjectType()const
 
396
        {
 
397
                fprintf(mFile,"\"%s.ot\"",mName.c_str());
 
398
        }
 
399
        void getFogType()const
 
400
        {
 
401
                fprintf(mFile,"\"%s.ft\"",mName.c_str());
 
402
        }
 
403
        void getPointWorld()const
 
404
        {
 
405
                fprintf(mFile,"\"%s.pw\"",mName.c_str());
 
406
        }
 
407
        void getPointWorldX()const
 
408
        {
 
409
                fprintf(mFile,"\"%s.pw.tx\"",mName.c_str());
 
410
        }
 
411
        void getPointWorldY()const
 
412
        {
 
413
                fprintf(mFile,"\"%s.pw.ty\"",mName.c_str());
 
414
        }
 
415
        void getPointWorldZ()const
 
416
        {
 
417
                fprintf(mFile,"\"%s.pw.tz\"",mName.c_str());
 
418
        }
 
419
        void getFarPointWorld()const
 
420
        {
 
421
                fprintf(mFile,"\"%s.fw\"",mName.c_str());
 
422
        }
 
423
        void getFarPointWorldX()const
 
424
        {
 
425
                fprintf(mFile,"\"%s.fw.fwx\"",mName.c_str());
 
426
        }
 
427
        void getFarPointWorldY()const
 
428
        {
 
429
                fprintf(mFile,"\"%s.fw.fwy\"",mName.c_str());
 
430
        }
 
431
        void getFarPointWorldZ()const
 
432
        {
 
433
                fprintf(mFile,"\"%s.fw.fwz\"",mName.c_str());
 
434
        }
 
435
        void getFogIntensity()const
 
436
        {
 
437
                fprintf(mFile,"\"%s.fin\"",mName.c_str());
 
438
        }
 
439
        void getMentalRayControls()const
 
440
        {
 
441
                fprintf(mFile,"\"%s.mrc\"",mName.c_str());
 
442
        }
 
443
        void getMiExportMrLight()const
 
444
        {
 
445
                fprintf(mFile,"\"%s.mrc.milt\"",mName.c_str());
 
446
        }
 
447
        void getMiLightShader()const
 
448
        {
 
449
                fprintf(mFile,"\"%s.mrc.mils\"",mName.c_str());
 
450
        }
 
451
        void getMiPhotonEmitter()const
 
452
        {
 
453
                fprintf(mFile,"\"%s.mrc.mipe\"",mName.c_str());
 
454
        }
 
455
        void getEmitPhotons()const
 
456
        {
 
457
                fprintf(mFile,"\"%s.mrc.phot\"",mName.c_str());
 
458
        }
 
459
        void getEnergy()const
 
460
        {
 
461
                fprintf(mFile,"\"%s.mrc.eng\"",mName.c_str());
 
462
        }
 
463
        void getEnergyR()const
 
464
        {
 
465
                fprintf(mFile,"\"%s.mrc.eng.engr\"",mName.c_str());
 
466
        }
 
467
        void getEnergyG()const
 
468
        {
 
469
                fprintf(mFile,"\"%s.mrc.eng.engg\"",mName.c_str());
 
470
        }
 
471
        void getEnergyB()const
 
472
        {
 
473
                fprintf(mFile,"\"%s.mrc.eng.engb\"",mName.c_str());
 
474
        }
 
475
        void getPhotonIntensity()const
 
476
        {
 
477
                fprintf(mFile,"\"%s.mrc.phi\"",mName.c_str());
 
478
        }
 
479
        void getExponent()const
 
480
        {
 
481
                fprintf(mFile,"\"%s.mrc.exp\"",mName.c_str());
 
482
        }
 
483
        void getCausticPhotons()const
 
484
        {
 
485
                fprintf(mFile,"\"%s.mrc.cph\"",mName.c_str());
 
486
        }
 
487
        void getGlobIllPhotons()const
 
488
        {
 
489
                fprintf(mFile,"\"%s.mrc.gph\"",mName.c_str());
 
490
        }
 
491
        void getShadowMap()const
 
492
        {
 
493
                fprintf(mFile,"\"%s.mrc.usm\"",mName.c_str());
 
494
        }
 
495
        void getSmapResolution()const
 
496
        {
 
497
                fprintf(mFile,"\"%s.mrc.smr\"",mName.c_str());
 
498
        }
 
499
        void getSmapSamples()const
 
500
        {
 
501
                fprintf(mFile,"\"%s.mrc.smsa\"",mName.c_str());
 
502
        }
 
503
        void getSmapSoftness()const
 
504
        {
 
505
                fprintf(mFile,"\"%s.mrc.smso\"",mName.c_str());
 
506
        }
 
507
        void getSmapBias()const
 
508
        {
 
509
                fprintf(mFile,"\"%s.mrc.smb\"",mName.c_str());
 
510
        }
 
511
        void getSmapCamera()const
 
512
        {
 
513
                fprintf(mFile,"\"%s.mrc.smc\"",mName.c_str());
 
514
        }
 
515
        void getSmapFilename()const
 
516
        {
 
517
                fprintf(mFile,"\"%s.mrc.smf\"",mName.c_str());
 
518
        }
 
519
        void getSmapLightName()const
 
520
        {
 
521
                fprintf(mFile,"\"%s.mrc.smln\"",mName.c_str());
 
522
        }
 
523
        void getSmapSceneName()const
 
524
        {
 
525
                fprintf(mFile,"\"%s.mrc.smsn\"",mName.c_str());
 
526
        }
 
527
        void getSmapFrameExt()const
 
528
        {
 
529
                fprintf(mFile,"\"%s.mrc.smfe\"",mName.c_str());
 
530
        }
 
531
        void getSmapDetail()const
 
532
        {
 
533
                fprintf(mFile,"\"%s.mrc.smd\"",mName.c_str());
 
534
        }
 
535
        void getSmapDetailSamples()const
 
536
        {
 
537
                fprintf(mFile,"\"%s.mrc.sds\"",mName.c_str());
 
538
        }
 
539
        void getSmapDetailAccuracy()const
 
540
        {
 
541
                fprintf(mFile,"\"%s.mrc.sdac\"",mName.c_str());
 
542
        }
 
543
        void getSmapDetailAlpha()const
 
544
        {
 
545
                fprintf(mFile,"\"%s.mrc.sdal\"",mName.c_str());
 
546
        }
 
547
        void getAreaLight()const
 
548
        {
 
549
                fprintf(mFile,"\"%s.mrc.algt\"",mName.c_str());
 
550
        }
 
551
        void getAreaType()const
 
552
        {
 
553
                fprintf(mFile,"\"%s.mrc.atyp\"",mName.c_str());
 
554
        }
 
555
        void getAreaNormal()const
 
556
        {
 
557
                fprintf(mFile,"\"%s.mrc.ano\"",mName.c_str());
 
558
        }
 
559
        void getAreaNormalX()const
 
560
        {
 
561
                fprintf(mFile,"\"%s.mrc.ano.anox\"",mName.c_str());
 
562
        }
 
563
        void getAreaNormalY()const
 
564
        {
 
565
                fprintf(mFile,"\"%s.mrc.ano.anoy\"",mName.c_str());
 
566
        }
 
567
        void getAreaNormalZ()const
 
568
        {
 
569
                fprintf(mFile,"\"%s.mrc.ano.anoz\"",mName.c_str());
 
570
        }
 
571
        void getAreaEdge()const
 
572
        {
 
573
                fprintf(mFile,"\"%s.mrc.aed\"",mName.c_str());
 
574
        }
 
575
        void getAreaEdgeX()const
 
576
        {
 
577
                fprintf(mFile,"\"%s.mrc.aed.aedx\"",mName.c_str());
 
578
        }
 
579
        void getAreaEdgeY()const
 
580
        {
 
581
                fprintf(mFile,"\"%s.mrc.aed.aedy\"",mName.c_str());
 
582
        }
 
583
        void getAreaEdgeZ()const
 
584
        {
 
585
                fprintf(mFile,"\"%s.mrc.aed.aedz\"",mName.c_str());
 
586
        }
 
587
        void getAreaRadius()const
 
588
        {
 
589
                fprintf(mFile,"\"%s.mrc.arad\"",mName.c_str());
 
590
        }
 
591
        void getAreaSampling()const
 
592
        {
 
593
                fprintf(mFile,"\"%s.mrc.asa\"",mName.c_str());
 
594
        }
 
595
        void getAreaSamplingU()const
 
596
        {
 
597
                fprintf(mFile,"\"%s.mrc.asa.asau\"",mName.c_str());
 
598
        }
 
599
        void getAreaSamplingV()const
 
600
        {
 
601
                fprintf(mFile,"\"%s.mrc.asa.asav\"",mName.c_str());
 
602
        }
 
603
        void getAreaLowLevel()const
 
604
        {
 
605
                fprintf(mFile,"\"%s.mrc.alev\"",mName.c_str());
 
606
        }
 
607
        void getAreaLowSampling()const
 
608
        {
 
609
                fprintf(mFile,"\"%s.mrc.alo\"",mName.c_str());
 
610
        }
 
611
        void getAreaLowSamplingU()const
 
612
        {
 
613
                fprintf(mFile,"\"%s.mrc.alo.alou\"",mName.c_str());
 
614
        }
 
615
        void getAreaLowSamplingV()const
 
616
        {
 
617
                fprintf(mFile,"\"%s.mrc.alo.alov\"",mName.c_str());
 
618
        }
 
619
        void getAreaVisible()const
 
620
        {
 
621
                fprintf(mFile,"\"%s.mrc.avis\"",mName.c_str());
 
622
        }
 
623
        void getMiLightProfile()const
 
624
        {
 
625
                fprintf(mFile,"\"%s.mrc.mlp\"",mName.c_str());
 
626
        }
 
627
protected:
 
628
        PointLight(FILE* file,const std::string& name,const std::string& parent,const std::string& nodeType,bool shared=false,bool create=true)
 
629
                :NonExtendedLightShapeNode(file, name, parent, nodeType, shared, create) {}
 
630
 
 
631
};
 
632
}//namespace MayaDM
 
633
#endif//__MayaDM_POINTLIGHT_H__