Visualization Library 2.0.0-b3

A lightweight C++ OpenGL middleware for 2D/3D graphics

VL     Star     Watch     Fork     Issue

[Download] [Tutorials] [All Classes] [Grouped Classes]
VLXWrappers.hpp
Go to the documentation of this file.
1 /**************************************************************************************/
2 /* */
3 /* Visualization Library */
4 /* http://visualizationlibrary.org */
5 /* */
6 /* Copyright (c) 2005-2017, Michele Bosi */
7 /* All rights reserved. */
8 /* */
9 /* Redistribution and use in source and binary forms, with or without modification, */
10 /* are permitted provided that the following conditions are met: */
11 /* */
12 /* - Redistributions of source code must retain the above copyright notice, this */
13 /* list of conditions and the following disclaimer. */
14 /* */
15 /* - Redistributions in binary form must reproduce the above copyright notice, this */
16 /* list of conditions and the following disclaimer in the documentation and/or */
17 /* other materials provided with the distribution. */
18 /* */
19 /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND */
20 /* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED */
21 /* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE */
22 /* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR */
23 /* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES */
24 /* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; */
25 /* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON */
26 /* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */
27 /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */
28 /* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
29 /* */
30 /**************************************************************************************/
31 
32 #ifndef VLXWrapper_Graphics_INCLUDE_ONCE
33 #define VLXWrapper_Graphics_INCLUDE_ONCE
34 
35 #include <vlCore/VLXWrappers.hpp>
37 #include <vlGraphics/Actor.hpp>
38 #include <vlGraphics/Effect.hpp>
39 #include <vlGraphics/Shader.hpp>
40 #include <vlGraphics/Geometry.hpp>
41 #include <vlGraphics/Light.hpp>
42 #include <vlGraphics/ClipPlane.hpp>
43 #include <vlGraphics/Camera.hpp>
51 #include <vlGraphics/GLSL.hpp>
53 #include <vlCore/DiskFile.hpp>
54 
55 namespace vl
56 {
59  {
61  {
62  if (!vlx->getValue("Value"))
63  {
64  Log::error( Say("Line %n : error. 'Value' expected in object '%s'. \n") << vlx->lineNumber() << vlx->tag() );
65  return NULL;
66  }
67 
68  const VLXValue& value = *vlx->getValue("Value");
69 
70  ref<ArrayAbstract> arr_abstract;
71 
72  if (vlx->tag() == "<vl::ArrayFloat1>")
73  {
75  const VLXArrayReal* vlx_arr_float = value.getArrayReal();
76  ref<ArrayFloat1> arr_float1 = new ArrayFloat1; arr_abstract = arr_float1;
77  arr_float1->resize( vlx_arr_float->value().size() );
78  vlx_arr_float->copyTo((float*)arr_float1->ptr());
79  }
80  else
81  if (vlx->tag() == "<vl::ArrayFloat2>")
82  {
84  const VLXArrayReal* vlx_arr_float = value.getArrayReal();
85  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_float->value().size() % 2 == 0, value)
86  ref<ArrayFloat2> arr_float2 = new ArrayFloat2; arr_abstract = arr_float2;
87  arr_float2->resize( vlx_arr_float->value().size() / 2 );
88  vlx_arr_float->copyTo((float*)arr_float2->ptr());
89  }
90  else
91  if (vlx->tag() == "<vl::ArrayFloat3>")
92  {
94  const VLXArrayReal* vlx_arr_float = value.getArrayReal();
95  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_float->value().size() % 3 == 0, value)
96  ref<ArrayFloat3> arr_float3 = new ArrayFloat3; arr_abstract = arr_float3;
97  arr_float3->resize( vlx_arr_float->value().size() / 3 );
98  vlx_arr_float->copyTo((float*)arr_float3->ptr());
99  }
100  else
101  if (vlx->tag() == "<vl::ArrayFloat4>")
102  {
104  const VLXArrayReal* vlx_arr_float = value.getArrayReal();
105  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_float->value().size() % 4 == 0, value)
106  ref<ArrayFloat4> arr_float4 = new ArrayFloat4; arr_abstract = arr_float4;
107  arr_float4->resize( vlx_arr_float->value().size() / 4 );
108  vlx_arr_float->copyTo((float*)arr_float4->ptr());
109  }
110  else
111  if (vlx->tag() == "<vl::ArrayDouble1>")
112  {
114  const VLXArrayReal* vlx_arr_floating = value.getArrayReal();
115  ref<ArrayDouble1> arr_floating1 = new ArrayDouble1; arr_abstract = arr_floating1;
116  arr_floating1->resize( vlx_arr_floating->value().size() );
117  vlx_arr_floating->copyTo((double*)arr_floating1->ptr());
118  }
119  else
120  if (vlx->tag() == "<vl::ArrayDouble2>")
121  {
123  const VLXArrayReal* vlx_arr_floating = value.getArrayReal();
124  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_floating->value().size() % 2 == 0, value)
125  ref<ArrayDouble2> arr_floating2 = new ArrayDouble2; arr_abstract = arr_floating2;
126  arr_floating2->resize( vlx_arr_floating->value().size() / 2 );
127  vlx_arr_floating->copyTo((double*)arr_floating2->ptr());
128  }
129  else
130  if (vlx->tag() == "<vl::ArrayDouble3>")
131  {
133  const VLXArrayReal* vlx_arr_floating = value.getArrayReal();
134  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_floating->value().size() % 3 == 0, value)
135  ref<ArrayDouble3> arr_floating3 = new ArrayDouble3; arr_abstract = arr_floating3;
136  arr_floating3->resize( vlx_arr_floating->value().size() / 3 );
137  vlx_arr_floating->copyTo((double*)arr_floating3->ptr());
138  }
139  else
140  if (vlx->tag() == "<vl::ArrayDouble4>")
141  {
143  const VLXArrayReal* vlx_arr_floating = value.getArrayReal();
144  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_floating->value().size() % 4 == 0, value)
145  ref<ArrayDouble4> arr_floating4 = new ArrayDouble4; arr_abstract = arr_floating4;
146  arr_floating4->resize( vlx_arr_floating->value().size() / 4 );
147  vlx_arr_floating->copyTo((double*)arr_floating4->ptr());
148  }
149  else
150  if (vlx->tag() == "<vl::ArrayInt1>")
151  {
153  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
154  ref<ArrayInt1> arr_int1 = new ArrayInt1; arr_abstract = arr_int1;
155  arr_int1->resize( vlx_arr_int->value().size() );
156  vlx_arr_int->copyTo((int*)arr_int1->ptr());
157  }
158  else
159  if (vlx->tag() == "<vl::ArrayInt2>")
160  {
162  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
163  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_int->value().size() % 2 == 0, value)
164  ref<ArrayInt2> arr_int2 = new ArrayInt2; arr_abstract = arr_int2;
165  arr_int2->resize( vlx_arr_int->value().size() / 2 );
166  vlx_arr_int->copyTo((int*)arr_int2->ptr());
167  }
168  else
169  if (vlx->tag() == "<vl::ArrayInt3>")
170  {
172  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
173  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_int->value().size() % 3 == 0, value)
174  ref<ArrayInt3> arr_int3 = new ArrayInt3; arr_abstract = arr_int3;
175  arr_int3->resize( vlx_arr_int->value().size() / 3 );
176  vlx_arr_int->copyTo((int*)arr_int3->ptr());
177  }
178  else
179  if (vlx->tag() == "<vl::ArrayInt4>")
180  {
182  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
183  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_int->value().size() % 4 == 0, value)
184  ref<ArrayInt4> arr_int4 = new ArrayInt4; arr_abstract = arr_int4;
185  arr_int4->resize( vlx_arr_int->value().size() / 4 );
186  vlx_arr_int->copyTo((int*)arr_int4->ptr());
187  }
188  else
189  if (vlx->tag() == "<vl::ArrayUInt1>")
190  {
192  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
193  ref<ArrayUInt1> arr_int1 = new ArrayUInt1; arr_abstract = arr_int1;
194  arr_int1->resize( vlx_arr_int->value().size() );
195  vlx_arr_int->copyTo((unsigned int*)arr_int1->ptr());
196  }
197  else
198  if (vlx->tag() == "<vl::ArrayUInt2>")
199  {
201  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
202  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_int->value().size() % 2 == 0, value)
203  ref<ArrayUInt2> arr_int2 = new ArrayUInt2; arr_abstract = arr_int2;
204  arr_int2->resize( vlx_arr_int->value().size() / 2 );
205  vlx_arr_int->copyTo((unsigned int*)arr_int2->ptr());
206  }
207  else
208  if (vlx->tag() == "<vl::ArrayUInt3>")
209  {
211  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
212  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_int->value().size() % 3 == 0, value)
213  ref<ArrayUInt3> arr_int3 = new ArrayUInt3; arr_abstract = arr_int3;
214  arr_int3->resize( vlx_arr_int->value().size() / 3 );
215  vlx_arr_int->copyTo((unsigned int*)arr_int3->ptr());
216  }
217  else
218  if (vlx->tag() == "<vl::ArrayUInt4>")
219  {
221  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
222  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_int->value().size() % 4 == 0, value)
223  ref<ArrayUInt4> arr_int4 = new ArrayUInt4; arr_abstract = arr_int4;
224  arr_int4->resize( vlx_arr_int->value().size() / 4 );
225  vlx_arr_int->copyTo((unsigned int*)arr_int4->ptr());
226  }
227  else
228  if (vlx->tag() == "<vl::ArrayShort1>")
229  {
231  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
232  ref<ArrayShort1> arr_short1 = new ArrayShort1; arr_abstract = arr_short1;
233  arr_short1->resize( vlx_arr_int->value().size() );
234  vlx_arr_int->copyTo((short*)arr_short1->ptr());
235  }
236  else
237  if (vlx->tag() == "<vl::ArrayShort2>")
238  {
240  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
241  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_int->value().size() % 2 == 0, value)
242  ref<ArrayShort2> arr_short2 = new ArrayShort2; arr_abstract = arr_short2;
243  arr_short2->resize( vlx_arr_int->value().size() / 2 );
244  vlx_arr_int->copyTo((short*)arr_short2->ptr());
245  }
246  else
247  if (vlx->tag() == "<vl::ArrayShort3>")
248  {
250  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
251  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_int->value().size() % 3 == 0, value)
252  ref<ArrayShort3> arr_short3 = new ArrayShort3; arr_abstract = arr_short3;
253  arr_short3->resize( vlx_arr_int->value().size() / 3 );
254  vlx_arr_int->copyTo((short*)arr_short3->ptr());
255  }
256  else
257  if (vlx->tag() == "<vl::ArrayShort4>")
258  {
260  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
261  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_int->value().size() % 4 == 0, value)
262  ref<ArrayShort4> arr_short4 = new ArrayShort4; arr_abstract = arr_short4;
263  arr_short4->resize( vlx_arr_int->value().size() / 4 );
264  vlx_arr_int->copyTo((short*)arr_short4->ptr());
265  }
266  else
267  if (vlx->tag() == "<vl::ArrayUShort1>")
268  {
270  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
271  ref<ArrayUShort1> arr_short1 = new ArrayUShort1; arr_abstract = arr_short1;
272  arr_short1->resize( vlx_arr_int->value().size() );
273  vlx_arr_int->copyTo((unsigned short*)arr_short1->ptr());
274  }
275  else
276  if (vlx->tag() == "<vl::ArrayUShort2>")
277  {
279  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
280  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_int->value().size() % 2 == 0, value)
281  ref<ArrayUShort2> arr_short2 = new ArrayUShort2; arr_abstract = arr_short2;
282  arr_short2->resize( vlx_arr_int->value().size() / 2 );
283  vlx_arr_int->copyTo((unsigned short*)arr_short2->ptr());
284  }
285  else
286  if (vlx->tag() == "<vl::ArrayUShort3>")
287  {
289  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
290  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_int->value().size() % 3 == 0, value)
291  ref<ArrayUShort3> arr_short3 = new ArrayUShort3; arr_abstract = arr_short3;
292  arr_short3->resize( vlx_arr_int->value().size() / 3 );
293  vlx_arr_int->copyTo((unsigned short*)arr_short3->ptr());
294  }
295  else
296  if (vlx->tag() == "<vl::ArrayUShort4>")
297  {
299  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
300  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_int->value().size() % 4 == 0, value)
301  ref<ArrayUShort4> arr_short4 = new ArrayUShort4; arr_abstract = arr_short4;
302  arr_short4->resize( vlx_arr_int->value().size() / 4 );
303  vlx_arr_int->copyTo((unsigned short*)arr_short4->ptr());
304  }
305  else
306  if (vlx->tag() == "<vl::ArrayByte1>")
307  {
309  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
310  ref<ArrayByte1> arr_byte1 = new ArrayByte1; arr_abstract = arr_byte1;
311  arr_byte1->resize( vlx_arr_int->value().size() );
312  vlx_arr_int->copyTo((char*)arr_byte1->ptr());
313  }
314  else
315  if (vlx->tag() == "<vl::ArrayByte2>")
316  {
318  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
319  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_int->value().size() % 2 == 0, value)
320  ref<ArrayByte2> arr_byte2 = new ArrayByte2; arr_abstract = arr_byte2;
321  arr_byte2->resize( vlx_arr_int->value().size() / 2 );
322  vlx_arr_int->copyTo((char*)arr_byte2->ptr());
323  }
324  else
325  if (vlx->tag() == "<vl::ArrayByte3>")
326  {
328  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
329  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_int->value().size() % 3 == 0, value)
330  ref<ArrayByte3> arr_byte3 = new ArrayByte3; arr_abstract = arr_byte3;
331  arr_byte3->resize( vlx_arr_int->value().size() / 3 );
332  vlx_arr_int->copyTo((char*)arr_byte3->ptr());
333  }
334  else
335  if (vlx->tag() == "<vl::ArrayByte4>")
336  {
338  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
339  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_int->value().size() % 4 == 0, value)
340  ref<ArrayByte4> arr_byte4 = new ArrayByte4; arr_abstract = arr_byte4;
341  arr_byte4->resize( vlx_arr_int->value().size() / 4 );
342  vlx_arr_int->copyTo((char*)arr_byte4->ptr());
343  }
344  else
345  if (vlx->tag() == "<vl::ArrayUByte1>")
346  {
348  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
349  ref<ArrayUByte1> arr_byte1 = new ArrayUByte1; arr_abstract = arr_byte1;
350  arr_byte1->resize( vlx_arr_int->value().size() );
351  vlx_arr_int->copyTo((unsigned char*)arr_byte1->ptr());
352  }
353  else
354  if (vlx->tag() == "<vl::ArrayUByte2>")
355  {
357  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
358  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_int->value().size() % 2 == 0, value)
359  ref<ArrayUByte2> arr_byte2 = new ArrayUByte2; arr_abstract = arr_byte2;
360  arr_byte2->resize( vlx_arr_int->value().size() / 2 );
361  vlx_arr_int->copyTo((unsigned char*)arr_byte2->ptr());
362  }
363  else
364  if (vlx->tag() == "<vl::ArrayUByte3>")
365  {
367  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
368  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_int->value().size() % 3 == 0, value)
369  ref<ArrayUByte3> arr_byte3 = new ArrayUByte3; arr_abstract = arr_byte3;
370  arr_byte3->resize( vlx_arr_int->value().size() / 3 );
371  vlx_arr_int->copyTo((unsigned char*)arr_byte3->ptr());
372  }
373  else
374  if (vlx->tag() == "<vl::ArrayUByte4>")
375  {
377  const VLXArrayInteger* vlx_arr_int = value.getArrayInteger();
378  VLX_IMPORT_CHECK_RETURN_NULL( vlx_arr_int->value().size() % 4 == 0, value)
379  ref<ArrayUByte4> arr_byte4 = new ArrayUByte4; arr_abstract = arr_byte4;
380  arr_byte4->resize( vlx_arr_int->value().size() / 4 );
381  vlx_arr_int->copyTo((unsigned char*)arr_byte4->ptr());
382  }
383  else
384  {
385  s.signalImportError(Say("Line %n : unknown array '%s'.\n") << vlx->lineNumber() << vlx->tag() );
386  }
387 
388  // register imported structure asap
389  s.registerImportedStructure(vlx, arr_abstract.get());
390  return arr_abstract.get();
391  }
392 
393  template<typename T_Array, typename T_VLXArray>
395  {
396  const T_Array* arr = arr_abstract->as<T_Array>();
397  ref<VLXStructure> st =new VLXStructure(vlx_makeTag(arr_abstract).c_str(), s.generateID("array_"));
398  ref<T_VLXArray> vlx_array = new T_VLXArray;
399  if (arr->size())
400  {
401  vlx_array->value().resize( arr->size() * arr->glSize() );
402  typename T_VLXArray::scalar_type* dst = &vlx_array->value()[0];
403  const typename T_Array::scalar_type* src = (const typename T_Array::scalar_type*)arr->begin();
404  const typename T_Array::scalar_type* end = (const typename T_Array::scalar_type*)arr->end();
405  for(; src<end; ++src, ++dst)
406  *dst = (typename T_VLXArray::scalar_type)*src;
407  }
408  st->value().push_back( VLXStructure::Value("Value", vlx_array.get() ) );
409  return st;
410  }
411 
413  {
414  ref<VLXStructure> vlx;
415  if(obj->classType() == ArrayUInt1::Type())
416  vlx = export_ArrayT<ArrayUInt1, VLXArrayInteger>(s, obj);
417  else
418  if(obj->classType() == ArrayUInt2::Type())
419  vlx = export_ArrayT<ArrayUInt2, VLXArrayInteger>(s, obj);
420  else
421  if(obj->classType() == ArrayUInt3::Type())
422  vlx = export_ArrayT<ArrayUInt3, VLXArrayInteger>(s, obj);
423  else
424  if(obj->classType() == ArrayUInt4::Type())
425  vlx = export_ArrayT<ArrayUInt4, VLXArrayInteger>(s, obj);
426  else
427 
428  if(obj->classType() == ArrayInt1::Type())
429  vlx = export_ArrayT<ArrayInt1, VLXArrayInteger>(s, obj);
430  else
431  if(obj->classType() == ArrayInt2::Type())
432  vlx = export_ArrayT<ArrayInt2, VLXArrayInteger>(s, obj);
433  else
434  if(obj->classType() == ArrayInt3::Type())
435  vlx = export_ArrayT<ArrayInt3, VLXArrayInteger>(s, obj);
436  else
437  if(obj->classType() == ArrayInt4::Type())
438  vlx = export_ArrayT<ArrayInt4, VLXArrayInteger>(s, obj);
439  else
440 
441  if(obj->classType() == ArrayUShort1::Type())
442  vlx = export_ArrayT<ArrayUShort1, VLXArrayInteger>(s, obj);
443  else
444  if(obj->classType() == ArrayUShort2::Type())
445  vlx = export_ArrayT<ArrayUShort2, VLXArrayInteger>(s, obj);
446  else
447  if(obj->classType() == ArrayUShort3::Type())
448  vlx = export_ArrayT<ArrayUShort3, VLXArrayInteger>(s, obj);
449  else
450  if(obj->classType() == ArrayUShort4::Type())
451  vlx = export_ArrayT<ArrayUShort4, VLXArrayInteger>(s, obj);
452  else
453 
454  if(obj->classType() == ArrayUShort1::Type())
455  vlx = export_ArrayT<ArrayUShort1, VLXArrayInteger>(s, obj);
456  else
457  if(obj->classType() == ArrayUShort2::Type())
458  vlx = export_ArrayT<ArrayUShort2, VLXArrayInteger>(s, obj);
459  else
460  if(obj->classType() == ArrayUShort3::Type())
461  vlx = export_ArrayT<ArrayUShort3, VLXArrayInteger>(s, obj);
462  else
463  if(obj->classType() == ArrayUShort4::Type())
464  vlx = export_ArrayT<ArrayUShort4, VLXArrayInteger>(s, obj);
465  else
466 
467  if(obj->classType() == ArrayShort1::Type())
468  vlx = export_ArrayT<ArrayShort1, VLXArrayInteger>(s, obj);
469  else
470  if(obj->classType() == ArrayShort2::Type())
471  vlx = export_ArrayT<ArrayShort2, VLXArrayInteger>(s, obj);
472  else
473  if(obj->classType() == ArrayShort3::Type())
474  vlx = export_ArrayT<ArrayShort3, VLXArrayInteger>(s, obj);
475  else
476  if(obj->classType() == ArrayShort4::Type())
477  vlx = export_ArrayT<ArrayShort4, VLXArrayInteger>(s, obj);
478  else
479 
480  if(obj->classType() == ArrayUByte1::Type())
481  vlx = export_ArrayT<ArrayUByte1, VLXArrayInteger>(s, obj);
482  else
483  if(obj->classType() == ArrayUByte2::Type())
484  vlx = export_ArrayT<ArrayUByte2, VLXArrayInteger>(s, obj);
485  else
486  if(obj->classType() == ArrayUByte3::Type())
487  vlx = export_ArrayT<ArrayUByte3, VLXArrayInteger>(s, obj);
488  else
489  if(obj->classType() == ArrayUByte4::Type())
490  vlx = export_ArrayT<ArrayUByte4, VLXArrayInteger>(s, obj);
491  else
492 
493  if(obj->classType() == ArrayByte1::Type())
494  vlx = export_ArrayT<ArrayByte1, VLXArrayInteger>(s, obj);
495  else
496  if(obj->classType() == ArrayByte2::Type())
497  vlx = export_ArrayT<ArrayByte2, VLXArrayInteger>(s, obj);
498  else
499  if(obj->classType() == ArrayByte3::Type())
500  vlx = export_ArrayT<ArrayByte3, VLXArrayInteger>(s, obj);
501  else
502  if(obj->classType() == ArrayByte4::Type())
503  vlx = export_ArrayT<ArrayByte4, VLXArrayInteger>(s, obj);
504  else
505 
506  if(obj->classType() == ArrayFloat1::Type())
507  vlx = export_ArrayT<ArrayFloat1, VLXArrayReal>(s, obj);
508  else
509  if(obj->classType() == ArrayFloat2::Type())
510  vlx = export_ArrayT<ArrayFloat2, VLXArrayReal>(s, obj);
511  else
512  if(obj->classType() == ArrayFloat3::Type())
513  vlx = export_ArrayT<ArrayFloat3, VLXArrayReal>(s, obj);
514  else
515  if(obj->classType() == ArrayFloat4::Type())
516  vlx = export_ArrayT<ArrayFloat4, VLXArrayReal>(s, obj);
517  else
518 
519  if(obj->classType() == ArrayDouble1::Type())
520  vlx = export_ArrayT<ArrayDouble1, VLXArrayReal>(s, obj);
521  else
522  if(obj->classType() == ArrayDouble2::Type())
523  vlx = export_ArrayT<ArrayDouble2, VLXArrayReal>(s, obj);
524  else
525  if(obj->classType() == ArrayDouble3::Type())
526  vlx = export_ArrayT<ArrayDouble3, VLXArrayReal>(s, obj);
527  else
528  if(obj->classType() == ArrayDouble4::Type())
529  vlx = export_ArrayT<ArrayDouble4, VLXArrayReal>(s, obj);
530  else
531  {
532  s.signalExportError("Array type not supported for export.\n");
533  }
534 
535  // register exported object asap
536  s.registerExportedObject(obj, vlx.get());
537  return vlx;
538  }
539  };
540 
541  //---------------------------------------------------------------------------
542 
545  {
546  virtual void exportRenderable(const Renderable* obj, VLXStructure* vlx)
547  {
548  if (!obj->objectName().empty() && obj->objectName() != obj->className())
549  *vlx << "ObjectName" << vlx_String(obj->objectName());
550  *vlx << "BufferObjectEnabled" << obj->isBufferObjectEnabled();
551  *vlx << "DisplayListEnabled" << obj->isDisplayListEnabled();
552  if (!obj->boundsDirty())
553  {
554  *vlx << "AABB" << export_AABB(obj->boundingBox());
555  *vlx << "Sphere" << export_Sphere(obj->boundingSphere());
556  }
557  else
558  Log::debug("VLXClassWrapper_Renderable : skipping dirty bounds.\n");
559  }
560 
561  void importRenderable(const VLXStructure* vlx, Renderable* ren)
562  {
563  const VLXValue* name = vlx->getValue("ObjectName");
564  if (name)
565  ren->setObjectName( name->getString() );
566 
567  const std::vector<VLXStructure::Value>& values = vlx->value();
568  for(size_t i=0; i<values.size(); ++i)
569  {
570  const std::string& key = values[i].key();
571  if (key == "BufferObjectEnabled")
572  {
573  ren->setBufferObjectEnabled( values[i].value().getBool() );
574  }
575  else
576  if (key == "DisplayListEnabled")
577  {
578  ren->setDisplayListEnabled( values[i].value().getBool() );
579  }
580  else
581  if (key == "AABB")
582  {
583  ren->setBoundingBox( import_AABB(values[i].value().getStructure()) );
584  }
585  else
586  if (key == "Sphere")
587  {
588  ren->setBoundingSphere( import_Sphere(values[i].value().getStructure()) );
589  }
590  }
591  }
592  };
593 
594  //---------------------------------------------------------------------------
595 
598  {
599  void importGeometry(VLXSerializer& s, const VLXStructure* vlx, Geometry* geom)
600  {
602 
603  for(size_t i=0; i<vlx->value().size(); ++i)
604  {
605  const std::string& key = vlx->value()[i].key();
606  const VLXValue& value = vlx->value()[i].value();
607 
608  if (key == "VertexArray")
609  {
611  ArrayAbstract* arr = s.importVLX(value.getStructure())->as<ArrayAbstract>();
612  if (arr)
613  geom->setVertexArray(arr);
614  else
615  s.signalImportError( Say("Line %n : import error.\n") << value.lineNumber() );
616  }
617  else
618  if (key == "NormalArray")
619  {
621  ArrayAbstract* arr = s.importVLX(value.getStructure())->as<ArrayAbstract>();
622  if (arr)
623  geom->setNormalArray(arr);
624  else
625  s.signalImportError( Say("Line %n : import error.\n") << value.lineNumber() );
626  }
627  else
628  if (key == "ColorArray")
629  {
631  ArrayAbstract* arr = s.importVLX(value.getStructure())->as<ArrayAbstract>();
632  if (arr)
633  geom->setColorArray(arr);
634  else
635  s.signalImportError( Say("Line %n : import error.\n") << value.lineNumber() );
636  }
637  else
638  if (key == "SecondaryColorArray")
639  {
641  ArrayAbstract* arr = s.importVLX(value.getStructure())->as<ArrayAbstract>();
642  if (arr)
643  geom->setSecondaryColorArray(arr);
644  else
645  s.signalImportError( Say("Line %n : import error.\n") << value.lineNumber() );
646  }
647  else
648  if (key == "FogCoordArray")
649  {
651  ArrayAbstract* arr = s.importVLX(value.getStructure())->as<ArrayAbstract>();
652  if (arr)
653  geom->setFogCoordArray(arr);
654  else
655  s.signalImportError( Say("Line %n : import error.\n") << value.lineNumber() );
656  }
657  else
658  if (strstr(key.c_str(), "TexCoordArray") == key.c_str())
659  {
660  const char* ch = key.c_str() + 13/*strlen("TexCoordArray")*/;
661  int tex_unit = 0;
662  for(; *ch; ++ch)
663  {
664  if (*ch>='0' && *ch<='9')
665  tex_unit = tex_unit*10 + (*ch - '0');
666  else
667  {
668  Log::error( Say("Line %n : error. ") << value.lineNumber() );
669  Log::error( "TexCoordArray must end with a number!\n" );
670  s.signalImportError( Say("Line %n : import error.\n") << value.lineNumber() );
671  }
672  }
673 
675  ArrayAbstract* arr = s.importVLX(value.getStructure())->as<ArrayAbstract>();
676  if (arr)
677  geom->setTexCoordArray(tex_unit, arr);
678  else
679  s.signalImportError( Say("Line %n : import error.\n") << value.lineNumber() );
680  }
681  else
682  if (strstr(key.c_str(), "VertexAttribArray") == key.c_str())
683  {
684  // MIC FIXME
685  //const char* ch = key.c_str() + 17/*strlen("VertexAttribArray")*/;
686  //int attrib_location = 0;
687  //for(; *ch; ++ch)
688  //{
689  // if (*ch>='0' && *ch<='9')
690  // attrib_location = attrib_location*10 + (*ch - '0');
691  // else
692  // {
693  // Log::error( Say("Line %n : error. ") << value.lineNumber() );
694  // Log::error( "VertexAttribArray must end with a number!\n" );
695  // s.signalImportError( Say("Line %n : import error.\n") << value.lineNumber() );
696  // }
697  //}
698 
699  //VLX_IMPORT_CHECK_RETURN(value.type() == VLXValue::Structure, value)
700  //VertexAttribInfo* info_ptr = s.importVLX(value.getStructure())->as<VertexAttribInfo>();
701  //if (info_ptr)
702  //{
703  // VertexAttribInfo info = *info_ptr;
704  // info.setAttribLocation(attrib_location);
705  // geom->setVertexAttribArray(info);
706  //}
707  //else
708  // s.signalImportError( Say("Line %n : import error.\n") << value.lineNumber() );
709  }
710  else
711  if (key == "DrawCall")
712  {
714  DrawCall* draw_call = s.importVLX(value.getStructure())->as<DrawCall>();
715  if (draw_call)
716  geom->drawCalls().push_back(draw_call);
717  else
718  s.signalImportError( Say("Line %n : import error.\n") << value.lineNumber() );
719  }
720  }
721  }
722 
724  {
725  ref<Geometry> geom = new Geometry;
726  // registration must be done here to avoid loops
727  s.registerImportedStructure(vlx, geom.get());
728  importGeometry(s, vlx, geom.get());
729  return geom;
730  }
731 
732  void exportGeometry(VLXSerializer& s, const Geometry* geom, VLXStructure* vlx)
733  {
734  // Renderable
736 
737  // Geometry
738  if (geom->vertexArray())
739  *vlx << "VertexArray" << s.exportVLX(geom->vertexArray());
740 
741  if (geom->normalArray())
742  *vlx << "NormalArray" << s.exportVLX(geom->normalArray());
743 
744  if (geom->colorArray())
745  *vlx << "ColorArray" << s.exportVLX(geom->colorArray());
746 
747  if (geom->secondaryColorArray())
748  *vlx << "SecondaryColorArray" << s.exportVLX(geom->secondaryColorArray());
749 
750  if (geom->fogCoordArray())
751  *vlx << "FogCoordArray" << s.exportVLX(geom->fogCoordArray());
752 
753  for( int i=0; i<VA_MaxTexCoordCount; ++i)
754  {
755  if (geom->texCoordArray(i))
756  {
757  std::string tex_coord_array = String::printf("TexCoordArray%d", i).toStdString();
758  *vlx << tex_coord_array.c_str() << s.exportVLX(geom->texCoordArray(i));
759  }
760  }
761 
762  // MIC FIXME: unify with above
763  //for(size_t i=0; i<VA_MaxAttribCount; ++i)
764  //{
765  // if (geom->vertexAttribArray(i))
766  // {
767  // std::string vertex_attrib_array = String::printf("VertexAttribArray%d", i).toStdString();
768  // *vlx << vertex_attrib_array.c_str() << s.exportVLX(geom->vertexAttribArray(i));
769  // }
770  //}
771 
772  for(int i=0; i<geom->drawCalls().size(); ++i) {
773  *vlx << "DrawCall" << s.exportVLX(geom->drawCalls().at(i));
774  }
775  }
776 
778  {
779  const Geometry* cast_obj = obj->as<Geometry>(); VL_CHECK(cast_obj)
780  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("geometry_"));
781  // register exported object asap
782  s.registerExportedObject(obj, vlx.get());
783  exportGeometry(s, cast_obj, vlx.get());
784  return vlx;
785  }
786  };
787 
788  //---------------------------------------------------------------------------
789 
792  {
793  void importDrawCall(VLXSerializer& s, const VLXStructure* vlx, DrawCall* draw_call)
794  {
795  if(draw_call->isOfType(DrawElementsBase::Type()))
796  {
797  DrawElementsBase* de= draw_call->as<DrawElementsBase>();
798 
799  const VLXValue* name = vlx->getValue("ObjectName");
800  if (name)
801  de->setObjectName( name->getString() );
802 
803  for(size_t i=0; i<vlx->value().size(); ++i)
804  {
805  const std::string& key = vlx->value()[i].key();
806  const VLXValue& value = vlx->value()[i].value();
807  if( key == "PrimitiveType" )
808  {
810  de->setPrimitiveType( vlx_EPrimitiveType( value, s ) );
812  }
813  else
814  if( key == "Enabled" )
815  {
816  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Bool , value)
817  de->setEnabled( value.getBool() );
818  }
819  else
820  if( key == "Instances" )
821  {
822  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer , value)
823  de->setInstances( (int)value.getInteger() );
824  }
825  else
826  if( key == "PrimitiveRestartEnabled" )
827  {
828  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Bool , value)
829  de->setPrimitiveRestartEnabled( value.getBool() );
830  }
831  else
832  if( key == "BaseVertex" )
833  {
834  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer , value)
835  de->setBaseVertex( (int)value.getInteger() );
836  }
837  else
838  if( key == "IndexBuffer" )
839  {
841  ArrayAbstract* arr_abstract = s.importVLX(value.getStructure())->as<ArrayAbstract>();
842  if(!arr_abstract)
843  s.signalImportError( Say("Line %n : import error.\n") << value.lineNumber() );
844 
845  if ( de->isOfType(DrawElementsUInt::Type()) )
846  {
847  VLX_IMPORT_CHECK_RETURN(arr_abstract->classType() == ArrayUInt1::Type(), value);
848  de->as<DrawElementsUInt>()->setIndexBuffer( arr_abstract->as<ArrayUInt1>() );
849  }
850  else
851  if ( de->isOfType(DrawElementsUShort::Type()) )
852  {
853  VLX_IMPORT_CHECK_RETURN(arr_abstract->classType() == ArrayUShort1::Type(), value);
854  de->as<DrawElementsUShort>()->setIndexBuffer( arr_abstract->as<ArrayUShort1>() );
855  }
856  else
857  if ( de->isOfType(DrawElementsUByte::Type()) )
858  {
859  VLX_IMPORT_CHECK_RETURN(arr_abstract->classType() == ArrayUByte1::Type(), value);
860  de->as<DrawElementsUByte>()->setIndexBuffer( arr_abstract->as<ArrayUByte1>() );
861  }
862  }
863  }
864  }
865  else
866  if(draw_call->isOfType( MultiDrawElementsBase::Type() ))
867  {
868  MultiDrawElementsBase* de = draw_call->as<MultiDrawElementsBase>();
869 
870  VL_CHECK(de)
871  VL_CHECK(draw_call)
872 
873  const VLXValue* name = vlx->getValue("ObjectName");
874  if (name)
875  de->setObjectName( name->getString() );
876 
877  for(size_t i=0; i<vlx->value().size(); ++i)
878  {
879  const std::string& key = vlx->value()[i].key();
880  const VLXValue& value = vlx->value()[i].value();
881  if( key == "PrimitiveType" )
882  {
884  de->setPrimitiveType( vlx_EPrimitiveType( value, s ) );
886  }
887  else
888  if( key == "Enabled" )
889  {
890  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Bool , value)
891  de->setEnabled( value.getBool() );
892  }
893  else
894  if( key == "PrimitiveRestartEnabled" )
895  {
896  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Bool , value)
897  de->setPrimitiveRestartEnabled( value.getBool() );
898  }
899  else
900  if( key == "BaseVertices" )
901  {
903  de->baseVertices().resize( value.getArrayInteger()->value().size() );
904  if (de->baseVertices().size())
905  value.getArrayInteger()->copyTo( &de->baseVertices()[0] );
906  // de->setBaseVertices( value.getArrayInt32()->value() );
907  }
908  else
909  if( key == "CountVector" )
910  {
912  de->countVector().resize( value.getArrayInteger()->value().size() );
913  if (de->countVector().size())
914  value.getArrayInteger()->copyTo( &de->countVector()[0] );
915  // de->countVector() = value.getArrayInt32()->value();
916  }
917  else
918  if( key == "IndexBuffer" )
919  {
921  ArrayAbstract* arr_abstract = s.importVLX(value.getStructure())->as<ArrayAbstract>();
922  if( !arr_abstract )
923  s.signalImportError( Say("Line %n : import error.\n") << value.lineNumber() );
924 
925  if ( de->isOfType(MultiDrawElementsUInt::Type()) )
926  {
927  VLX_IMPORT_CHECK_RETURN(arr_abstract->classType() == ArrayUInt1::Type(), value);
928  de->as<MultiDrawElementsUInt>()->setIndexBuffer( arr_abstract->as<ArrayUInt1>() );
929  }
930  else
931  if ( de->isOfType(MultiDrawElementsUShort::Type()) )
932  {
933  VLX_IMPORT_CHECK_RETURN(arr_abstract->classType() == ArrayUShort1::Type(), value);
934  de->as<MultiDrawElementsUShort>()->setIndexBuffer( arr_abstract->as<ArrayUShort1>() );
935  }
936  else
937  if ( de->isOfType(MultiDrawElementsUByte::Type()) )
938  {
939  VLX_IMPORT_CHECK_RETURN(arr_abstract->classType() == ArrayUByte1::Type(), value);
940  de->as<MultiDrawElementsUByte>()->setIndexBuffer( arr_abstract->as<ArrayUByte1>() );
941  }
942  }
943  }
944 
945  // finalize setup
946  de->computePointerVector();
948  if ( de->baseVertices().size() != de->countVector().size() )
949  de->baseVertices().resize( de->countVector().size() );
950  }
951  else
952  if( draw_call->isOfType( DrawArrays::Type() ) )
953  {
954  ref<DrawArrays> da = draw_call->as<DrawArrays>();
955 
956  const VLXValue* name = vlx->getValue("ObjectName");
957  if (name)
958  da->setObjectName( name->getString() );
959 
960  for(size_t i=0; i<vlx->value().size(); ++i)
961  {
962  const std::string& key = vlx->value()[i].key();
963  const VLXValue& value = vlx->value()[i].value();
964 
965  if( key == "PrimitiveType" )
966  {
968  da->setPrimitiveType( vlx_EPrimitiveType( value, s ) );
969  VLX_IMPORT_CHECK_RETURN( da->primitiveType() != PT_UNKNOWN , value);
970  }
971  else
972  if( key == "Enabled" )
973  {
974  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Bool , value)
975  da->setEnabled( value.getBool() );
976  }
977  else
978  if( key == "Instances" )
979  {
980  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer , value)
981  da->setInstances( (int)value.getInteger() );
982  }
983  else
984  if( key == "Start" )
985  {
986  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer , value)
987  da->setStart( (int)value.getInteger() );
988  }
989  else
990  if( key == "Count" )
991  {
992  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer , value)
993  da->setCount( (int)value.getInteger() );
994  }
995  }
996  }
997  }
998 
1000  {
1001  ref<DrawCall> dc;
1002  if (vlx->tag() == "<vl::DrawElementsUInt>")
1003  dc = new DrawElementsUInt;
1004  else
1005  if (vlx->tag() == "<vl::DrawElementsUShort>")
1006  dc = new DrawElementsUShort;
1007  else
1008  if (vlx->tag() == "<vl::DrawElementsUByte>")
1009  dc = new DrawElementsUByte;
1010  else
1011  if (vlx->tag() == "<vl::MultiDrawElementsUInt>")
1012  dc = new MultiDrawElementsUInt;
1013  else
1014  if (vlx->tag() == "<vl::MultiDrawElementsUShort>")
1015  dc = new MultiDrawElementsUShort;
1016  else
1017  if (vlx->tag() == "<vl::MultiDrawElementsUByte>")
1018  dc = new MultiDrawElementsUByte;
1019  else
1020  if (vlx->tag() == "<vl::DrawArrays>")
1021  dc = new DrawArrays;
1022  else
1023  s.signalImportError( Say("Line %n : error. Unknown draw call.\n") << vlx->lineNumber() );
1024  // register imported structure asap
1025  s.registerImportedStructure(vlx, dc.get());
1026  importDrawCall(s, vlx, dc.get());
1027  return dc;
1028  }
1029 
1031  {
1032  if (!obj->objectName().empty() && obj->objectName() != obj->className())
1033  *vlx << "ObjectName" << vlx_String(obj->objectName());
1034  *vlx << "PrimitiveType" << vlx_Identifier(vlx_EPrimitiveType(obj->primitiveType()));
1035  *vlx << "Enabled" << obj->isEnabled();
1036  if (obj->patchParameter())
1037  *vlx << "PatchParameter" << s.exportVLX(obj->patchParameter());
1038  }
1039 
1040  void exportDrawCall(VLXSerializer& s, const DrawCall* dcall, VLXStructure* vlx)
1041  {
1042  exportDrawCallBase(s, dcall, vlx);
1043 
1044  if (dcall->isOfType(DrawArrays::Type()))
1045  {
1046  const DrawArrays* da = dcall->as<DrawArrays>();
1047  *vlx << "Instances" << (long long)da->instances();
1048  *vlx << "Start" << (long long)da->start();
1049  *vlx << "Count" << (long long)da->count();
1050  }
1051  else
1052  if (dcall->isOfType(DrawElementsUInt::Type()))
1053  {
1054  const DrawElementsUInt* de = dcall->as<DrawElementsUInt>();
1055  *vlx << "Instances" << (long long)de->instances();
1056  *vlx << "PrimitiveRestartEnabled" << de->primitiveRestartEnabled();
1057  *vlx << "BaseVertex" << (long long)de->baseVertex();
1058  *vlx << "IndexBuffer" << s.exportVLX(de->indexBuffer());
1059  }
1060  else
1061  if (dcall->isOfType(DrawElementsUShort::Type()))
1062  {
1063  const DrawElementsUShort* de = dcall->as<DrawElementsUShort>();
1064  *vlx << "Instances" << (long long)de->instances();
1065  *vlx << "PrimitiveRestartEnabled" << de->primitiveRestartEnabled();
1066  *vlx << "BaseVertex" << (long long)de->baseVertex();
1067  *vlx << "IndexBuffer" << s.exportVLX(de->indexBuffer());
1068  }
1069  else
1070  if (dcall->isOfType(DrawElementsUByte::Type()))
1071  {
1072  const DrawElementsUByte* de = dcall->as<DrawElementsUByte>();
1073  *vlx << "Instances" << (long long)de->instances();
1074  *vlx << "PrimitiveRestartEnabled" << de->primitiveRestartEnabled();
1075  *vlx << "BaseVertex" << (long long)de->baseVertex();
1076  *vlx << "IndexBuffer" << s.exportVLX(de->indexBuffer());
1077  }
1078  else
1079  if (dcall->isOfType(MultiDrawElementsUInt::Type()))
1080  {
1081  const MultiDrawElementsUInt* de = dcall->as<MultiDrawElementsUInt>();
1082  *vlx << "PrimitiveRestartEnabled" << de->primitiveRestartEnabled();
1083  *vlx << "BaseVertices" << vlx_toValue(de->baseVertices());
1084  *vlx << "CountVector" << vlx_toValue(de->countVector());
1085  *vlx << "IndexBuffer" << s.exportVLX(de->indexBuffer());
1086  }
1087  else
1088  if (dcall->isOfType(MultiDrawElementsUShort::Type()))
1089  {
1090  const MultiDrawElementsUShort* de = dcall->as<MultiDrawElementsUShort>();
1091  *vlx << "PrimitiveRestartEnabled" << de->primitiveRestartEnabled();
1092  *vlx << "BaseVertices" << vlx_toValue(de->baseVertices());
1093  *vlx << "CountVector" << vlx_toValue(de->countVector());
1094  *vlx << "IndexBuffer" << s.exportVLX(de->indexBuffer());
1095  }
1096  else
1097  if (dcall->isOfType(MultiDrawElementsUByte::Type()))
1098  {
1099  const MultiDrawElementsUByte* de = dcall->as<MultiDrawElementsUByte>();
1100  *vlx << "PrimitiveRestartEnabled" << de->primitiveRestartEnabled();
1101  *vlx << "BaseVertices" << vlx_toValue(de->baseVertices());
1102  *vlx << "CountVector" << vlx_toValue(de->countVector());
1103  *vlx << "IndexBuffer" << s.exportVLX(de->indexBuffer());
1104  }
1105  else
1106  {
1107  Log::error("DrawCall type not supported for export.\n");
1108  }
1109  }
1110 
1112  {
1113  const DrawCall* cast_obj = obj->as<DrawCall>(); VL_CHECK(cast_obj)
1114  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("drawcall_"));
1115  // register exported object asap
1116  s.registerExportedObject(obj, vlx.get());
1117  exportDrawCall(s, cast_obj, vlx.get());
1118  return vlx;
1119  }
1120  };
1121 
1122  //---------------------------------------------------------------------------
1123 
1126  {
1128  {
1129  std::vector<VLXStructure::Value> values = vlx->value();
1130  for(size_t i=0; i<values.size(); ++i)
1131  {
1132  const std::string& key = values[i].key();
1133  if (key == "PatchVertices")
1134  {
1135  pp->setPatchVertices( (int)values[i].value().getInteger() );
1136  }
1137  else
1138  if (key == "PatchDefaultOuterLevel")
1139  {
1140  pp->setPatchDefaultOuterLevel( (fvec4)vlx_vec4(values[i].value().getArrayReal()) );
1141  }
1142  else
1143  if (key == "PatchDefaultInnerLevel")
1144  {
1145  pp->setPatchDefaultInnerLevel( (fvec2)vlx_vec2(values[i].value().getArrayReal()) );
1146  }
1147  }
1148  }
1149 
1151  {
1153  // register imported structure asap
1154  s.registerImportedStructure(vlx, pp.get());
1155  importPatchParameter(vlx, pp.get());
1156  return pp;
1157  }
1158 
1160  {
1161  *vlx << "PatchVertices" << (long long)pp->patchVertices();
1162  *vlx << "PatchDefaultOuterLevel" << vlx_toValue((vec4)pp->patchDefaultOuterLevel());
1163  *vlx << "PatchDefaultInnerLevel" << vlx_toValue((vec2)pp->patchDefaultInnerLevel());
1164  }
1165 
1167  {
1168  const PatchParameter* cast_obj = obj->as<PatchParameter>(); VL_CHECK(cast_obj)
1169  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("patchparam_"));
1170  // register exported object asap
1171  s.registerExportedObject(obj, vlx.get());
1172  exportPatchParameter(cast_obj, vlx.get());
1173  return vlx;
1174  }
1175  };
1176 
1177  //---------------------------------------------------------------------------
1178 
1181  {
1183  {
1184  const VLXValue* vlx_obj_name = vlx->getValue("ObjectName");
1185  if (vlx_obj_name)
1186  resdb->setObjectName( vlx_obj_name->getString() );
1187 
1188  const VLXValue* vlx_res = vlx->getValue("Resources");
1189  if (vlx_res)
1190  {
1191  VLX_IMPORT_CHECK_RETURN( vlx_res->type() == VLXValue::List, *vlx_res );
1192  // get the list
1193  const VLXList* list = vlx_res->getList();
1194  for(size_t i=0; i<list->value().size(); ++i)
1195  {
1196  const VLXValue& value = list->value()[i];
1197 
1198  // the member of this list must be all structures.
1199 
1200  if (value.type() != VLXValue::Structure)
1201  {
1202  s.signalImportError( Say("Line %n : structure expected.\n") << value.lineNumber() );
1203  return;
1204  }
1205 
1206  resdb->resources().push_back( s.importVLX(value.getStructure()) );
1207  }
1208  }
1209  }
1210 
1212  {
1214  // register imported structure asap
1215  s.registerImportedStructure(vlx, resdb.get());
1216  importResourceDatabase(s, vlx, resdb.get());
1217  return resdb;
1218  }
1219 
1221  {
1222  if (!obj->objectName().empty() && obj->objectName() != obj->className())
1223  *vlx << "ObjectName" << vlx_String(obj->objectName());
1224  ref<VLXList> list = new VLXList;
1225  *vlx << "Resources" << list.get();
1226 
1227  for(size_t i=0; i<obj->resources().size(); ++i)
1228  {
1229  if ( !s.canExport(obj->resources().at(i).get()) )
1230  {
1231  Log::debug( Say("VLXClassWrapper_ResourceDatabase : skipping '%s'.\n") << obj->resources().at(i).get()->className() );
1232  continue;
1233  }
1234  else
1235  {
1236  *list << s.exportVLX(obj->resources().at(i).get());
1237  }
1238  }
1239  }
1240 
1242  {
1243  const ResourceDatabase* cast_obj = obj->as<ResourceDatabase>(); VL_CHECK(cast_obj)
1244  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("resdb_"));
1245  // register exported object asap
1246  s.registerExportedObject(obj, vlx.get());
1247  exportResourceDatabase(s, cast_obj, vlx.get());
1248  return vlx;
1249  }
1250  };
1251 
1252  //---------------------------------------------------------------------------
1253 
1256  {
1257  void importUniform(VLXSerializer& s, const VLXStructure* vlx, Uniform* uniform)
1258  {
1259  const VLXValue* val = vlx->getValue("Name");
1260  if (val)
1261  {
1262  VL_CHECK( val->type() == VLXValue::String );
1263  uniform->setName( val->getString() );
1264  }
1265  else
1266  {
1267  s.signalImportError( Say("Line %d : uniform without 'Name'.\n") << vlx->lineNumber() );
1268  return;
1269  }
1270 
1271  // 'Count' is optional
1272  int count = 1;
1273  val = vlx->getValue("Count");
1274  if (val)
1275  {
1276  VL_CHECK( val->type() == VLXValue::Integer );
1277  count = (int)val->getInteger();
1278  }
1279 
1280  EUniformType type = UT_NONE;
1281  val = vlx->getValue("Type");
1282  if (val)
1283  {
1284  VL_CHECK( val->type() == VLXValue::Identifier );
1285  type = vlx_EUniformType( *val, s );
1286  }
1287  else
1288  {
1289  s.signalImportError( Say("Line %d : uniform without 'Type'.\n") << vlx->lineNumber() );
1290  return;
1291  }
1292 
1293  val = vlx->getValue("Data");
1294  const VLXArrayReal* arr_real = NULL;
1295  const VLXArrayInteger* arr_int = NULL;
1296  if (!val)
1297  {
1298  s.signalImportError( Say("Line %d : uniform without 'Data'.\n") << vlx->lineNumber() );
1299  return;
1300  }
1301  else
1302  {
1303  if (val->type() == VLXValue::ArrayReal)
1304  arr_real = val->getArrayReal();
1305  else
1306  if (val->type() == VLXValue::ArrayInteger)
1307  arr_int = val->getArrayInteger();
1308  }
1309 
1310  std::vector<int> int_vec;
1311  std::vector<unsigned int> uint_vec;
1312  std::vector<float> float_vec;
1313  std::vector<double> double_vec;
1314 
1315  switch(type)
1316  {
1317  case UT_INT:
1318  int_vec.resize(count*1); if (arr_int) arr_int->copyTo(&int_vec[0]); else int_vec[0] = (int)val->getInteger();
1319  uniform->setUniform1i(count, &int_vec[0]);
1320  break;
1321  case UT_INT_VEC2:
1322  int_vec.resize(count*2); arr_int->copyTo(&int_vec[0]); VLX_IMPORT_CHECK_RETURN(int_vec.size() == arr_int->value().size(), *val);
1323  uniform->setUniform2i(count, &int_vec[0]);
1324  break;
1325  case UT_INT_VEC3:
1326  int_vec.resize(count*3); arr_int->copyTo(&int_vec[0]); VLX_IMPORT_CHECK_RETURN(int_vec.size() == arr_int->value().size(), *val);
1327  uniform->setUniform3i(count, &int_vec[0]);
1328  break;
1329  case UT_INT_VEC4:
1330  int_vec.resize(count*4); arr_int->copyTo(&int_vec[0]); VLX_IMPORT_CHECK_RETURN(int_vec.size() == arr_int->value().size(), *val);
1331  uniform->setUniform4i(count, &int_vec[0]);
1332  break;
1333 
1334  case UT_UNSIGNED_INT:
1335  uint_vec.resize(count*1); if (arr_int) arr_int->copyTo(&uint_vec[0]); else uint_vec[0] = (unsigned int)val->getInteger();
1336  uniform->setUniform1ui(count, &uint_vec[0]);
1337  break;
1338  case UT_UNSIGNED_INT_VEC2:
1339  uint_vec.resize(count*2); arr_int->copyTo(&uint_vec[0]); VLX_IMPORT_CHECK_RETURN(uint_vec.size() == arr_int->value().size(), *val);
1340  uniform->setUniform2ui(count, &uint_vec[0]);
1341  break;
1342  case UT_UNSIGNED_INT_VEC3:
1343  uint_vec.resize(count*3); arr_int->copyTo(&uint_vec[0]); VLX_IMPORT_CHECK_RETURN(uint_vec.size() == arr_int->value().size(), *val);
1344  uniform->setUniform3ui(count, &uint_vec[0]);
1345  break;
1346  case UT_UNSIGNED_INT_VEC4:
1347  uint_vec.resize(count*4); arr_int->copyTo(&uint_vec[0]); VLX_IMPORT_CHECK_RETURN(uint_vec.size() == arr_int->value().size(), *val);
1348  uniform->setUniform4ui(count, &uint_vec[0]);
1349  break;
1350 
1351  case UT_FLOAT:
1352  float_vec.resize(count*1); if (arr_real) arr_real->copyTo(&float_vec[0]); else float_vec[0] = (float)val->getReal();
1353  uniform->setUniform1f(count, &float_vec[0]);
1354  break;
1355  case UT_FLOAT_VEC2:
1356  float_vec.resize(count*2); arr_real->copyTo(&float_vec[0]); VLX_IMPORT_CHECK_RETURN(float_vec.size() == arr_real->value().size(), *val);
1357  uniform->setUniform2f(count, &float_vec[0]);
1358  break;
1359  case UT_FLOAT_VEC3:
1360  float_vec.resize(count*3); arr_real->copyTo(&float_vec[0]); VLX_IMPORT_CHECK_RETURN(float_vec.size() == arr_real->value().size(), *val);
1361  uniform->setUniform3f(count, &float_vec[0]);
1362  break;
1363  case UT_FLOAT_VEC4:
1364  float_vec.resize(count*4); arr_real->copyTo(&float_vec[0]); VLX_IMPORT_CHECK_RETURN(float_vec.size() == arr_real->value().size(), *val);
1365  uniform->setUniform4f(count, &float_vec[0]);
1366  break;
1367 
1368  case UT_FLOAT_MAT2:
1369  float_vec.resize(count*2*2); arr_real->copyTo(&float_vec[0]); VLX_IMPORT_CHECK_RETURN(float_vec.size() == arr_real->value().size(), *val);
1370  uniform->setUniformMatrix2f(count, &float_vec[0]);
1371  break;
1372  case UT_FLOAT_MAT3:
1373  float_vec.resize(count*3*3); arr_real->copyTo(&float_vec[0]); VLX_IMPORT_CHECK_RETURN(float_vec.size() == arr_real->value().size(), *val);
1374  uniform->setUniformMatrix3f(count, &float_vec[0]);
1375  break;
1376  case UT_FLOAT_MAT4:
1377  float_vec.resize(count*4*4); arr_real->copyTo(&float_vec[0]); VLX_IMPORT_CHECK_RETURN(float_vec.size() == arr_real->value().size(), *val);
1378  uniform->setUniformMatrix4f(count, &float_vec[0]);
1379  break;
1380 
1381  case UT_FLOAT_MAT2x3:
1382  float_vec.resize(count*2*3); arr_real->copyTo(&float_vec[0]); VLX_IMPORT_CHECK_RETURN(float_vec.size() == arr_real->value().size(), *val);
1383  uniform->setUniformMatrix2x3f(count, &float_vec[0]);
1384  break;
1385  case UT_FLOAT_MAT3x2:
1386  float_vec.resize(count*3*2); arr_real->copyTo(&float_vec[0]); VLX_IMPORT_CHECK_RETURN(float_vec.size() == arr_real->value().size(), *val);
1387  uniform->setUniformMatrix3x2f(count, &float_vec[0]);
1388  break;
1389  case UT_FLOAT_MAT2x4:
1390  float_vec.resize(count*2*4); arr_real->copyTo(&float_vec[0]); VLX_IMPORT_CHECK_RETURN(float_vec.size() == arr_real->value().size(), *val);
1391  uniform->setUniformMatrix2x4f(count, &float_vec[0]);
1392  break;
1393  case UT_FLOAT_MAT4x2:
1394  float_vec.resize(count*4*2); arr_real->copyTo(&float_vec[0]); VLX_IMPORT_CHECK_RETURN(float_vec.size() == arr_real->value().size(), *val);
1395  uniform->setUniformMatrix4x2f(count, &float_vec[0]);
1396  break;
1397  case UT_FLOAT_MAT3x4:
1398  float_vec.resize(count*3*4); arr_real->copyTo(&float_vec[0]); VLX_IMPORT_CHECK_RETURN(float_vec.size() == arr_real->value().size(), *val);
1399  uniform->setUniformMatrix3x4f(count, &float_vec[0]);
1400  break;
1401  case UT_FLOAT_MAT4x3:
1402  float_vec.resize(count*4*3); arr_real->copyTo(&float_vec[0]); VLX_IMPORT_CHECK_RETURN(float_vec.size() == arr_real->value().size(), *val);
1403  uniform->setUniformMatrix4x3f(count, &float_vec[0]);
1404  break;
1405 
1406  case UT_DOUBLE:
1407  double_vec.resize(count*1); if (arr_real) arr_real->copyTo(&double_vec[0]); else double_vec[0] = (double)val->getReal();
1408  uniform->setUniform1d(count, &double_vec[0]);
1409  break;
1410  case UT_DOUBLE_VEC2:
1411  double_vec.resize(count*2); arr_real->copyTo(&double_vec[0]); VLX_IMPORT_CHECK_RETURN(double_vec.size() == arr_real->value().size(), *val);
1412  uniform->setUniform2d(count, &double_vec[0]);
1413  break;
1414  case UT_DOUBLE_VEC3:
1415  double_vec.resize(count*3); arr_real->copyTo(&double_vec[0]); VLX_IMPORT_CHECK_RETURN(double_vec.size() == arr_real->value().size(), *val);
1416  uniform->setUniform3d(count, &double_vec[0]);
1417  break;
1418  case UT_DOUBLE_VEC4:
1419  double_vec.resize(count*4); arr_real->copyTo(&double_vec[0]); VLX_IMPORT_CHECK_RETURN(double_vec.size() == arr_real->value().size(), *val);
1420  uniform->setUniform4d(count, &double_vec[0]);
1421  break;
1422 
1423  case UT_DOUBLE_MAT2:
1424  double_vec.resize(count*2*2); arr_real->copyTo(&double_vec[0]); VLX_IMPORT_CHECK_RETURN(double_vec.size() == arr_real->value().size(), *val);
1425  uniform->setUniformMatrix2d(count, &double_vec[0]);
1426  break;
1427  case UT_DOUBLE_MAT3:
1428  double_vec.resize(count*3*3); arr_real->copyTo(&double_vec[0]); VLX_IMPORT_CHECK_RETURN(double_vec.size() == arr_real->value().size(), *val);
1429  uniform->setUniformMatrix3d(count, &double_vec[0]);
1430  break;
1431  case UT_DOUBLE_MAT4:
1432  double_vec.resize(count*4*4); arr_real->copyTo(&double_vec[0]); VLX_IMPORT_CHECK_RETURN(double_vec.size() == arr_real->value().size(), *val);
1433  uniform->setUniformMatrix4d(count, &double_vec[0]);
1434  break;
1435 
1436  case UT_DOUBLE_MAT2x3:
1437  double_vec.resize(count*2*3); arr_real->copyTo(&double_vec[0]); VLX_IMPORT_CHECK_RETURN(double_vec.size() == arr_real->value().size(), *val);
1438  uniform->setUniformMatrix2x3d(count, &double_vec[0]);
1439  break;
1440  case UT_DOUBLE_MAT3x2:
1441  double_vec.resize(count*3*2); arr_real->copyTo(&double_vec[0]); VLX_IMPORT_CHECK_RETURN(double_vec.size() == arr_real->value().size(), *val);
1442  uniform->setUniformMatrix3x2d(count, &double_vec[0]);
1443  break;
1444  case UT_DOUBLE_MAT2x4:
1445  double_vec.resize(count*2*4); arr_real->copyTo(&double_vec[0]); VLX_IMPORT_CHECK_RETURN(double_vec.size() == arr_real->value().size(), *val);
1446  uniform->setUniformMatrix2x4d(count, &double_vec[0]);
1447  break;
1448  case UT_DOUBLE_MAT4x2:
1449  double_vec.resize(count*4*2); arr_real->copyTo(&double_vec[0]); VLX_IMPORT_CHECK_RETURN(double_vec.size() == arr_real->value().size(), *val);
1450  uniform->setUniformMatrix4x2d(count, &double_vec[0]);
1451  break;
1452  case UT_DOUBLE_MAT3x4:
1453  double_vec.resize(count*3*4); arr_real->copyTo(&double_vec[0]); VLX_IMPORT_CHECK_RETURN(double_vec.size() == arr_real->value().size(), *val);
1454  uniform->setUniformMatrix3x4d(count, &double_vec[0]);
1455  break;
1456  case UT_DOUBLE_MAT4x3:
1457  double_vec.resize(count*4*3); arr_real->copyTo(&double_vec[0]); VLX_IMPORT_CHECK_RETURN(double_vec.size() == arr_real->value().size(), *val);
1458  uniform->setUniformMatrix4x3d(count, &double_vec[0]);
1459  break;
1460 
1461  case UT_NONE:
1462  Log::error( Say("Error importing uniform : uninitialized uniform (%s).\n") << uniform->name() );
1463  break;
1464 
1465  default:
1466  Log::error( Say("Error importing uniform : illegal uniform type (%s).\n") << uniform->name() );
1467  break;
1468  }
1469 
1470  }
1471 
1473  {
1474  ref<Uniform> obj = new Uniform;
1475  // register imported structure asap
1476  s.registerImportedStructure(vlx, obj.get());
1477  importUniform(s, vlx, obj.get());
1478  return obj;
1479  }
1480 
1481  void exportUniform(const Uniform* uniform, VLXStructure* vlx)
1482  {
1483  *vlx << "Name" << vlx_String(uniform->name());
1484  *vlx << "Type" << vlx_Identifier(vlx_EUniformType(uniform->type()));
1485  *vlx << "Count" << (long long)uniform->count();
1486 
1487  const int count = uniform->count();
1488  ref<VLXArrayInteger> arr_int = new VLXArrayInteger;
1489  ref<VLXArrayReal> arr_real = new VLXArrayReal;
1490 
1491  switch(uniform->type())
1492  {
1493  case UT_INT:
1494  {
1495  if (count == 1)
1496  { int val = 0; uniform->getUniform(&val); *vlx << "Data" << (long long)val; break; }
1497  else
1498  { arr_int->value().resize(count*1); arr_int->copyFrom( (int*)uniform->rawData() ); break; }
1499  }
1500  case UT_INT_VEC2: arr_int->value().resize(count*2); arr_int->copyFrom( (int*)uniform->rawData() ); break;
1501  case UT_INT_VEC3: arr_int->value().resize(count*3); arr_int->copyFrom( (int*)uniform->rawData() ); break;
1502  case UT_INT_VEC4: arr_int->value().resize(count*4); arr_int->copyFrom( (int*)uniform->rawData() ); break;
1503 
1504  case UT_UNSIGNED_INT:
1505  {
1506  if (count == 1)
1507  { unsigned int val = 0; uniform->getUniform(&val); *vlx << "Data" << (long long)val; break; }
1508  else
1509  { arr_int->value().resize(count*1); arr_int->copyFrom( (int*)uniform->rawData() ); break; }
1510  }
1511  case UT_UNSIGNED_INT_VEC2: arr_int->value().resize(count*2); arr_int->copyFrom( (int*)uniform->rawData() ); break;
1512  case UT_UNSIGNED_INT_VEC3: arr_int->value().resize(count*3); arr_int->copyFrom( (int*)uniform->rawData() ); break;
1513  case UT_UNSIGNED_INT_VEC4: arr_int->value().resize(count*4); arr_int->copyFrom( (int*)uniform->rawData() ); break;
1514 
1515  case UT_FLOAT:
1516  {
1517  if (count == 1)
1518  { float val = 0; uniform->getUniform(&val); *vlx << "Data" << (double)val; break; }
1519  else
1520  { arr_real->value().resize(count*1); arr_real->copyFrom( (float*)uniform->rawData() ); break; }
1521  }
1522  case UT_FLOAT_VEC2: arr_real->value().resize(count*2); arr_real->copyFrom( (float*)uniform->rawData() ); break;
1523  case UT_FLOAT_VEC3: arr_real->value().resize(count*3); arr_real->copyFrom( (float*)uniform->rawData() ); break;
1524  case UT_FLOAT_VEC4: arr_real->value().resize(count*4); arr_real->copyFrom( (float*)uniform->rawData() ); break;
1525 
1526  case UT_FLOAT_MAT2: arr_real->value().resize(count*2*2); arr_real->copyFrom( (float*)uniform->rawData() ); break;
1527  case UT_FLOAT_MAT3: arr_real->value().resize(count*3*3); arr_real->copyFrom( (float*)uniform->rawData() ); break;
1528  case UT_FLOAT_MAT4: arr_real->value().resize(count*4*4); arr_real->copyFrom( (float*)uniform->rawData() ); break;
1529 
1530  case UT_FLOAT_MAT2x3: arr_real->value().resize(count*2*3); arr_real->copyFrom( (float*)uniform->rawData() ); break;
1531  case UT_FLOAT_MAT3x2: arr_real->value().resize(count*3*2); arr_real->copyFrom( (float*)uniform->rawData() ); break;
1532  case UT_FLOAT_MAT2x4: arr_real->value().resize(count*2*4); arr_real->copyFrom( (float*)uniform->rawData() ); break;
1533  case UT_FLOAT_MAT4x2: arr_real->value().resize(count*4*2); arr_real->copyFrom( (float*)uniform->rawData() ); break;
1534  case UT_FLOAT_MAT3x4: arr_real->value().resize(count*3*4); arr_real->copyFrom( (float*)uniform->rawData() ); break;
1535  case UT_FLOAT_MAT4x3: arr_real->value().resize(count*4*3); arr_real->copyFrom( (float*)uniform->rawData() ); break;
1536 
1537  case UT_DOUBLE:
1538  {
1539  if (count == 1)
1540  { double val = 0; uniform->getUniform(&val); *vlx << "Data" << (double)val; break; }
1541  else
1542  { arr_real->value().resize(count*1); arr_real->copyFrom( (double*)uniform->rawData() ); break; }
1543  }
1544  case UT_DOUBLE_VEC2: arr_real->value().resize(count*2); arr_real->copyFrom( (double*)uniform->rawData() ); break;
1545  case UT_DOUBLE_VEC3: arr_real->value().resize(count*3); arr_real->copyFrom( (double*)uniform->rawData() ); break;
1546  case UT_DOUBLE_VEC4: arr_real->value().resize(count*4); arr_real->copyFrom( (double*)uniform->rawData() ); break;
1547 
1548  case UT_DOUBLE_MAT2: arr_real->value().resize(count*2*2); arr_real->copyFrom( (double*)uniform->rawData() ); break;
1549  case UT_DOUBLE_MAT3: arr_real->value().resize(count*3*3); arr_real->copyFrom( (double*)uniform->rawData() ); break;
1550  case UT_DOUBLE_MAT4: arr_real->value().resize(count*4*4); arr_real->copyFrom( (double*)uniform->rawData() ); break;
1551 
1552  case UT_DOUBLE_MAT2x3: arr_real->value().resize(count*2*3); arr_real->copyFrom( (double*)uniform->rawData() ); break;
1553  case UT_DOUBLE_MAT3x2: arr_real->value().resize(count*3*2); arr_real->copyFrom( (double*)uniform->rawData() ); break;
1554  case UT_DOUBLE_MAT2x4: arr_real->value().resize(count*2*4); arr_real->copyFrom( (double*)uniform->rawData() ); break;
1555  case UT_DOUBLE_MAT4x2: arr_real->value().resize(count*4*2); arr_real->copyFrom( (double*)uniform->rawData() ); break;
1556  case UT_DOUBLE_MAT3x4: arr_real->value().resize(count*3*4); arr_real->copyFrom( (double*)uniform->rawData() ); break;
1557  case UT_DOUBLE_MAT4x3: arr_real->value().resize(count*4*3); arr_real->copyFrom( (double*)uniform->rawData() ); break;
1558 
1559  case UT_NONE:
1560  Log::error( Say("Error exporting uniform : uninitialized uniform (%s).\n") << uniform->name() );
1561  break;
1562 
1563  default:
1564  Log::error( Say("Error exporting uniform : illegal uniform type (%s).\n") << uniform->name() );
1565  break;
1566  }
1567 
1568  if (!arr_int->value().empty())
1569  *vlx << "Data" << arr_int.get();
1570  else
1571  if (!arr_real->value().empty())
1572  *vlx << "Data" << arr_real.get();
1573  }
1574 
1576  {
1577  const Uniform* cast_obj = obj->as<Uniform>(); VL_CHECK(cast_obj)
1578  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("uniform_"));
1579  // register exported object asap
1580  s.registerExportedObject(obj, vlx.get());
1581  exportUniform(cast_obj, vlx.get());
1582  return vlx;
1583  }
1584  };
1585 
1586  //---------------------------------------------------------------------------
1587 
1590  {
1591  void importShader(VLXSerializer& s, const VLXStructure* vlx, Shader* sh)
1592  {
1593  const VLXValue* name = vlx->getValue("ObjectName");
1594  if (name)
1595  sh->setObjectName( name->getString() );
1596 
1597  // enables
1598  const VLXValue* enables = vlx->getValue("Enables");
1599  if (enables)
1600  {
1601  VLX_IMPORT_CHECK_RETURN( enables->type() == VLXValue::List, *enables )
1602  const VLXList* list = enables->getList();
1603  for(size_t i=0; i<list->value().size(); ++i)
1604  {
1605  VLX_IMPORT_CHECK_RETURN( list->value()[i].type() == VLXValue::Identifier, list->value()[i] );
1606  EEnable en = vlx_EEnable( list->value()[i], s );
1607  VLX_IMPORT_CHECK_RETURN( en != EN_UnknownEnable, list->value()[i] );
1608  sh->enable(en);
1609  }
1610  }
1611 
1612  // render states
1613  const VLXValue* renderstates = vlx->getValue("RenderStates");
1614  if (renderstates)
1615  {
1616  VLX_IMPORT_CHECK_RETURN( renderstates->type() == VLXValue::List, *renderstates )
1617  const VLXList* list = renderstates->getList();
1618  int index = -1;
1619  for(size_t i=0; i<list->value().size(); ++i)
1620  {
1621  VLX_IMPORT_CHECK_RETURN( list->value()[i].type() == VLXValue::Structure || list->value()[i].type() == VLXValue::Integer, list->value()[i] );
1622  if (list->value()[i].type() == VLXValue::Integer)
1623  {
1624  VLX_IMPORT_CHECK_RETURN( index == -1, list->value()[i] );
1625  index = (int)list->value()[i].getInteger();
1626  }
1627  else
1628  {
1629  RenderState* renderstate = s.importVLX( list->value()[i].getStructure() )->as<RenderState>();
1630  VLX_IMPORT_CHECK_RETURN( renderstate != NULL, list->value()[i] )
1631  VLX_IMPORT_CHECK_RETURN( (index == -1 && !renderstate->isOfType(RenderStateIndexed::Type())) || (index >= 0 && renderstate->isOfType(RenderStateIndexed::Type())), list->value()[i] )
1632  sh->setRenderState(renderstate, index);
1633  // consume index in any case
1634  index = -1;
1635  }
1636  }
1637  }
1638 
1639  // uniforms
1640  const VLXValue* uniforms = vlx->getValue("Uniforms");
1641  if (uniforms)
1642  {
1643  VLX_IMPORT_CHECK_RETURN( uniforms->type() == VLXValue::List, *uniforms )
1644  const VLXList* list = uniforms->getList();
1645  for(size_t i=0; i<list->value().size(); ++i)
1646  {
1647  VLX_IMPORT_CHECK_RETURN( list->value()[i].type() == VLXValue::Structure, list->value()[i] );
1648  Uniform* uniform = s.importVLX( list->value()[i].getStructure() )->as<Uniform>();
1649  VLX_IMPORT_CHECK_RETURN( uniform != NULL, list->value()[i] )
1650  sh->setUniform(uniform);
1651  }
1652  }
1653  }
1654 
1656  {
1657  ref<Shader> obj = new Shader;
1658  // register imported structure asap
1659  s.registerImportedStructure(vlx, obj.get());
1660  importShader(s, vlx, obj.get());
1661  return obj;
1662  }
1663 
1664  void exportShader(VLXSerializer& s, const Shader* obj, VLXStructure* vlx)
1665  {
1666  if (!obj->objectName().empty() && obj->objectName() != obj->className())
1667  *vlx << "ObjectName" << vlx_String(obj->objectName());
1668 
1669  // uniforms
1670  VLXValue uniforms;
1671  uniforms.setList( new VLXList );
1672  if (obj->getUniformSet())
1673  {
1674  for(size_t i=0; i<obj->uniforms().size(); ++i)
1675  *uniforms.getList() << s.exportVLX(obj->uniforms()[i].get());
1676  }
1677  *vlx << "Uniforms" << uniforms;
1678 
1679  // enables
1680  ref<VLXList> enables = new VLXList;
1681  if (obj->getEnableSet() )
1682  {
1683  for(size_t i=0; i<obj->getEnableSet()->enables().size(); ++i)
1684  *enables << vlx_Identifier(vlx_EEnable(obj->getEnableSet()->enables()[i]));
1685  }
1686  *vlx << "Enables" << enables.get();
1687 
1688  // renderstates
1689  VLXValue renderstates;
1690  renderstates.setList( new VLXList );
1691  if (obj->getRenderStateSet())
1692  {
1693  for(size_t i=0; i<obj->getRenderStateSet()->renderStatesCount(); ++i)
1694  {
1695  const RenderState* rs = obj->getRenderStateSet()->renderStates()[i].mRS.get();
1696  if ( !s.canExport(rs) )
1697  {
1698  Log::debug( Say("VLXClassWrapper_Shader : skipping '%s'.\n") << rs->className() );
1699  continue;
1700  }
1701  int index = obj->getRenderStateSet()->renderStates()[i].mIndex;
1702  if (index != -1)
1703  *renderstates.getList() << (long long)index;
1704  *renderstates.getList() << s.exportVLX(rs);
1705  }
1706  }
1707  *vlx << "RenderStates" << renderstates;
1708  }
1709 
1711  {
1712  const Shader* cast_obj = obj->as<Shader>(); VL_CHECK(cast_obj)
1713  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("shader_"));
1714  // register exported object asap
1715  s.registerExportedObject(obj, vlx.get());
1716  exportShader(s, cast_obj, vlx.get());
1717  return vlx;
1718  }
1719  };
1720 
1721  //---------------------------------------------------------------------------
1722 
1725  {
1727  {
1728  if (obj->isOfType(DistanceLODEvaluator::Type()))
1729  {
1731  const VLXValue* vlx_distances = vlx->getValue("DistanceRageSet");
1732  VLX_IMPORT_CHECK_RETURN( vlx_distances != NULL, *vlx );
1733  VLX_IMPORT_CHECK_RETURN( vlx_distances->type() == VLXValue::ArrayReal, *vlx_distances );
1734  const VLXArrayReal* arr = vlx_distances->getArrayReal();
1735  if (arr->value().size())
1736  {
1737  lod->distanceRangeSet().resize( arr->value().size() );
1738  arr->copyTo( &lod->distanceRangeSet()[0] );
1739  }
1740  }
1741  else
1742  if (obj->isOfType(PixelLODEvaluator::Type()))
1743  {
1744  PixelLODEvaluator* lod = obj->as<PixelLODEvaluator>();
1745  const VLXValue* vlx_pixels = vlx->getValue("PixelRageSet");
1746  VLX_IMPORT_CHECK_RETURN( vlx_pixels != NULL, *vlx );
1747  VLX_IMPORT_CHECK_RETURN( vlx_pixels->type() == VLXValue::ArrayReal, *vlx_pixels );
1748  const VLXArrayReal* arr = vlx_pixels->getArrayReal();
1749  if (arr->value().size())
1750  {
1751  lod->pixelRangeSet().resize( arr->value().size() );
1752  arr->copyTo( &lod->pixelRangeSet()[0] );
1753  }
1754  }
1755  }
1756 
1758  {
1759  if (vlx->tag() == "<vl::DistanceLODEvaluator>")
1760  {
1762  // register imported structure asap
1763  s.registerImportedStructure(vlx, obj.get());
1764  importLODEvaluator(s, vlx, obj.get());
1765  return obj;
1766  }
1767  else
1768  if (vlx->tag() == "<vl::PixelLODEvaluator>")
1769  {
1771  // register imported structure asap
1772  s.registerImportedStructure(vlx, obj.get());
1773  importLODEvaluator(s, vlx, obj.get());
1774  return obj;
1775  }
1776  else
1777  {
1778  return NULL;
1779  }
1780  }
1781 
1783  {
1784  if (obj->classType() == DistanceLODEvaluator::Type())
1785  {
1786  const DistanceLODEvaluator* lod = obj->as<DistanceLODEvaluator>();
1787  VLXValue distances( new VLXArrayReal );
1788  distances.getArrayReal()->value().resize( lod->distanceRangeSet().size() );
1789  if (lod->distanceRangeSet().size() != 0)
1790  distances.getArrayReal()->copyFrom( &lod->distanceRangeSet()[0] );
1791  *vlx << "DistanceRageSet" << distances;
1792  }
1793  else
1794  if (obj->classType() == PixelLODEvaluator::Type())
1795  {
1796  const PixelLODEvaluator* lod = obj->as<PixelLODEvaluator>();
1797  VLXValue pixels( new VLXArrayReal );
1798  pixels.getArrayReal()->value().resize( lod->pixelRangeSet().size() );
1799  if (lod->pixelRangeSet().size() != 0)
1800  pixels.getArrayReal()->copyFrom( &lod->pixelRangeSet()[0] );
1801  *vlx << "PixelRageSet" << pixels;
1802  }
1803  else
1804  {
1805  s.signalExportError("LODEvaluator type not supported for export.\n");
1806  }
1807  }
1808 
1810  {
1811  const LODEvaluator* cast_obj = obj->as<LODEvaluator>(); VL_CHECK(cast_obj)
1812  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("lodeval_"));
1813  // register exported object asap
1814  s.registerExportedObject(obj, vlx.get());
1815  exportLODEvaluator(s, cast_obj, vlx.get());
1816  return vlx;
1817  }
1818  };
1819 
1820  //---------------------------------------------------------------------------
1821 
1824  {
1825  void importEffect(VLXSerializer& s, const VLXStructure* vlx, Effect* obj)
1826  {
1827  const VLXValue* name = vlx->getValue("ObjectName");
1828  if (name)
1829  obj->setObjectName( name->getString() );
1830 
1831  const std::vector<VLXStructure::Value>& values = vlx->value();
1832  for(size_t i=0; i<values.size(); ++i)
1833  {
1834  const std::string& key = values[i].key();
1835  const VLXValue& value = values[i].value();
1836  if (key == "RenderRank")
1837  {
1838  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer, value )
1839  obj->setRenderRank( (int)value.getInteger() );
1840  }
1841  else
1842  if (key == "EnableMask")
1843  {
1844  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer, value )
1845  obj->setEnableMask( (int)value.getInteger() );
1846  }
1847  else
1848  if (key == "ActiveLod")
1849  {
1850  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer, value )
1851  obj->setActiveLod( (int)value.getInteger() );
1852  }
1853  else
1854  if (key == "LODEvaluator")
1855  {
1856  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Structure, value )
1857  LODEvaluator* lod_eval = s.importVLX( value.getStructure() )->as<LODEvaluator>();
1858  VLX_IMPORT_CHECK_RETURN( lod_eval, value )
1859  obj->setLODEvaluator(lod_eval);
1860  }
1861  else
1862  if (key == "Lods")
1863  {
1864  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::List, value )
1865  const VLXList* lod_list = value.getList();
1866  for(size_t ilod=0; ilod< lod_list->value().size(); ++ilod)
1867  {
1868  const VLXValue& lod_shaders = lod_list->value()[ilod];
1869  VLX_IMPORT_CHECK_RETURN( lod_shaders.type() == VLXValue::List, lod_shaders )
1870  obj->lod(ilod) = new ShaderPasses;
1871  for( size_t ish=0; ish<lod_shaders.getList()->value().size(); ++ish)
1872  {
1873  const VLXValue& vlx_sh = lod_shaders.getList()->value()[ish];
1874  VLX_IMPORT_CHECK_RETURN( vlx_sh.type() == VLXValue::Structure, vlx_sh )
1875  Shader* shader = s.importVLX( vlx_sh.getStructure() )->as<Shader>();
1876  VLX_IMPORT_CHECK_RETURN( shader, vlx_sh )
1877  obj->lod(ilod)->push_back( shader );
1878  }
1879  }
1880  }
1881  }
1882  }
1883 
1885  {
1886  ref<Effect> obj = new Effect;
1887  // register imported structure asap
1888  s.registerImportedStructure(vlx, obj.get());
1889  importEffect(s, vlx, obj.get());
1890  return obj;
1891  }
1892 
1894  {
1895  VLXValue value( new VLXList(vlx_makeTag(sh_seq).c_str()) );
1896  for(int i=0; i<sh_seq->size(); ++i)
1897  *value.getList() << s.exportVLX(sh_seq->at(i));
1898  return value;
1899  }
1900 
1901  void exportEffect(VLXSerializer& s, const Effect* obj, VLXStructure* vlx)
1902  {
1903  if (!obj->objectName().empty() && obj->objectName() != obj->className())
1904  *vlx << "ObjectName" << vlx_String(obj->objectName());
1905  *vlx << "RenderRank" << (long long)obj->renderRank();
1906  *vlx << "EnableMask" << (long long)obj->enableMask();
1907  *vlx << "ActiveLod" << (long long)obj->activeLod();
1908 
1909  if (obj->lodEvaluator())
1910  *vlx << "LODEvaluator" << s.exportVLX(obj->lodEvaluator());
1911 
1912  // shaders
1913  ref<VLXList> lod_list = new VLXList;
1914  for(int i=0; obj->lod(i) && i<VL_MAX_EFFECT_LOD; ++i)
1915  *lod_list << export_ShaderPasses(s, obj->lod(i).get());
1916  *vlx << "Lods" << lod_list.get();
1917  }
1918 
1920  {
1921  const Effect* cast_obj = obj->as<Effect>(); VL_CHECK(cast_obj)
1922  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("effect_"));
1923  // register exported object asap
1924  s.registerExportedObject(obj, vlx.get());
1925  exportEffect(s, cast_obj, vlx.get());
1926  return vlx;
1927  }
1928  };
1929 
1930  //---------------------------------------------------------------------------
1931 
1934  {
1935  void importActor(VLXSerializer& s, const VLXStructure* vlx, Actor* obj)
1936  {
1937  const VLXValue* name = vlx->getValue("ObjectName");
1938  if (name)
1939  obj->setObjectName( name->getString() );
1940 
1941  const std::vector<VLXStructure::Value>& values = vlx->value();
1942  for(size_t i=0; i<values.size(); ++i)
1943  {
1944  const std::string& key = values[i].key();
1945  const VLXValue& value = values[i].value();
1946  if (key == "RenderRank")
1947  {
1948  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer, value )
1949  obj->setRenderRank( (int)value.getInteger() );
1950  }
1951  else
1952  if (key == "RenderBlock")
1953  {
1954  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer, value )
1955  obj->setRenderBlock( (int)value.getInteger() );
1956  }
1957  else
1958  if (key == "EnableMask")
1959  {
1960  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer, value )
1961  obj->setEnableMask( (int)value.getInteger() );
1962  }
1963  else
1964  if (key == "IsOccludee")
1965  {
1966  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Bool, value )
1967  obj->setOccludee( value.getBool() );
1968  }
1969  else
1970  if (key == "Enabled")
1971  {
1972  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Bool, value )
1973  obj->setEnabled( value.getBool() );
1974  }
1975  else
1976  if (key == "Lods")
1977  {
1978  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::List, value )
1979  const VLXList* list = value.getList();
1980  for(size_t i=0; i<list->value().size(); ++i)
1981  {
1982  const VLXValue& lod = list->value()[i];
1984  Renderable* rend = s.importVLX( lod.getStructure() )->as<Renderable>();
1985  VLX_IMPORT_CHECK_RETURN( rend != NULL, lod )
1986  obj->setLod(i, rend);
1987  }
1988  }
1989  else
1990  if (key == "Effect")
1991  {
1992  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Structure, value )
1993  Effect* fx = s.importVLX(value.getStructure())->as<Effect>();
1994  VLX_IMPORT_CHECK_RETURN( fx != NULL, value )
1995  obj->setEffect(fx);
1996  }
1997  else
1998  if (key == "Transform")
1999  {
2000  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Structure, value )
2001  Transform* tr = s.importVLX(value.getStructure())->as<Transform>();
2002  VLX_IMPORT_CHECK_RETURN( tr != NULL, value )
2003  obj->setTransform(tr);
2004  }
2005  else
2006  if (key == "Uniforms")
2007  {
2008  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::List, value )
2009  const VLXList* list = value.getList();
2010  for(size_t i=0; i<list->value().size(); ++i)
2011  {
2012  VLX_IMPORT_CHECK_RETURN( list->value()[i].type() == VLXValue::Structure, list->value()[i] )
2013  Uniform* uniform = s.importVLX( list->value()[i].getStructure() )->as<Uniform>();
2014  VLX_IMPORT_CHECK_RETURN( uniform != NULL, list->value()[i] )
2015  obj->setUniform(uniform);
2016  }
2017  }
2018  // bounding volumes are not serialized, they are computed based on the geometry's bounds
2019  // else if (key == "AABB") {}
2020  // else if (key == "Sphere") {}
2021  else
2022  if (key == "LODEvaluator")
2023  {
2024  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Structure, value )
2025  if (s.canImport( value.getStructure() ) )
2026  {
2027  LODEvaluator* lod = s.importVLX( value.getStructure() )->as<LODEvaluator>();
2028  VLX_IMPORT_CHECK_RETURN( lod != NULL, value )
2029  obj->setLODEvaluator(lod);
2030  }
2031  }
2032  else
2033  if (key == "ActorEventCallbacks")
2034  {
2035  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::List, value )
2036  const VLXList* list = value.getList();
2037  for(size_t i=0; i<list->value().size(); ++i)
2038  {
2039  const VLXValue& elem = list->value()[i];
2041  if (s.canImport(elem.getStructure()))
2042  {
2043  ActorEventCallback* cb = s.importVLX( elem.getStructure() )->as<ActorEventCallback>();
2044  VLX_IMPORT_CHECK_RETURN( cb != NULL, elem )
2045  obj->actorEventCallbacks()->push_back(cb);
2046  }
2047  }
2048  }
2049  }
2050  }
2051 
2053  {
2054  ref<Actor> obj = new Actor;
2055  // register imported structure asap
2056  s.registerImportedStructure(vlx, obj.get());
2057  importActor(s, vlx, obj.get());
2058  return obj;
2059  }
2060 
2061  void exportActor(VLXSerializer& s, const Actor* obj, VLXStructure* vlx)
2062  {
2063  if (!obj->objectName().empty() && obj->objectName() != obj->className())
2064  *vlx << "ObjectName" << vlx_String(obj->objectName());
2065  *vlx << "EnableMask" << (long long)obj->enableMask();
2066  *vlx << "RenderBlock" << (long long)obj->renderBlock();
2067  *vlx << "RenderRank" << (long long)obj->renderRank();
2068  *vlx << "IsOccludee" << obj->isOccludee();
2069  *vlx << "Enabled" << obj->isEnabled();
2070 
2071  VLXValue renderables;
2072  renderables.setList( new VLXList );
2073  for(size_t i=0; i<VL_MAX_ACTOR_LOD && obj->lod(i); ++i)
2074  *renderables.getList() << s.exportVLX(obj->lod(i));
2075  *vlx << "Lods" << renderables;
2076 
2077  // bounding volumes are not serialized, they are computed based on the geometry's bounds
2078  // *vlx << "AABB" << export_AABB(obj->boundingBox());
2079  // *vlx << "Sphere" << export_Sphere(obj->boundingSphere());
2080 
2081  if (obj->effect())
2082  *vlx << "Effect" << s.exportVLX(obj->effect());
2083  if (obj->transform())
2084  *vlx << "Transform" << s.exportVLX(obj->transform());
2085 
2086  VLXValue uniforms;
2087  uniforms.setList( new VLXList );
2088  for(size_t i=0; obj->getUniformSet() && i<obj->uniforms().size(); ++i)
2089  *uniforms.getList() << s.exportVLX(obj->uniforms()[i].get());
2090  *vlx << "Uniforms" << uniforms;
2091 
2092  if (obj->lodEvaluator())
2093  *vlx << "LODEvaluator" << s.exportVLX(obj->lodEvaluator());
2094 
2095  // mic fixme:
2096  // Scissor: scissors might go away from the Actor
2097 
2098  VLXValue callbacks;
2099  callbacks.setList( new VLXList );
2100  for(int i=0; i<obj->actorEventCallbacks()->size(); ++i)
2101  *callbacks.getList() << s.exportVLX(obj->actorEventCallbacks()->at(i));
2102  *vlx << "ActorEventCallbacks" << callbacks;
2103  }
2104 
2106  {
2107  const Actor* cast_obj = obj->as<Actor>(); VL_CHECK(cast_obj)
2108  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("actor_"));
2109  // register exported object asap
2110  s.registerExportedObject(obj, vlx.get());
2111  exportActor(s, cast_obj, vlx.get());
2112  return vlx;
2113  }
2114  };
2115 
2116  //---------------------------------------------------------------------------
2117 
2120  {
2121  void importCamera(VLXSerializer& s, const VLXStructure* vlx, Camera* obj)
2122  {
2123  const VLXValue* name = vlx->getValue("ObjectName");
2124  if (name)
2125  obj->setObjectName( name->getString() );
2126 
2127  for(size_t i=0; i<vlx->value().size(); ++i)
2128  {
2129  const std::string& key = vlx->value()[i].key();
2130  const VLXValue& value = vlx->value()[i].value();
2131  if (key == "ViewMatrix")
2132  {
2133  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::List, value);
2134  obj->setViewMatrix( vlx_mat4(value.getList()) );
2135  // VLX_IMPORT_CHECK_RETURN( !obj->viewMatrix().isNull(), value )
2136  }
2137  else
2138  if (key == "ProjectionMatrix")
2139  {
2141  const VLXValue* pmtype = vlx->getValue("ProjectionMatrixType");
2142  if ( pmtype )
2143  {
2144  VLX_IMPORT_CHECK_RETURN( pmtype->type() == VLXValue::Identifier, *pmtype );
2145  ptype = vlx_EProjectionMatrixType( *pmtype, s );
2146  }
2147 
2148  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::List, value);
2149  obj->setProjectionMatrix( vlx_mat4(value.getList()), ptype );
2150  // VLX_IMPORT_CHECK_RETURN( !obj->projectionMatrix().isNull(), value )
2151  }
2152  else
2153  if (key == "Viewport")
2154  {
2156  Viewport* viewp = s.importVLX( value.getStructure() )->as<Viewport>();
2157  VLX_IMPORT_CHECK_RETURN( viewp != NULL, value )
2158  obj->setViewport(viewp);
2159  }
2160  else
2161  if (key == "FOV")
2162  {
2163  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Real, value )
2164  obj->setFOV( (float)value.getReal() );
2165  }
2166  else
2167  if (key == "NearPlane")
2168  {
2169  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Real, value )
2170  obj->setNearPlane( (float)value.getReal() );
2171  }
2172  else
2173  if (key == "FarPlane")
2174  {
2175  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Real, value )
2176  obj->setFarPlane( (float)value.getReal() );
2177  }
2178  else
2179  if (key == "Left")
2180  {
2181  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Real, value )
2182  obj->setLeft( (float)value.getReal() );
2183  }
2184  else
2185  if (key == "Right")
2186  {
2187  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Real, value )
2188  obj->setRight( (float)value.getReal() );
2189  }
2190  else
2191  if (key == "Bottom")
2192  {
2193  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Real, value )
2194  obj->setBottom( (float)value.getReal() );
2195  }
2196  else
2197  if (key == "Top")
2198  {
2199  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Real, value )
2200  obj->setTop( (float)value.getReal() );
2201  }
2202  else
2203  if (key == "BoundTransform")
2204  {
2206  Transform* tr= s.importVLX( value.getStructure() )->as<Transform>();
2207  VLX_IMPORT_CHECK_RETURN( tr != NULL, value )
2208  obj->bindTransform(tr);
2209  }
2210  }
2211  }
2212 
2214  {
2215  ref<Camera> obj = new Camera;
2216  // register imported structure asap
2217  s.registerImportedStructure(vlx, obj.get());
2218  importCamera(s, vlx, obj.get());
2219  return obj;
2220  }
2221 
2222  void exportCamera(VLXSerializer& s, const Camera* obj, VLXStructure* vlx)
2223  {
2224  if (!obj->objectName().empty() && obj->objectName() != obj->className())
2225  *vlx << "ObjectName" << vlx_String(obj->objectName());
2226  *vlx << "ViewMatrix" << vlx_toValue(obj->viewMatrix());
2227  *vlx << "ProjectionMatrix" << vlx_toValue(obj->projectionMatrix());
2228  *vlx << "ProjectionMatrixType" << vlx_Identifier(vlx_EProjectionMatrixType(obj->projectionMatrixType()));
2229  *vlx << "Viewport" << s.exportVLX(obj->viewport());
2230  *vlx << "NearPlane" << (double)obj->nearPlane();
2231  *vlx << "FarPlane" << (double)obj->farPlane();
2232  *vlx << "FOV" << (double)obj->fov();
2233  *vlx << "Left" << (double)obj->left();
2234  *vlx << "Right" << (double)obj->right();
2235  *vlx << "Bottom" << (double)obj->bottom();
2236  *vlx << "Top" << (double)obj->top();
2237  if (obj->boundTransform())
2238  *vlx << "BoundTransfrm" << s.exportVLX(obj->boundTransform());
2239  }
2240 
2242  {
2243  const Camera* cast_obj = obj->as<Camera>(); VL_CHECK(cast_obj)
2244  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("camera_"));
2245  // register exported object asap
2246  s.registerExportedObject(obj, vlx.get());
2247  exportCamera(s, cast_obj, vlx.get());
2248  return vlx;
2249  }
2250  };
2251 
2252 
2253  //---------------------------------------------------------------------------
2254 
2257  {
2259  {
2260  const VLXValue* name = vlx->getValue("ObjectName");
2261  if (name)
2262  obj->setObjectName( name->getString() );
2263 
2264  for(size_t i=0; i<vlx->value().size(); ++i)
2265  {
2266  const std::string& key = vlx->value()[i].key();
2267  const VLXValue& value = vlx->value()[i].value();
2268  if (key == "ClearColor")
2269  {
2270  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::ArrayReal, value );
2271  obj->setClearColor( (fvec4)vlx_vec4( value.getArrayReal() ) );
2272  }
2273  else
2274  if (key == "ClearColorInt")
2275  {
2277  obj->setClearColorInt( vlx_ivec4( value.getArrayInteger() ) );
2278  }
2279  else
2280  if (key == "ClearColorUInt")
2281  {
2283  obj->setClearColorUInt( vlx_uivec4( value.getArrayInteger() ) );
2284  }
2285  else
2286  if (key == "ClearDepth")
2287  {
2288  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Real, value );
2289  obj->setClearDepth( (float)value.getReal() );
2290  }
2291  else
2292  if (key == "ClearStecil")
2293  {
2294  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer, value );
2295  obj->setClearStencil( (int)value.getInteger() );
2296  }
2297  else
2298  if (key == "ClearColorMode")
2299  {
2300  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Identifier, value );
2301  obj->setClearColorMode( vlx_EClearColorMode( value, s) );
2302  }
2303  else
2304  if (key == "ClearFlags")
2305  {
2306  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Identifier, value );
2307  obj->setClearFlags( vlx_EClearFlags( value, s ) );
2308  }
2309  else
2310  if (key == "X")
2311  {
2312  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer, value );
2313  obj->setX( (int)value.getInteger() );
2314  }
2315  else
2316  if (key == "Y")
2317  {
2318  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer, value );
2319  obj->setY( (int)value.getInteger() );
2320  }
2321  else
2322  if (key == "Width")
2323  {
2324  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer, value );
2325  obj->setWidth( (int)value.getInteger() );
2326  }
2327  else
2328  if (key == "Height")
2329  {
2330  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer, value );
2331  obj->setHeight( (int)value.getInteger() );
2332  }
2333  }
2334  }
2335 
2337  {
2338  ref<Viewport> obj = new Viewport;
2339  // register imported structure asap
2340  s.registerImportedStructure(vlx, obj.get());
2341  importViewport(s, vlx, obj.get());
2342  return obj;
2343  }
2344 
2345  void exportViewport(const Viewport* obj, VLXStructure* vlx)
2346  {
2347  if (!obj->objectName().empty() && obj->objectName() != obj->className())
2348  *vlx << "ObjectName" << vlx_String(obj->objectName());
2349  *vlx << "ClearColor" << vlx_toValue((vec4)obj->clearColor());
2350  *vlx << "ClearColorInt" << vlx_toValue(obj->clearColorInt());
2351  *vlx << "ClearColorUInt" << vlx_toValue(obj->clearColorUInt());
2352  *vlx << "ClearDepth" << (double)obj->clearDepth();
2353  *vlx << "ClearStecil" << (long long)obj->clearStencil();
2354  *vlx << "ClearColorMode" << vlx_Identifier(vlx_EClearColorMode(obj->clearColorMode()));
2355  *vlx << "ClearFlags" << vlx_Identifier(vlx_EClearFlags(obj->clearFlags()));
2356  *vlx << "X" << (long long)obj->x();
2357  *vlx << "Y" << (long long)obj->y();
2358  *vlx << "Width" << (long long)obj->width();
2359  *vlx << "Height" << (long long)obj->height();
2360  }
2361 
2363  {
2364  const Viewport* cast_obj = obj->as<Viewport>(); VL_CHECK(cast_obj)
2365  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("viewport_"));
2366  // register exported object asap
2367  s.registerExportedObject(obj, vlx.get());
2368  exportViewport(cast_obj, vlx.get());
2369  return vlx;
2370  }
2371  };
2372 
2373  //---------------------------------------------------------------------------
2374 
2377  {
2379  {
2380  const VLXValue* name = vlx->getValue("ObjectName");
2381  if (name)
2382  obj->setObjectName( name->getString() );
2383 
2384  for(size_t i=0; i<vlx->value().size(); ++i)
2385  {
2386  const std::string& key = vlx->value()[i].key();
2387  const VLXValue& value = vlx->value()[i].value();
2388  if (key == "LocalMatrix")
2389  {
2390  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::List, value )
2391  obj->setLocalAndWorldMatrix( vlx_mat4( value.getList() ) );
2392  }
2393  else
2394  // let the "Children" property take care of children binding
2395  /*
2396  if (key == "Parent")
2397  {
2398  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Structure, value )
2399  Transform* tr = s.importVLX( value.getStructure() )->as<Transform>();
2400  VLX_IMPORT_CHECK_RETURN( tr != NULL, value )
2401  tr->addChild(obj);
2402  }
2403  else
2404  */
2405  if (key == "Children")
2406  {
2407  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::List, value )
2408  const VLXList* list = value.getList();
2409  for(size_t ich=0; ich<list->value().size(); ++ich)
2410  {
2411  VLX_IMPORT_CHECK_RETURN( list->value()[ich].type() == VLXValue::Structure, list->value()[ich] )
2412  const VLXStructure* vlx_tr = list->value()[ich].getStructure();
2413  Transform* child = s.importVLX( vlx_tr )->as<Transform>();
2414  VLX_IMPORT_CHECK_RETURN( child != NULL, *vlx_tr )
2415  obj->addChild(child);
2416  }
2417  }
2418  }
2419  }
2420 
2422  {
2423  ref<Transform> obj = new Transform;
2424  // register imported structure asap
2425  s.registerImportedStructure(vlx, obj.get());
2426  importTransform(s, vlx, obj.get());
2427  return obj;
2428  }
2429 
2431  {
2432  if (!obj->objectName().empty() && obj->objectName() != obj->className())
2433  *vlx << "ObjectName" << vlx_String(obj->objectName());
2434  *vlx << "LocalMatrix" << vlx_toValue(obj->localMatrix());
2435 
2436  // not needed
2437  /*if (obj->parent())
2438  *vlx << "Parent" << s.exportVLX(obj->parent());*/
2439 
2440  VLXValue childs;
2441  childs.setList( new VLXList );
2442  for(size_t i=0; i<obj->childrenCount(); ++i)
2443  childs.getList()->value().push_back( s.exportVLX(obj->children()[i].get()) );
2444  *vlx << "Children" << childs;
2445  }
2446 
2448  {
2449  const Transform* cast_obj = obj->as<Transform>(); VL_CHECK(cast_obj)
2450  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("transform_"));
2451  // register exported object asap
2452  s.registerExportedObject(obj, vlx.get());
2453  exportTransform(s, cast_obj, vlx.get());
2454  return vlx;
2455  }
2456  };
2457 
2458  //---------------------------------------------------------------------------
2459 
2462  {
2463  void importLight(VLXSerializer& s, const VLXStructure* vlx, Light* obj)
2464  {
2465  const VLXValue* name = vlx->getValue("ObjectName");
2466  if (name)
2467  obj->setObjectName( name->getString() );
2468 
2469  for(size_t i=0; i<vlx->value().size(); ++i)
2470  {
2471  const std::string& key = vlx->value()[i].key();
2472  const VLXValue& value = vlx->value()[i].value();
2473  if (key == "Ambient")
2474  {
2475  // note: what if the user specifies ( 1 0 0 0 ) -> becomes a ArrayInteger and an error is issued.
2476  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::ArrayReal, value )
2477  obj->setAmbient( (fvec4)vlx_vec4( value.getArrayReal() ) );
2478  }
2479  else
2480  if (key == "Diffuse")
2481  {
2482  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::ArrayReal, value )
2483  obj->setDiffuse( (fvec4)vlx_vec4( value.getArrayReal() ) );
2484  }
2485  else
2486  if (key == "Specular")
2487  {
2488  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::ArrayReal, value )
2489  obj->setSpecular( (fvec4)vlx_vec4( value.getArrayReal() ) );
2490  }
2491  else
2492  if (key == "Position")
2493  {
2494  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::ArrayReal, value )
2495  obj->setPosition( (fvec4)vlx_vec4( value.getArrayReal() ) );
2496  }
2497  else
2498  if (key == "SpotDirection")
2499  {
2500  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::ArrayReal, value )
2501  obj->setSpotDirection( (fvec3)vlx_vec3( value.getArrayReal() ) );
2502  }
2503  else
2504  if (key == "SpotExponent")
2505  {
2506  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Real, value )
2507  obj->setSpotExponent( (float)value.getReal() );
2508  }
2509  else
2510  if (key == "SpotCutoff")
2511  {
2512  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Real, value )
2513  obj->setSpotCutoff( (float)value.getReal() );
2514  }
2515  else
2516  if (key == "ConstantAttenuation")
2517  {
2518  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Real, value )
2519  obj->setConstantAttenuation( (float)value.getReal() );
2520  }
2521  else
2522  if (key == "LinearAttenuation")
2523  {
2524  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Real, value )
2525  obj->setLinearAttenuation( (float)value.getReal() );
2526  }
2527  else
2528  if (key == "QuadraticAttenuation")
2529  {
2530  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Real, value )
2531  obj->setQuadraticAttenuation( (float)value.getReal() );
2532  }
2533  else
2534  if (key == "BoundTransform")
2535  {
2537  Transform* tr= s.importVLX( value.getStructure() )->as<Transform>();
2538  VLX_IMPORT_CHECK_RETURN( tr != NULL, value )
2539  obj->bindTransform(tr);
2540  }
2541  }
2542  }
2543 
2545  {
2546  ref<Light> obj = new Light;
2547  // register imported structure asap
2548  s.registerImportedStructure(vlx, obj.get());
2549  importLight(s, vlx, obj.get());
2550  return obj;
2551  }
2552 
2553  void exportLight(VLXSerializer& s, const Light* obj, VLXStructure* vlx)
2554  {
2555  if (!obj->objectName().empty() && obj->objectName() != obj->className())
2556  *vlx << "ObjectName" << vlx_String(obj->objectName());
2557  *vlx << "Ambient" << vlx_toValue((vec4)obj->ambient());
2558  *vlx << "Diffuse" << vlx_toValue((vec4)obj->diffuse());
2559  *vlx << "Specular" << vlx_toValue((vec4)obj->specular());
2560  *vlx << "Position" << vlx_toValue((vec4)obj->position());
2561  *vlx << "SpotDirection" << vlx_toValue((vec3)obj->spotDirection());
2562  *vlx << "SpotExponent" << obj->spotExponent();
2563  *vlx << "SpotCutoff" << obj->spotCutoff();
2564  *vlx << "ConstantAttenuation" << obj->constantAttenuation();
2565  *vlx << "LinearAttenuation" << obj->linearAttenuation();
2566  *vlx << "QuadraticAttenuation" << obj->quadraticAttenuation();
2567  if (obj->boundTransform())
2568  *vlx << "BoundTransform" << s.exportVLX(obj->boundTransform());
2569  }
2570 
2572  {
2573  const Light* cast_obj = obj->as<Light>(); VL_CHECK(cast_obj)
2574  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("light_"));
2575  // register exported object asap
2576  s.registerExportedObject(obj, vlx.get());
2577  exportLight(s, cast_obj, vlx.get());
2578  return vlx;
2579  }
2580  };
2581 
2582  //---------------------------------------------------------------------------
2583 
2586  {
2588  {
2589  for(size_t i=0; i<vlx->value().size(); ++i)
2590  {
2591  const std::string& key = vlx->value()[i].key();
2592  const VLXValue& value = vlx->value()[i].value();
2593  if (key == "PlaneNormal")
2594  {
2595  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::ArrayReal, value )
2596  obj->plane().setNormal( vlx_vec3( value.getArrayReal() ) );
2597  }
2598  else
2599  if (key == "PlaneOrigin")
2600  {
2601  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Real, value )
2602  obj->plane().setOrigin( (float)value.getReal() );
2603  }
2604  else
2605  if (key == "BoundTransform")
2606  {
2608  Transform* tr= s.importVLX( value.getStructure() )->as<Transform>();
2609  VLX_IMPORT_CHECK_RETURN( tr != NULL, value )
2610  obj->bindTransform(tr);
2611  }
2612  }
2613  }
2614 
2616  {
2617  ref<ClipPlane> obj = new ClipPlane;
2618  // register imported structure asap
2619  s.registerImportedStructure(vlx, obj.get());
2620  importClipPlane(s, vlx, obj.get());
2621  return obj;
2622  }
2623 
2625  {
2626  *vlx << "PlaneNormal" << vlx_toValue(clip->plane().normal());
2627  *vlx << "PlaneOrigin" << clip->plane().origin();
2628  if (clip->boundTransform())
2629  *vlx << "BoundTransform" << s.exportVLX(clip->boundTransform());
2630  }
2631 
2633  {
2634  const ClipPlane* cast_obj = obj->as<ClipPlane>(); VL_CHECK(cast_obj)
2635  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("clipplane_"));
2636  // register exported object asap
2637  s.registerExportedObject(obj, vlx.get());
2638  exportClipPlane(s, cast_obj, vlx.get());
2639  return vlx;
2640  }
2641  };
2642 
2643  //---------------------------------------------------------------------------
2644 
2647  {
2649  {
2650  const VLXValue* name = vlx->getValue("ObjectName");
2651  if (name)
2652  obj->setObjectName( name->getString() );
2653 
2654  for(size_t i=0; i<vlx->value().size(); ++i)
2655  {
2656  const std::string& key = vlx->value()[i].key();
2657  const VLXValue& value = vlx->value()[i].value();
2658  if (key == "AttachShader")
2659  {
2660  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Structure, value )
2661  const VLXStructure* st = value.getStructure();
2662  GLSLShader* glsl_sh = s.importVLX(st)->as<GLSLShader>();
2663  VLX_IMPORT_CHECK_RETURN( glsl_sh != NULL, *st )
2664  obj->attachShader(glsl_sh);
2665  }
2666  else
2667  if (key == "FragDataLocation")
2668  {
2669  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::List, value )
2670  const VLXList* list = value.getList();
2671  VLX_IMPORT_CHECK_RETURN( list->value().size() == 2, *list )
2672  VLX_IMPORT_CHECK_RETURN( list->value()[0].type() == VLXValue::Identifier, *list )
2673  VLX_IMPORT_CHECK_RETURN( list->value()[1].type() == VLXValue::Integer, *list )
2674  const char* name = list->value()[0].getIdentifier().c_str();
2675  int index = (int)list->value()[1].getInteger();
2676  obj->bindFragDataLocation(index, name);
2677  }
2678  // MIC FIXME
2679  //else
2680  //if (key == "AttribLocation")
2681  //{
2682  // VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::List, value )
2683  // const VLXList* list = value.getList();
2684  // VLX_IMPORT_CHECK_RETURN( list->value().size() == 2, *list )
2685  // VLX_IMPORT_CHECK_RETURN( list->value()[0].type() == VLXValue::Identifier, *list )
2686  // VLX_IMPORT_CHECK_RETURN( list->value()[1].type() == VLXValue::Integer, *list )
2687  // const char* name = list->value()[0].getIdentifier().c_str();
2688  // int index = (int)list->value()[1].getInteger();
2689  // obj->addAutoAttribLocation(index, name);
2690  //}
2691  else
2692  if (key == "Uniforms")
2693  {
2694  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::List, value )
2695  const VLXList* list = value.getList();
2696  for(size_t i=0; i<list->value().size(); ++i)
2697  {
2698  VLX_IMPORT_CHECK_RETURN( list->value()[i].type() == VLXValue::Structure, list->value()[i] )
2699  Uniform* uniform = s.importVLX( list->value()[i].getStructure() )->as<Uniform>();
2700  VLX_IMPORT_CHECK_RETURN( uniform != NULL, list->value()[i] )
2701  obj->setUniform(uniform);
2702  }
2703  }
2704  }
2705  }
2706 
2708  {
2709  ref<GLSLProgram> obj = new GLSLProgram;
2710  // register imported structure asap
2711  s.registerImportedStructure(vlx, obj.get());
2712  importGLSLProgram(s, vlx, obj.get());
2713  return obj;
2714  }
2715 
2717  {
2718  if (!obj->objectName().empty() && obj->objectName() != obj->className())
2719  *vlx << "ObjectName" << vlx_String(obj->objectName());
2720 
2721  // export obj shaders
2722  for(int i=0; i<obj->shaderCount(); ++i)
2723  *vlx << "AttachShader" << s.exportVLX(obj->shader(i));
2724 
2725  // export uniforms
2726  VLXValue uniforms;
2727  uniforms.setList( new VLXList );
2728  for(size_t i=0; obj->getUniformSet() && i<obj->getUniformSet()->uniforms().size(); ++i)
2729  *uniforms.getList() << s.exportVLX(obj->getUniformSet()->uniforms()[i].get());
2730  *vlx << "Uniforms" << uniforms;
2731 
2732  // frag data location
2733  for(std::map<std::string, int>::const_iterator it = obj->fragDataLocations().begin(); it != obj->fragDataLocations().end(); ++it)
2734  {
2735  VLXList* location = new VLXList;
2736  *location << vlx_Identifier(it->first); // Name
2737  *location << (long long)it->second; // Location
2738  *vlx << "FragDataLocation" << location;
2739  }
2740 
2742  // MIC FIXME
2743  //for(std::map<std::string, int>::const_iterator it = obj->autoAttribLocations().begin(); it != obj->autoAttribLocations().end(); ++it)
2744  //{
2745  // VLXList* location = new VLXList;
2746  // *location << vlx_Identifier(it->first); // Name
2747  // *location << (long long)it->second; // Location
2748  // *vlx << "AttribLocation" << location;
2749  //}
2750  }
2751 
2753  {
2754  const GLSLProgram* cast_obj = obj->as<GLSLProgram>(); VL_CHECK(cast_obj)
2755  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("glslprog_"));
2756  // register exported object asap
2757  s.registerExportedObject(obj, vlx.get());
2758  exportGLSLProgram(s, cast_obj, vlx.get());
2759  return vlx;
2760  }
2761  };
2762 
2763  //---------------------------------------------------------------------------
2764 
2767  {
2769  {
2770  const VLXValue* path = vlx->getValue("Path");
2771  const VLXValue* source = vlx->getValue("Source");
2772  VLX_IMPORT_CHECK_RETURN( path != NULL || source != NULL, *vlx )
2773  if (path)
2774  {
2775  VLX_IMPORT_CHECK_RETURN( path->type() == VLXValue::String, *path )
2776  std::string resolved_path = path->getString();
2777  s.resolvePath(resolved_path);
2778  obj->setSource(resolved_path.c_str()); // this automatically loads the source and sets the path
2779  }
2780  else
2781  if (source)
2782  {
2783  VLX_IMPORT_CHECK_RETURN( source->type() == VLXValue::RawtextBlock, *source )
2784  obj->setSource(source->getRawtextBlock()->value().c_str());
2785  }
2786  else
2787  {
2788  Log::warning( Say("Line %n : no source or path specified for glsl shader.\n") << vlx->lineNumber() );
2789  }
2790  }
2791 
2793  {
2794  ref<GLSLShader> obj = NULL;
2795  if (vlx->tag() == "<vl::GLSLVertexShader>")
2796  obj = new GLSLVertexShader;
2797  else
2798  if (vlx->tag() == "<vl::GLSLFragmentShader>")
2799  obj = new GLSLFragmentShader;
2800  else
2801  if (vlx->tag() == "<vl::GLSLGeometryShader>")
2802  obj = new GLSLGeometryShader;
2803  else
2804  if (vlx->tag() == "<vl::GLSLTessControlShader>")
2805  obj = new GLSLTessControlShader;
2806  else
2807  if (vlx->tag() == "<vl::GLSLTessEvaluationShader>")
2808  obj = new GLSLTessEvaluationShader;
2809  else
2810  {
2811  s.signalImportError( Say("Line %n : shader type '%s' not supported.\n") << vlx->tag() );
2812  return NULL;
2813  }
2814 
2815  // register imported structure asap
2816  s.registerImportedStructure(vlx, obj.get());
2817  importGLSLShader(s, vlx, obj.get());
2818  return obj;
2819  }
2820 
2821  void exportGLSLShader(const GLSLShader* glslsh, VLXStructure* vlx)
2822  {
2823  if (!glslsh->path().empty())
2824  *vlx << "Path" << vlx_String(glslsh->path().toStdString());
2825  else
2826  if (!glslsh->source().empty())
2827  *vlx << "Source" << vlx_Rawtext(glslsh->source());
2828  else
2829  if (glslsh->handle())
2830  *vlx << "Source" << vlx_Rawtext(glslsh->getShaderSource());
2831  else
2832  *vlx << "Source" << vlx_Identifier("NO_SOURCE_FOUND");
2833  }
2834 
2836  {
2837  const GLSLShader* cast_obj = obj->as<GLSLShader>(); VL_CHECK(cast_obj)
2838  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("glslsh_"));
2839  // register exported object asap
2840  s.registerExportedObject(obj, vlx.get());
2841  exportGLSLShader(cast_obj, vlx.get());
2842  return vlx;
2843  }
2844  };
2845 
2846  //---------------------------------------------------------------------------
2847 
2850  {
2852  {
2853  const VLXValue* name = vlx->getValue("ObjectName");
2854  if (name)
2855  obj->setObjectName( name->getString() );
2856 
2857  const VLXValue* value = vlx->getValue("Value");
2858  VLX_IMPORT_CHECK_RETURN( value->type() == VLXValue::ArrayReal, *value )
2859  obj->setValue( (fvec4)vlx_vec4( value->getArrayReal() ) );
2860  }
2861 
2863  {
2864  ref<VertexAttrib> obj = new VertexAttrib;
2865  // register imported structure asap
2866  s.registerImportedStructure(vlx, obj.get());
2867  importVertexAttrib(s, vlx, obj.get());
2868  return obj;
2869  }
2870 
2872  {
2873  if (!obj->objectName().empty() && obj->objectName() != obj->className())
2874  *vlx << "ObjectName" << vlx_String(obj->objectName());
2875  *vlx << "Value" << vlx_toValue((vec4)obj->value());
2876  }
2877 
2879  {
2880  const VertexAttrib* cast_obj = obj->as<VertexAttrib>(); VL_CHECK(cast_obj)
2881  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("vertexattrib_"));
2882  // register exported object asap
2883  s.registerExportedObject(obj, vlx.get());
2884  exportVertexAttrib(cast_obj, vlx.get());
2885  return vlx;
2886  }
2887  };
2888 
2889  //---------------------------------------------------------------------------
2890 
2893  {
2894  void importColor(VLXSerializer& s, const VLXStructure* vlx, Color* obj)
2895  {
2896  const VLXValue* value = vlx->getValue("Value");
2897  VLX_IMPORT_CHECK_RETURN( value->type() == VLXValue::ArrayReal, *value )
2898  obj->setValue( (fvec4)vlx_vec4( value->getArrayReal() ) );
2899  }
2900 
2902  {
2903  ref<Color> obj = new Color;
2904  // register imported structure asap
2905  s.registerImportedStructure(vlx, obj.get());
2906  importColor(s, vlx, obj.get());
2907  return obj;
2908  }
2909 
2910  void exportColor(const Color* obj, VLXStructure* vlx)
2911  {
2912  *vlx << "Value" << vlx_toValue((vec4)obj->value());
2913  }
2914 
2916  {
2917  const Color* cast_obj = obj->as<Color>(); VL_CHECK(cast_obj)
2918  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("color_"));
2919  // register exported object asap
2920  s.registerExportedObject(obj, vlx.get());
2921  exportColor(cast_obj, vlx.get());
2922  return vlx;
2923  }
2924  };
2925 
2926  //---------------------------------------------------------------------------
2927 
2930  {
2932  {
2933  const VLXValue* value = vlx->getValue("Value");
2934  VLX_IMPORT_CHECK_RETURN( value->type() == VLXValue::ArrayReal, *value )
2935  obj->setValue( (fvec3)vlx_vec3( value->getArrayReal() ) );
2936  }
2937 
2939  {
2941  // register imported structure asap
2942  s.registerImportedStructure(vlx, obj.get());
2943  importSecondaryColor(s, vlx, obj.get());
2944  return obj;
2945  }
2946 
2948  {
2949  *vlx << "Value" << vlx_toValue((vec3)obj->value());
2950  }
2951 
2953  {
2954  const SecondaryColor* cast_obj = obj->as<SecondaryColor>(); VL_CHECK(cast_obj)
2955  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("seccolor_"));
2956  // register exported object asap
2957  s.registerExportedObject(obj, vlx.get());
2958  exportSecondaryColor(cast_obj, vlx.get());
2959  return vlx;
2960  }
2961  };
2962 
2963  //---------------------------------------------------------------------------
2964 
2967  {
2968  void importNormal(VLXSerializer& s, const VLXStructure* vlx, Normal* obj)
2969  {
2970  const VLXValue* value = vlx->getValue("Value");
2971  VLX_IMPORT_CHECK_RETURN( value->type() == VLXValue::ArrayReal, *value )
2972  obj->setValue( (fvec3)vlx_vec3( value->getArrayReal() ) );
2973  }
2974 
2976  {
2977  ref<Normal> obj = new Normal;
2978  // register imported structure asap
2979  s.registerImportedStructure(vlx, obj.get());
2980  importNormal(s, vlx, obj.get());
2981  return obj;
2982  }
2983 
2984  void exportNormal(const Normal* obj, VLXStructure* vlx)
2985  {
2986  *vlx << "Value" << vlx_toValue((vec3)obj->value());
2987  }
2988 
2990  {
2991  const Normal* cast_obj = obj->as<Normal>(); VL_CHECK(cast_obj)
2992  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("normal_"));
2993  // register exported object asap
2994  s.registerExportedObject(obj, vlx.get());
2995  exportNormal(cast_obj, vlx.get());
2996  return vlx;
2997  }
2998  };
2999 
3000  //---------------------------------------------------------------------------
3001 
3004  {
3006  {
3007  const VLXValue* name = vlx->getValue("ObjectName");
3008  if (name)
3009  obj->setObjectName( name->getString() );
3010 
3011  for(size_t i=0; i<vlx->value().size(); ++i)
3012  {
3013  const std::string& key = vlx->value()[i].key();
3014  const VLXValue& value = vlx->value()[i].value();
3015  if (key == "FrontAmbient")
3016  {
3017  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::ArrayReal, value );
3018  obj->setFrontAmbient( (fvec4)vlx_vec4( value.getArrayReal() ) );
3019  }
3020  else
3021  if (key == "FrontDiffuse")
3022  {
3023  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::ArrayReal, value );
3024  obj->setFrontDiffuse( (fvec4)vlx_vec4( value.getArrayReal() ) );
3025  }
3026  else
3027  if (key == "FrontEmission")
3028  {
3029  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::ArrayReal, value );
3030  obj->setFrontEmission( (fvec4)vlx_vec4( value.getArrayReal() ) );
3031  }
3032  else
3033  if (key == "FrontSpecular")
3034  {
3035  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::ArrayReal, value );
3036  obj->setFrontSpecular( (fvec4)vlx_vec4( value.getArrayReal() ) );
3037  }
3038  else
3039  if (key == "FrontShininess")
3040  {
3041  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Real, value );
3042  obj->setFrontShininess( (float)value.getReal() );
3043  }
3044  else
3045  if (key == "BackAmbient")
3046  {
3047  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::ArrayReal, value );
3048  obj->setBackAmbient( (fvec4)vlx_vec4( value.getArrayReal() ) );
3049  }
3050  else
3051  if (key == "BackDiffuse")
3052  {
3053  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::ArrayReal, value );
3054  obj->setBackDiffuse( (fvec4)vlx_vec4( value.getArrayReal() ) );
3055  }
3056  else
3057  if (key == "BackEmission")
3058  {
3059  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::ArrayReal, value );
3060  obj->setBackEmission( (fvec4)vlx_vec4( value.getArrayReal() ) );
3061  }
3062  else
3063  if (key == "BackSpecular")
3064  {
3065  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::ArrayReal, value );
3066  obj->setBackSpecular( (fvec4)vlx_vec4( value.getArrayReal() ) );
3067  }
3068  else
3069  if (key == "BackShininess")
3070  {
3071  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Real, value );
3072  obj->setBackShininess( (float)value.getReal() );
3073  }
3074  else
3075  if (key == "ColorMaterialEnabled")
3076  {
3077  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Bool, value );
3078  obj->setColorMaterialEnabled( value.getBool() );
3079  }
3080  }
3081 
3083  const VLXValue* vlx_col_mat = vlx->getValue("ColorMaterial");
3084  if (vlx_col_mat)
3085  {
3086  VLX_IMPORT_CHECK_RETURN( vlx_col_mat->type() == VLXValue::Identifier, *vlx_col_mat );
3087  col_mat = vlx_EColorMaterial( *vlx_col_mat, s );
3088  }
3089 
3090  EPolygonFace poly_face = PF_FRONT_AND_BACK;
3091  const VLXValue* vlx_poly_mat = vlx->getValue("ColorMaterialFace");
3092  if (vlx_poly_mat)
3093  {
3094  VLX_IMPORT_CHECK_RETURN( vlx_poly_mat->type() == VLXValue::Identifier, *vlx_poly_mat );
3095  poly_face = vlx_EPolygonFace( *vlx_poly_mat, s );
3096  }
3097 
3098  obj->setColorMaterial( poly_face, col_mat );
3099  }
3100 
3102  {
3103  ref<Material> obj = new Material;
3104  // register imported structure asap
3105  s.registerImportedStructure(vlx, obj.get());
3106  importMaterial(s, vlx, obj.get());
3107  return obj;
3108  }
3109 
3110  void exportMaterial(const Material* obj, VLXStructure* vlx)
3111  {
3112  if (!obj->objectName().empty() && obj->objectName() != obj->className())
3113  *vlx << "ObjectName" << vlx_String(obj->objectName());
3114 
3115  *vlx << "FrontAmbient" << vlx_toValue((vec4)obj->frontAmbient());
3116  *vlx << "FrontDiffuse" << vlx_toValue((vec4)obj->frontDiffuse());
3117  *vlx << "FrontEmission" << vlx_toValue((vec4)obj->frontEmission());
3118  *vlx << "FrontSpecular" << vlx_toValue((vec4)obj->frontSpecular());
3119  *vlx << "FrontShininess" << (double)obj->frontShininess();
3120 
3121  *vlx << "BackAmbient" << vlx_toValue((vec4)obj->backAmbient());
3122  *vlx << "BackDiffuse" << vlx_toValue((vec4)obj->backDiffuse());
3123  *vlx << "BackEmission" << vlx_toValue((vec4)obj->backEmission());
3124  *vlx << "BackSpecular" << vlx_toValue((vec4)obj->backSpecular());
3125  *vlx << "BackShininess" << (double)obj->backShininess();
3126 
3127  *vlx << "ColorMaterial" << vlx_Identifier(vlx_EColorMaterial(obj->colorMaterial()));
3128  *vlx << "ColorMaterialFace" << vlx_Identifier(vlx_EPolygonFace(obj->colorMaterialFace()));
3129 
3130  *vlx << "ColorMaterialEnabled" << obj->colorMaterialEnabled();
3131  }
3132 
3134  {
3135  const Material* cast_obj = obj->as<Material>(); VL_CHECK(cast_obj)
3136  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("material_"));
3137  // register exported object asap
3138  s.registerExportedObject(obj, vlx.get());
3139  exportMaterial(cast_obj, vlx.get());
3140  return vlx;
3141  }
3142  };
3143 
3144  //---------------------------------------------------------------------------
3145 
3148  {
3150  {
3151  if (obj->isOfType(DepthSortCallback::Type()))
3152  {
3153  const VLXValue* vlx_sm = vlx->getValue("SortMode");
3154  VLX_IMPORT_CHECK_RETURN( vlx_sm->type() == VLXValue::Identifier, *vlx_sm )
3155  if (vlx_sm)
3156  {
3158  if ( vlx_sm->getIdentifier() == "SM_SortBackToFront" )
3159  sm = SM_SortBackToFront;
3160  else
3161  if ( vlx_sm->getIdentifier() == "SM_SortFrontToBack" )
3162  sm = SM_SortFrontToBack;
3163  else
3164  s.signalImportError( Say("Line %n : unknown sort mode '%s'.\n") << vlx_sm->lineNumber() << vlx_sm->getIdentifier() );
3165  obj->as<DepthSortCallback>()->setSortMode(sm);
3166  }
3167  }
3168  }
3169 
3171  {
3173 
3174  if (vlx->tag() == "<vl::DepthSortCallback>")
3175  obj = new DepthSortCallback;
3176  else
3177  {
3178  s.signalImportError( Say("Line %n : ActorEventCallback type not supported for import.\n") << vlx->lineNumber() );
3179  return NULL;
3180  }
3181 
3182  // register imported structure asap
3183  s.registerImportedStructure(vlx, obj.get());
3184  importActorEventCallback(s, vlx, obj.get());
3185  return obj;
3186  }
3187 
3189  {
3190  if (cb->classType() == DepthSortCallback::Type())
3191  {
3192  const DepthSortCallback* dsc = cb->as<DepthSortCallback>();
3193 
3194  if (dsc->sortMode() == SM_SortBackToFront)
3195  *vlx << "SortMode" << vlx_Identifier("SM_SortBackToFront");
3196  else
3197  *vlx << "SortMode" << vlx_Identifier("SM_SortFrontToBack");
3198  }
3199  else
3200  {
3201  s.signalExportError("ActorEventCallback type not supported for export.\n");
3202  }
3203  }
3204 
3206  {
3207  const ActorEventCallback* cast_obj = obj->as<ActorEventCallback>(); VL_CHECK(cast_obj)
3208  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("actorcallback_"));
3209  // register exported object asap
3210  s.registerExportedObject(obj, vlx.get());
3211  exportActorEventCallback(s, cast_obj, vlx.get());
3212  return vlx;
3213  }
3214  };
3215 
3216  //---------------------------------------------------------------------------
3217 
3220  {
3222  {
3223  const VLXValue* name = vlx->getValue("ObjectName");
3224  if (name)
3225  obj->setObjectName( name->getString() );
3226 
3228 
3229  for(size_t i=0; i<vlx->value().size(); ++i)
3230  {
3231  const std::string& key = vlx->value()[i].key();
3232  const VLXValue& value = vlx->value()[i].value();
3233 
3234  if (key == "Dimension")
3235  {
3236  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Identifier, value );
3237  obj->setupParams()->setDimension( vlx_ETextureDimension( value, s ) );
3238  }
3239  else
3240  if (key == "TexParameter")
3241  {
3242  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Structure, value );
3243  TexParameter* tex_param = s.importVLX( value.getStructure() )->as<TexParameter>();
3244  VLX_IMPORT_CHECK_RETURN( tex_param != NULL, value );
3245  // copy the content over
3246  *obj->getTexParameter() = *tex_param;
3247  }
3248  else
3249  if (key == "ImagePath")
3250  {
3251  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::String, value );
3252  std::string resolved_path = value.getString();
3253  s.resolvePath( resolved_path );
3254  obj->setupParams()->setImagePath( resolved_path.c_str() );
3255  }
3256  else
3257  if (key == "Format")
3258  {
3259  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Identifier, value );
3260  obj->setupParams()->setFormat( vlx_ETextureFormat( value, s ) );
3261  }
3262  else
3263  if (key == "Width")
3264  {
3265  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer, value );
3266  obj->setupParams()->setWidth( (int)value.getInteger() );
3267  }
3268  else
3269  if (key == "Height")
3270  {
3271  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer, value );
3272  obj->setupParams()->setHeight( (int)value.getInteger() );
3273  }
3274  else
3275  if (key == "Depth")
3276  {
3277  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer, value );
3278  obj->setupParams()->setDepth( (int)value.getInteger() );
3279  }
3280  else
3281  if (key == "GenMipmaps")
3282  {
3283  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Bool, value );
3284  obj->setupParams()->setGenMipmaps( (int)value.getBool() );
3285  }
3286  else
3287  if (key == "BufferObject")
3288  {
3289  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Structure, value );
3290  BufferObject* buf_obj = s.importVLX( value.getStructure() )->as<BufferObject>();
3291  VLX_IMPORT_CHECK_RETURN( buf_obj, value );
3292  obj->setupParams()->setBufferObject( buf_obj );
3293  }
3294  else
3295  if (key == "Samples")
3296  {
3297  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Integer, value );
3298  obj->setupParams()->setSamples( (int)value.getInteger() );
3299  }
3300  else
3301  if (key == "FixedSamplesLocations")
3302  {
3303  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Bool, value );
3304  obj->setupParams()->setFixedSamplesLocations( (int)value.getBool() );
3305  }
3306  }
3307  }
3308 
3310  {
3311  ref<Texture> obj = new Texture;
3312  // register imported structure asap
3313  s.registerImportedStructure(vlx, obj.get());
3314  importTexture(s, vlx, obj.get());
3315  return obj;
3316  }
3317 
3319  {
3320  // mic fixme:
3321  // - we should allow patterns such as initializing a texture from an image filled by a shader or procedure.
3322  // - we should allow avoid loading twice the same image or shader source or any externa resource etc. time for a resource manager?
3323 
3324  if (!obj->objectName().empty() && obj->objectName() != obj->className())
3325  *vlx << "ObjectName" << vlx_String(obj->objectName());
3326 
3327  if (obj->getTexParameter())
3328  *vlx << "TexParameter" << s.exportVLX(obj->getTexParameter());
3329 
3330  if (obj->setupParams())
3331  {
3332  const Texture::SetupParams* par = obj->setupParams();
3333 
3334  if (par)
3335  {
3336  *vlx << "Dimension" << vlx_Identifier(vlx_ETextureDimension(par->dimension()));
3337 
3338  *vlx << "Format" << vlx_Identifier(vlx_ETextureFormat(par->format()));
3339 
3340  if (!par->imagePath().empty())
3341  *vlx << "ImagePath" << vlx_String(par->imagePath().toStdString());
3342  else
3343  if (par->image())
3344  *vlx << "ImagePath" << vlx_String(par->image()->filePath().toStdString());
3345 
3346  if (par->width())
3347  *vlx << "Width" << (long long)par->width();
3348 
3349  if (par->height())
3350  *vlx << "Height" << (long long)par->height();
3351 
3352  if (par->depth())
3353  *vlx << "Depth" << (long long)par->depth();
3354 
3355  *vlx << "GenMipmaps" << par->genMipmaps();
3356 
3357  // mic fixme: implement BufferObject importer/exporter
3358 #if 0
3359  if (par->bufferObject())
3360  {
3361  *vlx << "BufferObject" << s.exportVLX(par->bufferObject());
3362  }
3363 #endif
3364 
3365  if(par->samples())
3366  {
3367  *vlx << "Samples" << (long long)par->samples();
3368  *vlx << "FixedSamplesLocations" << par->fixedSamplesLocations();
3369  }
3370  }
3371  }
3372  }
3373 
3375  {
3376  const Texture* cast_obj = obj->as<Texture>(); VL_CHECK(cast_obj)
3377  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("texture_"));
3378  // register exported object asap
3379  s.registerExportedObject(obj, vlx.get());
3380  exportTexture(s, cast_obj, vlx.get());
3381  return vlx;
3382  }
3383  };
3384 
3385  //---------------------------------------------------------------------------
3386 
3389  {
3391  {
3392  for(size_t i=0; i<vlx->value().size(); ++i)
3393  {
3394  const std::string& key = vlx->value()[i].key();
3395  const VLXValue& value = vlx->value()[i].value();
3396 
3397  if (key == "MinFilter")
3398  {
3399  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Identifier, value );
3400  obj->setMinFilter( vlx_ETexParamFilter( value, s ) );
3401  }
3402  else
3403  if (key == "MagFilter")
3404  {
3405  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Identifier, value );
3406  obj->setMagFilter( vlx_ETexParamFilter( value, s ) );
3407  }
3408  else
3409  if (key == "WrapS")
3410  {
3411  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Identifier, value );
3412  obj->setWrapS( vlx_ETexParamWrap( value, s ) );
3413  }
3414  else
3415  if (key == "WrapT")
3416  {
3417  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Identifier, value );
3418  obj->setWrapT( vlx_ETexParamWrap( value, s ) );
3419  }
3420  else
3421  if (key == "WrapR")
3422  {
3423  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Identifier, value );
3424  obj->setWrapR( vlx_ETexParamWrap( value, s ) );
3425  }
3426  else
3427  if (key == "CompareMode")
3428  {
3429  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Identifier, value );
3430  obj->setCompareMode( vlx_ETexCompareMode( value, s ) );
3431  }
3432  else
3433  if (key == "CompareFunc")
3434  {
3435  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Identifier, value );
3436  obj->setCompareFunc( vlx_ETexCompareFunc( value, s ) );
3437  }
3438  else
3439  if (key == "DepthTextureMode")
3440  {
3441  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Identifier, value );
3442  obj->setDepthTextureMode( vlx_EDepthTextureMode( value, s ) );
3443  }
3444  else
3445  if (key == "BorderColor")
3446  {
3447  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::ArrayReal, value );
3448  obj->setBorderColor( (fvec4)vlx_vec4(value.getArrayReal()) );
3449  }
3450  else
3451  if (key == "Anisotropy")
3452  {
3453  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Real, value );
3454  obj->setAnisotropy( (float)value.getReal() );
3455  }
3456  else
3457  if (key == "GenerateMipmap")
3458  {
3459  VLX_IMPORT_CHECK_RETURN( value.type() == VLXValue::Bool, value );
3460  obj->setGenerateMipmap( value.getBool() );
3461  }
3462  }
3463  }
3464 
3466  {
3467  ref<TexParameter> obj = new TexParameter;
3468  // register imported structure asap
3469  s.registerImportedStructure(vlx, obj.get());
3470  importTexParameter(s, vlx, obj.get());
3471  return obj;
3472  }
3473 
3474  void exportTexParameter(const TexParameter* texparam, VLXStructure* vlx)
3475  {
3476  *vlx << "MinFilter" << vlx_Identifier(vlx_ETexParamFilter(texparam->minFilter()));
3477  *vlx << "MagFilter" << vlx_Identifier(vlx_ETexParamFilter(texparam->magFilter()));
3478  *vlx << "WrapS" << vlx_Identifier(vlx_ETexParamWrap(texparam->wrapS()));
3479  *vlx << "WrapT" << vlx_Identifier(vlx_ETexParamWrap(texparam->wrapT()));
3480  *vlx << "WrapR" << vlx_Identifier(vlx_ETexParamWrap(texparam->wrapR()));
3481  *vlx << "CompareMode" << vlx_Identifier(vlx_ETexCompareMode(texparam->compareMode()));
3482  *vlx << "CompareFunc" << vlx_Identifier(vlx_ETexCompareFunc(texparam->compareFunc()));
3483  *vlx << "DepthTextureMode" << vlx_Identifier(vlx_EDepthTextureMode(texparam->depthTextureMode()));
3484  *vlx << "BorderColor" << vlx_toValue((vec4)texparam->borderColor());
3485  *vlx << "Anisotropy" << texparam->anisotropy();
3486  *vlx << "GenerateMipmap" << texparam->generateMipmap();
3487  }
3488 
3490  {
3491  const TexParameter* cast_obj = obj->as<TexParameter>(); VL_CHECK(cast_obj)
3492  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("texparam_"));
3493  // register exported object asap
3494  s.registerExportedObject(obj, vlx.get());
3495  exportTexParameter(cast_obj, vlx.get());
3496  return vlx;
3497  }
3498  };
3499 
3500  //---------------------------------------------------------------------------
3501 
3504  {
3506  {
3507  const VLXValue* vlx_texture = vlx->getValue("Texture");
3508  if (vlx_texture)
3509  {
3510  VLX_IMPORT_CHECK_RETURN(vlx_texture->type() == VLXValue::Structure, *vlx_texture);
3511  Texture* texture = s.importVLX(vlx_texture->getStructure())->as<Texture>();
3512  VLX_IMPORT_CHECK_RETURN( texture != NULL , *vlx_texture);
3513  obj->setTexture(texture);
3514  }
3515 
3516  const VLXValue* vlx_texp = vlx->getValue("TexParameter");
3517  if (vlx_texp)
3518  {
3519  VLX_IMPORT_CHECK_RETURN(vlx_texp->type() == VLXValue::Structure, *vlx_texp);
3520  TexParameter* texp = s.importVLX(vlx_texp->getStructure())->as<TexParameter>();
3521  VLX_IMPORT_CHECK_RETURN( texp != NULL , *vlx_texp);
3522  obj->setTexParameter(texp);
3523  }
3524  }
3525 
3527  {
3529  // register imported structure asap
3530  s.registerImportedStructure(vlx, obj.get());
3531  importTextureSampler(s, vlx, obj.get());
3532  return obj;
3533  }
3534 
3536  {
3537  if (tex_sampler->texture())
3538  *vlx << "Texture" << s.exportVLX(tex_sampler->texture());
3539  if (tex_sampler->getTexParameter())
3540  *vlx << "TexParameter" << s.exportVLX(tex_sampler->getTexParameter());
3541  }
3542 
3544  {
3545  const TextureSampler* cast_obj = obj->as<TextureSampler>(); VL_CHECK(cast_obj)
3546  ref<VLXStructure> vlx = new VLXStructure(vlx_makeTag(obj).c_str(), s.generateID("texsampler_"));
3547  // register exported object asap
3548  s.registerExportedObject(obj, vlx.get());
3549  exportTextureSampler(s, cast_obj, vlx.get());
3550  return vlx;
3551  }
3552  };
3553 }
3554 
3555 #endif
static void debug(const String &message)
Use this function to provide extra information useful to investigate and solve problems.
Definition: Log.cpp:144
void setUniformMatrix3d(int count, const double *value)
Definition: Uniform.hpp:133
const char * vlx_ETextureFormat(ETextureFormat tf)
Definition: vlxutils.hpp:383
EProjectionMatrixType projectionMatrixType() const
The Camera&#39;s projection matrix type.
Definition: Camera.hpp:178
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
void setUniformMatrix4x2d(int count, const double *value)
Definition: Uniform.hpp:139
The ArrayAbstract class defines an abstract interface to conveniently manipulate data stored in a Buf...
Definition: Array.hpp:58
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
An array of vl::svec3.
Definition: Array.hpp:468
Associates a Renderable object to an Effect and Transform.
Definition: Actor.hpp:130
VLXRawtextBlock * getRawtextBlock()
Definition: VLXValue.hpp:417
See DrawElements.
void setNearPlane(real nearplane)
The near clipping plane.
Definition: Camera.hpp:100
void setFrontSpecular(const fvec4 &color)
Definition: Shader.hpp:801
int baseVertex() const
Returns the currently used base vertex.
VLX wrapper of vl::Shader.
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
void registerImportedStructure(const VLXStructure *st, Object *obj)
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
An array of vl::uvec2.
Definition: Array.hpp:439
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
void setBaseVertex(int base_vertex)
If base_vertx is != 0 glDrawElementsBaseVertex/glDrawElementsInstancedBaseVertex will be used instead...
const Renderable * lod(int lod_index) const
Returns the Renderable object representing the LOD level specifed by lod_index.
Definition: Actor.hpp:173
ETextureFormat format() const
Definition: Texture.hpp:182
void exportGeometry(VLXSerializer &s, const Geometry *geom, VLXStructure *vlx)
Wraps an OpenGL Shading Language uniform to be associated to a GLSLProgram (see vl::GLSLProgram docum...
Definition: Uniform.hpp:59
void setEffect(Effect *effect)
Binds an Effect to an Actor.
Definition: Actor.hpp:196
const char * vlx_ETexParamWrap(ETexParamWrap tpw)
Definition: vlxutils.hpp:1073
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
void exportTransform(VLXSerializer &s, const Transform *obj, VLXStructure *vlx)
const T * at(int i) const
Definition: Collection.hpp:100
int y() const
Definition: Viewport.hpp:67
TexParameter * getTexParameter()
The TexParameter object associated to a Texture.
Definition: Texture.hpp:246
void setTexture(Texture *texture)
The texture sampler by a texture unit.
Definition: Shader.hpp:1765
void setClearStencil(int stencil)
Definition: Viewport.hpp:91
void setEnableMask(unsigned int mask)
The enable mask of an Actor&#39;s Effect defines whether the actor should be rendered or not depending on...
Definition: Effect.hpp:200
An array of vl::uvec4.
Definition: Array.hpp:443
const mat4 & viewMatrix() const
Returns the Camera&#39;s view matrix (inverse of the modeling matrix).
Definition: Camera.hpp:161
void importTransform(VLXSerializer &s, const VLXStructure *vlx, Transform *obj)
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
void setViewport(Viewport *viewport)
The viewport bound to a camera.
Definition: Camera.hpp:138
VLX wrapper of vl::Viewport.
void setUniform1i(int count, const int *value)
Definition: Uniform.hpp:99
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
VLX wrapper of vl::Geometry.
bool isEnabled() const
Whether an Actor should be considered for rendering, picking, scene bounding box calculation etc...
Definition: Actor.hpp:277
std::string & value()
Definition: VLXValue.hpp:83
An array of vl::fvec4.
Definition: Array.hpp:416
const std::vector< ref< Uniform > > & uniforms() const
Equivalent to getUniformSet()->uniforms()
Definition: Actor.cpp:121
void copyTo(T2 *ptr) const
Definition: VLXValue.hpp:123
See MultiDrawElements.
vec3 vlx_vec3(const VLXArrayReal *arr)
Definition: vlxutils.hpp:56
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
bool canExport(const Object *obj) const
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
void setPrimitiveType(EPrimitiveType type)
Sets the draw call&#39;s primitive type.
Definition: DrawCall.hpp:107
Transform * transform()
Returns the Transform bound tho an Actor.
Definition: Actor.hpp:190
void setUniform3f(int count, const float *value)
Definition: Uniform.hpp:111
const Transform * boundTransform() const
Returns the Transform bound to a camera.
Definition: Camera.hpp:150
An array of GLubyte.
Definition: Array.hpp:455
VLX wrapper of vl::TextureSampler.
Implements a 4x4 matrix transform used to define the position and orientation of an Actor...
Definition: Transform.hpp:72
Wraps the OpenGL function glTexParameter(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexPa...
Definition: Texture.hpp:62
void setUniformMatrix2f(int count, const float *value)
Definition: Uniform.hpp:121
const T * get() const
Definition: Object.hpp:128
ETexCompareFunc compareFunc() const
Definition: Texture.hpp:81
const fvec4 & value() const
Definition: Shader.hpp:76
void exportSecondaryColor(const SecondaryColor *obj, VLXStructure *vlx)
float spotCutoff() const
Valid values are from 0.0f to 90.0f plus the special value 180.0f (default) which disables the spot l...
Definition: Light.hpp:90
size_t renderStatesCount() const
EPolygonFace
VLXValue export_AABB(const AABB &aabb)
Definition: VLXWrappers.hpp:59
void setBackDiffuse(const fvec4 &color)
Definition: Shader.hpp:812
VLX wrapper of vl::DrawCall and subclasses.
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
Definition: VLXWrappers.hpp:60
void exportResourceDatabase(VLXSerializer &s, const ResourceDatabase *obj, VLXStructure *vlx)
A simple String formatting class.
Definition: Say.hpp:124
float frontShininess() const
Definition: Shader.hpp:809
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
const std::vector< GLint > & baseVertices() const
Returns the list of base vertices, one for each primitive.
void setObjectName(const char *name)
The name of the object, by default set to the object&#39;s class name in debug builds.
Definition: Object.hpp:220
static void warning(const String &message)
Use this function to provide information about situations that might lead to errors or loss of data...
Definition: Log.cpp:154
void setUniformMatrix3x4d(int count, const double *value)
Definition: Uniform.hpp:140
void setSetupParams(SetupParams *setup_params)
See SetupParams.
Definition: Texture.hpp:728
VLX wrapper of vl::Array.
Definition: VLXWrappers.hpp:58
void exportTexture(VLXSerializer &s, const Texture *obj, VLXStructure *vlx)
VLXArrayInteger * getArrayInteger()
Definition: VLXValue.hpp:443
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
void bindTransform(Transform *transform)
Attach the light to a vl::Transform.
Definition: ClipPlane.hpp:68
const fvec4 & backDiffuse() const
Definition: Shader.hpp:818
const std::vector< float > & pixelRangeSet() const
void importShader(VLXSerializer &s, const VLXStructure *vlx, Shader *sh)
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
An array of vl::usvec4.
Definition: Array.hpp:479
void importTexParameter(VLXSerializer &s, const VLXStructure *vlx, TexParameter *obj)
EColorMaterial colorMaterial() const
Definition: Shader.hpp:827
const std::string & getString() const
Definition: VLXValue.hpp:459
RenderState wrapping the OpenGL function glNormal(), see also http://www.opengl.org/sdk/docs/man/xhtm...
Definition: Shader.hpp:162
VLX wrapper of vl::Light.
VLXValue vlx_Rawtext(const std::string &str)
Definition: vlxutils.hpp:52
unsigned int handle() const
The handle of this OpenGL shader object as returned by glCreateShader()
Definition: GLSL.hpp:104
Wraps a GLSL geometry shader to be bound to a GLSLProgram: the shader this shader will run on the pro...
Definition: GLSL.hpp:154
double getReal() const
Definition: VLXValue.hpp:505
const std::vector< GLsizei > & countVector() const
The count vector used as &#39;count&#39; parameter of glMultiDrawElements.
bool canImport(const VLXStructure *st) const
void setFrontAmbient(const fvec4 &color)
Definition: Shader.hpp:799
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
const String & imagePath() const
Definition: Texture.hpp:169
const String & filePath() const
The file from which the image was loaded.
Definition: Image.hpp:371
EnableSet * getEnableSet()
Definition: Shader.hpp:2240
Wraps a GLSL vertex shader to be bound to a GLSLProgram: the shader this shader will run on the progr...
Definition: GLSL.hpp:117
int size() const
Definition: Collection.hpp:82
const ArrayAbstract * vertexArray() const
Conventional vertex array.
Definition: Geometry.hpp:248
void setClearColor(float r, float g, float b, float a)
Definition: Viewport.hpp:79
void importGeometry(VLXSerializer &s, const VLXStructure *vlx, Geometry *geom)
void setClearColorInt(int r, int g, int b, int a)
Definition: Viewport.hpp:83
VLX wrapper of vl::ClipPlane.
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
const SetupParams * setupParams() const
See SetupParams.
Definition: Texture.hpp:731
VLX wrapper of vl::TexParameter.
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
Base interface for all MultiDrawElements* sub classes.
See DrawElements.
void importUniform(VLXSerializer &s, const VLXStructure *vlx, Uniform *uniform)
VLX wrapper of vl::DepthSortCallback.
const char * vlx_ETexCompareFunc(ETexCompareFunc tcf)
Definition: vlxutils.hpp:1013
const std::string & getIdentifier() const
Definition: VLXValue.hpp:471
bool isEnabled() const
True if the draw call is enabled.
Definition: DrawCall.hpp:128
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
An array of vl::ivec4.
Definition: Array.hpp:434
bool boundsDirty() const
Returns whether the bounding sphere or bounding box are "dirty", that is, meant to be recomputed...
Definition: Renderable.hpp:126
void exportGLSLProgram(VLXSerializer &s, const GLSLProgram *obj, VLXStructure *vlx)
VLXValue vlx_String(const std::string &str)
Definition: vlxutils.hpp:50
An array of GLuint.
Definition: Array.hpp:437
static void error(const String &message)
Use this function to provide information about run-time errors: file not found, out of memory...
Definition: Log.cpp:164
void setFarPlane(real farplane)
The far clipping plane.
Definition: Camera.hpp:107
void setWrapT(ETexParamWrap texturewrap)
Definition: Texture.hpp:88
void setFrontShininess(float shininess)
Definition: Shader.hpp:803
VLXStructure * exportVLX(const Object *obj)
void setVertexArray(ArrayAbstract *data)
Conventional vertex array.
Definition: Geometry.cpp:155
TexParameter * getTexParameter()
The TexParameter used by the sampler used to override the one specified by the bound Texture...
Definition: Shader.hpp:1778
const char * vlx_ETexParamFilter(ETexParamFilter tpf)
Definition: vlxutils.hpp:1045
void registerExportedObject(const Object *obj, VLXStructure *st)
void setInstances(int instances)
Sets the number of instances for this set of primitives.
const std::vector< ref< Uniform > > & uniforms() const
Equivalent to gocUniformSet()->uniforms(...)
Definition: Shader.hpp:2216
void importPatchParameter(const VLXStructure *vlx, PatchParameter *pp)
real origin() const
Definition: Plane.hpp:76
void signalExportError(const String &str)
float linearAttenuation() const
Definition: Light.hpp:96
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
An array of vl::uvec3.
Definition: Array.hpp:441
void setPosition(const fvec4 &position)
The position or direction of a light.
Definition: Light.hpp:77
void importMaterial(VLXSerializer &s, const VLXStructure *vlx, Material *obj)
void exportLODEvaluator(VLXSerializer &s, const LODEvaluator *obj, VLXStructure *vlx)
Wraps a GLSL tessellation evaluation shader to be bound to a GLSLProgram: this shader will run on the...
Definition: GLSL.hpp:190
int renderBlock() const
Returns the rendering block of an Actor.
Definition: Actor.hpp:249
Wraps a GLSL program to which you can bind vertex, fragment and geometry shaders. ...
Definition: GLSL.hpp:233
VLCORE_EXPORT VLXList * setList(VLXList *)
Definition: VLXValue.cpp:143
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
std::string generateID(const char *prefix)
float constantAttenuation() const
Definition: Light.hpp:108
VLX wrapper of vl::PatchParameter.
Wraps an OpenGL texture object representing and managing all the supported texture types...
Definition: Texture.hpp:143
const Collection< ActorEventCallback > * actorEventCallbacks() const
Returns the list of ActorEventCallback bound to an Actor.
Definition: Actor.hpp:370
bool isBufferObjectEnabled() const
Returns true if BufferObject (vertex buffer object) are enabled for a Renderable (enabled by default)...
Definition: Renderable.hpp:201
An array of 64 bits floating point numbers, can also have a tag.
Definition: VLXValue.hpp:143
void setWrapS(ETexParamWrap texturewrap)
Definition: Texture.hpp:87
void setValue(const fvec3 &color)
Definition: Shader.hpp:176
void setSpecular(const fvec4 &specularcolor)
Definition: Light.hpp:68
void setLeft(real v)
Definition: Camera.hpp:114
void resize(size_t dim)
Definition: Array.hpp:233
real left() const
&#39;left&#39; parameter as passed to the last setProjectionFrustum() or setProjectionOrtho*() ...
Definition: Camera.hpp:113
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
void setBoundingSphere(const Sphere &sphere)
Sets the bounding sphere of a Renderable.
Definition: Renderable.hpp:140
void setNormalArray(ArrayAbstract *data)
Conventional normal array.
Definition: Geometry.cpp:164
See MultiDrawElements.
real nearPlane() const
The near clipping plane.
Definition: Camera.hpp:103
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
void setSecondaryColorArray(ArrayAbstract *data)
Conventional secondary color array.
Definition: Geometry.cpp:195
void setLinearAttenuation(float linearattenuation)
If the light is positional, rather than directional, its intensity is attenuated by the reciprocal of...
Definition: Light.hpp:95
void setUniformMatrix3f(int count, const float *value)
Definition: Uniform.hpp:122
void setDiffuse(const fvec4 &diffusecolor)
Definition: Light.hpp:65
An array of vl::ubvec2.
Definition: Array.hpp:457
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
void importViewport(VLXSerializer &s, const VLXStructure *vlx, Viewport *obj)
void setColorArray(const fvec4 &color)
Fills the color array with the given color.
Definition: Geometry.hpp:108
const UniformSet * getUniformSet() const
Returns the installed UniformSet.
Definition: Actor.hpp:345
EUniformType type() const
Definition: Uniform.hpp:259
An array of GLdouble.
Definition: Array.hpp:419
const char * vlx_ETexCompareMode(ETexCompareMode tcm)
Definition: vlxutils.hpp:991
const std::string & source() const
Returns the sources for this shader.
Definition: GLSL.hpp:72
const mat4 & localMatrix() const
The matrix representing the transform&#39;s local space.
Definition: Transform.hpp:145
void setLocalAndWorldMatrix(const mat4 &matrix)
Sets both the local and the world matrices.
Definition: Transform.hpp:176
void setBackSpecular(const fvec4 &color)
Definition: Shader.hpp:813
void setBackEmission(const fvec4 &color)
Definition: Shader.hpp:814
const std::vector< ref< Uniform > > & uniforms() const
Definition: UniformSet.hpp:68
void setFormat(ETextureFormat format)
Definition: Texture.hpp:181
Texture * texture()
The texture sampler by a texture unit.
Definition: Shader.hpp:1768
VLX wrapper of vl::GLSLProgram.
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
VLX wrapper of vl::DistanceLODEvaluator and vl::PixelLODEvaluator.
void setEnableMask(unsigned int mask)
The enable mask of an Actor is usually used to defines whether the actor should be rendered or not de...
Definition: Actor.hpp:265
const char * vlx_EUniformType(EUniformType type)
Definition: vlxutils.hpp:867
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
VLXValue * getValue(const char *key)
Definition: VLXValue.hpp:611
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
bool genMipmaps() const
Definition: Texture.hpp:188
void setSpotCutoff(float spotcutoff)
Valid values are from 0.0f to 90.0f plus the special value 180.0f (default) which disables the spot l...
Definition: Light.hpp:88
vec2 vlx_vec2(const VLXArrayReal *arr)
Definition: vlxutils.hpp:54
void setBoundingBox(const AABB &aabb)
Sets the bounding box of a Renderable.
Definition: Renderable.hpp:129
unsigned int enableMask() const
The enable mask of an Actor is usually used to defines whether the actor should be rendered or not de...
Definition: Actor.hpp:270
const fvec4 & backAmbient() const
Definition: Shader.hpp:817
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
void exportMaterial(const Material *obj, VLXStructure *vlx)
bool isDisplayListEnabled() const
Returns true if display lists are enabled for a Renderable (disabled by default). ...
Definition: Renderable.hpp:189
void getUniform(double *value) const
Definition: Uniform.hpp:230
void exportLight(VLXSerializer &s, const Light *obj, VLXStructure *vlx)
void setPatchVertices(int vertices)
Specifies the number of vertices that will be used to make up a single patch primitive.
ref< VLXStructure > export_ArrayT(VLXSerializer &s, const Object *arr_abstract)
RenderState wrapping the OpenGL function glColor(), see also http://www.opengl.org/sdk/docs/man/xhtml...
Definition: Shader.hpp:94
const fvec3 & spotDirection() const
Definition: Light.hpp:82
The Geometry class is a Renderable that implements a polygonal mesh made of polygons, lines and points.
Definition: Geometry.hpp:66
EUniformType
Uniform types, see also vl::UniformInfo, vl::GLSLProgram, vl::Uniform, http://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniform.xml.
VLXList * getList()
Definition: VLXValue.hpp:409
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
const ArrayAbstract * colorArray() const
Conventional color array.
Definition: Geometry.hpp:260
int activeLod() const
Returns the lod to be used for rendering.
Definition: Effect.hpp:217
void importActor(VLXSerializer &s, const VLXStructure *vlx, Actor *obj)
void setPatchDefaultInnerLevel(const fvec2 &level)
The two floating-point values corresponding to the tow inner tessellation levels for each subsequent ...
void importLODEvaluator(VLXSerializer &s, const VLXStructure *vlx, LODEvaluator *obj)
Viewport * viewport()
The viewport bound to a camera.
Definition: Camera.hpp:141
VLXValue export_Sphere(const Sphere &sphere)
Definition: VLXWrappers.hpp:93
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
const fvec4 & backSpecular() const
Definition: Shader.hpp:819
std::string vlx_makeTag(const Object *obj)
Definition: vlxutils.hpp:44
Visualization Library main namespace.
void setTexParameter(TexParameter *tex_param)
The TexParameter used by the sampler used to override the one specified by the bound Texture...
Definition: Shader.hpp:1775
VLX wrapper of vl::Uniform.
Sphere import_Sphere(const VLXStructure *vlx)
void setUniform4i(int count, const int *value)
Definition: Uniform.hpp:102
const fvec4 & diffuse() const
Definition: Light.hpp:66
ETexParamFilter minFilter() const
Definition: Texture.hpp:72
void setUniformMatrix2x4f(int count, const float *value)
Definition: Uniform.hpp:127
void setCompareFunc(ETexCompareFunc func)
Definition: Texture.hpp:94
Wraps a GLSL tessellation control shader to be bound to a GLSLProgram: the shader this shader will ru...
Definition: GLSL.hpp:172
void importCamera(VLXSerializer &s, const VLXStructure *vlx, Camera *obj)
void exportNormal(const Normal *obj, VLXStructure *vlx)
const fvec4 & frontAmbient() const
Definition: Shader.hpp:805
Wraps a GLSL fragment shader to be bound to a GLSLProgram: the shader this shader will run on the pro...
Definition: GLSL.hpp:136
VLX wrapper of vl::GLSLVertexShader, vl::GLSLFragmentShader, vl::GLSLGeometryShader, vl::GLSLTessControlShader, vl::GLSLTessEvaluationShader.
void setGenerateMipmap(bool generate_mipmap)
Definition: Texture.hpp:92
virtual bool primitiveRestartEnabled() const
Returns whether the primitive-restart functionality is enabled or not.
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
ivec4 vlx_ivec4(const VLXArrayInteger *arr)
Definition: vlxutils.hpp:60
void setClearColorUInt(unsigned int r, unsigned int g, unsigned int b, unsigned int a)
Definition: Viewport.hpp:87
bool generateMipmap() const
Definition: Texture.hpp:79
void exportColor(const Color *obj, VLXStructure *vlx)
Base interface for all DrawElements* sub classes.
DepthSortCallback sorts the primitives of the Geometry bound to the Actor in which the callback is in...
int count() const
Definition: Uniform.hpp:261
Key/value pair used by VLXStructure.
Definition: VLXValue.hpp:581
const unsigned char * ptr() const
Returns the pointer to the first element of the local buffer. Equivalent to bufferObject()->ptr() ...
Definition: Array.hpp:103
Transform * boundTransform()
Returns the vl::Transform to which the Light is attached.
Definition: ClipPlane.hpp:71
vec4 vlx_vec4(const VLXArrayReal *arr)
Definition: vlxutils.hpp:58
void exportActor(VLXSerializer &s, const Actor *obj, VLXStructure *vlx)
void * rawData()
Definition: Uniform.hpp:316
float quadraticAttenuation() const
Definition: Light.hpp:102
const fvec4 & frontDiffuse() const
Definition: Shader.hpp:806
EClearColorMode clearColorMode() const
Definition: Viewport.hpp:102
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
void setFixedSamplesLocations(bool fixed)
Definition: Texture.hpp:203
Base class for most of the OpenGL render state wrapper classes.
Definition: RenderState.hpp:50
void importLight(VLXSerializer &s, const VLXStructure *vlx, Light *obj)
VLXStructure * getStructure()
Definition: VLXValue.hpp:401
void setMinFilter(ETexParamFilter minfilter)
Definition: Texture.hpp:84
An array of vl::ivec3.
Definition: Array.hpp:432
void setRenderState(RenderStateNonIndexed *renderstate)
Definition: Shader.hpp:2183
PatchParameter * patchParameter()
The PatchParameter attached to a DrawCall to be used when using primitive-type PT_PATCHES.
Definition: DrawCall.hpp:172
uvec4 vlx_uivec4(const VLXArrayInteger *arr)
Definition: vlxutils.hpp:62
void importActorEventCallback(VLXSerializer &s, const VLXStructure *vlx, ActorEventCallback *obj)
void setUniformMatrix4x3d(int count, const double *value)
Definition: Uniform.hpp:141
VLXValue export_ShaderPasses(VLXSerializer &s, const ShaderPasses *sh_seq)
void setDepthTextureMode(EDepthTextureMode mode)
Definition: Texture.hpp:95
EProjectionMatrixType
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
void setImagePath(const String &path)
Definition: Texture.hpp:168
#define VLX_IMPORT_CHECK_RETURN(Condition, Obj)
Definition: VLXWrappers.hpp:43
void setFrontEmission(const fvec4 &color)
Definition: Shader.hpp:802
bool isOccludee() const
If is_occludee equals true an occlusion test will be performed before the rendering of the Actor (if ...
Definition: Actor.hpp:427
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
void setBackShininess(float shininess)
Definition: Shader.hpp:815
int height() const
Definition: Viewport.hpp:71
virtual void computePointerVector()=0
Computes the pointer vector to be used when BufferObjects are DISABLED.
real fov() const
The field of view of the camera.
Definition: Camera.hpp:96
Wraps the OpenGL function glClipPlane().
Definition: ClipPlane.hpp:49
int width() const
Definition: Viewport.hpp:69
VLX wrapper of vl::Renderable.
EColorMaterial
const std::string & tag() const
Definition: VLXValue.hpp:62
void setValue(const fvec3 &color)
Definition: Shader.hpp:142
const char * vlx_EPolygonFace(EPolygonFace pf)
Definition: vlxutils.hpp:335
mat4 vlx_mat4(const VLXArrayReal *arr)
Definition: vlxutils.hpp:182
std::vector< T > & value()
Definition: VLXValue.hpp:115
const std::map< std::string, int > & fragDataLocations() const
Definition: GLSL.hpp:353
real top() const
&#39;top&#39; parameter as passed to the last setProjectionFrustum() or setProjectionOrtho*() ...
Definition: Camera.hpp:125
An array of GLushort.
Definition: Array.hpp:473
For internal use only.
Definition: GLSL.hpp:50
std::vector< Value > & value()
Definition: VLXValue.hpp:606
void setSamples(int samples)
Definition: Texture.hpp:200
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
void exportEffect(VLXSerializer &s, const Effect *obj, VLXStructure *vlx)
void setConstantAttenuation(float constantattenuation)
If the light is positional, rather than directional, its intensity is attenuated by the reciprocal of...
Definition: Light.hpp:107
const std::vector< ref< Object > > & resources() const
size_t childrenCount() const
Returns the number of child Transform.
Definition: Transform.hpp:243
const std::string & name() const
Returns the name of the uniform variable.
Definition: Uniform.hpp:86
RenderState wrapping the OpenGL function glVertexAttrib(), see also http://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml for more information.
Definition: Shader.hpp:60
void exportPatchParameter(const PatchParameter *pp, VLXStructure *vlx)
UniformSet * getUniformSet()
Returns a GLSLProgram&#39;s static UniformSet. Static uniforms are those uniforms whose value is constant...
Definition: GLSL.hpp:470
void exportUniform(const Uniform *uniform, VLXStructure *vlx)
An array of vl::ubvec3.
Definition: Array.hpp:459
VLX wrapper of vl::Actor.
The base class for all the reference counted objects.
Definition: Object.hpp:158
See DrawElements.
void setRenderRank(int rank)
Modifies the rendering rank of an Actor.
Definition: Actor.hpp:231
void exportClipPlane(VLXSerializer &s, const ClipPlane *clip, VLXStructure *vlx)
An array of vl::dvec2.
Definition: Array.hpp:421
const Plane & plane() const
Returns the actual plane used to perform the clipping.
Definition: ClipPlane.hpp:77
void setBorderColor(fvec4 bordercolor)
Definition: Texture.hpp:90
void exportDrawCall(VLXSerializer &s, const DrawCall *dcall, VLXStructure *vlx)
void get(std::vector< ref< T > > &resources, bool clear_vector=true)
Returns all the objects of the specified type in the given vector.
An abstract class that represents all the objects that can be rendered.
Definition: Renderable.hpp:58
The TextureSampler class associates a Texture object to an OpenGL texture unit.
Definition: Shader.hpp:1747
const uvec4 & clearColorUInt() const
Definition: Viewport.hpp:89
void setSource(const String &source_or_path)
Sets the sources for this shader and schedules a recompilation for it. If the string passed is a file...
Definition: GLSL.cpp:115
virtual void exportRenderable(const Renderable *obj, VLXStructure *vlx)
ETexParamWrap wrapR() const
Definition: Texture.hpp:76
VLXValue vlx_Identifier(const std::string &str)
Definition: vlxutils.hpp:46
Object * importVLX(const VLXStructure *st)
void exportGLSLShader(const GLSLShader *glslsh, VLXStructure *vlx)
void setValue(const fvec4 &value)
Definition: Shader.hpp:74
EType type() const
Definition: VLXValue.hpp:395
int count() const
returns the number of vertices to be rendered.
Definition: DrawArrays.hpp:129
const std::vector< double > & distanceRangeSet() const
int lineNumber() const
Definition: VLXValue.hpp:54
void setUniformMatrix2d(int count, const double *value)
Definition: Uniform.hpp:132
int renderRank() const
Returns the rendering rank of an Actor.
Definition: Actor.hpp:246
void importColor(VLXSerializer &s, const VLXStructure *vlx, Color *obj)
LODEvaluator * lodEvaluator()
Returns the installed LODEvaluator (if any) or NULL.
Definition: Actor.hpp:255
void setUniform3ui(int count, const unsigned int *value)
Definition: Uniform.hpp:106
VLX wrapper of vl::Transform.
An array of vl::bvec4.
Definition: Array.hpp:452
virtual void computeBufferObjectPointerVector()=0
Computes the pointer vector to be used when BufferObjects are ENABLED.
Transform * boundTransform()
Definition: Light.cpp:119
bool empty() const
Returns true if length() == 0.
Definition: String.hpp:136
Implements the viewport and clearing settings associated to a Camera.
Definition: Viewport.hpp:51
Wrapper for all VLX value types.
Definition: VLXValue.hpp:239
ETexParamWrap wrapS() const
Definition: Texture.hpp:74
real farPlane() const
The far clipping plane.
Definition: Camera.hpp:110
LODEvaluator * lodEvaluator()
Returns the installed LODEvaluator (if any) or NULL.
Definition: Effect.hpp:194
void setTransform(Transform *transform)
Binds a Transform to an Actor.
Definition: Actor.hpp:182
void setClearDepth(real depth)
Definition: Viewport.hpp:94
fvec4 borderColor() const
Definition: Texture.hpp:77
real bottom() const
&#39;bottom&#39; parameter as passed to the last setProjectionFrustum() or setProjectionOrtho*() ...
Definition: Camera.hpp:121
void setUniform(Uniform *uniform)
Utility function using getUniformSet(). Adds a Uniform to this program&#39;s static uniform set...
Definition: GLSL.hpp:476
void exportVertexAttrib(const VertexAttrib *obj, VLXStructure *vlx)
void setBackAmbient(const fvec4 &color)
Definition: Shader.hpp:811
void setRight(real v)
Definition: Camera.hpp:118
int x() const
Definition: Viewport.hpp:65
AABB import_AABB(const VLXStructure *vlx)
Definition: VLXWrappers.hpp:67
const BufferObject * bufferObject() const
Definition: Texture.hpp:174
void setRenderRank(int rank)
Modifies the rendering rank of an Actor.
Definition: Effect.hpp:164
void setOccludee(bool is_occludee)
If is_occludee equals true an occlusion test will be performed before the rendering of the Actor (if ...
Definition: Actor.hpp:423
void importDrawCall(VLXSerializer &s, const VLXStructure *vlx, DrawCall *draw_call)
void importGLSLProgram(VLXSerializer &s, const VLXStructure *vlx, GLSLProgram *obj)
void setUniformMatrix4x3f(int count, const float *value)
Definition: Uniform.hpp:130
const char * vlx_EEnable(EEnable en)
Definition: vlxutils.hpp:1099
void setUniformMatrix3x2f(int count, const float *value)
Definition: Uniform.hpp:126
void setTexCoordArray(int tex_unit, ArrayAbstract *data)
Conventional texture coords arrays.
Definition: Geometry.cpp:222
void setProjectionMatrix(const mat4 &mat, EProjectionMatrixType proj_type)
The Camera&#39;s projection matrix.
Definition: Camera.hpp:172
A sequence of Shader objects each of which represent a rendering pass.
Definition: Effect.hpp:51
void exportDrawCallBase(VLXSerializer &s, const DrawCall *obj, VLXStructure *vlx)
void setPatchDefaultOuterLevel(const fvec4 &level)
The four floating-point values corresponding to the four outer tessellation levels for each subsequen...
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
void setQuadraticAttenuation(float quadraticattenuation)
If the light is positional, rather than directional, its intensity is attenuated by the reciprocal of...
Definition: Light.hpp:101
An array of 64 bits integers, can also have a tag.
Definition: VLXValue.hpp:132
T * as()
Casts an Object to the specified class.
Definition: Object.hpp:282
void setDimension(ETextureDimension dimension)
Definition: Texture.hpp:178
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
void setLODEvaluator(LODEvaluator *lod_evaluator)
Installs the LODEvaluator used to compute the current LOD at rendering time.
Definition: Effect.hpp:191
ETextureDimension dimension() const
Definition: Texture.hpp:179
VLXArrayReal * getArrayReal()
Definition: VLXValue.hpp:446
VLX wrapper of vl::Camera.
void setUniform2ui(int count, const unsigned int *value)
Definition: Uniform.hpp:105
void setEnabled(bool enabled)
Whether an Actor should be considered for rendering, picking, scene bounding box calculation etc...
Definition: Actor.hpp:274
void importGLSLShader(VLXSerializer &s, const VLXStructure *vlx, GLSLShader *obj)
void setUniformMatrix4f(int count, const float *value)
Definition: Uniform.hpp:123
int patchVertices() const
Returns the number of vertices that will be used to make up a single patch primitive.
void setUniform(Uniform *uniform)
Equivalent to getUniformSet()->setUniform(uniform)
Definition: Actor.cpp:119
void setActiveLod(int lod)
Sets the lod to be used for rendering.
Definition: Effect.hpp:209
The ActorEventCallback class defines a callback object to react to Actor-related events.
Definition: Actor.hpp:75
void exportActorEventCallback(VLXSerializer &s, const ActorEventCallback *cb, VLXStructure *vlx)
#define NULL
Definition: OpenGLDefs.hpp:81
int renderRank() const
Returns the rendering rank of an Effect.
Definition: Effect.hpp:167
void setViewMatrix(const mat4 &mat)
Sets the Camera&#39;s view matrix (inverse of the modeling matrix).
Definition: Camera.hpp:157
void exportCamera(VLXSerializer &s, const Camera *obj, VLXStructure *vlx)
Manages most of the OpenGL rendering states responsible of the final aspect of the rendered objects...
Definition: Shader.hpp:1841
An array of vl::ivec2.
Definition: Array.hpp:430
void setSpotExponent(float spotexponent)
Definition: Light.hpp:84
unsigned int enableMask() const
The enable mask of an Actor&#39;s Effect defines whether the actor should be rendered or not depending on...
Definition: Effect.hpp:203
VLX wrapper of vl::VertexAttrib.
float anisotropy() const
Definition: Texture.hpp:78
VLX wrapper of vl::SecondaryColor.
void setPrimitiveRestartEnabled(bool enabled)
Enables the primitive-restart functionality.
real clearDepth() const
Definition: Viewport.hpp:95
void exportViewport(const Viewport *obj, VLXStructure *vlx)
arr_type * indexBuffer()
The BufferObject containing the indices used to render.
const ref< Transform > * children() const
Returns the array containing the child Transforms.
Definition: Transform.hpp:237
void setWidth(int width)
Definition: Viewport.hpp:68
void setClearColorMode(EClearColorMode mode)
Definition: Viewport.hpp:101
Abstract class to compute the appropriate LOD of an Actor or Effect.
void setSpotDirection(const fvec3 &spotdirection)
Definition: Light.hpp:81
A LODEvaluator that computes the appropriate LOD based on the distance of an Actor from the Camera...
int lineNumber() const
Definition: VLXValue.hpp:518
An array of GLfloat.
Definition: Array.hpp:410
void importResourceDatabase(VLXSerializer &s, const VLXStructure *vlx, ResourceDatabase *resdb)
RenderState wrapping the OpenGL function glMaterial() and glColorMaterial(), see also http://www...
Definition: Shader.hpp:774
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
Defines the sequence of Shader objects used to render an Actor.
Definition: Effect.hpp:91
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
const fvec4 & frontSpecular() const
Definition: Shader.hpp:807
See MultiDrawElements.
void setUniformMatrix2x3f(int count, const float *value)
Definition: Uniform.hpp:125
void signalImportError(const String &str)
An array of vl::usvec2.
Definition: Array.hpp:475
void setDisplayListEnabled(bool enabled)
Enable/disable display lists (disabled by default).
Definition: Renderable.hpp:192
Effect * effect()
Returns the Effect bound to an Actor.
Definition: Actor.hpp:199
void setUniform4ui(int count, const unsigned int *value)
Definition: Uniform.hpp:107
void importRenderable(const VLXStructure *vlx, Renderable *ren)
void importSecondaryColor(VLXSerializer &s, const VLXStructure *vlx, SecondaryColor *obj)
EEnable
Constant that enable/disable a specific OpenGL feature, see also Shader, Shader::enable(), Shader::disable(), Shader::isEnabled()
The BufferObject class is a Buffer that can upload its data on the GPU memory.
const ivec4 & clearColorInt() const
Definition: Viewport.hpp:85
A simple sequence of VLXValue objects, can also have a tag.
Definition: VLXValue.hpp:633
void importTexture(VLXSerializer &s, const VLXStructure *vlx, Texture *obj)
int instances() const
Returns the number of instances for this set of primitives.
Base cass for all class wrappers implementing the translation to/from its VLX representation.
ETexParamFilter magFilter() const
Definition: Texture.hpp:73
ETextureDimension vlx_ETextureDimension(const VLXValue &value, VLXSerializer &s)
Definition: vlxutils.hpp:1258
const vec3 & normal() const
Definition: Plane.hpp:74
const fvec4 & specular() const
Definition: Light.hpp:69
An array of vl::ubvec4.
Definition: Array.hpp:461
VLX wrapper of vl::Effect.
const std::string & objectName() const
The name of the object, by default set to the object&#39;s class name.
Definition: Object.hpp:217
void setColorMaterial(EPolygonFace face, EColorMaterial color)
Definition: Shader.hpp:825
int clearStencil() const
Definition: Viewport.hpp:92
void setUniform2f(int count, const float *value)
Definition: Uniform.hpp:110
An array of vl::bvec2.
Definition: Array.hpp:448
void importTextureSampler(VLXSerializer &s, const VLXStructure *vlx, TextureSampler *obj)
The base class of DrawArrays, DrawElements, MultiDrawElements and DrawRangeElements.
Definition: DrawCall.hpp:90
UniformSet * getUniformSet()
Returns the UniformSet installed.
Definition: Shader.hpp:2272
void importClipPlane(VLXSerializer &s, const VLXStructure *vlx, ClipPlane *obj)
SetupParams wraps all the parameters needed to crate a Texture.
Definition: Texture.hpp:154
An array of vl::dvec3.
Definition: Array.hpp:423
void setFrontDiffuse(const fvec4 &color)
Definition: Shader.hpp:800
Unknown or other projection type.
VLX wrapper of vl::Color.
void setLODEvaluator(LODEvaluator *lod_evaluator)
Installs the LODEvaluator used to compute the current LOD at rendering time.
Definition: Actor.hpp:252
#define VLX_IMPORT_CHECK_RETURN_NULL(Condition, Obj)
Definition: VLXWrappers.hpp:50
void setColorMaterialEnabled(bool enabled)
Definition: Shader.hpp:828
void bindTransform(Transform *transform)
Bind the camera to a Transform.
Definition: Camera.hpp:147
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
VLX wrapper of vl::Texture.
RenderStateSet * getRenderStateSet()
Definition: Shader.hpp:2246
void setName(const char *name)
Sets the name of the uniform variable.
Definition: Uniform.hpp:92
void setUniformMatrix2x4d(int count, const double *value)
Definition: Uniform.hpp:138
An array of vl::svec2.
Definition: Array.hpp:466
void bindTransform(Transform *transform)
If NULL follows the camera otherwise the given transformation node.
Definition: Light.cpp:114
const fvec4 & position() const
The position or direction of a light.
Definition: Light.hpp:79
const fvec4 & clearColor() const
Definition: Viewport.hpp:81
void setValue(const fvec4 &color)
Definition: Shader.hpp:108
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
void setLod(int lod_index, Renderable *renderable)
Sets the Renderable object representing the LOD level specifed by lod_index.
Definition: Actor.hpp:159
virtual bool primitiveRestartEnabled() const
Returns whether the primitive-restart functionality is enabled or not (requires OpenGL 3...
const fvec2 & patchDefaultInnerLevel() const
The two floating-point values corresponding to the tow inner tessellation levels for each subsequent ...
virtual ref< Object > importVLX(VLXSerializer &s, const VLXStructure *vlx)
An array of vl::svec4.
Definition: Array.hpp:470
const String & path() const
The path from which the shader was loaded.
Definition: GLSL.hpp:78
An array of vl::bvec3.
Definition: Array.hpp:450
virtual ref< VLXStructure > exportVLX(VLXSerializer &s, const Object *obj)
EPrimitiveType vlx_EPrimitiveType(const VLXValue &value, VLXSerializer &s)
Definition: vlxutils.hpp:1188