diff options
Diffstat (limited to 'libraries/irrlicht-1.8/source/Irrlicht/CAttributeImpl.h')
-rw-r--r-- | libraries/irrlicht-1.8/source/Irrlicht/CAttributeImpl.h | 4120 |
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 | ||
10 | namespace irr | 10 | namespace irr |
11 | { | 11 | { |
12 | namespace io | 12 | namespace 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 |
20 | class CBoolAttribute : public IAttribute | 20 | class CBoolAttribute : public IAttribute |
21 | { | 21 | { |
22 | public: | 22 | public: |
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 |
84 | class CIntAttribute : public IAttribute | 84 | class CIntAttribute : public IAttribute |
85 | { | 85 | { |
86 | public: | 86 | public: |
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 |
144 | class CFloatAttribute : public IAttribute | 144 | class CFloatAttribute : public IAttribute |
145 | { | 145 | { |
146 | public: | 146 | public: |
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 |
211 | class CNumbersAttribute : public IAttribute | 211 | class CNumbersAttribute : public IAttribute |
212 | { | 212 | { |
213 | public: | 213 | public: |
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 | ||
1176 | protected: | 1176 | protected: |
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 |
1197 | class CColorfAttribute : public CNumbersAttribute | 1197 | class CColorfAttribute : public CNumbersAttribute |
1198 | { | 1198 | { |
1199 | public: | 1199 | public: |
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 |
1241 | class CColorAttribute : public CNumbersAttribute | 1241 | class CColorAttribute : public CNumbersAttribute |
1242 | { | 1242 | { |
1243 | public: | 1243 | public: |
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 |
1307 | class CVector3DAttribute : public CNumbersAttribute | 1307 | class CVector3DAttribute : public CNumbersAttribute |
1308 | { | 1308 | { |
1309 | public: | 1309 | public: |
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 |
1333 | class CVector2DAttribute : public CNumbersAttribute | 1333 | class CVector2DAttribute : public CNumbersAttribute |
1334 | { | 1334 | { |
1335 | public: | 1335 | public: |
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 |
1351 | class CPosition2DAttribute : public CNumbersAttribute | 1351 | class CPosition2DAttribute : public CNumbersAttribute |
1352 | { | 1352 | { |
1353 | public: | 1353 | public: |
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 |
1371 | class CRectAttribute : public CNumbersAttribute | 1371 | class CRectAttribute : public CNumbersAttribute |
1372 | { | 1372 | { |
1373 | public: | 1373 | public: |
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 |
1390 | class CDimension2dAttribute : public CNumbersAttribute | 1390 | class CDimension2dAttribute : public CNumbersAttribute |
1391 | { | 1391 | { |
1392 | public: | 1392 | public: |
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 |
1408 | class CMatrixAttribute : public CNumbersAttribute | 1408 | class CMatrixAttribute : public CNumbersAttribute |
1409 | { | 1409 | { |
1410 | public: | 1410 | public: |
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 |
1431 | class CQuaternionAttribute : public CNumbersAttribute | 1431 | class CQuaternionAttribute : public CNumbersAttribute |
1432 | { | 1432 | { |
1433 | public: | 1433 | public: |
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 |
1455 | class CBBoxAttribute : public CNumbersAttribute | 1455 | class CBBoxAttribute : public CNumbersAttribute |
1456 | { | 1456 | { |
1457 | public: | 1457 | public: |
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 |
1473 | class CPlaneAttribute : public CNumbersAttribute | 1473 | class CPlaneAttribute : public CNumbersAttribute |
1474 | { | 1474 | { |
1475 | public: | 1475 | public: |
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 |
1491 | class CTriangleAttribute : public CNumbersAttribute | 1491 | class CTriangleAttribute : public CNumbersAttribute |
1492 | { | 1492 | { |
1493 | public: | 1493 | public: |
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 |
1515 | class CLine2dAttribute : public CNumbersAttribute | 1515 | class CLine2dAttribute : public CNumbersAttribute |
1516 | { | 1516 | { |
1517 | public: | 1517 | public: |
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 |
1533 | class CLine3dAttribute : public CNumbersAttribute | 1533 | class CLine3dAttribute : public CNumbersAttribute |
1534 | { | 1534 | { |
1535 | public: | 1535 | public: |
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 |
1559 | class CEnumAttribute : public IAttribute | 1559 | class CEnumAttribute : public IAttribute |
1560 | { | 1560 | { |
1561 | public: | 1561 | public: |
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 |
1661 | class CStringAttribute : public IAttribute | 1661 | class CStringAttribute : public IAttribute |
1662 | { | 1662 | { |
1663 | public: | 1663 | public: |
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 | ||
1813 | protected: | 1813 | protected: |
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 |
1843 | class CBinaryAttribute : public CStringAttribute | 1843 | class CBinaryAttribute : public CStringAttribute |
1844 | { | 1844 | { |
1845 | public: | 1845 | public: |
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 |
1868 | class CTextureAttribute : public IAttribute | 1868 | class CTextureAttribute : public IAttribute |
1869 | { | 1869 | { |
1870 | public: | 1870 | public: |
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 |
1961 | class CStringWArrayAttribute : public IAttribute | 1961 | class CStringWArrayAttribute : public IAttribute |
1962 | { | 1962 | { |
1963 | public: | 1963 | public: |
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 |
1996 | class CUserPointerAttribute : public IAttribute | 1996 | class CUserPointerAttribute : public IAttribute |
1997 | { | 1997 | { |
1998 | public: | 1998 | public: |
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 |