?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
changed: gcc8 base update
[opensg.git] / Source / System / FileIO / Collada / OSGColladaSource.cpp
blob456d9495fb8a99bb48cf319681edcb7387265f44
1 /*---------------------------------------------------------------------------*\
2 * OpenSG *
3 * *
4 * *
5 * Copyright (C) 2009 by the OpenSG Forum *
6 * *
7 * www.opensg.org *
8 * *
9 * contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de *
10 * *
11 \*---------------------------------------------------------------------------*/
12 /*---------------------------------------------------------------------------*\
13 * License *
14 * *
15 * This library is free software; you can redistribute it and/or modify it *
16 * under the terms of the GNU Library General Public License as published *
17 * by the Free Software Foundation, version 2. *
18 * *
19 * This library is distributed in the hope that it will be useful, but *
20 * WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
22 * Library General Public License for more details. *
23 * *
24 * You should have received a copy of the GNU Library General Public *
25 * License along with this library; if not, write to the Free Software *
26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
27 * *
28 \*---------------------------------------------------------------------------*/
29 /*---------------------------------------------------------------------------*\
30 * Changes *
31 * *
32 * *
33 * *
34 * *
35 * *
36 * *
37 \*---------------------------------------------------------------------------*/
38
39 #if __GNUC__ >= 4 || __GNUC_MINOR__ >=3
40 #pragma GCC diagnostic ignored "-Wold-style-cast"
41 #endif
42
43 #include "OSGColladaSource.h"
44
45 #if defined(OSG_WITH_COLLADA) || defined(OSG_DO_DOC)
46
47 #include "OSGColladaLog.h"
48 #include "OSGTypedGeoVectorProperty.h"
49 #include "OSGAnimMatrixDataSource.h"
50 #include "OSGAnimQuaternionDataSource.h"
51 #include "OSGAnimVec3fDataSource.h"
52
53 #include <dom/domSource.h>
54 #include <dom/domAccessor.h>
55 #include <dom/domParam.h>
56 #include <dom/domIDREF_array.h>
57
58 OSG_BEGIN_NAMESPACE
59
60 ColladaElementRegistrationHelper ColladaSource::_regHelper(
61 &ColladaSource::create, "source");
62
63
64 ColladaElementTransitPtr
65 ColladaSource::create(daeElement *elem, ColladaGlobal *global)
66 {
67 return ColladaElementTransitPtr(new ColladaSource(elem, global));
68 }
69
70 void
71 ColladaSource::read(ColladaElement *colElemParent)
72 {
73 OSG_COLLADA_LOG(("ColladaSource::read\n"));
74
75 domSourceRef source = getDOMElementAs<domSource>();
76
77 OSG_COLLADA_LOG(("ColladaSource::read: id [%s]\n",
78 source->getID()));
79
80 domSource::domTechnique_commonRef techCom = source ->getTechnique_common();
81 domAccessorRef acc = techCom->getAccessor ();
82
83 _offset = acc->getOffset();
84 _count = acc->getCount ();
85 _stride = acc->getStride();
86 _elemSize = 0;
87
88 _strideMap.resize(_stride, -1);
89
90 const domParam_Array &params = acc->getParam_array();
91
92 UInt32 idx = 0;
93
94 for(UInt32 i = 0; i < params.getCount(); ++i)
95 {
96 if(params[i]->getName() == NULL)
97 {
98 _strideMap[idx] = -1;
99 ++idx;
100 }
101 else
102 {
103 std::string paramType = params[i]->getType();
104
105 if(paramType == "float")
106 {
107 _strideMap[idx] = _elemSize;
108 ++idx;
109 ++_elemSize;
110 }
111 else if(paramType == "float4x4")
112 {
113 for(UInt32 j = 0; j < 16; ++j)
114 {
115 _strideMap[idx] = _elemSize;
116 ++idx;
117 ++_elemSize;
118 }
119 }
120 else if(paramType == "Name")
121 {
122 _strideMap[idx] = _elemSize;
123 ++idx;
124 ++_elemSize;
125 }
126 else
127 {
128 SWARNING << "ColladaSource::read: Unknown <param> type ["
129 << paramType << "], defaulting to elemSize 1"
130 << std::endl;
131
132 _strideMap[idx] = _elemSize;
133 ++idx;
134 ++_elemSize;
135 }
136 }
137 }
138
139 OSG_COLLADA_LOG(("ColladaSource::read: offset [%d] count [%d] "
140 "stride [%d] elemSize [%d]\n",
141 _offset, _count, _stride, _elemSize));
142 }
143
144 GeoVectorProperty *
145 ColladaSource::getProperty(const std::string &semantic)
146 {
147 GeoVectorProperty *retVal = NULL;
148 domSourceRef source = getDOMElementAs<domSource>();
149 PropertyMapIt pmIt = _propMap.find(semantic);
150
151 if(pmIt != _propMap.end())
152 {
153 retVal = pmIt->second;
154 }
155 else
156 {
157 retVal = fillProperty(semantic);
158 }
159
160 if(retVal == NULL)
161 {
162 SFATAL << "ColladaSource::getProperty: Could not read data for "
163 << "semantic [" << semantic << "] from source ["
164 << source->getId() << "]."
165 << std::endl;
166 }
167
168 return retVal;
169 }
170
171 AnimKeyFrameDataSource *
172 ColladaSource::getDataSource(const std::string &semantic)
173 {
174 AnimKeyFrameDataSource *retVal = NULL;
175 domSourceRef source = getDOMElementAs<domSource>();
176 DataSourceMapIt dmIt = _dataMap.find(semantic);
177
178 if(dmIt != _dataMap.end())
179 {
180 retVal = dmIt->second;
181 }
182 else
183 {
184 retVal = fillDataSource(semantic);
185 }
186
187 if(retVal == NULL)
188 {
189 SFATAL << "ColladaSource::getDataSource: Could not read data for "
190 << "semantic [" << semantic << "] from source ["
191 << source->getId() << "]." << std::endl;
192 }
193
194 return retVal;
195 }
196
197 const ColladaSource::NameStore &
198 ColladaSource::getNameStore(void)
199 {
200 if(_nameStore.empty() == true && _count > 0)
201 {
202 fillNameStore();
203 }
204
205 return _nameStore;
206 }
207
208 const ColladaSource::MatrixStore &
209 ColladaSource::getMatrixStore(void)
210 {
211 if(_matrixStore.empty() == true && _count > 0)
212 {
213 fillMatrixStore();
214 }
215
216 return _matrixStore;
217 }
218
219 const ColladaSource::FloatStore &
220 ColladaSource::getFloatStore(void)
221 {
222 if(_floatStore.empty() == true && _count > 0)
223 {
224 fillFloatStore();
225 }
226
227 return _floatStore;
228 }
229
230 std::string
231 ColladaSource::getNameValue(UInt32 idx)
232 {
233 std::string retVal;
234 getNameValue(idx, retVal);
235
236 return retVal;
237 }
238
239 bool
240 ColladaSource::getNameValue(UInt32 idx, std::string &nameVal)
241 {
242 bool retVal = false;
243 domSourceRef source = getDOMElementAs<domSource> ();
244 domSource::domTechnique_commonRef techCom = source ->getTechnique_common();
245 domAccessorRef acc = techCom->getAccessor ();
246
247 daeURI dataURI = acc->getSource();
248 domName_arrayRef dataArray =
249 daeSafeCast<domName_array>(dataURI.getElement());
250
251 if(dataArray == NULL)
252 {
253 SWARNING << "ColladaSource::getNameValue: Could not find <name_array> "
254 << "for [" << dataURI.str() << "]." << std::endl;
255 return retVal;
256 }
257
258 if(_elemSize != 1)
259 {
260 SWARNING << "ColladaSource::getNameValue: Unexpected elemSize ["
261 << _elemSize << "] != 1." << std::endl;
262 }
263
264 nameVal = dataArray->getValue()[_offset + idx * _stride];
265 retVal = true;
266
267 return retVal;
268 }
269
270 Real32
271 ColladaSource::getFloatValue(UInt32 idx)
272 {
273 Real32 retVal;
274 getFloatValue(idx, retVal);
275
276 return retVal;
277 }
278
279 bool
280 ColladaSource::getFloatValue(UInt32 idx, Real32 &floatVal)
281 {
282 bool retVal = false;
283 domSourceRef source = getDOMElementAs<domSource> ();
284 domSource::domTechnique_commonRef techCom = source->getTechnique_common();
285 domAccessorRef acc = techCom->getAccessor ();
286
287 daeURI dataURI = acc->getSource();
288 domFloat_arrayRef dataArray =
289 daeSafeCast<domFloat_array>(dataURI.getElement());
290
291 if(dataArray == NULL)
292 {
293 SWARNING << "ColladaSource::getFloatValue: Could not find "
294 << "<float_array> for [" << dataURI.str() << "]."
295 << std::endl;
296 return retVal;
297 }
298
299 if(_elemSize != 1)
300 {
301 SWARNING << "ColladaSource::getFloatValue: Unexpected elemSize ["
302 << _elemSize << "] != 1." << std::endl;
303 }
304
305 floatVal = dataArray->getValue()[_offset + idx * _stride];
306 retVal = true;
307
308 return retVal;
309 }
310
311 Matrix
312 ColladaSource::getMatrixValue(UInt32 idx)
313 {
314 Matrix retVal;
315 getMatrixValue(idx, retVal);
316
317 return retVal;
318 }
319
320 bool
321 ColladaSource::getMatrixValue(UInt32 idx, Matrix &matVal)
322 {
323 bool retVal = false;
324 domSourceRef source = getDOMElementAs<domSource> ();
325 domSource::domTechnique_commonRef techCom = source->getTechnique_common();
326 domAccessorRef acc = techCom->getAccessor ();
327
328 daeURI dataURI = acc->getSource();
329 domFloat_arrayRef dataArray =
330 daeSafeCast<domFloat_array>(dataURI.getElement());
331
332 if(dataArray == NULL)
333 {
334 SWARNING << "ColladaSource::getMatrixValue: Could not find "
335 << "<float_array> for [" << dataURI.str() << "]."
336 << std::endl;
337 return retVal;
338 }
339
340 if(_elemSize != 16)
341 {
342 SWARNING << "ColladaSource::getMatrixValue: Not a matrix <source>, "
343 << "elemSize [" << _elemSize << "] != 16" << std::endl;
344 }
345
346 UInt32 currIdx = 0;
347 UInt32 currRow = 0;
348 UInt32 currCol = 0;
349 const domListOfFloats &data = dataArray->getValue();
350
351 for(UInt32 i = _offset + (idx * _stride);
352 i < _offset + (idx + 1) * _stride; ++i)
353 {
354 if(_strideMap[currIdx] != -1)
355 {
356 matVal[currCol][currRow] = data[i];
357 }
358
359 ++currIdx;
360 ++currRow;
361
362 if(currRow >= 4)
363 {
364 currRow = 0;
365 ++currCol;
366 }
367 }
368
369 return true;
370 }
371
372
373 ColladaSource::ColladaSource(daeElement *elem, ColladaGlobal *global)
374 : Inherited (elem, global)
375 , _offset (0)
376 , _count (0)
377 , _stride (1)
378 , _elemSize (0)
379 , _strideMap ()
380 , _propMap ()
381 , _dataMap ()
382 , _nameStore ()
383 , _matrixStore()
384 , _floatStore ()
385 {
386 }
387
388 ColladaSource::~ColladaSource(void)
389 {
390 }
391
392 GeoVectorProperty *
393 ColladaSource::fillProperty(const std::string &semantic)
394 {
395 OSG_COLLADA_LOG(("ColladaSource::fillProperty: semantic [%s]\n",
396 semantic.c_str()));
397
398 GeoVectorPropertyUnrecPtr prop = NULL;
399 domSourceRef source = getDOMElementAs<domSource> ();
400 domSource::domTechnique_commonRef techCom = source ->getTechnique_common();
401 domAccessorRef acc = techCom->getAccessor ();
402
403 daeURI dataURI = acc->getSource();
404 domFloat_arrayRef dataArray =
405 daeSafeCast<domFloat_array>(dataURI.getElement());
406
407 if(dataArray == NULL)
408 {
409 SWARNING << "ColladaSource::fillProperty: Could not find <float_array> "
410 << "for [" << dataURI.str() << "]." << std::endl;
411 return NULL;
412 }
413
414 const domListOfFloats &data = dataArray->getValue();
415
416 OSG_ASSERT((_offset + _count * _stride) <= data.getCount());
417
418 if(semantic == "POSITION")
419 {
420 if(_elemSize != 3)
421 {
422 SWARNING << "ColladaSource::fillProperty: Unexpected _elemSize ["
423 << _elemSize << "]." << std::endl;
424 return NULL;
425 }
426
427 prop = GeoPnt3fProperty::create();
428
429 Pnt3f currPnt;
430 UInt32 currIdx = 0;
431
432 for(UInt32 i = _offset; i < _count * _stride; ++i)
433 {
434 if(_strideMap[currIdx] != -1)
435 currPnt[_strideMap[currIdx]] = data[i];
436
437 ++currIdx;
438
439 if(currIdx == _stride)
440 {
441 prop->push_back(currPnt);
442 currIdx = 0;
443 }
444 }
445 }
446 else
447 {
448 OSG_COLLADA_LOG(("ColladaSource::fillProperty: Reading semantic [%s] "
449 "with elemSize [%d] stride [%d] offset [%d] count [%d]\n",
450 semantic.c_str(), _elemSize, _stride, _offset, _count));
451
452 if(_elemSize == 2)
453 {
454 prop = GeoVec2fProperty::create();
455 }
456 else if(_elemSize == 3)
457 {
458 prop = GeoVec3fProperty::create();
459 }
460 else if(_elemSize == 4)
461 {
462 prop = GeoVec4fProperty::create();
463 }
464 else
465 {
466 SWARNING << "ColladaSource::fillProperty: Unhandled element size ["
467 << _elemSize << "] for semantic [" << semantic << "]"
468 << std::endl;
469 return NULL;
470 }
471
472 Vec4f currVec;
473 UInt32 currIdx = 0;
474
475 for(UInt32 i = _offset; i < _count * _stride; ++i)
476 {
477 if(_strideMap[currIdx] != -1)
478 {
479 currVec[_strideMap[currIdx]] = data[i];
480 }
481
482 ++currIdx;
483
484 if(currIdx == _stride)
485 {
486 prop->push_back(currVec);
487 currIdx = 0;
488 }
489 }
490 }
491
492 if(prop != NULL)
493 {
494 _propMap.insert(PropertyMap::value_type(semantic, prop));
495 }
496
497 return prop;
498 }
499
500 AnimKeyFrameDataSource *
501 ColladaSource::fillDataSource(const std::string &semantic)
502 {
503 AnimKeyFrameDataSourceUnrecPtr retVal = NULL;
504 domSourceRef source = getDOMElementAs<domSource> ();
505 domSource::domTechnique_commonRef techCom = source ->getTechnique_common();
506 domAccessorRef acc = techCom->getAccessor ();
507
508 daeURI dataURI = acc->getSource();
509 domFloat_arrayRef dataArray =
510 daeSafeCast<domFloat_array>(dataURI.getElement());
511
512 if(dataArray == NULL)
513 {
514 SWARNING << "ColladaSource::fillDataSource: Could not find "
515 << "<float_array> for [" << dataURI.str() << "]."
516 << std::endl;
517 return NULL;
518 }
519
520 const domListOfFloats &data = dataArray->getValue();
521
522 OSG_ASSERT((_offset + _count * _stride) <= data.getCount());
523
524
525 if(_elemSize == 3)
526 {
527 AnimVec3fDataSourceUnrecPtr dataSource =
528 AnimVec3fDataSource::create();
529
530 Vec3f currVal;
531 UInt32 currIdx = 0;
532
533 for(UInt32 i = _offset; i < _count * _stride; ++i)
534 {
535 if(_strideMap[currIdx] != -1)
536 currVal[_strideMap[currIdx]] = data[i];
537
538 ++currIdx;
539
540 if(currIdx == _stride)
541 {
542 dataSource->editMFValues()->push_back(currVal);
543 currIdx = 0;
544 }
545 }
546
547 retVal = dataSource;
548 }
549 else if(_elemSize == 4)
550 {
551 AnimQuaternionDataSourceUnrecPtr dataSource =
552 AnimQuaternionDataSource::create();
553
554 Quaternion currVal;
555 UInt32 currIdx = 0;
556
557 for(UInt32 i = _offset; i < _count * _stride; ++i)
558 {
559 if(_strideMap[currIdx] != -1)
560 currVal[_strideMap[currIdx]] = data[i];
561
562 ++currIdx;
563
564 if(currIdx == _stride)
565 {
566 dataSource->editMFValues()->push_back(currVal);
567 currIdx = 0;
568 }
569 }
570
571 retVal = dataSource;
572 }
573 else if(_elemSize == 16)
574 {
575 AnimMatrixDataSourceUnrecPtr dataSource =
576 AnimMatrixDataSource::create();
577
578 Matrix currVal;
579 UInt32 currIdx = 0;
580 UInt32 currRowIdx = 0;
581 UInt32 currColIdx = 0;
582
583 for(UInt32 i = _offset; i < _count * _stride; ++i)
584 {
585 if(_strideMap[currIdx] != -1)
586 currVal[currColIdx][currRowIdx] = data[i];
587
588 ++currIdx;
589 ++currColIdx;
590
591 if(currColIdx >= 4)
592 {
593 currColIdx = 0;
594 ++currRowIdx;
595 }
596
597 if(currIdx == _stride)
598 {
599 dataSource->editMFValues()->push_back(currVal);
600 currIdx = 0;
601 currRowIdx = 0;
602 currColIdx = 0;
603 }
604 }
605
606 retVal = dataSource;
607 }
608 else
609 {
610 SWARNING << "ColladaSource::fillDataSource: Unhandled element size ["
611 << _elemSize << "] for semantic [" << semantic << "]"
612 << std::endl;
613 }
614
615 if(retVal != NULL)
616 {
617 _dataMap.insert(DataSourceMap::value_type(semantic, retVal));
618 }
619
620 return retVal;
621 }
622
623 void
624 ColladaSource::fillNameStore(void)
625 {
626 domSourceRef source = getDOMElementAs<domSource> ();
627 domSource::domTechnique_commonRef techCom = source ->getTechnique_common();
628 domAccessorRef acc = techCom->getAccessor ();
629
630 daeURI dataURI = acc->getSource();
631 domName_arrayRef nameArray =
632 daeSafeCast<domName_array> (dataURI.getElement());
633 domIDREF_arrayRef idrefArray =
634 daeSafeCast<domIDREF_array>(dataURI.getElement());
635
636 if(nameArray == NULL && idrefArray == NULL)
637 {
638 SWARNING << "ColladaSource::fillNameStore: Could not find <name_array>"
639 << " or <IDREF_array> for [" << dataURI.str() << "]."
640 << std::endl;
641 return;
642 }
643
644 if(nameArray != NULL)
645 {
646 std::string currVal;
647 UInt32 currIdx = 0;
648 const domListOfNames &data = nameArray->getValue();
649
650 for(UInt32 i = _offset; i < _count * _stride; ++i)
651 {
652 if(_strideMap[currIdx] != -1)
653 {
654 currVal = data[i];
655 }
656
657 ++currIdx;
658
659 if(currIdx == _stride)
660 {
661 _nameStore.push_back(currVal);
662 currIdx = 0;
663 }
664 }
665 }
666 else if(idrefArray != NULL)
667 {
668 std::string currVal;
669 UInt32 currIdx = 0;
670 const xsIDREFS &data = idrefArray->getValue();
671
672 for(UInt32 i = _offset; i < _count * _stride; ++i)
673 {
674 if(_strideMap[currIdx] != -1)
675 {
676 currVal = data[i].getID();
677 }
678
679 ++currIdx;
680
681 if(currIdx == _stride)
682 {
683 _nameStore.push_back(currVal);
684 currIdx = 0;
685 }
686 }
687 }
688 }
689
690 void
691 ColladaSource::fillMatrixStore(void)
692 {
693 domSourceRef source = getDOMElementAs<domSource> ();
694 domSource::domTechnique_commonRef techCom = source ->getTechnique_common();
695 domAccessorRef acc = techCom->getAccessor ();
696
697 daeURI dataURI = acc->getSource();
698 domFloat_arrayRef dataArray =
699 daeSafeCast<domFloat_array>(dataURI.getElement());
700
701 if(dataArray == NULL)
702 {
703 SWARNING << "ColladaSource::fillMatrixStore: Could not find "
704 << "<float_array> for [" << dataURI.str() << "]."
705 << std::endl;
706 return;
707 }
708
709 Matrix currVal;
710 UInt32 currIdx = 0;
711 UInt32 currRowIdx = 0;
712 UInt32 currColIdx = 0;
713 const domListOfFloats &data = dataArray->getValue();
714
715 for(UInt32 i = _offset; i < _count * _stride; ++i)
716 {
717 if(_strideMap[currIdx] != -1)
718 {
719 currVal[currColIdx][currRowIdx] = data[i];
720 }
721
722 ++currIdx;
723 ++currColIdx;
724
725 if(currColIdx >= 4)
726 {
727 currColIdx = 0;
728 ++currRowIdx;
729 }
730
731 if(currIdx == _stride)
732 {
733 _matrixStore.push_back(currVal);
734 currIdx = 0;
735 currRowIdx = 0;
736 currColIdx = 0;
737 }
738 }
739 }
740
741 void
742 ColladaSource::fillFloatStore(void)
743 {
744 domSourceRef source = getDOMElementAs<domSource> ();
745 domSource::domTechnique_commonRef techCom = source ->getTechnique_common();
746 domAccessorRef acc = techCom->getAccessor ();
747
748 daeURI dataURI = acc->getSource();
749 domFloat_arrayRef dataArray =
750 daeSafeCast<domFloat_array>(dataURI.getElement());
751
752 if(dataArray == NULL)
753 {
754 SWARNING << "ColladaSource::fillFloatStore: Could not find "
755 << "<float_array> for [" << dataURI.str() << "]."
756 << std::endl;
757 return;
758 }
759
760 Real32 currVal;
761 UInt32 currIdx = 0;
762 const domListOfFloats &data = dataArray->getValue();
763
764 for(UInt32 i = _offset; i < _count * _stride; ++i)
765 {
766 if(_strideMap[currIdx] != -1)
767 {
768 currVal = data[i];
769 }
770
771 ++currIdx;
772
773 if(currIdx == _stride)
774 {
775 _floatStore.push_back(currVal);
776 currIdx = 0;
777 }
778 }
779 }
780
781 OSG_END_NAMESPACE
782
783 #endif // OSG_WITH_COLLADA