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