← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Externals/MayaDataModel/include/MayaDMVolumeLight.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/MayaDMVolumeLight.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_VOLUMELIGHT_H__
 
11
#define __MayaDM_VOLUMELIGHT_H__
 
12
#include "MayaDMTypes.h"
 
13
#include "MayaDMConnectables.h"
 
14
#include "MayaDMPointLight.h"
 
15
namespace MayaDM
 
16
{
 
17
class VolumeLight : public PointLight
 
18
{
 
19
public:
 
20
        struct ColorRange{
 
21
                float colorRange_Position;
 
22
                float3 colorRange_Color;
 
23
                unsigned int colorRange_Interp;
 
24
                void write(FILE* file) const
 
25
                {
 
26
                        fprintf(file,"%f ", colorRange_Position);
 
27
                        colorRange_Color.write(file);
 
28
                        fprintf(file, " ");
 
29
                        fprintf(file,"%i", colorRange_Interp);
 
30
                }
 
31
        };
 
32
        struct Penumbra{
 
33
                float penumbra_Position;
 
34
                float penumbra_FloatValue;
 
35
                unsigned int penumbra_Interp;
 
36
                void write(FILE* file) const
 
37
                {
 
38
                        fprintf(file,"%f ", penumbra_Position);
 
39
                        fprintf(file,"%f ", penumbra_FloatValue);
 
40
                        fprintf(file,"%i", penumbra_Interp);
 
41
                }
 
42
        };
 
43
public:
 
44
 
 
45
        VolumeLight():PointLight(){}
 
46
        VolumeLight(FILE* file,const std::string& name,const std::string& parent="",bool shared=false,bool create=true)
 
47
                :PointLight(file, name, parent, "volumeLight", shared, create){}
 
48
        virtual ~VolumeLight(){}
 
49
 
 
50
        void setLightShape(unsigned int lis)
 
51
        {
 
52
                if(lis == 1) return;
 
53
                fprintf(mFile,"\tsetAttr \".lis\" %i;\n", lis);
 
54
        }
 
55
        void setVolumeLightDir(unsigned int vld)
 
56
        {
 
57
                if(vld == 0) return;
 
58
                fprintf(mFile,"\tsetAttr \".vld\" %i;\n", vld);
 
59
        }
 
60
        void setArc(float ac)
 
61
        {
 
62
                if(ac == 360.0) return;
 
63
                fprintf(mFile,"\tsetAttr \".ac\" %f;\n", ac);
 
64
        }
 
65
        void setConeEndRadius(float cer)
 
66
        {
 
67
                if(cer == 0.0) return;
 
68
                fprintf(mFile,"\tsetAttr \".cer\" %f;\n", cer);
 
69
        }
 
70
        void setColorRange(size_t crg_i,const ColorRange& crg)
 
71
        {
 
72
                fprintf(mFile,"\tsetAttr \".crg[%i]\" ",crg_i);
 
73
                crg.write(mFile);
 
74
                fprintf(mFile,";\n");
 
75
        }
 
76
        void setColorRange(size_t crg_start,size_t crg_end,ColorRange* crg)
 
77
        {
 
78
                fprintf(mFile,"\tsetAttr \".crg[%i:%i]\" ", crg_start,crg_end);
 
79
                size_t size = (crg_end-crg_start)*1+1;
 
80
                for(size_t i=0;i<size;++i)
 
81
                {
 
82
                        crg[i].write(mFile);
 
83
                        fprintf(mFile,"\n");
 
84
                }
 
85
                fprintf(mFile,";\n");
 
86
        }
 
87
        void startColorRange(size_t crg_start,size_t crg_end)const
 
88
        {
 
89
                fprintf(mFile,"\tsetAttr \".crg[%i:%i]\"",crg_start,crg_end);
 
90
                fprintf(mFile," -type \"ColorRange\" ");
 
91
        }
 
92
        void appendColorRange(const ColorRange& crg)const
 
93
        {
 
94
                fprintf(mFile," ");
 
95
                crg.write(mFile);
 
96
        }
 
97
        void endColorRange()const
 
98
        {
 
99
                fprintf(mFile,";\n");
 
100
        }
 
101
        void setColorRange_Position(size_t crg_i,float crgp)
 
102
        {
 
103
                if(crgp == 0.0) return;
 
104
                fprintf(mFile,"\tsetAttr \".crg[%i].crgp\" %f;\n", crg_i,crgp);
 
105
        }
 
106
        void setColorRange_Color(size_t crg_i,const float3& crgc)
 
107
        {
 
108
                fprintf(mFile,"\tsetAttr \".crg[%i].crgc\" -type \"float3\" ",crg_i);
 
109
                crgc.write(mFile);
 
110
                fprintf(mFile,";\n");
 
111
        }
 
112
        void setColorRange_ColorR(size_t crg_i,float crgcr)
 
113
        {
 
114
                if(crgcr == 0.0) return;
 
115
                fprintf(mFile,"\tsetAttr \".crg[%i].crgc.crgcr\" %f;\n", crg_i,crgcr);
 
116
        }
 
117
        void setColorRange_ColorG(size_t crg_i,float crgcg)
 
118
        {
 
119
                if(crgcg == 0.0) return;
 
120
                fprintf(mFile,"\tsetAttr \".crg[%i].crgc.crgcg\" %f;\n", crg_i,crgcg);
 
121
        }
 
122
        void setColorRange_ColorB(size_t crg_i,float crgcb)
 
123
        {
 
124
                if(crgcb == 0.0) return;
 
125
                fprintf(mFile,"\tsetAttr \".crg[%i].crgc.crgcb\" %f;\n", crg_i,crgcb);
 
126
        }
 
127
        void setColorRange_Interp(size_t crg_i,unsigned int crgi)
 
128
        {
 
129
                if(crgi == 0) return;
 
130
                fprintf(mFile,"\tsetAttr \".crg[%i].crgi\" %i;\n", crg_i,crgi);
 
131
        }
 
132
        void setPenumbra(size_t pen_i,const Penumbra& pen)
 
133
        {
 
134
                fprintf(mFile,"\tsetAttr \".pen[%i]\" ",pen_i);
 
135
                pen.write(mFile);
 
136
                fprintf(mFile,";\n");
 
137
        }
 
138
        void setPenumbra(size_t pen_start,size_t pen_end,Penumbra* pen)
 
139
        {
 
140
                fprintf(mFile,"\tsetAttr \".pen[%i:%i]\" ", pen_start,pen_end);
 
141
                size_t size = (pen_end-pen_start)*1+1;
 
142
                for(size_t i=0;i<size;++i)
 
143
                {
 
144
                        pen[i].write(mFile);
 
145
                        fprintf(mFile,"\n");
 
146
                }
 
147
                fprintf(mFile,";\n");
 
148
        }
 
149
        void startPenumbra(size_t pen_start,size_t pen_end)const
 
150
        {
 
151
                fprintf(mFile,"\tsetAttr \".pen[%i:%i]\"",pen_start,pen_end);
 
152
                fprintf(mFile," -type \"Penumbra\" ");
 
153
        }
 
154
        void appendPenumbra(const Penumbra& pen)const
 
155
        {
 
156
                fprintf(mFile," ");
 
157
                pen.write(mFile);
 
158
        }
 
159
        void endPenumbra()const
 
160
        {
 
161
                fprintf(mFile,";\n");
 
162
        }
 
163
        void setPenumbra_Position(size_t pen_i,float penp)
 
164
        {
 
165
                if(penp == 0.0) return;
 
166
                fprintf(mFile,"\tsetAttr \".pen[%i].penp\" %f;\n", pen_i,penp);
 
167
        }
 
168
        void setPenumbra_FloatValue(size_t pen_i,float penfv)
 
169
        {
 
170
                if(penfv == 0.0) return;
 
171
                fprintf(mFile,"\tsetAttr \".pen[%i].penfv\" %f;\n", pen_i,penfv);
 
172
        }
 
173
        void setPenumbra_Interp(size_t pen_i,unsigned int peni)
 
174
        {
 
175
                if(peni == 0) return;
 
176
                fprintf(mFile,"\tsetAttr \".pen[%i].peni\" %i;\n", pen_i,peni);
 
177
        }
 
178
        void setEmitAmbient(bool ema)
 
179
        {
 
180
                if(ema == false) return;
 
181
                fprintf(mFile,"\tsetAttr \".ema\" %i;\n", ema);
 
182
        }
 
183
        void getLightShape()const
 
184
        {
 
185
                fprintf(mFile,"\"%s.lis\"",mName.c_str());
 
186
        }
 
187
        void getVolumeLightDir()const
 
188
        {
 
189
                fprintf(mFile,"\"%s.vld\"",mName.c_str());
 
190
        }
 
191
        void getArc()const
 
192
        {
 
193
                fprintf(mFile,"\"%s.ac\"",mName.c_str());
 
194
        }
 
195
        void getConeEndRadius()const
 
196
        {
 
197
                fprintf(mFile,"\"%s.cer\"",mName.c_str());
 
198
        }
 
199
        void getColorRange(size_t crg_i)const
 
200
        {
 
201
                fprintf(mFile,"\"%s.crg[%i]\"",mName.c_str(),crg_i);
 
202
        }
 
203
        void getColorRange()const
 
204
        {
 
205
 
 
206
                fprintf(mFile,"\"%s.crg\"",mName.c_str());
 
207
        }
 
208
        void getColorRange_Position(size_t crg_i)const
 
209
        {
 
210
                fprintf(mFile,"\"%s.crg[%i].crgp\"",mName.c_str(),crg_i);
 
211
        }
 
212
        void getColorRange_Position()const
 
213
        {
 
214
 
 
215
                fprintf(mFile,"\"%s.crg.crgp\"",mName.c_str());
 
216
        }
 
217
        void getColorRange_Color(size_t crg_i)const
 
218
        {
 
219
                fprintf(mFile,"\"%s.crg[%i].crgc\"",mName.c_str(),crg_i);
 
220
        }
 
221
        void getColorRange_Color()const
 
222
        {
 
223
 
 
224
                fprintf(mFile,"\"%s.crg.crgc\"",mName.c_str());
 
225
        }
 
226
        void getColorRange_ColorR(size_t crg_i)const
 
227
        {
 
228
                fprintf(mFile,"\"%s.crg[%i].crgc.crgcr\"",mName.c_str(),crg_i);
 
229
        }
 
230
        void getColorRange_ColorR()const
 
231
        {
 
232
 
 
233
                fprintf(mFile,"\"%s.crg.crgc.crgcr\"",mName.c_str());
 
234
        }
 
235
        void getColorRange_ColorG(size_t crg_i)const
 
236
        {
 
237
                fprintf(mFile,"\"%s.crg[%i].crgc.crgcg\"",mName.c_str(),crg_i);
 
238
        }
 
239
        void getColorRange_ColorG()const
 
240
        {
 
241
 
 
242
                fprintf(mFile,"\"%s.crg.crgc.crgcg\"",mName.c_str());
 
243
        }
 
244
        void getColorRange_ColorB(size_t crg_i)const
 
245
        {
 
246
                fprintf(mFile,"\"%s.crg[%i].crgc.crgcb\"",mName.c_str(),crg_i);
 
247
        }
 
248
        void getColorRange_ColorB()const
 
249
        {
 
250
 
 
251
                fprintf(mFile,"\"%s.crg.crgc.crgcb\"",mName.c_str());
 
252
        }
 
253
        void getColorRange_Interp(size_t crg_i)const
 
254
        {
 
255
                fprintf(mFile,"\"%s.crg[%i].crgi\"",mName.c_str(),crg_i);
 
256
        }
 
257
        void getColorRange_Interp()const
 
258
        {
 
259
 
 
260
                fprintf(mFile,"\"%s.crg.crgi\"",mName.c_str());
 
261
        }
 
262
        void getPenumbra(size_t pen_i)const
 
263
        {
 
264
                fprintf(mFile,"\"%s.pen[%i]\"",mName.c_str(),pen_i);
 
265
        }
 
266
        void getPenumbra()const
 
267
        {
 
268
 
 
269
                fprintf(mFile,"\"%s.pen\"",mName.c_str());
 
270
        }
 
271
        void getPenumbra_Position(size_t pen_i)const
 
272
        {
 
273
                fprintf(mFile,"\"%s.pen[%i].penp\"",mName.c_str(),pen_i);
 
274
        }
 
275
        void getPenumbra_Position()const
 
276
        {
 
277
 
 
278
                fprintf(mFile,"\"%s.pen.penp\"",mName.c_str());
 
279
        }
 
280
        void getPenumbra_FloatValue(size_t pen_i)const
 
281
        {
 
282
                fprintf(mFile,"\"%s.pen[%i].penfv\"",mName.c_str(),pen_i);
 
283
        }
 
284
        void getPenumbra_FloatValue()const
 
285
        {
 
286
 
 
287
                fprintf(mFile,"\"%s.pen.penfv\"",mName.c_str());
 
288
        }
 
289
        void getPenumbra_Interp(size_t pen_i)const
 
290
        {
 
291
                fprintf(mFile,"\"%s.pen[%i].peni\"",mName.c_str(),pen_i);
 
292
        }
 
293
        void getPenumbra_Interp()const
 
294
        {
 
295
 
 
296
                fprintf(mFile,"\"%s.pen.peni\"",mName.c_str());
 
297
        }
 
298
        void getEmitAmbient()const
 
299
        {
 
300
                fprintf(mFile,"\"%s.ema\"",mName.c_str());
 
301
        }
 
302
protected:
 
303
        VolumeLight(FILE* file,const std::string& name,const std::string& parent,const std::string& nodeType,bool shared=false,bool create=true)
 
304
                :PointLight(file, name, parent, nodeType, shared, create) {}
 
305
 
 
306
};
 
307
}//namespace MayaDM
 
308
#endif//__MayaDM_VOLUMELIGHT_H__