← Back to branch summary

~baltix/+junk/irrlicht-test

« back to all changes in this revision

Viewing changes to source/Irrlicht/CAttributeImpl.h

  • Committer: Mantas Kriaučiūnas
  • Date: 2011-07-18 13:06:25 UTC
  • Revision ID: mantas@akl.lt-20110718130625-c5pvifp61e7kj1ol
Included whole irrlicht SVN libraries to work around launchpad recipe issue with quilt, see https://answers.launchpad.net/launchpad/+question/165193

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/Irrlicht/CAttributeImpl.h
 
1
// Copyright (C) 2002-2011 Nikolaus Gebhardt
 
2
// This file is part of the "Irrlicht Engine".
 
3
// For conditions of distribution and use, see copyright notice in irrlicht.h
 
4
 
 
5
#include "CAttributes.h"
 
6
#include "fast_atof.h"
 
7
#include "ITexture.h"
 
8
#include "IVideoDriver.h"
 
9
 
 
10
namespace irr
 
11
{
 
12
namespace io
 
13
{
 
14
 
 
15
/*
 
16
        basic types
 
17
*/
 
18
 
 
19
// Attribute implemented for boolean values
 
20
class CBoolAttribute : public IAttribute
 
21
{
 
22
public:
 
23
 
 
24
        CBoolAttribute(const char* name, bool value)
 
25
        {
 
26
                Name = name;
 
27
                setBool(value);
 
28
        }
 
29
 
 
30
        virtual s32 getInt()
 
31
        {
 
32
                return BoolValue ? 1 : 0;
 
33
        }
 
34
 
 
35
        virtual f32 getFloat()
 
36
        {
 
37
                return BoolValue ? 1.0f : 0.0f;
 
38
        }
 
39
 
 
40
        virtual bool getBool()
 
41
        {
 
42
                return BoolValue;
 
43
        }
 
44
 
 
45
        virtual core::stringw getStringW()
 
46
        {
 
47
                return core::stringw( BoolValue ? L"true" : L"false" );
 
48
        }
 
49
 
 
50
        virtual void setInt(s32 intValue)
 
51
        {
 
52
                BoolValue = (intValue != 0);
 
53
        }
 
54
 
 
55
        virtual void setFloat(f32 floatValue)
 
56
        {
 
57
                BoolValue = (floatValue != 0);
 
58
        }
 
59
 
 
60
        virtual void setBool(bool boolValue)
 
61
        {
 
62
                BoolValue = boolValue;
 
63
        }
 
64
 
 
65
        virtual void setString(const char* string)
 
66
        {
 
67
                BoolValue = strcmp(string, "true") == 0;
 
68
        }
 
69
 
 
70
        virtual E_ATTRIBUTE_TYPE getType() const
 
71
        {
 
72
                return EAT_BOOL;
 
73
        }
 
74
 
 
75
        virtual const wchar_t* getTypeString() const
 
76
        {
 
77
                return L"bool";
 
78
        }
 
79
 
 
80
        bool BoolValue;
 
81
};
 
82
 
 
83
// Attribute implemented for integers
 
84
class CIntAttribute : public IAttribute
 
85
{
 
86
public:
 
87
 
 
88
        CIntAttribute(const char* name, s32 value)
 
89
        {
 
90
                Name = name;
 
91
                setInt(value);
 
92
        }
 
93
 
 
94
        virtual s32 getInt()
 
95
        {
 
96
                return Value;
 
97
        }
 
98
 
 
99
        virtual f32 getFloat()
 
100
        {
 
101
                return (f32)Value;
 
102
        }
 
103
 
 
104
        virtual bool getBool()
 
105
        {
 
106
                return (Value != 0);
 
107
        }
 
108
 
 
109
        virtual core::stringw getStringW()
 
110
        {
 
111
                return core::stringw(Value);
 
112
        }
 
113
 
 
114
        virtual void setInt(s32 intValue)
 
115
        {
 
116
                Value = intValue;
 
117
        }
 
118
 
 
119
        virtual void setFloat(f32 floatValue)
 
120
        {
 
121
                Value = (s32)floatValue;
 
122
        };
 
123
 
 
124
        virtual void setString(const char* text)
 
125
        {
 
126
                Value = atoi(text);
 
127
        }
 
128
 
 
129
        virtual E_ATTRIBUTE_TYPE getType() const
 
130
        {
 
131
                return EAT_INT;
 
132
        }
 
133
 
 
134
 
 
135
        virtual const wchar_t* getTypeString() const
 
136
        {
 
137
                return L"int";
 
138
        }
 
139
 
 
140
        s32 Value;
 
141
};
 
142
 
 
143
// Attribute implemented for floats
 
144
class CFloatAttribute : public IAttribute
 
145
{
 
146
public:
 
147
 
 
148
        CFloatAttribute(const char* name, f32 value)
 
149
        {
 
150
                Name = name;
 
151
                setFloat(value);
 
152
        }
 
153
 
 
154
        virtual s32 getInt()
 
155
        {
 
156
                return (s32)Value;
 
157
        }
 
158
 
 
159
        virtual f32 getFloat()
 
160
        {
 
161
                return Value;
 
162
        }
 
163
 
 
164
        virtual bool getBool()
 
165
        {
 
166
                return (Value != 0);
 
167
        }
 
168
 
 
169
        virtual core::stringw getStringW()
 
170
        {
 
171
                return core::stringw(Value);
 
172
        }
 
173
 
 
174
        virtual void setInt(s32 intValue)
 
175
        {
 
176
                Value = (f32)intValue;
 
177
        }
 
178
 
 
179
        virtual void setFloat(f32 floatValue)
 
180
        {
 
181
                Value = floatValue;
 
182
        }
 
183
 
 
184
        virtual void setString(const char* text)
 
185
        {
 
186
                Value = core::fast_atof(text);
 
187
        }
 
188
 
 
189
        virtual E_ATTRIBUTE_TYPE getType() const
 
190
        {
 
191
                return EAT_FLOAT;
 
192
        }
 
193
 
 
194
 
 
195
        virtual const wchar_t* getTypeString() const
 
196
        {
 
197
                return L"float";
 
198
        }
 
199
 
 
200
        f32 Value;
 
201
};
 
202
 
 
203
 
 
204
 
 
205
/*
 
206
        Types which can be represented as a list of numbers
 
207
*/
 
208
 
 
209
// Base class for all attributes which are a list of numbers-
 
210
// vectors, colors, positions, triangles, etc
 
211
class CNumbersAttribute : public IAttribute
 
212
{
 
213
public:
 
214
 
 
215
        CNumbersAttribute(const char* name, video::SColorf value) :
 
216
                ValueI(), ValueF(), Count(4), IsFloat(true)
 
217
        {
 
218
                Name = name;
 
219
                ValueF.push_back(value.r);
 
220
                ValueF.push_back(value.g);
 
221
                ValueF.push_back(value.b);
 
222
                ValueF.push_back(value.a);
 
223
        }
 
224
 
 
225
        CNumbersAttribute(const char* name, video::SColor value) :
 
226
                ValueI(), ValueF(), Count(4), IsFloat(false)
 
227
        {
 
228
                Name = name;
 
229
                ValueI.push_back(value.getRed());
 
230
                ValueI.push_back(value.getGreen());
 
231
                ValueI.push_back(value.getBlue());
 
232
                ValueI.push_back(value.getAlpha());
 
233
        }
 
234
 
 
235
 
 
236
        CNumbersAttribute(const char* name, core::vector3df value) :
 
237
                ValueI(), ValueF(), Count(3), IsFloat(true)
 
238
        {
 
239
                Name = name;
 
240
                ValueF.push_back(value.X);
 
241
                ValueF.push_back(value.Y);
 
242
                ValueF.push_back(value.Z);
 
243
        }
 
244
 
 
245
        CNumbersAttribute(const char* name, core::rect<s32> value) :
 
246
                ValueI(), ValueF(), Count(4), IsFloat(false)
 
247
        {
 
248
                Name = name;
 
249
                ValueI.push_back(value.UpperLeftCorner.X);
 
250
                ValueI.push_back(value.UpperLeftCorner.Y);
 
251
                ValueI.push_back(value.LowerRightCorner.X);
 
252
                ValueI.push_back(value.LowerRightCorner.Y);
 
253
        }
 
254
 
 
255
        CNumbersAttribute(const char* name, core::rect<f32> value) :
 
256
                ValueI(), ValueF(), Count(4), IsFloat(true)
 
257
        {
 
258
                Name = name;
 
259
                ValueF.push_back(value.UpperLeftCorner.X);
 
260
                ValueF.push_back(value.UpperLeftCorner.Y);
 
261
                ValueF.push_back(value.LowerRightCorner.X);
 
262
                ValueF.push_back(value.LowerRightCorner.Y);
 
263
        }
 
264
 
 
265
        CNumbersAttribute(const char* name, core::matrix4 value) :
 
266
                ValueI(), ValueF(), Count(16), IsFloat(true)
 
267
        {
 
268
                Name = name;
 
269
                for (s32 r=0; r<4; ++r)
 
270
                        for (s32 c=0; c<4; ++c)
 
271
                                ValueF.push_back(value(r,c));
 
272
        }
 
273
 
 
274
        CNumbersAttribute(const char* name, core::quaternion value) :
 
275
                ValueI(), ValueF(), Count(4), IsFloat(true)
 
276
        {
 
277
                Name = name;
 
278
                ValueF.push_back(value.X);
 
279
                ValueF.push_back(value.Y);
 
280
                ValueF.push_back(value.Z);
 
281
                ValueF.push_back(value.W);
 
282
        }
 
283
 
 
284
        CNumbersAttribute(const char* name, core::aabbox3d<f32> value) :
 
285
                ValueI(), ValueF(), Count(6), IsFloat(true)
 
286
        {
 
287
                Name = name;
 
288
                ValueF.push_back(value.MinEdge.X);
 
289
                ValueF.push_back(value.MinEdge.Y);
 
290
                ValueF.push_back(value.MinEdge.Z);
 
291
                ValueF.push_back(value.MaxEdge.X);
 
292
                ValueF.push_back(value.MaxEdge.Y);
 
293
                ValueF.push_back(value.MaxEdge.Z);
 
294
        }
 
295
 
 
296
        CNumbersAttribute(const char* name, core::plane3df value) :
 
297
                ValueI(), ValueF(), Count(4), IsFloat(true)
 
298
        {
 
299
                Name = name;
 
300
                ValueF.push_back(value.Normal.X);
 
301
                ValueF.push_back(value.Normal.Y);
 
302
                ValueF.push_back(value.Normal.Z);
 
303
                ValueF.push_back(value.D);
 
304
        }
 
305
 
 
306
        CNumbersAttribute(const char* name, core::triangle3df value) :
 
307
                ValueI(), ValueF(), Count(9), IsFloat(true)
 
308
        {
 
309
                Name = name;
 
310
                ValueF.push_back(value.pointA.X);
 
311
                ValueF.push_back(value.pointA.Y);
 
312
                ValueF.push_back(value.pointA.Z);
 
313
                ValueF.push_back(value.pointB.X);
 
314
                ValueF.push_back(value.pointB.Y);
 
315
                ValueF.push_back(value.pointB.Z);
 
316
                ValueF.push_back(value.pointC.X);
 
317
                ValueF.push_back(value.pointC.Y);
 
318
                ValueF.push_back(value.pointC.Z);
 
319
        }
 
320
 
 
321
        CNumbersAttribute(const char* name, core::vector2df value) :
 
322
                ValueI(), ValueF(), Count(2), IsFloat(true)
 
323
        {
 
324
                Name = name;
 
325
                ValueF.push_back(value.X);
 
326
                ValueF.push_back(value.Y);
 
327
        }
 
328
 
 
329
        CNumbersAttribute(const char* name, core::vector2di value) :
 
330
                ValueI(), ValueF(), Count(2), IsFloat(false)
 
331
        {
 
332
                Name = name;
 
333
                ValueI.push_back(value.X);
 
334
                ValueI.push_back(value.Y);
 
335
        }
 
336
 
 
337
        CNumbersAttribute(const char* name, core::line2di value) :
 
338
                ValueI(), ValueF(), Count(4), IsFloat(false)
 
339
        {
 
340
                Name = name;
 
341
                ValueI.push_back(value.start.X);
 
342
                ValueI.push_back(value.start.Y);
 
343
                ValueI.push_back(value.end.X);
 
344
                ValueI.push_back(value.end.Y);
 
345
        }
 
346
 
 
347
        CNumbersAttribute(const char* name, core::line2df value) :
 
348
                ValueI(), ValueF(), Count(4), IsFloat(true)
 
349
        {
 
350
                Name = name;
 
351
                ValueF.push_back(value.start.X);
 
352
                ValueF.push_back(value.start.Y);
 
353
                ValueF.push_back(value.end.X);
 
354
                ValueF.push_back(value.end.Y);
 
355
        }
 
356
 
 
357
        CNumbersAttribute(const char* name, core::line3df value) :
 
358
                ValueI(), ValueF(), Count(6), IsFloat(true)
 
359
        {
 
360
                Name = name;
 
361
                ValueF.push_back(value.start.X);
 
362
                ValueF.push_back(value.start.Y);
 
363
                ValueF.push_back(value.start.Z);
 
364
                ValueF.push_back(value.end.X);
 
365
                ValueF.push_back(value.end.Y);
 
366
                ValueF.push_back(value.end.Z);
 
367
        }
 
368
 
 
369
        CNumbersAttribute(const char* name, core::dimension2du value) :
 
370
                ValueI(), ValueF(), Count(2), IsFloat(false)
 
371
        {
 
372
                Name = name;
 
373
                ValueI.push_back(value.Width);
 
374
                ValueI.push_back(value.Height);
 
375
        }
 
376
 
 
377
 
 
378
        CNumbersAttribute(const char* name, core::dimension2df value) :
 
379
                ValueI(), ValueF(), Count(2), IsFloat(true)
 
380
        {
 
381
                Name = name;
 
382
                ValueF.push_back(value.Width);
 
383
                ValueF.push_back(value.Height);
 
384
        }
 
385
 
 
386
 
 
387
 
 
388
        // getting values
 
389
        virtual s32 getInt()
 
390
        {
 
391
                if (Count==0)
 
392
                        return 0;
 
393
 
 
394
                if (IsFloat)
 
395
                        return (s32)ValueF[0];
 
396
                else
 
397
                        return ValueI[0];
 
398
        }
 
399
 
 
400
        virtual f32 getFloat()
 
401
        {
 
402
                if (Count==0)
 
403
                        return 0.0f;
 
404
 
 
405
                if (IsFloat)
 
406
                        return ValueF[0];
 
407
                else
 
408
                        return (f32)ValueI[0];
 
409
        }
 
410
 
 
411
        virtual bool getBool()
 
412
        {
 
413
                // return true if any number is nonzero
 
414
                bool ret=false;
 
415
 
 
416
                for (u32 i=0; i < Count; ++i)
 
417
                        if ( IsFloat ? (ValueF[i] != 0) : (ValueI[i] != 0) )
 
418
                        {
 
419
                                ret=true;
 
420
                                break;
 
421
                        }
 
422
 
 
423
                return ret;
 
424
 
 
425
        }
 
426
 
 
427
 
 
428
        virtual core::stringc getString()
 
429
        {
 
430
                core::stringc outstr;
 
431
 
 
432
                for (u32 i=0; i <Count; ++i)
 
433
                {
 
434
                        if (IsFloat)
 
435
                                outstr += ValueF[i];
 
436
                        else
 
437
                                outstr += ValueI[i];
 
438
 
 
439
                        if (i < Count-1)
 
440
                                outstr += ", ";
 
441
                }
 
442
                return outstr;
 
443
        }
 
444
        virtual core::stringw getStringW()
 
445
        {
 
446
                core::stringw outstr;
 
447
 
 
448
                for (u32 i=0; i <Count; ++i)
 
449
                {
 
450
                        if (IsFloat)
 
451
                                outstr += ValueF[i];
 
452
                        else
 
453
                                outstr += ValueI[i];
 
454
 
 
455
                        if (i < Count-1)
 
456
                                outstr += L", ";
 
457
                }
 
458
                return outstr;
 
459
        }
 
460
 
 
461
        virtual core::position2di getPosition()
 
462
        {
 
463
                core::position2di p;
 
464
 
 
465
                if (IsFloat)
 
466
                {
 
467
                        p.X = (s32)(Count > 0 ? ValueF[0] : 0);
 
468
                        p.Y = (s32)(Count > 1 ? ValueF[1] : 0);
 
469
                }
 
470
                else
 
471
                {
 
472
                        p.X = Count > 0 ? ValueI[0] : 0;
 
473
                        p.Y = Count > 1 ? ValueI[1] : 0;
 
474
                }
 
475
 
 
476
                return p;
 
477
        }
 
478
 
 
479
        virtual core::vector3df getVector()
 
480
        {
 
481
                core::vector3df v;
 
482
 
 
483
                if (IsFloat)
 
484
                {
 
485
                        v.X = Count > 0 ? ValueF[0] : 0;
 
486
                        v.Y = Count > 1 ? ValueF[1] : 0;
 
487
                        v.Z = Count > 2 ? ValueF[2] : 0;
 
488
                }
 
489
                else
 
490
                {
 
491
                        v.X = (f32)(Count > 0 ? ValueI[0] : 0);
 
492
                        v.Y = (f32)(Count > 1 ? ValueI[1] : 0);
 
493
                        v.Z = (f32)(Count > 2 ? ValueI[2] : 0);
 
494
                }
 
495
 
 
496
                return v;
 
497
        }
 
498
 
 
499
        virtual video::SColorf getColorf()
 
500
        {
 
501
                video::SColorf c;
 
502
                if (IsFloat)
 
503
                {
 
504
                        c.setColorComponentValue(0, Count > 0 ? ValueF[0] : 0);
 
505
                        c.setColorComponentValue(1, Count > 1 ? ValueF[1] : 0);
 
506
                        c.setColorComponentValue(2, Count > 2 ? ValueF[2] : 0);
 
507
                        c.setColorComponentValue(3, Count > 3 ? ValueF[3] : 0);
 
508
                }
 
509
                else
 
510
                {
 
511
                        c.setColorComponentValue(0, Count > 0 ? (f32)(ValueI[0]) / 255.0f : 0);
 
512
                        c.setColorComponentValue(1, Count > 1 ? (f32)(ValueI[1]) / 255.0f : 0);
 
513
                        c.setColorComponentValue(2, Count > 2 ? (f32)(ValueI[2]) / 255.0f : 0);
 
514
                        c.setColorComponentValue(3, Count > 3 ? (f32)(ValueI[3]) / 255.0f : 0);
 
515
                }
 
516
 
 
517
                return c;
 
518
        }
 
519
 
 
520
        virtual video::SColor getColor()
 
521
        {
 
522
                return getColorf().toSColor();
 
523
        }
 
524
 
 
525
 
 
526
        virtual core::rect<s32> getRect()
 
527
        {
 
528
                core::rect<s32> r;
 
529
 
 
530
                if (IsFloat)
 
531
                {
 
532
                        r.UpperLeftCorner.X  = (s32)(Count > 0 ? ValueF[0] : 0);
 
533
                        r.UpperLeftCorner.Y  = (s32)(Count > 1 ? ValueF[1] : 0);
 
534
                        r.LowerRightCorner.X = (s32)(Count > 2 ? ValueF[2] : r.UpperLeftCorner.X);
 
535
                        r.LowerRightCorner.Y = (s32)(Count > 3 ? ValueF[3] : r.UpperLeftCorner.Y);
 
536
                }
 
537
                else
 
538
                {
 
539
                        r.UpperLeftCorner.X  = Count > 0 ? ValueI[0] : 0;
 
540
                        r.UpperLeftCorner.Y  = Count > 1 ? ValueI[1] : 0;
 
541
                        r.LowerRightCorner.X = Count > 2 ? ValueI[2] : r.UpperLeftCorner.X;
 
542
                        r.LowerRightCorner.Y = Count > 3 ? ValueI[3] : r.UpperLeftCorner.Y;
 
543
                }
 
544
                return r;
 
545
        }
 
546
 
 
547
        virtual core::matrix4 getMatrix()
 
548
        {
 
549
                core::matrix4 ret;
 
550
                if (IsFloat)
 
551
                {
 
552
                        for (u32 r=0; r<4; ++r)
 
553
                                for (u32 c=0; c<4; ++c)
 
554
                                        if (Count > c+r*4)
 
555
                                                ret(r,c) = ValueF[c+r*4];
 
556
                }
 
557
                else
 
558
                {
 
559
                        for (u32 r=0; r<4; ++r)
 
560
                                for (u32 c=0; c<4; ++c)
 
561
                                        if (Count > c+r*4)
 
562
                                                ret(r,c) = (f32)ValueI[c+r*4];
 
563
                }
 
564
                return ret;
 
565
        }
 
566
 
 
567
        virtual core::quaternion getQuaternion()
 
568
        {
 
569
                core::quaternion ret;
 
570
                if (IsFloat)
 
571
                {
 
572
                        ret.X = Count > 0 ? ValueF[0] : 0.0f;
 
573
                        ret.Y = Count > 1 ? ValueF[1] : 0.0f;
 
574
                        ret.Z = Count > 2 ? ValueF[2] : 0.0f;
 
575
                        ret.W = Count > 3 ? ValueF[3] : 0.0f;
 
576
                }
 
577
                else
 
578
                {
 
579
                        ret.X = Count > 0 ? (f32)ValueI[0] : 0.0f;
 
580
                        ret.Y = Count > 1 ? (f32)ValueI[1] : 0.0f;
 
581
                        ret.Z = Count > 2 ? (f32)ValueI[2] : 0.0f;
 
582
                        ret.W = Count > 3 ? (f32)ValueI[3] : 0.0f;
 
583
                }
 
584
                return ret;
 
585
        }
 
586
 
 
587
        virtual core::triangle3df getTriangle()
 
588
        {
 
589
                core::triangle3df ret;
 
590
 
 
591
                if (IsFloat)
 
592
                {
 
593
                        ret.pointA.X = Count > 0 ? ValueF[0] : 0.0f;
 
594
                        ret.pointA.Y = Count > 1 ? ValueF[1] : 0.0f;
 
595
                        ret.pointA.Z = Count > 2 ? ValueF[2] : 0.0f;
 
596
                        ret.pointB.X = Count > 3 ? ValueF[3] : 0.0f;
 
597
                        ret.pointB.Y = Count > 4 ? ValueF[4] : 0.0f;
 
598
                        ret.pointB.Z = Count > 5 ? ValueF[5] : 0.0f;
 
599
                        ret.pointC.X = Count > 6 ? ValueF[6] : 0.0f;
 
600
                        ret.pointC.Y = Count > 7 ? ValueF[7] : 0.0f;
 
601
                        ret.pointC.Z = Count > 8 ? ValueF[8] : 0.0f;
 
602
                }
 
603
                else
 
604
                {
 
605
                        ret.pointA.X = Count > 0 ? (f32)ValueI[0] : 0.0f;
 
606
                        ret.pointA.Y = Count > 1 ? (f32)ValueI[1] : 0.0f;
 
607
                        ret.pointA.Z = Count > 2 ? (f32)ValueI[2] : 0.0f;
 
608
                        ret.pointB.X = Count > 3 ? (f32)ValueI[3] : 0.0f;
 
609
                        ret.pointB.Y = Count > 4 ? (f32)ValueI[4] : 0.0f;
 
610
                        ret.pointB.Z = Count > 5 ? (f32)ValueI[5] : 0.0f;
 
611
                        ret.pointC.X = Count > 6 ? (f32)ValueI[6] : 0.0f;
 
612
                        ret.pointC.Y = Count > 7 ? (f32)ValueI[7] : 0.0f;
 
613
                        ret.pointC.Z = Count > 8 ? (f32)ValueI[8] : 0.0f;
 
614
                }
 
615
 
 
616
                return ret;
 
617
        }
 
618
 
 
619
        virtual core::plane3df getPlane()
 
620
        {
 
621
                core::plane3df ret;
 
622
 
 
623
                if (IsFloat)
 
624
                {
 
625
                        ret.Normal.X = Count > 0 ? ValueF[0] : 0.0f;
 
626
                        ret.Normal.Y = Count > 1 ? ValueF[1] : 0.0f;
 
627
                        ret.Normal.Z = Count > 2 ? ValueF[2] : 0.0f;
 
628
                        ret.D            = Count > 3 ? ValueF[3] : 0.0f;
 
629
                }
 
630
                else
 
631
                {
 
632
                        ret.Normal.X = Count > 0 ? (f32)ValueI[0] : 0.0f;
 
633
                        ret.Normal.Y = Count > 1 ? (f32)ValueI[1] : 0.0f;
 
634
                        ret.Normal.Z = Count > 2 ? (f32)ValueI[2] : 0.0f;
 
635
                        ret.D            = Count > 3 ? (f32)ValueI[3] : 0.0f;
 
636
                }
 
637
 
 
638
                return ret;
 
639
        }
 
640
 
 
641
        virtual core::aabbox3df getBBox()
 
642
        {
 
643
                core::aabbox3df ret;
 
644
                if (IsFloat)
 
645
                {
 
646
                        ret.MinEdge.X = Count > 0 ? ValueF[0] : 0.0f;
 
647
                        ret.MinEdge.Y = Count > 1 ? ValueF[1] : 0.0f;
 
648
                        ret.MinEdge.Z = Count > 2 ? ValueF[2] : 0.0f;
 
649
                        ret.MaxEdge.X = Count > 3 ? ValueF[3] : 0.0f;
 
650
                        ret.MaxEdge.Y = Count > 4 ? ValueF[4] : 0.0f;
 
651
                        ret.MaxEdge.Z = Count > 5 ? ValueF[5] : 0.0f;
 
652
                }
 
653
                else
 
654
                {
 
655
                        ret.MinEdge.X = Count > 0 ? (f32)ValueI[0] : 0.0f;
 
656
                        ret.MinEdge.Y = Count > 1 ? (f32)ValueI[1] : 0.0f;
 
657
                        ret.MinEdge.Z = Count > 2 ? (f32)ValueI[2] : 0.0f;
 
658
                        ret.MaxEdge.X = Count > 3 ? (f32)ValueI[3] : 0.0f;
 
659
                        ret.MaxEdge.Y = Count > 4 ? (f32)ValueI[4] : 0.0f;
 
660
                        ret.MaxEdge.Z = Count > 5 ? (f32)ValueI[5] : 0.0f;
 
661
                }
 
662
                return ret;
 
663
 
 
664
        }
 
665
 
 
666
        virtual core::line2df getLine2d()
 
667
        {
 
668
                core::line2df ret;
 
669
                if (IsFloat)
 
670
                {
 
671
                        ret.start.X = Count > 0 ? ValueF[0] : 0.0f;
 
672
                        ret.start.Y = Count > 1 ? ValueF[1] : 0.0f;
 
673
                        ret.end.X   = Count > 2 ? ValueF[2] : 0.0f;
 
674
                        ret.end.Y   = Count > 3 ? ValueF[3] : 0.0f;
 
675
                }
 
676
                else
 
677
                {
 
678
                        ret.start.X = Count > 0 ? (f32)ValueI[0] : 0.0f;
 
679
                        ret.start.Y = Count > 1 ? (f32)ValueI[1] : 0.0f;
 
680
                        ret.end.X   = Count > 2 ? (f32)ValueI[2] : 0.0f;
 
681
                        ret.end.Y   = Count > 3 ? (f32)ValueI[3] : 0.0f;
 
682
                }
 
683
                return ret;
 
684
        }
 
685
 
 
686
        virtual core::line3df getLine3d()
 
687
        {
 
688
                core::line3df ret;
 
689
                if (IsFloat)
 
690
                {
 
691
                        ret.start.X = Count > 0 ? ValueF[0] : 0.0f;
 
692
                        ret.start.Y = Count > 1 ? ValueF[1] : 0.0f;
 
693
                        ret.start.Z = Count > 2 ? ValueF[2] : 0.0f;
 
694
                        ret.end.X   = Count > 3 ? ValueF[3] : 0.0f;
 
695
                        ret.end.Y   = Count > 4 ? ValueF[4] : 0.0f;
 
696
                        ret.end.Z   = Count > 5 ? ValueF[5] : 0.0f;
 
697
                }
 
698
                else
 
699
                {
 
700
                        ret.start.X = Count > 0 ? (f32)ValueI[0] : 0.0f;
 
701
                        ret.start.Y = Count > 1 ? (f32)ValueI[1] : 0.0f;
 
702
                        ret.start.Z = Count > 2 ? (f32)ValueI[2] : 0.0f;
 
703
                        ret.end.X   = Count > 3 ? (f32)ValueI[3] : 0.0f;
 
704
                        ret.end.Y   = Count > 4 ? (f32)ValueI[4] : 0.0f;
 
705
                        ret.end.Z   = Count > 5 ? (f32)ValueI[5] : 0.0f;
 
706
                }
 
707
                return ret;
 
708
        }
 
709
 
 
710
        //! get float array
 
711
        virtual core::array<f32> getFloatArray()
 
712
        {
 
713
                if (!IsFloat)
 
714
                {
 
715
                        ValueF.clear();
 
716
                        for (u32 i=0; i<Count; ++i)
 
717
                                ValueF.push_back( (f32) ValueI[i] );
 
718
                }
 
719
                return ValueF;
 
720
        }
 
721
 
 
722
        //! get int array
 
723
        virtual core::array<s32> getIntArray()
 
724
        {
 
725
                if (IsFloat)
 
726
                {
 
727
                        ValueI.clear();
 
728
                        for (u32 i=0; i<Count; ++i)
 
729
                                ValueI.push_back( (s32) ValueF[i] );
 
730
                }
 
731
                return ValueI;
 
732
        }
 
733
 
 
734
 
 
735
        // setting values
 
736
        virtual void setInt(s32 intValue)
 
737
        {
 
738
                // set all values
 
739
                for (u32 i=0; i < Count; ++i)
 
740
                        if (IsFloat)
 
741
                                ValueF[i] = (f32)intValue;
 
742
                        else
 
743
                                ValueI[i] = intValue;
 
744
        }
 
745
 
 
746
        virtual void setFloat(f32 floatValue)
 
747
        {
 
748
                // set all values
 
749
                for (u32 i=0; i < Count; ++i)
 
750
                        if (IsFloat)
 
751
                                ValueF[i] = floatValue;
 
752
                        else
 
753
                                ValueI[i] = (s32)floatValue;
 
754
        }
 
755
 
 
756
        virtual void setBool(bool boolValue)
 
757
        {
 
758
                setInt( boolValue ? 1 : 0);
 
759
        }
 
760
 
 
761
        virtual void setString(const char* text)
 
762
        {
 
763
                // parse text
 
764
 
 
765
                const char* P = (const char*)text;
 
766
 
 
767
                reset();
 
768
 
 
769
                u32 i=0;
 
770
 
 
771
                for ( i=0; i<Count && *P; ++i )
 
772
                {
 
773
                        while(*P && P[0]!='-' && ( P[0]==' ' || (P[0] < '0' || P[0] > '9') ) )
 
774
                                ++P;
 
775
 
 
776
                        // set value
 
777
                        if ( *P)
 
778
                        {
 
779
                                if (IsFloat)
 
780
                                {
 
781
                                        f32 c = 0;
 
782
                                        P = core::fast_atof_move(P, c);
 
783
                                        ValueF[i] = c;
 
784
                                }
 
785
                                else
 
786
                                {
 
787
                                        // todo: fix this to read ints properly
 
788
                                        f32 c = 0;
 
789
                                        P = core::fast_atof_move(P, c);
 
790
                                        ValueI[i] = (s32)c;
 
791
 
 
792
                                }
 
793
                        }
 
794
                }
 
795
                // todo: warning message
 
796
                //if (i < Count-1)
 
797
                //{
 
798
                //
 
799
                //}
 
800
        }
 
801
 
 
802
        virtual void setPosition(core::position2di v)
 
803
        {
 
804
                reset();
 
805
                if (IsFloat)
 
806
                {
 
807
                        if (Count > 0) ValueF[0] = (f32)v.X;
 
808
                        if (Count > 1) ValueF[1] = (f32)v.Y;
 
809
                }
 
810
                else
 
811
                {
 
812
                        if (Count > 0) ValueI[0] = v.X;
 
813
                        if (Count > 1) ValueI[1] = v.Y;
 
814
                }
 
815
        }
 
816
 
 
817
        virtual void setVector(core::vector3df v)
 
818
        {
 
819
                reset();
 
820
                if (IsFloat)
 
821
                {
 
822
                        if (Count > 0) ValueF[0] = v.X;
 
823
                        if (Count > 1) ValueF[1] = v.Y;
 
824
                        if (Count > 2) ValueF[2] = v.Z;
 
825
                }
 
826
                else
 
827
                {
 
828
                        if (Count > 0) ValueI[0] = (s32)v.X;
 
829
                        if (Count > 1) ValueI[1] = (s32)v.Y;
 
830
                        if (Count > 2) ValueI[2] = (s32)v.Z;
 
831
                }
 
832
        }
 
833
 
 
834
        virtual void setColor(video::SColorf color)
 
835
        {
 
836
                reset();
 
837
                if (IsFloat)
 
838
                {
 
839
                        if (Count > 0) ValueF[0] = color.r;
 
840
                        if (Count > 1) ValueF[1] = color.g;
 
841
                        if (Count > 2) ValueF[2] = color.b;
 
842
                        if (Count > 3) ValueF[3] = color.a;
 
843
                }
 
844
                else
 
845
                {
 
846
                        if (Count > 0) ValueI[0] = (s32)(color.r * 255);
 
847
                        if (Count > 1) ValueI[1] = (s32)(color.g * 255);
 
848
                        if (Count > 2) ValueI[2] = (s32)(color.b * 255);
 
849
                        if (Count > 3) ValueI[3] = (s32)(color.a * 255);
 
850
                }
 
851
 
 
852
        }
 
853
 
 
854
        virtual void setColor(video::SColor color)
 
855
        {
 
856
                reset();
 
857
                if (IsFloat)
 
858
                {
 
859
                        if (Count > 0) ValueF[0] = (f32)color.getRed() / 255.0f;
 
860
                        if (Count > 1) ValueF[1] = (f32)color.getGreen() / 255.0f;
 
861
                        if (Count > 2) ValueF[2] = (f32)color.getBlue() / 255.0f;
 
862
                        if (Count > 3) ValueF[3] = (f32)color.getAlpha() / 255.0f;
 
863
                }
 
864
                else
 
865
                {
 
866
                        if (Count > 0) ValueI[0] = color.getRed();
 
867
                        if (Count > 1) ValueI[1] = color.getGreen();
 
868
                        if (Count > 2) ValueI[2] = color.getBlue();
 
869
                        if (Count > 3) ValueI[3] = color.getAlpha();
 
870
                }
 
871
        }
 
872
 
 
873
        virtual void setRect(core::rect<s32> value)
 
874
        {
 
875
                reset();
 
876
                if (IsFloat)
 
877
                {
 
878
                        if (Count > 0) ValueF[0] = (f32)value.UpperLeftCorner.X;
 
879
                        if (Count > 1) ValueF[1] = (f32)value.UpperLeftCorner.Y;
 
880
                        if (Count > 2) ValueF[2] = (f32)value.LowerRightCorner.X;
 
881
                        if (Count > 3) ValueF[3] = (f32)value.LowerRightCorner.Y;
 
882
                }
 
883
                else
 
884
                {
 
885
                        if (Count > 0) ValueI[0] = value.UpperLeftCorner.X;
 
886
                        if (Count > 1) ValueI[1] = value.UpperLeftCorner.Y;
 
887
                        if (Count > 2) ValueI[2] = value.LowerRightCorner.X;
 
888
                        if (Count > 3) ValueI[3] = value.LowerRightCorner.Y;
 
889
                }
 
890
        }
 
891
 
 
892
        virtual void setMatrix(core::matrix4 value)
 
893
        {
 
894
                reset();
 
895
                if (IsFloat)
 
896
                {
 
897
                        for (u32 r=0; r<4; ++r)
 
898
                                for (u32 c=0; c<4; ++c)
 
899
                                        if (Count > c+r*4)
 
900
                                                ValueF[c+r*4] = value(r,c);
 
901
                }
 
902
                else
 
903
                {
 
904
                        for (u32 r=0; r<4; ++r)
 
905
                                for (u32 c=0; c<4; ++c)
 
906
                                        if (Count > c+r*4)
 
907
                                                ValueI[c+r*4] = (s32)value(r,c);
 
908
                }
 
909
        }
 
910
 
 
911
        virtual void setQuaternion(core::quaternion value)
 
912
        {
 
913
                reset();
 
914
                if (IsFloat)
 
915
                {
 
916
                        if (Count > 0) ValueF[0] = value.X;
 
917
                        if (Count > 1) ValueF[1] = value.Y;
 
918
                        if (Count > 2) ValueF[2] = value.Z;
 
919
                        if (Count > 3) ValueF[3] = value.W;
 
920
                }
 
921
                else
 
922
                {
 
923
                        if (Count > 0) ValueI[0] = (s32)value.X;
 
924
                        if (Count > 1) ValueI[1] = (s32)value.Y;
 
925
                        if (Count > 2) ValueI[2] = (s32)value.Z;
 
926
                        if (Count > 3) ValueI[3] = (s32)value.W;
 
927
                }
 
928
        }
 
929
 
 
930
        virtual void setBoundingBox(core::aabbox3d<f32> value)
 
931
        {
 
932
                reset();
 
933
                if (IsFloat)
 
934
                {
 
935
                        if (Count > 0) ValueF[0] = value.MinEdge.X;
 
936
                        if (Count > 1) ValueF[1] = value.MinEdge.Y;
 
937
                        if (Count > 2) ValueF[2] = value.MinEdge.Z;
 
938
                        if (Count > 3) ValueF[3] = value.MaxEdge.X;
 
939
                        if (Count > 4) ValueF[4] = value.MaxEdge.Y;
 
940
                        if (Count > 5) ValueF[5] = value.MaxEdge.Z;
 
941
                }
 
942
                else
 
943
                {
 
944
                        if (Count > 0) ValueI[0] = (s32)value.MinEdge.X;
 
945
                        if (Count > 1) ValueI[1] = (s32)value.MinEdge.Y;
 
946
                        if (Count > 2) ValueI[2] = (s32)value.MinEdge.Z;
 
947
                        if (Count > 3) ValueI[3] = (s32)value.MaxEdge.X;
 
948
                        if (Count > 4) ValueI[4] = (s32)value.MaxEdge.Y;
 
949
                        if (Count > 5) ValueI[5] = (s32)value.MaxEdge.Z;
 
950
                }
 
951
        }
 
952
 
 
953
        virtual void setPlane(core::plane3df value)
 
954
        {
 
955
                reset();
 
956
                if (IsFloat)
 
957
                {
 
958
                        if (Count > 0) ValueF[0] = value.Normal.X;
 
959
                        if (Count > 1) ValueF[1] = value.Normal.Y;
 
960
                        if (Count > 2) ValueF[2] = value.Normal.Z;
 
961
                        if (Count > 3) ValueF[3] = value.D;
 
962
                }
 
963
                else
 
964
                {
 
965
                        if (Count > 0) ValueI[0] = (s32)value.Normal.X;
 
966
                        if (Count > 1) ValueI[1] = (s32)value.Normal.Y;
 
967
                        if (Count > 2) ValueI[2] = (s32)value.Normal.Z;
 
968
                        if (Count > 3) ValueI[3] = (s32)value.D;
 
969
                }
 
970
        }
 
971
 
 
972
        virtual void setTriangle3d(core::triangle3df value)
 
973
        {
 
974
                reset();
 
975
                if (IsFloat)
 
976
                {
 
977
                        if (Count > 0) ValueF[0] = value.pointA.X;
 
978
                        if (Count > 1) ValueF[1] = value.pointA.Y;
 
979
                        if (Count > 2) ValueF[2] = value.pointA.Z;
 
980
                        if (Count > 3) ValueF[3] = value.pointB.X;
 
981
                        if (Count > 4) ValueF[4] = value.pointB.Y;
 
982
                        if (Count > 5) ValueF[5] = value.pointB.Z;
 
983
                        if (Count > 6) ValueF[6] = value.pointC.X;
 
984
                        if (Count > 7) ValueF[7] = value.pointC.Y;
 
985
                        if (Count > 8) ValueF[8] = value.pointC.Z;
 
986
                }
 
987
                else
 
988
                {
 
989
                        if (Count > 0) ValueI[0] = (s32)value.pointA.X;
 
990
                        if (Count > 1) ValueI[1] = (s32)value.pointA.Y;
 
991
                        if (Count > 2) ValueI[2] = (s32)value.pointA.Z;
 
992
                        if (Count > 3) ValueI[3] = (s32)value.pointB.X;
 
993
                        if (Count > 4) ValueI[4] = (s32)value.pointB.Y;
 
994
                        if (Count > 5) ValueI[5] = (s32)value.pointB.Z;
 
995
                        if (Count > 6) ValueI[6] = (s32)value.pointC.X;
 
996
                        if (Count > 7) ValueI[7] = (s32)value.pointC.Y;
 
997
                        if (Count > 8) ValueI[8] = (s32)value.pointC.Z;
 
998
                }
 
999
        }
 
1000
 
 
1001
        virtual void setVector2d(core::vector2df v)
 
1002
        {
 
1003
                reset();
 
1004
                if (IsFloat)
 
1005
                {
 
1006
                        if (Count > 0) ValueF[0] = v.X;
 
1007
                        if (Count > 1) ValueF[1] = v.Y;
 
1008
                }
 
1009
                else
 
1010
                {
 
1011
                        if (Count > 0) ValueI[0] = (s32)v.X;
 
1012
                        if (Count > 1) ValueI[1] = (s32)v.Y;
 
1013
                }
 
1014
        }
 
1015
 
 
1016
        virtual void setVector2d(core::vector2di v)
 
1017
        {
 
1018
                reset();
 
1019
                if (IsFloat)
 
1020
                {
 
1021
                        if (Count > 0) ValueF[0] = (f32)v.X;
 
1022
                        if (Count > 1) ValueF[1] = (f32)v.Y;
 
1023
                }
 
1024
                else
 
1025
                {
 
1026
                        if (Count > 0) ValueI[0] = v.X;
 
1027
                        if (Count > 1) ValueI[1] = v.Y;
 
1028
                }
 
1029
        }
 
1030
 
 
1031
        virtual void setLine2d(core::line2di v)
 
1032
        {
 
1033
                reset();
 
1034
                if (IsFloat)
 
1035
                {
 
1036
                        if (Count > 0) ValueF[0] = (f32)v.start.X;
 
1037
                        if (Count > 1) ValueF[1] = (f32)v.start.Y;
 
1038
                        if (Count > 2) ValueF[2] = (f32)v.end.X;
 
1039
                        if (Count > 3) ValueF[3] = (f32)v.end.Y;
 
1040
                }
 
1041
                else
 
1042
                {
 
1043
                        if (Count > 0) ValueI[0] = v.start.X;
 
1044
                        if (Count > 1) ValueI[1] = v.start.Y;
 
1045
                        if (Count > 2) ValueI[2] = v.end.X;
 
1046
                        if (Count > 3) ValueI[3] = v.end.Y;
 
1047
                }
 
1048
        }
 
1049
 
 
1050
        virtual void setLine2d(core::line2df v)
 
1051
        {
 
1052
                reset();
 
1053
                if (IsFloat)
 
1054
                {
 
1055
                        if (Count > 0) ValueF[0] = v.start.X;
 
1056
                        if (Count > 1) ValueF[1] = v.start.Y;
 
1057
                        if (Count > 2) ValueF[2] = v.end.X;
 
1058
                        if (Count > 3) ValueF[3] = v.end.Y;
 
1059
                }
 
1060
                else
 
1061
                {
 
1062
                        if (Count > 0) ValueI[0] = (s32)v.start.X;
 
1063
                        if (Count > 1) ValueI[1] = (s32)v.start.Y;
 
1064
                        if (Count > 2) ValueI[2] = (s32)v.end.X;
 
1065
                        if (Count > 3) ValueI[3] = (s32)v.end.Y;
 
1066
                }
 
1067
        }
 
1068
 
 
1069
        virtual void setDimension2d(core::dimension2du v)
 
1070
        {
 
1071
                reset();
 
1072
                if (IsFloat)
 
1073
                {
 
1074
                        if (Count > 0) ValueF[0] = (f32)v.Width;
 
1075
                        if (Count > 1) ValueF[1] = (f32)v.Height;
 
1076
                }
 
1077
                else
 
1078
                {
 
1079
                        if (Count > 0) ValueI[0] = v.Width;
 
1080
                        if (Count > 1) ValueI[1] = v.Height;
 
1081
                }
 
1082
        }
 
1083
 
 
1084
        //! set float array
 
1085
        virtual void setFloatArray(core::array<f32> &vals)
 
1086
        {
 
1087
                reset();
 
1088
 
 
1089
                for (u32 i=0; i<vals.size() && i<Count; ++i)
 
1090
                {
 
1091
                        if (IsFloat)
 
1092
                                ValueF[i] = vals[i];
 
1093
                        else
 
1094
                                ValueI[i] = (s32)vals[i];
 
1095
                }
 
1096
        }
 
1097
 
 
1098
        //! set int array
 
1099
        virtual void setIntArray(core::array<s32> &vals)
 
1100
        {
 
1101
                reset();
 
1102
 
 
1103
                for (u32 i=0; i<vals.size() && i<Count; ++i)
 
1104
                {
 
1105
                        if (IsFloat)
 
1106
                                ValueF[i] = (f32)vals[i];
 
1107
                        else
 
1108
                                ValueI[i] = vals[i];
 
1109
                }
 
1110
        }
 
1111
 
 
1112
 
 
1113
        //! is it a number list?
 
1114
        virtual bool isNumberList()
 
1115
        {
 
1116
                return true;
 
1117
        }
 
1118
 
 
1119
        //! is it a float list?
 
1120
        virtual bool isFloat()
 
1121
        {
 
1122
                return IsFloat;
 
1123
        }
 
1124
 
 
1125
        virtual E_ATTRIBUTE_TYPE getType() const
 
1126
        {
 
1127
                if (IsFloat)
 
1128
                        return EAT_FLOATARRAY;
 
1129
                else
 
1130
                        return EAT_INTARRAY;
 
1131
        }
 
1132
 
 
1133
        virtual const wchar_t* getTypeString() const
 
1134
        {
 
1135
                if (IsFloat)
 
1136
                        return L"floatlist";
 
1137
                else
 
1138
                        return L"intlist";
 
1139
        }
 
1140
 
 
1141
protected:
 
1142
 
 
1143
        //! clear all values
 
1144
        void reset()
 
1145
        {
 
1146
                if (IsFloat)
 
1147
                        for (u32 i=0; i < Count ; ++i)
 
1148
                                ValueF[i] = 0.0f;
 
1149
                else
 
1150
                        for (u32 i=0; i < Count ; ++i)
 
1151
                                ValueI[i] = 0;
 
1152
        }
 
1153
 
 
1154
        core::array<s32> ValueI;
 
1155
        core::array<f32> ValueF;
 
1156
        u32 Count;
 
1157
        bool IsFloat;
 
1158
};
 
1159
 
 
1160
 
 
1161
// Attribute implemented for floating point colors
 
1162
class CColorfAttribute : public CNumbersAttribute
 
1163
{
 
1164
public:
 
1165
 
 
1166
        CColorfAttribute(const char* name, video::SColorf value) : CNumbersAttribute(name, value) {}
 
1167
 
 
1168
        virtual s32 getInt()
 
1169
        {
 
1170
                return getColor().color;
 
1171
        }
 
1172
 
 
1173
        virtual f32 getFloat()
 
1174
        {
 
1175
                return (f32)getColor().color;
 
1176
        }
 
1177
 
 
1178
        virtual void setInt(s32 intValue)
 
1179
        {
 
1180
                video::SColorf c = video::SColor(intValue);
 
1181
                ValueF[0] = c.r;
 
1182
                ValueF[1] = c.g;
 
1183
                ValueF[2] = c.b;
 
1184
                ValueF[3] = c.a;
 
1185
        }
 
1186
 
 
1187
        virtual void setFloat(f32 floatValue)
 
1188
        {
 
1189
                setInt((s32)floatValue);
 
1190
        }
 
1191
 
 
1192
        virtual E_ATTRIBUTE_TYPE getType() const
 
1193
        {
 
1194
                return EAT_COLORF;
 
1195
        }
 
1196
 
 
1197
        virtual const wchar_t* getTypeString() const
 
1198
        {
 
1199
                return L"colorf";
 
1200
        }
 
1201
};
 
1202
 
 
1203
 
 
1204
 
 
1205
// Attribute implemented for colors
 
1206
class CColorAttribute : public CNumbersAttribute
 
1207
{
 
1208
public:
 
1209
 
 
1210
        CColorAttribute(const char* name, const video::SColorf& value) : CNumbersAttribute(name, value) {}
 
1211
 
 
1212
        CColorAttribute(const char* name, const video::SColor& value) : CNumbersAttribute(name, value) {}
 
1213
 
 
1214
        virtual s32 getInt()
 
1215
        {
 
1216
                return getColor().color;
 
1217
        }
 
1218
 
 
1219
        virtual f32 getFloat()
 
1220
        {
 
1221
                return (f32)getColor().color;
 
1222
        }
 
1223
 
 
1224
        virtual void setInt(s32 intValue)
 
1225
        {
 
1226
                video::SColorf c = video::SColor(intValue);
 
1227
                ValueF[0] = c.r;
 
1228
                ValueF[1] = c.g;
 
1229
                ValueF[2] = c.b;
 
1230
                ValueF[3] = c.a;
 
1231
        }
 
1232
 
 
1233
        virtual void setFloat(f32 floatValue)
 
1234
        {
 
1235
                setInt((s32)floatValue);
 
1236
        }
 
1237
 
 
1238
        virtual core::stringw getStringW()
 
1239
        {
 
1240
                char tmp[10];
 
1241
                const video::SColor c = getColor();
 
1242
                sprintf(tmp, "%02x%02x%02x%02x", c.getAlpha(), c.getRed(), c.getGreen(), c.getBlue());
 
1243
                return core::stringw(tmp);
 
1244
        }
 
1245
 
 
1246
        virtual void setString(const char* text)
 
1247
        {
 
1248
                u32 c;
 
1249
                if (sscanf(text, "%08x", &c)!=1)
 
1250
                {
 
1251
                        CNumbersAttribute::setString(text);
 
1252
                }
 
1253
                else
 
1254
                        setColor(c);
 
1255
        }
 
1256
 
 
1257
        virtual E_ATTRIBUTE_TYPE getType() const
 
1258
        {
 
1259
                return EAT_COLOR;
 
1260
        }
 
1261
 
 
1262
 
 
1263
        virtual const wchar_t* getTypeString() const
 
1264
        {
 
1265
                return L"color";
 
1266
        }
 
1267
 
 
1268
};
 
1269
 
 
1270
 
 
1271
// Attribute implemented for 3d vectors
 
1272
class CVector3DAttribute : public CNumbersAttribute
 
1273
{
 
1274
public:
 
1275
 
 
1276
        CVector3DAttribute(const char* name, core::vector3df value) : CNumbersAttribute(name, value) {}
 
1277
 
 
1278
        virtual E_ATTRIBUTE_TYPE getType() const
 
1279
        {
 
1280
                return EAT_VECTOR3D;
 
1281
        }
 
1282
 
 
1283
        virtual core::matrix4 getMatrix()
 
1284
        {
 
1285
                core::matrix4 ret;
 
1286
                ret.makeIdentity();
 
1287
                ret.setTranslation( core::vector3df(ValueF[0],ValueF[1],ValueF[2]) );
 
1288
                return ret;
 
1289
        }
 
1290
 
 
1291
        virtual const wchar_t* getTypeString() const
 
1292
        {
 
1293
                return L"vector3d";
 
1294
        }
 
1295
};
 
1296
 
 
1297
// Attribute implemented for 2d vectors
 
1298
class CPosition2DAttribute : public CNumbersAttribute
 
1299
{
 
1300
public:
 
1301
 
 
1302
        CPosition2DAttribute(const char* name, core::position2di value) : CNumbersAttribute(name, value) {}
 
1303
 
 
1304
        virtual E_ATTRIBUTE_TYPE getType() const
 
1305
        {
 
1306
                return EAT_POSITION2D;
 
1307
        }
 
1308
 
 
1309
        virtual const wchar_t* getTypeString() const
 
1310
        {
 
1311
                return L"position";
 
1312
        }
 
1313
};
 
1314
 
 
1315
 
 
1316
 
 
1317
// Attribute implemented for rectangles
 
1318
class CRectAttribute : public CNumbersAttribute
 
1319
{
 
1320
public:
 
1321
 
 
1322
        CRectAttribute(const char* name, core::rect<s32> value) : CNumbersAttribute(name, value) { }
 
1323
 
 
1324
        virtual E_ATTRIBUTE_TYPE getType() const
 
1325
        {
 
1326
                return EAT_RECT;
 
1327
        }
 
1328
 
 
1329
        virtual const wchar_t* getTypeString() const
 
1330
        {
 
1331
                return L"rect";
 
1332
        }
 
1333
};
 
1334
 
 
1335
// Attribute implemented for matrices
 
1336
class CMatrixAttribute : public CNumbersAttribute
 
1337
{
 
1338
public:
 
1339
 
 
1340
        CMatrixAttribute(const char* name, core::matrix4 value) : CNumbersAttribute(name, value) { }
 
1341
 
 
1342
        virtual E_ATTRIBUTE_TYPE getType() const
 
1343
        {
 
1344
                return EAT_MATRIX;
 
1345
        }
 
1346
 
 
1347
        virtual core::quaternion getQuaternion()
 
1348
        {
 
1349
                return core::quaternion(getMatrix());
 
1350
        }
 
1351
 
 
1352
        virtual const wchar_t* getTypeString() const
 
1353
        {
 
1354
                return L"matrix";
 
1355
        }
 
1356
};
 
1357
 
 
1358
// Attribute implemented for quaternions
 
1359
class CQuaternionAttribute : public CNumbersAttribute
 
1360
{
 
1361
public:
 
1362
 
 
1363
        CQuaternionAttribute(const char* name, core::quaternion value) : CNumbersAttribute(name, value) { }
 
1364
 
 
1365
        virtual E_ATTRIBUTE_TYPE getType() const
 
1366
        {
 
1367
                return EAT_QUATERNION;
 
1368
        }
 
1369
 
 
1370
        virtual core::matrix4 getMatrix()
 
1371
        {
 
1372
                return getQuaternion().getMatrix();
 
1373
        }
 
1374
 
 
1375
        virtual const wchar_t* getTypeString() const
 
1376
        {
 
1377
                return L"quaternion";
 
1378
        }
 
1379
};
 
1380
 
 
1381
 
 
1382
// Attribute implemented for bounding boxes
 
1383
class CBBoxAttribute : public CNumbersAttribute
 
1384
{
 
1385
public:
 
1386
 
 
1387
        CBBoxAttribute(const char* name, core::aabbox3df value) : CNumbersAttribute(name, value) { }
 
1388
 
 
1389
        virtual E_ATTRIBUTE_TYPE getType() const
 
1390
        {
 
1391
                return EAT_BBOX;
 
1392
        }
 
1393
 
 
1394
        virtual const wchar_t* getTypeString() const
 
1395
        {
 
1396
                return L"box3d";
 
1397
        }
 
1398
};
 
1399
 
 
1400
// Attribute implemented for planes
 
1401
class CPlaneAttribute : public CNumbersAttribute
 
1402
{
 
1403
public:
 
1404
 
 
1405
        CPlaneAttribute(const char* name, core::plane3df value) : CNumbersAttribute(name, value) { }
 
1406
 
 
1407
        virtual E_ATTRIBUTE_TYPE getType() const
 
1408
        {
 
1409
                return EAT_PLANE;
 
1410
        }
 
1411
 
 
1412
        virtual const wchar_t* getTypeString() const
 
1413
        {
 
1414
                return L"plane";
 
1415
        }
 
1416
};
 
1417
 
 
1418
// Attribute implemented for triangles
 
1419
class CTriangleAttribute : public CNumbersAttribute
 
1420
{
 
1421
public:
 
1422
 
 
1423
        CTriangleAttribute(const char* name, core::triangle3df value) : CNumbersAttribute(name, value) { }
 
1424
 
 
1425
        virtual E_ATTRIBUTE_TYPE getType() const
 
1426
        {
 
1427
                return EAT_TRIANGLE3D;
 
1428
        }
 
1429
 
 
1430
        virtual core::plane3df getPlane()
 
1431
        {
 
1432
                return getTriangle().getPlane();
 
1433
        }
 
1434
 
 
1435
        virtual const wchar_t* getTypeString() const
 
1436
        {
 
1437
                return L"triangle";
 
1438
        }
 
1439
};
 
1440
 
 
1441
 
 
1442
// Attribute implemented for 2d lines
 
1443
class CLine2dAttribute : public CNumbersAttribute
 
1444
{
 
1445
public:
 
1446
 
 
1447
        CLine2dAttribute(const char* name, core::line2df value) : CNumbersAttribute(name, value) { }
 
1448
 
 
1449
        virtual E_ATTRIBUTE_TYPE getType() const
 
1450
        {
 
1451
                return EAT_LINE2D;
 
1452
        }
 
1453
 
 
1454
        virtual const wchar_t* getTypeString() const
 
1455
        {
 
1456
                return L"line2d";
 
1457
        }
 
1458
};
 
1459
 
 
1460
// Attribute implemented for 3d lines
 
1461
class CLine3dAttribute : public CNumbersAttribute
 
1462
{
 
1463
public:
 
1464
 
 
1465
        CLine3dAttribute(const char* name, core::line3df value) : CNumbersAttribute(name, value) { }
 
1466
 
 
1467
        virtual E_ATTRIBUTE_TYPE getType() const
 
1468
        {
 
1469
                return EAT_LINE3D;
 
1470
        }
 
1471
 
 
1472
        virtual const wchar_t* getTypeString() const
 
1473
        {
 
1474
                return L"line3d";
 
1475
        }
 
1476
};
 
1477
 
 
1478
 
 
1479
// vector2df
 
1480
// dimension2du
 
1481
 
 
1482
/*
 
1483
        Special attributes
 
1484
*/
 
1485
 
 
1486
// Attribute implemented for enumeration literals
 
1487
class CEnumAttribute : public IAttribute
 
1488
{
 
1489
public:
 
1490
 
 
1491
        CEnumAttribute(const char* name, const char* value, const char* const* literals)
 
1492
        {
 
1493
                Name = name;
 
1494
                setEnum(value, literals);
 
1495
        }
 
1496
 
 
1497
        virtual void setEnum(const char* enumValue, const char* const* enumerationLiterals)
 
1498
        {
 
1499
                int literalCount = 0;
 
1500
 
 
1501
                if (enumerationLiterals)
 
1502
                {
 
1503
                        s32 i;
 
1504
                        for (i=0; enumerationLiterals[i]; ++i)
 
1505
                                ++literalCount;
 
1506
 
 
1507
                        EnumLiterals.reallocate(literalCount);
 
1508
                        for (i=0; enumerationLiterals[i]; ++i)
 
1509
                                EnumLiterals.push_back(enumerationLiterals[i]);
 
1510
                }
 
1511
 
 
1512
                setString(enumValue);
 
1513
        }
 
1514
 
 
1515
        virtual s32 getInt()
 
1516
        {
 
1517
                for (s32 i=0; EnumLiterals.size(); ++i)
 
1518
                        if (Value.equals_ignore_case(EnumLiterals[i]))
 
1519
                        {
 
1520
                                return i;
 
1521
                        }
 
1522
 
 
1523
                return -1;
 
1524
        }
 
1525
 
 
1526
        virtual f32 getFloat()
 
1527
        {
 
1528
                return (f32)getInt();
 
1529
        }
 
1530
 
 
1531
        virtual bool getBool()
 
1532
        {
 
1533
                return (getInt() != 0); // does not make a lot of sense, I know
 
1534
        }
 
1535
 
 
1536
        virtual core::stringc getString()
 
1537
        {
 
1538
                return Value;
 
1539
        }
 
1540
 
 
1541
        virtual core::stringw getStringW()
 
1542
        {
 
1543
                return core::stringw(Value.c_str());
 
1544
        }
 
1545
 
 
1546
        virtual void setInt(s32 intValue)
 
1547
        {
 
1548
                if (intValue>=0 && intValue<(s32)EnumLiterals.size())
 
1549
                        Value = EnumLiterals[intValue];
 
1550
                else
 
1551
                        Value = "";
 
1552
        }
 
1553
 
 
1554
        virtual void setFloat(f32 floatValue)
 
1555
        {
 
1556
                setInt((s32)floatValue);
 
1557
        };
 
1558
 
 
1559
        virtual void setString(const char* text)
 
1560
        {
 
1561
                Value = text;
 
1562
        }
 
1563
 
 
1564
        virtual const char* getEnum()
 
1565
        {
 
1566
                return Value.c_str();
 
1567
        }
 
1568
 
 
1569
        virtual E_ATTRIBUTE_TYPE getType() const
 
1570
        {
 
1571
                return EAT_ENUM;
 
1572
        }
 
1573
 
 
1574
 
 
1575
        virtual const wchar_t* getTypeString() const
 
1576
        {
 
1577
                return L"enum";
 
1578
        }
 
1579
 
 
1580
        core::stringc Value;
 
1581
        core::array<core::stringc> EnumLiterals;
 
1582
};
 
1583
 
 
1584
 
 
1585
 
 
1586
 
 
1587
 
 
1588
// Attribute implemented for strings
 
1589
class CStringAttribute : public IAttribute
 
1590
{
 
1591
public:
 
1592
 
 
1593
        CStringAttribute(const char* name, const char* value)
 
1594
        {
 
1595
                IsStringW=false;
 
1596
                Name = name;
 
1597
                setString(value);
 
1598
        }
 
1599
 
 
1600
        CStringAttribute(const char* name, const wchar_t* value)
 
1601
        {
 
1602
                IsStringW = true;
 
1603
                Name = name;
 
1604
                setString(value);
 
1605
        }
 
1606
 
 
1607
        CStringAttribute(const char* name, void* binaryData, s32 lenghtInBytes)
 
1608
        {
 
1609
                IsStringW=false;
 
1610
                Name = name;
 
1611
                setBinary(binaryData, lenghtInBytes);
 
1612
        }
 
1613
 
 
1614
        virtual s32 getInt()
 
1615
        {
 
1616
                if (IsStringW)
 
1617
                        return atoi(core::stringc(ValueW.c_str()).c_str());
 
1618
                else
 
1619
                        return atoi(Value.c_str());
 
1620
        }
 
1621
 
 
1622
        virtual f32 getFloat()
 
1623
        {
 
1624
                if (IsStringW)
 
1625
                        return core::fast_atof(core::stringc(ValueW.c_str()).c_str());
 
1626
                else
 
1627
                        return core::fast_atof(Value.c_str());
 
1628
        }
 
1629
 
 
1630
        virtual bool getBool()
 
1631
        {
 
1632
                if (IsStringW)
 
1633
                        return ValueW.equals_ignore_case(L"true");
 
1634
                else
 
1635
                        return Value.equals_ignore_case("true");
 
1636
        }
 
1637
 
 
1638
        virtual core::stringc getString()
 
1639
        {
 
1640
                if (IsStringW)
 
1641
                        return core::stringc(ValueW.c_str());
 
1642
                else
 
1643
                        return Value;
 
1644
        }
 
1645
        virtual core::stringw getStringW()
 
1646
        {
 
1647
                if (IsStringW)
 
1648
                        return ValueW;
 
1649
                else
 
1650
                        return core::stringw(Value.c_str());
 
1651
        }
 
1652
 
 
1653
        virtual void setInt(s32 intValue)
 
1654
        {
 
1655
                if (IsStringW)
 
1656
                        ValueW = core::stringw(intValue);
 
1657
                else
 
1658
                        Value = core::stringc(intValue);
 
1659
        }
 
1660
 
 
1661
        virtual void setFloat(f32 floatValue)
 
1662
        {
 
1663
                if (IsStringW)
 
1664
                {
 
1665
                        ValueW = core::stringw(floatValue);
 
1666
                }
 
1667
                else
 
1668
                {
 
1669
                        Value = core::stringc(floatValue);
 
1670
                }
 
1671
        };
 
1672
 
 
1673
        virtual void setString(const char* text)
 
1674
        {
 
1675
                if (IsStringW)
 
1676
                        ValueW = core::stringw(text);
 
1677
                else
 
1678
                        Value = text;
 
1679
        }
 
1680
 
 
1681
        virtual void setString(const wchar_t* text)
 
1682
        {
 
1683
                if (IsStringW)
 
1684
                        ValueW = text;
 
1685
                else
 
1686
                        Value = core::stringc(text);
 
1687
        }
 
1688
 
 
1689
        virtual E_ATTRIBUTE_TYPE getType() const
 
1690
        {
 
1691
                return EAT_STRING;
 
1692
        }
 
1693
 
 
1694
 
 
1695
        virtual const wchar_t* getTypeString() const
 
1696
        {
 
1697
                return L"string";
 
1698
        }
 
1699
 
 
1700
        virtual void getBinary(void* outdata, s32 maxLength)
 
1701
        {
 
1702
                s32 dataSize = maxLength;
 
1703
                c8* datac8 = (c8*)(outdata);
 
1704
                s32 p = 0;
 
1705
                const c8* dataString = Value.c_str();
 
1706
 
 
1707
                for (s32 i=0; i<dataSize; ++i)
 
1708
                        datac8[i] = 0;
 
1709
 
 
1710
                while(dataString[p] && p<dataSize)
 
1711
                {
 
1712
                        s32 v = getByteFromHex((c8)dataString[p*2]) * 16;
 
1713
 
 
1714
                        if (dataString[(p*2)+1])
 
1715
                                v += getByteFromHex((c8)dataString[(p*2)+1]);
 
1716
 
 
1717
                        datac8[p] = v;
 
1718
                        ++p;
 
1719
                }
 
1720
        };
 
1721
 
 
1722
        virtual void setBinary(void* data, s32 maxLength)
 
1723
        {
 
1724
                s32 dataSize = maxLength;
 
1725
                c8* datac8 = (c8*)(data);
 
1726
                char tmp[3];
 
1727
                tmp[2] = 0;
 
1728
                Value = "";
 
1729
 
 
1730
                for (s32 b=0; b<dataSize; ++b)
 
1731
                {
 
1732
                        getHexStrFromByte(datac8[b], tmp);
 
1733
                        Value.append(tmp);
 
1734
                }
 
1735
        };
 
1736
 
 
1737
        bool IsStringW;
 
1738
        core::stringc Value;
 
1739
        core::stringw ValueW;
 
1740
 
 
1741
protected:
 
1742
 
 
1743
        static inline s32 getByteFromHex(c8 h)
 
1744
        {
 
1745
                if (h >= '0' && h <='9')
 
1746
                        return h-'0';
 
1747
 
 
1748
                if (h >= 'a' && h <='f')
 
1749
                        return h-'a' + 10;
 
1750
 
 
1751
                return 0;
 
1752
        }
 
1753
 
 
1754
        static inline void getHexStrFromByte(c8 byte, c8* out)
 
1755
        {
 
1756
                s32 b = (byte & 0xf0) >> 4;
 
1757
 
 
1758
                for (s32 i=0; i<2; ++i)
 
1759
                {
 
1760
                        if (b >=0 && b <= 9)
 
1761
                                out[i] = b+'0';
 
1762
                        if (b >=10 && b <= 15)
 
1763
                                out[i] = (b-10)+'a';
 
1764
 
 
1765
                        b = byte & 0x0f;
 
1766
                }
 
1767
        }
 
1768
};
 
1769
 
 
1770
// Attribute implemented for binary data
 
1771
class CBinaryAttribute : public CStringAttribute
 
1772
{
 
1773
public:
 
1774
 
 
1775
        CBinaryAttribute(const char* name, void* binaryData, s32 lenghtInBytes)
 
1776
                : CStringAttribute(name, binaryData, lenghtInBytes)
 
1777
        {
 
1778
 
 
1779
        }
 
1780
 
 
1781
        virtual E_ATTRIBUTE_TYPE getType() const
 
1782
        {
 
1783
                return EAT_BINARY;
 
1784
        }
 
1785
 
 
1786
 
 
1787
        virtual const wchar_t* getTypeString() const
 
1788
        {
 
1789
                return L"binary";
 
1790
        }
 
1791
};
 
1792
 
 
1793
 
 
1794
 
 
1795
// Attribute implemented for texture references
 
1796
class CTextureAttribute : public IAttribute
 
1797
{
 
1798
public:
 
1799
 
 
1800
        CTextureAttribute(const char* name, video::ITexture* value, video::IVideoDriver* driver, const io::path& filename)
 
1801
                : Value(0), Driver(driver), OverrideName(filename)
 
1802
        {
 
1803
                if (Driver)
 
1804
                        Driver->grab();
 
1805
 
 
1806
                Name = name;
 
1807
                setTexture(value);
 
1808
        }
 
1809
 
 
1810
        ~CTextureAttribute()
 
1811
        {
 
1812
                if (Driver)
 
1813
                        Driver->drop();
 
1814
 
 
1815
                if (Value)
 
1816
                        Value->drop();
 
1817
        }
 
1818
 
 
1819
        virtual video::ITexture* getTexture()
 
1820
        {
 
1821
                return Value;
 
1822
        }
 
1823
 
 
1824
        virtual bool getBool()
 
1825
        {
 
1826
                return (Value != 0);
 
1827
        }
 
1828
 
 
1829
        virtual core::stringw getStringW()
 
1830
        {
 
1831
                return core::stringw(OverrideName.size()?OverrideName:
 
1832
                        Value ? Value->getName().getPath().c_str() : 0);
 
1833
        }
 
1834
 
 
1835
        virtual core::stringc getString()
 
1836
        {
 
1837
                // since texture names can be stringw we are careful with the types
 
1838
                return core::stringc(OverrideName.size()?OverrideName:
 
1839
                        Value ? Value->getName().getPath().c_str() : 0);
 
1840
        }
 
1841
 
 
1842
        virtual void setString(const char* text)
 
1843
        {
 
1844
                if (Driver)
 
1845
                {
 
1846
                        if (text && *text)
 
1847
                        {
 
1848
                                setTexture(Driver->getTexture(text));
 
1849
                                OverrideName=text;
 
1850
                        }
 
1851
                        else
 
1852
                                setTexture(0);
 
1853
                }
 
1854
        }
 
1855
 
 
1856
        virtual void setTexture(video::ITexture* value)
 
1857
        {
 
1858
                if ( value == Value )
 
1859
                        return;
 
1860
 
 
1861
                if (Value)
 
1862
                        Value->drop();
 
1863
 
 
1864
                Value = value;
 
1865
 
 
1866
                if (Value)
 
1867
                        Value->grab();
 
1868
        }
 
1869
 
 
1870
        virtual E_ATTRIBUTE_TYPE getType() const
 
1871
        {
 
1872
                return EAT_TEXTURE;
 
1873
        }
 
1874
 
 
1875
 
 
1876
        virtual const wchar_t* getTypeString() const
 
1877
        {
 
1878
                return L"texture";
 
1879
        }
 
1880
 
 
1881
        video::ITexture* Value;
 
1882
        video::IVideoDriver* Driver;
 
1883
        io::path OverrideName;
 
1884
};
 
1885
 
 
1886
 
 
1887
 
 
1888
// Attribute implemented for array of stringw
 
1889
class CStringWArrayAttribute : public IAttribute
 
1890
{
 
1891
public:
 
1892
 
 
1893
        CStringWArrayAttribute(const char* name, const core::array<core::stringw>& value)
 
1894
        {
 
1895
                Name = name;
 
1896
                setArray(value);
 
1897
        }
 
1898
 
 
1899
        virtual core::array<core::stringw> getArray()
 
1900
        {
 
1901
                return Value;
 
1902
        }
 
1903
 
 
1904
        virtual void setArray(const core::array<core::stringw>& value)
 
1905
        {
 
1906
                Value = value;
 
1907
        }
 
1908
 
 
1909
        virtual E_ATTRIBUTE_TYPE getType() const
 
1910
        {
 
1911
                return EAT_STRINGWARRAY;
 
1912
        }
 
1913
 
 
1914
        virtual const wchar_t* getTypeString() const
 
1915
        {
 
1916
                return L"stringwarray";
 
1917
        }
 
1918
 
 
1919
        core::array<core::stringw> Value;
 
1920
};
 
1921
 
 
1922
 
 
1923
// Attribute implemented for user pointers
 
1924
class CUserPointerAttribute : public IAttribute
 
1925
{
 
1926
public:
 
1927
 
 
1928
        CUserPointerAttribute(const char* name, void* value)
 
1929
        {
 
1930
                Name = name;
 
1931
                Value = value;
 
1932
        }
 
1933
 
 
1934
        virtual s32 getInt()
 
1935
        {
 
1936
                return *static_cast<s32*>(Value);
 
1937
        }
 
1938
 
 
1939
        virtual bool getBool()
 
1940
        {
 
1941
                return (Value != 0);
 
1942
        }
 
1943
 
 
1944
        virtual core::stringw getStringW()
 
1945
        {
 
1946
                wchar_t buf[32];
 
1947
                swprintf(buf, 32, L"%p", Value);
 
1948
 
 
1949
                return core::stringw(buf);
 
1950
        }
 
1951
 
 
1952
        virtual void setString(const char* text)
 
1953
        {
 
1954
                sscanf(text, "0x%x", (unsigned int*)(&Value));
 
1955
        }
 
1956
 
 
1957
        virtual E_ATTRIBUTE_TYPE getType() const
 
1958
        {
 
1959
                return EAT_USER_POINTER;
 
1960
        }
 
1961
 
 
1962
        virtual void setUserPointer(void* v)
 
1963
        {
 
1964
                Value = v;
 
1965
        }
 
1966
 
 
1967
        virtual void* getUserPointer()
 
1968
        {
 
1969
                return Value;
 
1970
        }
 
1971
 
 
1972
 
 
1973
        virtual const wchar_t* getTypeString() const
 
1974
        {
 
1975
                return L"userPointer";
 
1976
        }
 
1977
 
 
1978
        void* Value;
 
1979
};
 
1980
 
 
1981
 
 
1982
// todo: CGUIFontAttribute
 
1983
 
 
1984
} // end namespace io
 
1985
} // end namespace irr