?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fixed: auto_ptr -> unique_ptr
[opensg.git] / Source / System / FileIO / WRL / OSGVRMLNodeHelper.cpp
blob74fadb198842873c7ab4f26d508c960fb432013b
1 /*---------------------------------------------------------------------------*\
2 * OpenSG *
3 * *
4 * *
5 * Copyright (C) 2000-2002 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 #include <cstdlib>
40 #include <cstdio>
41
42 #include "OSGConfig.h"
43
44 #include <iostream>
45 #include <fstream>
46
47 #include "OSGVRMLNodeHelper.h"
48 #include "OSGSingletonHolder.ins"
49
50 #include "OSGFieldDescFactory.h"
51
52 #include "OSGScanParseSkel.h"
53 #include "OSGSceneFileHandler.h"
54 #include "OSGNameAttachment.h"
55 #include "OSGNode.h"
56 #include "OSGGroup.h"
57 #include "OSGMaterialGroup.h"
58 #include "OSGChunkMaterial.h"
59 #include "OSGGeometry.h"
60 #include "OSGGeoFunctions.h"
61 #include "OSGChunkMaterial.h"
62 #include "OSGMaterialChunk.h"
63 #include "OSGBlendChunk.h"
64 #include "OSGTextureObjChunk.h"
65 #include "OSGTextureEnvChunk.h"
66 #include "OSGImageFileHandler.h"
67 #include "OSGSimpleGeometry.h"
68 #include "OSGComponentTransform.h"
69 #include "OSGInline.h"
70 #include "OSGSwitch.h"
71 #include "OSGTimeSensor.h"
72 #include "OSGVRMLOrientationInterpolator.h"
73 #include "OSGVRMLPositionInterpolator.h"
74 #include "OSGVRMLCoordinateInterpolator.h"
75 #include "OSGVRMLNormalInterpolator.h"
76 #include "OSGVRMLScalarInterpolator.h"
77
78 #include "OSGTypedGeoIntegralProperty.h"
79
80 #ifndef OSG_LOG_MODULE
81 #define OSG_LOG_MODULE "VRMLLoader"
82 #endif
83
84 //#define OSG_DEBUG_VRML
85
86 #ifndef OSG_DO_DOC
87 # ifdef OSG_DEBUG_VRML
88 # define OSG_VRML_ARG(ARG) ARG
89 # else
90 # define OSG_VRML_ARG(ARG)
91 # endif
92 #else
93 # define OSG_VRML_ARG(ARG) ARG
94 #endif
95
96 OSG_BEGIN_NAMESPACE
97
98 OSG_DYNFIELDATTACHMENT_INST(VRMLGenericAttDesc)
99
100 OSG_SINGLETON_INST(VRMLNodeHelperFactoryBase, addPostFactoryExitFunction)
101
102 template class SingletonHolder<VRMLNodeHelperFactoryBase>;
103
104 //---------------------------------------------------------------------------
105 // Class
106 //---------------------------------------------------------------------------
107
108 VRMLNodeHelperFactoryBase::RegisterHelper::RegisterHelper(
109 CreateHelper fCreate,
110 const Char8 *szNodeName,
111 InitFuncF fStaticInit)
112 {
113 VRMLNodeHelperFactory::the()->registerNodeHelper(fCreate,
114 szNodeName);
115
116 if(fStaticInit)
117 addPostFactoryInitFunction(fStaticInit);
118 }
119
120
121 VRMLNodeHelperFactoryBase::VRMLNodeHelperFactoryBase(void) :
122 _mRegisteredNodeHelperHash()
123 {
124 }
125
126 VRMLNodeHelperFactoryBase::~VRMLNodeHelperFactoryBase(void)
127 {
128 }
129
130 void VRMLNodeHelperFactoryBase::registerNodeHelper(
131 CreateHelper fHelper,
132 const Char8 *szNodeName)
133 {
134 if(szNodeName == NULL || fHelper == NULL)
135 return;
136
137 NameHelperCreateMap::iterator mNodeHelperIt =
138 _mRegisteredNodeHelperHash.find(szNodeName);
139
140
141 if(mNodeHelperIt == _mRegisteredNodeHelperHash.end())
142 {
143 _mRegisteredNodeHelperHash[szNodeName] = fHelper;
144
145 PINFO << "Helper registered for "
146 << szNodeName
147 << std::endl;
148 }
149 else
150 {
151 PWARNING << "Helper already registered for %s "
152 << szNodeName
153 << std::endl;
154 }
155 }
156
157 VRMLNodeHelper *VRMLNodeHelperFactoryBase::createHelper(
158 const Char8 *szNodeName)
159 {
160 if(szNodeName == NULL)
161 return NULL;
162
163 NameHelperCreateMap::iterator mNodeHelperIt =
164 _mRegisteredNodeHelperHash.find(szNodeName);
165
166
167 if(mNodeHelperIt != _mRegisteredNodeHelperHash.end())
168 {
169 return (*mNodeHelperIt).second();
170 }
171 else
172 {
173 return NULL;
174 }
175 }
176
177
178 //---------------------------------------------------------------------------
179 // Class
180 //---------------------------------------------------------------------------
181
182 UInt32 VRMLNodeHelper::_uiIndent = 0;
183
184 /*-------------------------------------------------------------------------*/
185 /* Static Get */
186
187 UInt32 VRMLNodeHelper::getIndent(void)
188 {
189 return _uiIndent;
190 }
191
192 void VRMLNodeHelper::incIndent(void)
193 {
194 _uiIndent += 4;
195 }
196
197 void VRMLNodeHelper::decIndent(void)
198 {
199 if(_uiIndent < 4)
200 {
201 // PWARNING << "Indent smaller 4 decremented" << std::endl;
202
203 _uiIndent = 4;
204 }
205
206 _uiIndent -= 4;
207 }
208
209 void VRMLNodeHelper::resetIndent(void)
210 {
211 _uiIndent = 0;
212 }
213
214 /*-------------------------------------------------------------------------*/
215 /* Constructors */
216
217 #define OSG_INIT_DESC(VAR, TYPE, NAME) \
218 VAR(TYPE::getClassType(), \
219 NAME, \
220 "VRML Helper", \
221 0, \
222 0, \
223 true, \
224 Field::SFDefaultFlags, \
225 static_cast<FieldEditMethodSig>(&Node::invalidEditField), \
226 NULL)
227
228 VRMLNodeHelper::VRMLNodeHelper(void) :
229 _bProtoInterfaceDone(false ),
230 _pGenAttProto (NULL ),
231 _pNodeProto (NULL ),
232 _pNodeCoreProto (NULL ),
233
234 OSG_INIT_DESC(_sfVec3fDesc,
235 SFVec3f,
236 "sfVec3fHelperDesc" ),
237
238 OSG_INIT_DESC(_sfFCPtrDesc,
239 SFUnrecFieldContainerPtr,
240 "sfFCPtrHelperDesc" ),
241
242 OSG_INIT_DESC(_sfImagePtrDesc,
243 SFUnrecImagePtr,
244 "sfImageHelperDesc" ),
245
246 OSG_INIT_DESC(_sfReal32Desc,
247 SFReal32,
248 "sfReal32HelperDesc" ),
249
250 OSG_INIT_DESC(_sfColor3fDesc,
251 SFColor3f,
252 "sfColor3fHelperDesc"),
253
254 OSG_INIT_DESC(_mfStringDesc,
255 MFString,
256 "mfStringHelperDesc" ),
257
258 OSG_INIT_DESC(_sfBoolDesc,
259 SFBool,
260 "sfBoolDesc" )
261 {
262 }
263
264 /*-------------------------------------------------------------------------*/
265 /* Destructor */
266
267 VRMLNodeHelper::~VRMLNodeHelper(void)
268 {
269 _pNodeProto = NULL;
270 _pNodeCoreProto = NULL;
271 _pGenAttProto = NULL;
272 }
273
274 /*-------------------------------------------------------------------------*/
275 /* Helper */
276
277
278 void VRMLNodeHelper::reset(void)
279 {
280 }
281
282
283 /*-------------------------------------------------------------------------*/
284 /* Field */
285
286 FieldContainerTransitPtr VRMLNodeHelper::beginNode(
287 const Char8 *szTypename,
288 const Char8 *szName,
289 FieldContainer *pCurrentFC)
290 {
291 FieldContainerUnrecPtr returnValue = NULL;
292 NodeUnrecPtr pNode = NULL;
293 NodeCoreUnrecPtr pCore = NULL;
294 VRMLGenericAttUnrecPtr pAtt = NULL;
295
296 if(_pNodeProto != NULL)
297 {
298 returnValue = _pNodeProto->shallowCopy();
299
300 if(_pNodeCoreProto != NULL)
301 {
302 FieldContainerTransitPtr pCoreClone
303 = _pNodeCoreProto->shallowCopy();
304
305 pNode = dynamic_pointer_cast<Node >(returnValue);
306 pCore = dynamic_pointer_cast<NodeCore>(pCoreClone );
307
308 pNode->setCore(pCore);
309 }
310
311 if(_pGenAttProto != NULL)
312 {
313 FieldContainer *pAttClone = _pGenAttProto->clone();
314
315 pAtt = dynamic_cast<VRMLGenericAtt *>(pAttClone);
316
317 OSG_ASSERT(pAttClone == pAtt);
318
319 if(pAtt != NULL)
320 {
321 pAtt->setVrmlNodeTypename(szTypename);
322 pAtt->setInternal (true);
323 }
324
325 if(pCore != NULL)
326 {
327 pCore->addAttachment(pAtt);
328 }
329 else
330 {
331 AttachmentContainer *pAttCnt =
332 dynamic_pointer_cast<AttachmentContainer>(returnValue);
333
334 if(pAttCnt != NULL)
335 {
336 pAttCnt->addAttachment(pAtt);
337 }
338 }
339 }
340 }
341
342 return FieldContainerTransitPtr(returnValue);
343 }
344
345 void VRMLNodeHelper::endNode(FieldContainer *)
346 {
347 }
348
349 void VRMLNodeHelper::mapFieldname(const std::string &, std::string &)
350 {
351 }
352
353 /*-------------------------------------------------------------------------*/
354 /* Prototypes */
355
356 void VRMLNodeHelper::init(const Char8 *szName)
357 {
358 _bProtoInterfaceDone = false;
359 }
360
361 /*-------------------------------------------------------------------------*/
362 /* Node */
363
364 bool VRMLNodeHelper::prototypeAddField(const Char8 *szFieldType,
365 const UInt32 uiFieldTypeId,
366 const Char8 *szFieldName)
367 {
368 bool returnValue = false;
369
370
371 GetFieldHandlePtr pField = getField(_pNodeProto,
372 _pNodeCoreProto,
373 _pGenAttProto,
374 szFieldName);
375
376 #ifdef OSG_DEBUG_VRML
377 indentLog(getIndent(), PINFO);
378 PINFO << "VRMLNodeDesc::prototypeAddField | getField "
379 << szFieldName
380 << " returned : "
381 << pField
382 << std::endl;
383 #endif
384
385 if(pField == NULL || pField->isValid() == false)
386 {
387 FieldDescriptionBase *pDesc = getFieldDescription(szFieldName,
388 uiFieldTypeId);
389
390 if(pDesc != NULL && _pGenAttProto != NULL)
391 {
392 _pGenAttProto->addField(*pDesc);
393
394 pField = getField(_pNodeProto,
395 _pNodeCoreProto,
396 _pGenAttProto,
397 szFieldName);
398
399 delete pDesc;
400 }
401
402 #ifdef OSG_DEBUG_VRML
403 indentLog(getIndent(), PINFO);
404 PINFO << "VRMLNodeDesc::prototypeAddField | field added : "
405 << szFieldType
406 << " "
407 << uiFieldTypeId
408 << " "
409 << szFieldName
410 << " "
411 << pField
412 << std::endl;
413 #endif
414
415 returnValue = (pField != NULL && pField->isValid());
416 }
417 else
418 {
419 #ifdef OSG_DEBUG_VRML
420 incIndent();
421 indentLog(getIndent(), PINFO);
422 #endif
423 PINFO << "VRMLNodeDesc::prototypeAddField | "
424 << "Could not add field "
425 << szFieldName
426 << " a second time"
427 << std::endl;
428
429 #ifdef OSG_DEBUG_VRML
430 decIndent();
431 #endif
432 }
433
434 return returnValue;
435 }
436
437 void VRMLNodeHelper::endProtoInterface(void)
438 {
439 _bProtoInterfaceDone = true;
440 }
441
442 /*-------------------------------------------------------------------------*/
443 /* Dump */
444
445 void VRMLNodeHelper::getFieldAndDesc( FieldContainer * pFC,
446 const Char8 * szFieldname,
447 FieldContainer *&pFieldFC,
448 EditFieldHandlePtr &pField,
449 const FieldDescriptionBase *&pDesc)
450 {
451 if(szFieldname == NULL)
452 return;
453
454 FieldContainer *pTmpFC = NULL;
455 Node *pNode = NULL;
456 NodeCore *pNodeCore = NULL;
457
458 pFieldFC = NULL;
459 pField.reset();
460 pDesc = NULL;
461
462 if(pFC == NULL)
463 {
464 if(_bProtoInterfaceDone == false)
465 {
466 getField(szFieldname, pFieldFC, pField, pDesc);
467 }
468
469 return;
470 }
471 #ifdef OSG_DEBUG_VRML
472 indentLog(getIndent(), PINFO);
473 PINFO << "VRMLNodeHelper::getFieldAndDesc : looking for "
474 << szFieldname
475 << std::endl;
476
477 incIndent();
478 #endif
479
480 pDesc = pFC->getFieldDescription(szFieldname);
481
482 if(pDesc != NULL)
483 {
484 pFieldFC = pFC;
485 pField = pFC->editField(szFieldname);
486 }
487 else
488 {
489 if(pFC->getType().isNode() == true)
490 {
491 pNode = dynamic_cast<Node *>(pFC);
492
493 pNodeCore = pNode->getCore();
494
495 if(pNodeCore != NULL)
496 {
497 pDesc = pNodeCore->getFieldDescription(szFieldname);
498
499 #ifdef OSG_DEBUG_VRML
500 indentLog(getIndent(), PINFO);
501 PINFO << "Got this from nodecore : "
502 << pDesc
503 << std::endl;
504 #endif
505
506 if(pDesc != NULL)
507 {
508 pFieldFC = pNodeCore;
509 pField = pNodeCore->editField(szFieldname);
510 }
511 else
512 {
513 pTmpFC = pNode->findAttachment(
514 VRMLGenericAtt::getClassType().getGroupId());
515
516 if(pTmpFC != NULL)
517 {
518 pDesc = pTmpFC->getFieldDescription(szFieldname);
519 }
520
521 #ifdef OSG_DEBUG_VRML
522 indentLog(getIndent(), PINFO);
523 PINFO << "Got this from node attachment : "
524 << pDesc << std::endl;
525 #endif
526
527 if(pDesc == NULL)
528 {
529 pTmpFC =
530 pNodeCore->findAttachment(
531 VRMLGenericAtt::getClassType().getGroupId());
532
533 if(pTmpFC != NULL)
534 {
535 pDesc = pTmpFC->getFieldDescription(szFieldname);
536 }
537
538 #ifdef OSG_DEBUG_VRML
539 indentLog(getIndent(), PINFO);
540 PINFO << "Got this from nodecore attachment : "
541 << pDesc << std::endl;
542 #endif
543 }
544
545 if(pDesc != NULL)
546 {
547 pFieldFC = pTmpFC;
548 pField = pTmpFC->editField(szFieldname);
549 }
550 }
551 }
552 else
553 {
554 if(pDesc == NULL)
555 {
556 pTmpFC =
557 pNode->findAttachment(
558 VRMLGenericAtt::getClassType().getGroupId());
559
560 if(pTmpFC != NULL)
561 {
562 pDesc = pTmpFC->getFieldDescription(szFieldname);
563 }
564
565 #ifdef OSG_DEBUG_VRML
566 indentLog(getIndent(), PINFO);
567 PINFO << "Got this from node (no core) attachment : "
568 << pDesc << std::endl;
569 #endif
570 }
571
572 if(pDesc != NULL)
573 {
574 pFieldFC = pTmpFC;
575 pField = pTmpFC->editField(szFieldname);
576 }
577 }
578 }
579 else if(pFC->getType().isNodeCore() == true)
580 {
581 pNodeCore = dynamic_cast<NodeCore *>(pFC);
582
583 pTmpFC = pNodeCore->findAttachment(
584 VRMLGenericAtt::getClassType().getGroupId());
585
586 if(pTmpFC != NULL)
587 {
588 pDesc = pTmpFC->getFieldDescription(szFieldname);
589 }
590
591 if(pDesc != NULL)
592 {
593 pFieldFC = pTmpFC;
594 pField = pTmpFC->editField(szFieldname);
595 }
596
597 #ifdef OSG_DEBUG_VRML
598 indentLog(getIndent(), PINFO);
599 PINFO << "Got this from nodecore attachment : "
600 << pDesc << std::endl;
601 #endif
602 }
603 }
604
605 #ifdef OSG_DEBUG_VRML
606 decIndent();
607 #endif
608 }
609
610 GetFieldHandlePtr VRMLNodeHelper::getField( FieldContainer *pFC1,
611 FieldContainer *pFC2,
612 VRMLGenericAtt *pGenAtt,
613 const Char8 *szFieldname)
614 {
615 GetFieldHandlePtr returnValue;
616
617 if(szFieldname == NULL)
618 {
619 return returnValue;
620 }
621
622 #ifdef OSG_DEBUG_VRML
623 indentLog(getIndent(), PINFO);
624 PINFO << "VRMLNodeDesc::getField " << std::endl;
625
626 incIndent();
627
628 indentLog(getIndent(), PINFO);
629 PINFO << "Trying to find field : " << szFieldname << std::endl;
630 #endif
631
632 if(pFC1 != NULL)
633 {
634 returnValue = pFC1->getField(szFieldname);
635 }
636
637 #ifdef OSG_DEBUG_VRML
638 incIndent();
639
640 indentLog(getIndent(), PINFO);
641 PINFO << "Got this from node : " << returnValue << std::endl;
642 #endif
643
644 if(returnValue == NULL)
645 {
646 if(pFC2 != NULL)
647 {
648 returnValue = pFC2->getField(szFieldname);
649
650 #ifdef OSG_DEBUG_VRML
651 indentLog(getIndent(), PINFO);
652 PINFO << "Got this from nodecore : " << returnValue << std::endl;
653 #endif
654 }
655 else
656 {
657 #ifdef OSG_DEBUG_VRML
658 indentLog(getIndent(), PINFO);
659 PINFO << "No core to check" << std::endl;
660 #endif
661 }
662
663
664 if(returnValue == NULL)
665 {
666 if(pGenAtt != NULL)
667 {
668 returnValue = pGenAtt->getField(szFieldname);
669 }
670
671 #ifdef OSG_DEBUG_VRML
672 indentLog(getIndent(), PINFO);
673 PINFO << "Got this from attachment : " << returnValue << std::endl;
674 #endif
675 }
676 }
677
678
679 #ifdef OSG_DEBUG_VRML
680 decIndent();
681 decIndent();
682 #endif
683
684 return returnValue;
685 }
686
687
688 void VRMLNodeHelper::getField(const Char8 * szFieldname,
689 FieldContainer *&pFieldFC,
690 EditFieldHandlePtr &pField,
691 const FieldDescriptionBase *&pDesc )
692 {
693 pFieldFC = NULL;
694 pField.reset();
695 pDesc = NULL;
696
697 if(szFieldname == NULL)
698 {
699 return;
700 }
701
702 #ifdef OSG_DEBUG_VRML
703 indentLog(getIndent(), PINFO);
704 PINFO << "VRMLNodeDesc::getField " << std::endl;
705
706 incIndent();
707
708 indentLog(getIndent(), PINFO);
709 PINFO << "Trying to find field : " << szFieldname << std::endl;
710 #endif
711
712 if(_pNodeProto != NULL)
713 {
714 pFieldFC = _pNodeProto;
715 pField = _pNodeProto->editField (szFieldname);
716 pDesc = _pNodeProto->getFieldDescription(szFieldname);
717 }
718
719 #ifdef OSG_DEBUG_VRML
720 incIndent();
721
722 indentLog(getIndent(), PINFO);
723 PINFO << "Got this from node : " << pDesc << " " << pField << std::endl;
724 #endif
725
726 if(pDesc == NULL)
727 {
728 if(_pNodeCoreProto != NULL)
729 {
730 pFieldFC = _pNodeCoreProto;
731 pField = _pNodeCoreProto->editField (szFieldname);
732 pDesc = _pNodeCoreProto->getFieldDescription(szFieldname);
733
734 #ifdef OSG_DEBUG_VRML
735 indentLog(getIndent(), PINFO);
736 PINFO << "Got this from nodecore : "
737 << pDesc
738 << " "
739 << pField
740 << std::endl;
741 #endif
742 }
743 else
744 {
745 #ifdef OSG_DEBUG_VRML
746 indentLog(getIndent(), PINFO);
747 PINFO << "No core to check" << std::endl;
748 #endif
749 }
750
751
752 if(pDesc == NULL)
753 {
754 if(_pGenAttProto != NULL)
755 {
756 pFieldFC = _pGenAttProto;
757 pField = _pGenAttProto->editField (szFieldname);
758 pDesc = _pGenAttProto->getFieldDescription(szFieldname);
759 }
760
761 #ifdef OSG_DEBUG_VRML
762 indentLog(getIndent(), PINFO);
763 PINFO << "Got this from attachment : "
764 << pDesc
765 << " "
766 << pField
767 << std::endl;
768 #endif
769 }
770 }
771
772
773 if(pDesc == NULL)
774 {
775 pFieldFC = NULL;
776 }
777
778 #ifdef OSG_DEBUG_VRML
779 decIndent();
780 decIndent();
781 #endif
782 }
783
784
785 FieldDescriptionBase *VRMLNodeHelper::getFieldDescription(
786 const Char8 *szFieldName,
787 const UInt32 uiFieldTypeId)
788 {
789 FieldDescriptionBase *returnValue = NULL;
790
791 returnValue = FieldDescFactory::the()->createIdx(
792 uiFieldTypeId,
793 szFieldName,
794 static_cast<OSG::FieldIndexEditMethodSig>(
795 &VRMLGenericAtt::editDynamicField),
796 static_cast<OSG::FieldIndexGetMethodSig >(
797 &VRMLGenericAtt::getDynamicField));
798
799
800 if(returnValue == NULL)
801 {
802 FWARNING(("could not create field desc for %s (%d)\n",
803 szFieldName,
804 uiFieldTypeId));
805 }
806
807 return returnValue;
808 }
809
810 void VRMLNodeHelper::addFieldValue( EditFieldHandlePtr pField,
811 const FieldDescriptionBase *pFieldDesc,
812 const Char8 *szFieldVal)
813 {
814 if(pField != NULL && pField->isValid() == true)
815 {
816 pField->pushValueFromCString(szFieldVal);
817 }
818 }
819
820 void VRMLNodeHelper::addImageValue( EditFieldHandlePtr ,
821 const FieldDescriptionBase *,
822 Image * )
823 {
824 FWARNING(("addImageValue not caught, something is strange\n"));
825 }
826
827 void VRMLNodeHelper::setContainerFieldValue(
828 FieldContainer *pFC,
829 const FieldDescriptionBase *pFieldDesc,
830 FieldContainer *pFieldFC )
831 {
832 if((pFieldDesc != NULL ) &&
833 (pFieldFC != NULL) )
834 {
835 FieldContainerPtrSFieldBase::EditHandlePtr pSFHandle =
836 boost::dynamic_pointer_cast<
837 FieldContainerPtrSFieldBase::EditHandle>(
838 pFieldFC->editField(pFieldDesc->getFieldId()));
839
840 FieldContainerPtrMFieldBase::EditHandlePtr pMFHandle =
841 boost::dynamic_pointer_cast<
842 FieldContainerPtrMFieldBase::EditHandle>(
843 pFieldFC->editField(pFieldDesc->getFieldId()));
844
845 if(pSFHandle != NULL && pSFHandle->isValid())
846 {
847 pSFHandle->set(pFC);
848 }
849 else if(pMFHandle != NULL && pMFHandle->isValid())
850 {
851 pMFHandle->add(pFC);
852 }
853 /*
854 pFieldFC->pushToField(pFC,
855 pFieldDesc->getFieldId());
856 */
857 }
858 }
859
860 /*-------------------------------------------------------------------------*/
861 /* Get */
862
863
864
865
866
867
868
869
870 //---------------------------------------------------------------------------
871 // Class
872 //---------------------------------------------------------------------------
873
874 VRMLNodeHelper *VRMLDefaultHelper::create(void)
875 {
876 return new VRMLDefaultHelper();
877 }
878
879 /*-------------------------------------------------------------------------*/
880 /* Constructors */
881
882 VRMLDefaultHelper::VRMLDefaultHelper(void) :
883 Inherited()
884 {
885 }
886
887 /*-------------------------------------------------------------------------*/
888 /* Destructor */
889
890 VRMLDefaultHelper::~VRMLDefaultHelper(void)
891 {
892 }
893
894 /*-------------------------------------------------------------------------*/
895 /* Helper */
896
897 void VRMLDefaultHelper::init(const Char8 *szName)
898 {
899 Inherited::init(szName);
900
901 #ifdef OSG_DEBUG_VRML
902 indentLog(getIndent(), PINFO);
903 PINFO << "GroupHelper::init : " << szName << std::endl;
904 #endif
905
906 _pNodeProto = Node ::create();
907 _pNodeCoreProto = Group::create();
908
909 _pGenAttProto = VRMLGenericAtt::createLocal(FCLocal::Cluster);
910 _pGenAttProto->setInternal(true);
911 }
912
913 FieldContainerTransitPtr VRMLDefaultHelper::beginNode(
914 const Char8 *szTypename,
915 const Char8 *szName,
916 FieldContainer *pCurrentFC)
917 {
918 FWARNING(("Use default helper for %s, functionality currently not "
919 "supported\n", szTypename));
920
921 return Inherited::beginNode(szTypename, szName, pCurrentFC);
922 }
923
924 /*-------------------------------------------------------------------------*/
925 /* Dump */
926
927 void VRMLDefaultHelper::dump(const Char8 *)
928 {
929 }
930
931
932
933
934
935 //---------------------------------------------------------------------------
936 // Generic Helper with 1:1 mapping
937 //---------------------------------------------------------------------------
938
939 template<>
940 VRMLNodeHelperFactoryBase::RegisterHelper
941 VRMLGenericHelper<Group>::_regHelper(
942 &VRMLGenericHelper<Group>::create,
943 "Group",
944 NULL);
945
946 OSG_INST_GENERICVRMLHELPER(Group);
947
948 template<>
949 VRMLNodeHelperFactoryBase::RegisterHelper
950 VRMLGenericHelper<ComponentTransform>::_regHelper(
951 &VRMLGenericHelper<ComponentTransform>::create,
952 "Transform",
953 NULL);
954
955 OSG_INST_GENERICVRMLHELPER(ComponentTransform);
956
957
958
959 //---------------------------------------------------------------------------
960 // Class
961 //---------------------------------------------------------------------------
962
963 VRMLNodeHelper *VRMLMaterialHelper::create(void)
964 {
965 return new VRMLMaterialHelper();
966 }
967
968 /*-------------------------------------------------------------------------*/
969 /* Constructors */
970
971 VRMLMaterialHelper::VRMLMaterialHelper(void) :
972 Inherited ( ),
973
974 _defaultAmbientIntensity(),
975 _defaultDiffuseColor (),
976 _defaultEmissiveColor (),
977 _defaultShininess (),
978 _defaultSpecularColor (),
979 _defaultTransparency (),
980
981 _ambientIntensity (),
982 _diffuseColor (),
983 _emissiveColor (),
984 _shininess (),
985 _specularColor (),
986 _transparency (),
987
988 _pDefMat (NULL),
989 _pMat (NULL),
990
991 _szName ( )
992 {
993 }
994
995 /*-------------------------------------------------------------------------*/
996 /* Destructor */
997
998 VRMLMaterialHelper::~VRMLMaterialHelper(void)
999 {
1000 _pDefMat = NULL;
1001 }
1002
1003 /*-------------------------------------------------------------------------*/
1004 /* Helper */
1005
1006 void VRMLMaterialHelper::init(const Char8 *OSG_VRML_ARG(szName))
1007 {
1008 #ifdef OSG_DEBUG_VRML
1009 indentLog(getIndent(), PINFO);
1010 PINFO << "MaterialDesc::init : " << szName << std::endl;
1011 #endif
1012
1013 }
1014
1015 void VRMLMaterialHelper::reset(void)
1016 {
1017 _ambientIntensity.setValue(_defaultAmbientIntensity);
1018 _diffuseColor .setValue(_defaultDiffuseColor);
1019 _emissiveColor .setValue(_defaultEmissiveColor);
1020 _shininess .setValue(_defaultShininess);
1021 _specularColor .setValue(_defaultSpecularColor);
1022 _transparency .setValue(_defaultTransparency);
1023
1024 _szName .erase ();
1025
1026 _pMat = NULL;
1027 }
1028
1029 Material *VRMLMaterialHelper::getDefaultMaterial(void)
1030 {
1031 return _pDefMat;
1032 }
1033
1034 /*-------------------------------------------------------------------------*/
1035 /* Field */
1036
1037 bool VRMLMaterialHelper::prototypeAddField(const Char8 *,
1038 const UInt32 ,
1039 const Char8 *szFieldname)
1040 {
1041 bool bFound = false;
1042
1043 if(osgStringCaseCmp("ambientIntensity", szFieldname) == 0)
1044 {
1045 bFound = true;
1046 }
1047 else if(osgStringCaseCmp("diffuseColor", szFieldname) == 0)
1048 {
1049 bFound = true;
1050 }
1051 else if(osgStringCaseCmp("emissiveColor", szFieldname) == 0)
1052 {
1053 bFound = true;
1054 }
1055 else if(osgStringCaseCmp("shininess", szFieldname) == 0)
1056 {
1057 bFound = true;
1058 }
1059 else if(osgStringCaseCmp("specularColor", szFieldname) == 0)
1060 {
1061 bFound = true;
1062 }
1063 else if(osgStringCaseCmp("transparency", szFieldname) == 0)
1064 {
1065 bFound = true;
1066 }
1067
1068 if(bFound == true)
1069 {
1070 #ifdef OSG_DEBUG_VRML
1071 indentLog(getIndent(), PINFO);
1072 PINFO << "MaterialDesc::prototypeAddField : add part "
1073 << szFieldname
1074 << std::endl;
1075 #endif
1076 return true;
1077 }
1078 else
1079 {
1080 return false;
1081 }
1082 }
1083
1084 void VRMLMaterialHelper::endProtoInterface(void)
1085 {
1086 Color4f cCol;
1087 MaterialChunkUnrecPtr pMatChunk;
1088
1089 cCol.setValuesRGBA(_defaultDiffuseColor .getValue().red() *
1090 _defaultAmbientIntensity.getValue(),
1091 _defaultDiffuseColor .getValue().green() *
1092 _defaultAmbientIntensity.getValue(),
1093 _defaultDiffuseColor .getValue().blue() *
1094 _defaultAmbientIntensity.getValue(),
1095 1.f - _defaultTransparency .getValue());
1096
1097 _pDefMat = ChunkMaterial::create();
1098
1099 pMatChunk = MaterialChunk::create();
1100
1101 pMatChunk->setAmbient(cCol);
1102
1103 cCol.setValuesRGBA (_defaultDiffuseColor.getValue()[0],
1104 _defaultDiffuseColor.getValue()[1],
1105 _defaultDiffuseColor.getValue()[2],
1106 1.f - _defaultTransparency.getValue());
1107
1108 pMatChunk->setDiffuse(cCol);
1109
1110 cCol.setValuesRGBA (_defaultSpecularColor.getValue()[0],
1111 _defaultSpecularColor.getValue()[1],
1112 _defaultSpecularColor.getValue()[2],
1113 1.f - _defaultTransparency.getValue());
1114 pMatChunk->setSpecular(cCol);
1115
1116 pMatChunk->setShininess(_defaultShininess.getValue() * 128.f);
1117
1118 cCol.setValuesRGBA (_defaultEmissiveColor.getValue()[0],
1119 _defaultEmissiveColor.getValue()[1],
1120 _defaultEmissiveColor.getValue()[2],
1121 1.f - _defaultTransparency.getValue());
1122 pMatChunk->setEmission(cCol);
1123
1124 _pDefMat->addChunk(pMatChunk);
1125
1126 Inherited::endProtoInterface();
1127 }
1128
1129
1130 void VRMLMaterialHelper::getFieldAndDesc(
1131 FieldContainer *,
1132 const Char8 * szFieldname,
1133 FieldContainer *&pFieldFC,
1134 EditFieldHandlePtr &pField,
1135 const FieldDescriptionBase *&pDesc)
1136 {
1137 pFieldFC = NULL;
1138 pField.reset();
1139 pDesc = NULL;
1140
1141 if(osgStringCaseCmp("ambientIntensity", szFieldname) == 0)
1142 {
1143 pFieldFC = NULL;
1144
1145 if(_bProtoInterfaceDone == false)
1146 {
1147 pField =
1148 _sfReal32Desc.createEditHandler(&_defaultAmbientIntensity,
1149 NULL );
1150 }
1151 else
1152 {
1153 pField = _sfReal32Desc.createEditHandler(&_ambientIntensity,
1154 NULL );
1155 }
1156
1157 pDesc = &_sfReal32Desc;
1158 }
1159 else if(osgStringCaseCmp("diffuseColor", szFieldname) == 0)
1160 {
1161 pFieldFC = NULL;
1162
1163 if(_bProtoInterfaceDone == false)
1164 {
1165 pField = _sfColor3fDesc.createEditHandler(&_defaultDiffuseColor,
1166 NULL );
1167 }
1168 else
1169 {
1170 pField = _sfColor3fDesc.createEditHandler(&_diffuseColor,
1171 NULL );
1172 }
1173
1174 pDesc = &_sfColor3fDesc;
1175 }
1176 else if(osgStringCaseCmp("emissiveColor", szFieldname) == 0)
1177 {
1178 pFieldFC = NULL;
1179
1180 if(_bProtoInterfaceDone == false)
1181 {
1182 pField = _sfColor3fDesc.createEditHandler(&_defaultEmissiveColor,
1183 NULL );
1184 }
1185 else
1186 {
1187 pField = _sfColor3fDesc.createEditHandler(&_emissiveColor,
1188 NULL );
1189 }
1190
1191 pDesc = &_sfColor3fDesc;
1192 }
1193 else if(osgStringCaseCmp("shininess", szFieldname) == 0)
1194 {
1195 pFieldFC = NULL;
1196
1197 if(_bProtoInterfaceDone == false)
1198 {
1199 pField = _sfReal32Desc.createEditHandler(&_defaultShininess,
1200 NULL );
1201 }
1202 else
1203 {
1204 pField = _sfReal32Desc.createEditHandler(&_shininess,
1205 NULL );
1206 }
1207
1208 pDesc = &_sfReal32Desc;
1209 }
1210 else if(osgStringCaseCmp("specularColor", szFieldname) == 0)
1211 {
1212 pFieldFC = NULL;
1213
1214 if(_bProtoInterfaceDone == false)
1215 {
1216 pField = _sfColor3fDesc.createEditHandler(&_defaultSpecularColor,
1217 NULL );
1218 }
1219 else
1220 {
1221 pField = _sfColor3fDesc.createEditHandler(&_specularColor,
1222 NULL );
1223 }
1224
1225 pDesc = &_sfColor3fDesc;
1226 }
1227 else if(osgStringCaseCmp("transparency", szFieldname) == 0)
1228 {
1229 pFieldFC = NULL;
1230
1231 if(_bProtoInterfaceDone == false)
1232 {
1233 pField = _sfReal32Desc.createEditHandler(&_defaultTransparency,
1234 NULL );
1235 }
1236 else
1237 {
1238 pField = _sfReal32Desc.createEditHandler(&_transparency,
1239 NULL );
1240 }
1241
1242 pDesc = &_sfReal32Desc;
1243 }
1244 }
1245
1246 /*-------------------------------------------------------------------------*/
1247 /* Node */
1248
1249 FieldContainerTransitPtr VRMLMaterialHelper::beginNode(
1250 const Char8 *,
1251 const Char8 *szName,
1252 FieldContainer * )
1253 {
1254 reset();
1255
1256 _pMat = MaterialChunk::create();
1257
1258 _szName = (szName != NULL) ? szName : "";
1259
1260 return FieldContainerTransitPtr(_pMat);
1261 }
1262
1263 void VRMLMaterialHelper::endNode(FieldContainer *)
1264 {
1265 if(_pMat != NULL)
1266 {
1267 Color4f cCol;
1268
1269 cCol.setValuesRGBA (_diffuseColor .getValue().red() *
1270 _ambientIntensity.getValue(),
1271 _diffuseColor .getValue().green() *
1272 _ambientIntensity.getValue(),
1273 _diffuseColor .getValue().blue() *
1274 _ambientIntensity.getValue(),
1275 1.f - _transparency.getValue());
1276
1277 _pMat->setAmbient (cCol);
1278
1279 cCol.setValuesRGBA (_diffuseColor.getValue()[0],
1280 _diffuseColor.getValue()[1],
1281 _diffuseColor.getValue()[2],
1282 1.f - _transparency.getValue());
1283 _pMat->setDiffuse (cCol);
1284
1285 cCol.setValuesRGBA (_specularColor.getValue()[0],
1286 _specularColor.getValue()[1],
1287 _specularColor.getValue()[2],
1288 1.f - _transparency.getValue());
1289 _pMat->setSpecular (cCol);
1290
1291 _pMat->setShininess(_shininess.getValue() * 128.f );
1292
1293 cCol.setValuesRGBA (_emissiveColor.getValue()[0],
1294 _emissiveColor.getValue()[1],
1295 _emissiveColor.getValue()[2],
1296 1.f - _transparency.getValue());
1297 _pMat->setEmission (cCol);
1298
1299 }
1300 }
1301
1302 /*-------------------------------------------------------------------------*/
1303 /* Type Specific */
1304
1305 const std::string &VRMLMaterialHelper::getName(void) const
1306 {
1307 return _szName;
1308 }
1309
1310 /*-------------------------------------------------------------------------*/
1311 /* Dump */
1312
1313 void VRMLMaterialHelper::dump(const Char8 *)
1314 {
1315 }
1316
1317 VRMLNodeHelperFactoryBase::RegisterHelper VRMLMaterialHelper::_regHelper(
1318 &VRMLMaterialHelper::create,
1319 "Material",
1320 NULL);
1321
1322
1323
1324
1325
1326 //---------------------------------------------------------------------------
1327 // Class
1328 //---------------------------------------------------------------------------
1329
1330 VRMLNodeHelper *VRMLShapeHelper::create(void)
1331 {
1332 return new VRMLShapeHelper();
1333 }
1334
1335
1336 /*-------------------------------------------------------------------------*/
1337 /* Constructors */
1338
1339 VRMLShapeHelper::VRMLShapeHelper(void) :
1340 Inherited ( ),
1341 _pMaterialHelper(NULL)
1342 {
1343 }
1344
1345 /*-------------------------------------------------------------------------*/
1346 /* Destructor */
1347
1348 VRMLShapeHelper::~VRMLShapeHelper(void)
1349 {
1350 }
1351
1352 /*-------------------------------------------------------------------------*/
1353 /* Helper */
1354
1355 void VRMLShapeHelper::init(const Char8 *szName)
1356 {
1357 Inherited::init(szName);
1358
1359 #ifdef OSG_DEBUG_VRML
1360 indentLog(getIndent(), PINFO);
1361 PINFO << "ShapeHelper::init : " << szName << std::endl;
1362 #endif
1363
1364 _pNodeProto = Node ::create();
1365 _pNodeCoreProto = MaterialGroup::create();
1366
1367 _pGenAttProto = VRMLGenericAtt::createLocal(FCLocal::Cluster);
1368 _pGenAttProto->setInternal(true);
1369 }
1370
1371 void VRMLShapeHelper::setMaterialHelper(VRMLMaterialHelper *pMaterialHelper)
1372 {
1373 _pMaterialHelper = pMaterialHelper;
1374 }
1375
1376 /*-------------------------------------------------------------------------*/
1377 /* Get */
1378
1379 bool VRMLShapeHelper::prototypeAddField(const Char8 *szFieldType,
1380 const UInt32 uiFieldTypeId,
1381 const Char8 *szFieldname)
1382 {
1383 bool returnValue = false;
1384
1385 #ifdef OSG_DEBUG_VRML
1386 indentLog(getIndent(), PINFO);
1387 PINFO << "VRMLShapeHelper::prototypeAddField | add request : "
1388 << szFieldname
1389 << std::endl;
1390 #endif
1391
1392 if(szFieldname == NULL)
1393 return false;
1394
1395 incIndent();
1396
1397 if(osgStringCaseCmp("geometry", szFieldname) == 0)
1398 {
1399 returnValue = true;
1400
1401 #ifdef OSG_DEBUG_VRML
1402 indentLog(getIndent(), PINFO);
1403 PINFO << "VRMLShapeHelper::prototypeAddField | request internal : "
1404 << szFieldname
1405 << " "
1406 << std::endl;
1407 #endif
1408 }
1409
1410 if(osgStringCaseCmp("appearance", szFieldname) == 0)
1411 {
1412 returnValue = true;
1413
1414 #ifdef OSG_DEBUG_VRML
1415 indentLog(getIndent(), PINFO);
1416
1417 PINFO << "VRMLShapeHelper::prototypeAddField | request internal : "
1418 << szFieldname
1419 << " "
1420 << std::endl;
1421 #endif
1422 }
1423
1424 if(returnValue == false)
1425 {
1426 returnValue = Inherited::prototypeAddField(szFieldType,
1427 uiFieldTypeId,
1428 szFieldname);
1429 }
1430
1431 #ifdef OSG_DEBUG_VRML
1432 decIndent();
1433 #endif
1434
1435 return returnValue;
1436 }
1437
1438 void VRMLShapeHelper::getFieldAndDesc(
1439 FieldContainer * pFC,
1440 const Char8 * szFieldname,
1441 FieldContainer *&pFieldFC,
1442 EditFieldHandlePtr &pField,
1443 const FieldDescriptionBase *&pDesc)
1444 {
1445 if(szFieldname == NULL)
1446 return;
1447
1448 if(pFC == NULL)
1449 {
1450 if(_bProtoInterfaceDone == false)
1451 {
1452 Inherited::getField(szFieldname, pFieldFC, pField, pDesc);
1453 }
1454
1455 return;
1456 }
1457
1458 #ifdef OSG_DEBUG_VRML
1459 indentLog(getIndent(), PINFO);
1460 PINFO << "VRMLShapeHelper::getFieldAndDesc : looking for "
1461 << szFieldname
1462 << std::endl;
1463
1464 incIndent();
1465 #endif
1466
1467 if(osgStringCaseCmp("geometry", szFieldname) == 0)
1468 {
1469 #ifdef OSG_DEBUG_VRML
1470 indentLog(getIndent(), PINFO);
1471 PINFO << "VRMLShapeHelper::getFieldAndDesc : request internal "
1472 << szFieldname
1473 << std::endl;
1474 #endif
1475 pFieldFC = pFC;
1476 pField = pFC->editField("children");
1477 pDesc = pFC->getFieldDescription("children");
1478 }
1479 else if(osgStringCaseCmp("appearance", szFieldname) == 0)
1480 {
1481 #ifdef OSG_DEBUG_VRML
1482 indentLog(getIndent(), PINFO);
1483 PINFO << "VRMLShapeHelper::getFieldAndDesc : request internal "
1484 << szFieldname
1485 << std::endl;
1486 #endif
1487
1488 Node *pNode = dynamic_cast<Node *>(pFC);
1489
1490 if(pNode != NULL)
1491 {
1492 if(pNode->getCore() != NULL)
1493 {
1494 pFieldFC = pNode->getCore();
1495 pField = pNode->getCore()->editField("material");
1496 pDesc = pNode->getCore()->getFieldDescription("material");
1497 }
1498 }
1499 else
1500 {
1501 Inherited::getFieldAndDesc(pFC,
1502 szFieldname,
1503 pFC,
1504 pField,
1505 pDesc);
1506 }
1507 }
1508 else
1509 {
1510 Inherited::getFieldAndDesc(pFC,
1511 szFieldname,
1512 pFC,
1513 pField,
1514 pDesc);
1515 }
1516
1517 #ifdef OSG_DEBUG_VRML
1518 decIndent();
1519 #endif
1520 }
1521
1522 /*-------------------------------------------------------------------------*/
1523 /* Node */
1524
1525
1526 void VRMLShapeHelper::endNode(FieldContainer *pFC)
1527 {
1528 if(pFC != NULL)
1529 {
1530 Node *pNode = dynamic_cast<Node *>(pFC);
1531
1532 if(pNode != NULL && pNode->getCore() == NULL)
1533 {
1534 PWARNING << "warning empty material, using default\n" << std::endl;
1535
1536 MaterialGroupUnrecPtr pMatGroup = MaterialGroup::create();
1537
1538 pMatGroup->setMaterial(_pMaterialHelper->getDefaultMaterial());
1539
1540 pNode->setCore(pMatGroup);
1541 }
1542 else
1543 {
1544 MaterialGroup *pMatGroup;
1545
1546 pMatGroup = dynamic_cast<MaterialGroup *>(pNode->getCore());
1547
1548 if(pMatGroup != NULL)
1549 {
1550 if(pMatGroup->getMaterial() == NULL)
1551 {
1552 pMatGroup->setMaterial(
1553 _pMaterialHelper->getDefaultMaterial());
1554 }
1555 }
1556 }
1557
1558 if(pNode->getNChildren() > 0)
1559 {
1560 Node *pChild = pNode->getChild(0);
1561
1562 if(pChild != NULL)
1563 {
1564 Geometry *pShapeGeo = pChild->getCore<Geometry >();
1565 MaterialGroup *pShapeMat = pNode ->getCore<MaterialGroup>();
1566
1567 if(pShapeGeo != NULL && pShapeMat != NULL)
1568 {
1569 pShapeGeo->setMaterial(pShapeMat->getMaterial());
1570 }
1571 }
1572 }
1573 }
1574
1575 #ifdef OSG_DEBUG_VRML
1576 // decIndent();
1577
1578 indentLog(getIndent(), PINFO);
1579 PINFO << "End Shape " << &(*pFC) << std::endl;
1580 #endif
1581 }
1582
1583 /*-------------------------------------------------------------------------*/
1584 /* Dump */
1585
1586 void VRMLShapeHelper::dump(const Char8 *)
1587 {
1588 }
1589
1590 VRMLNodeHelperFactoryBase::RegisterHelper VRMLShapeHelper::_regHelper(
1591 &VRMLShapeHelper::create,
1592 "Shape",
1593 NULL);
1594
1595
1596
1597
1598 //---------------------------------------------------------------------------
1599 // Class
1600 //---------------------------------------------------------------------------
1601
1602 VRMLNodeHelper *VRMLAppearanceHelper::create(void)
1603 {
1604 return new VRMLAppearanceHelper();
1605 }
1606
1607 /*-------------------------------------------------------------------------*/
1608 /* Constructors */
1609
1610 VRMLAppearanceHelper::VRMLAppearanceHelper(void) :
1611 Inherited ( ),
1612 _pMaterialHelper(NULL)
1613 {
1614 }
1615
1616 /*-------------------------------------------------------------------------*/
1617 /* Destructor */
1618
1619 VRMLAppearanceHelper::~VRMLAppearanceHelper(void)
1620 {
1621 }
1622
1623 /*-------------------------------------------------------------------------*/
1624 /* Helper */
1625
1626 void VRMLAppearanceHelper::init(const Char8 *szName)
1627 {
1628 Inherited::init(szName);
1629
1630 #ifdef OSG_DEBUG_VRML
1631 indentLog(getIndent(), PINFO);
1632 PINFO << "ApperanceHelper::init : " << szName << std::endl;
1633 #endif
1634
1635 _pNodeProto = ChunkMaterial::create();
1636
1637 _pGenAttProto = VRMLGenericAtt::createLocal(FCLocal::Cluster);
1638 _pGenAttProto->setInternal(true);
1639 }
1640
1641 void VRMLAppearanceHelper::setMaterialHelper(
1642 VRMLMaterialHelper *pMaterialHelper)
1643 {
1644 _pMaterialHelper = pMaterialHelper;
1645 }
1646
1647 /*-------------------------------------------------------------------------*/
1648 /* Field */
1649
1650 bool VRMLAppearanceHelper::prototypeAddField(const Char8 *szFieldType,
1651 const UInt32 uiFieldTypeId,
1652 const Char8 *szFieldname)
1653 {
1654 if(szFieldname == NULL)
1655 return false;
1656
1657 if(osgStringCaseCmp("material", szFieldname) == 0)
1658 {
1659 return true;
1660 }
1661 else if(osgStringCaseCmp("texture", szFieldname) == 0)
1662 {
1663 return true;
1664 }
1665 else if(osgStringCaseCmp("textureTransform", szFieldname) == 0)
1666 {
1667 return true;
1668 }
1669 else
1670 {
1671 return Inherited::prototypeAddField(szFieldType,
1672 uiFieldTypeId,
1673 szFieldname);
1674 }
1675 }
1676
1677 void VRMLAppearanceHelper::getFieldAndDesc(
1678 FieldContainer * pFC,
1679 const Char8 * szFieldname,
1680 FieldContainer *&pFieldFC,
1681 EditFieldHandlePtr &pField,
1682 const FieldDescriptionBase *&pDesc)
1683 {
1684
1685 #ifdef OSG_DEBUG_VRML
1686 indentLog(getIndent(), PINFO);
1687 PINFO << "VRMLAppearanceHelper::getFieldAndDesc : looking for "
1688 << szFieldname
1689 << std::endl;
1690 #endif
1691
1692 if(pFC == NULL)
1693 {
1694 if(_bProtoInterfaceDone == false)
1695 {
1696 Inherited::getField(szFieldname, pFieldFC, pField, pDesc);
1697 }
1698
1699 return;
1700 }
1701
1702 if(szFieldname == NULL)
1703 return;
1704
1705 incIndent();
1706
1707 if(osgStringCaseCmp("material", szFieldname) == 0)
1708 {
1709 #ifdef OSG_DEBUG_VRML
1710 indentLog(getIndent(), PINFO);
1711 PINFO << "VRMLAppearanceDesc::getFieldAndDesc : request internal "
1712 << szFieldname
1713 << std::endl;
1714 #endif
1715 pFieldFC = pFC;
1716 pField = pFC->editField("chunks");
1717 pDesc = pFC->getFieldDescription("chunks");
1718 }
1719 else if(osgStringCaseCmp("texture", szFieldname) == 0)
1720 {
1721 #ifdef OSG_DEBUG_VRML
1722 indentLog(getIndent(), PINFO);
1723 PINFO << "VRMLAppearanceHelper::getFieldAndDesc : request internal "
1724 << szFieldname
1725 << std::endl;
1726 #endif
1727
1728 pFieldFC = pFC;
1729 pField = pFC->editField("chunks");
1730 pDesc = pFC->getFieldDescription("chunks");
1731 }
1732 else if(osgStringCaseCmp("textureTransform", szFieldname) == 0)
1733 {
1734 #ifdef OSG_DEBUG_VRML
1735 indentLog(getIndent(), PINFO);
1736 PINFO << "VRMLAppearanceDesc::getFieldAndDesc : request internal "
1737 << szFieldname
1738 << std::endl;
1739 #endif
1740
1741 pFieldFC = pFC;
1742 pField = pFC->editField("chunks");
1743 pDesc = pFC->getFieldDescription("chunks");
1744 }
1745 else
1746 {
1747 Inherited::getFieldAndDesc(pFC,
1748 szFieldname,
1749 pFC,
1750 pField,
1751 pDesc);
1752 }
1753
1754 #ifdef OSG_DEBUG_VRML
1755 decIndent();
1756 #endif
1757 }
1758
1759 /*-------------------------------------------------------------------------*/
1760 /* Node */
1761
1762
1763 void VRMLAppearanceHelper::endNode(FieldContainer *pFC)
1764 {
1765 if(pFC != NULL)
1766 {
1767 ChunkMaterial *pChunkMat = dynamic_cast<ChunkMaterial *>(pFC);
1768
1769 if(pChunkMat != NULL)
1770 {
1771 TextureObjChunk *pTexC =
1772 dynamic_cast<TextureObjChunk *>(
1773 pChunkMat->find(TextureObjChunk::getClassType()));
1774
1775 TextureEnvChunkUnrecPtr pTexE =
1776 dynamic_cast<TextureEnvChunk *>(
1777 pChunkMat->find(TextureEnvChunk::getClassType()));
1778
1779
1780
1781
1782 if ((pChunkMat->isTransparent() == true) ||
1783 (pTexC != NULL &&
1784 pTexC->getImage() != NULL &&
1785 pTexC->getImage()->hasAlphaChannel() == true ))
1786 {
1787 BlendChunkUnrecPtr pBlendChunk = OSG::BlendChunk::create();
1788
1789 if(pTexC != NULL &&
1790 pTexC->getImage() != NULL &&
1791 pTexC->getImage()->isAlphaBinary() == true)
1792 {
1793 pBlendChunk->setAlphaFunc(GL_NOTEQUAL);
1794 pBlendChunk->setAlphaValue(0);
1795 }
1796 else
1797 {
1798 pBlendChunk->setSrcFactor (GL_SRC_ALPHA);
1799 pBlendChunk->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
1800 }
1801
1802 pChunkMat->addChunk(pBlendChunk);
1803 }
1804
1805 if(pTexC != NULL)
1806 {
1807 if(pTexE == NULL)
1808 {
1809 pTexE = TextureEnvChunk::create();
1810
1811 pChunkMat->addChunk(pTexE);
1812 }
1813
1814 MaterialChunk *pMatC =
1815 dynamic_cast<MaterialChunk *>(
1816 pChunkMat->find(MaterialChunk::getClassType()));
1817
1818 if(pMatC == NULL)
1819 {
1820 pTexE->setEnvMode(GL_REPLACE);
1821 }
1822 else
1823 {
1824 pTexE->setEnvMode(GL_MODULATE);
1825 }
1826 }
1827 }
1828
1829 // This works around the problem that MaterialChunks can not have
1830 // NameAttachments on them (they are attachments themselves).
1831 //
1832 // If the ChunkMaterial (which corresponds to the VRML Appearance Node)
1833 // has no name of its own, the material's name is set instead.
1834
1835 // BEGIN Material name hack
1836
1837 AttachmentContainer *attCon =
1838 dynamic_cast<AttachmentContainer *>(pFC);
1839 bool pushNames = false;
1840
1841 if(SceneFileHandler::the()->getOptionAs("wrl",
1842 "pushNames",
1843 pushNames) == false)
1844 {
1845 pushNames = false;
1846 }
1847
1848 if(( attCon != NULL ) &&
1849 ( pushNames == true ) &&
1850 (_pMaterialHelper != NULL ) &&
1851 (_pMaterialHelper->getName().empty() == false) )
1852 {
1853 FieldContainer *att = attCon->findAttachment(
1854 Name::getClassType().getGroupId());
1855
1856 if(att != NULL)
1857 {
1858 // ChunkMaterial (Appearance) already has a NameAttachment
1859 Name *nameAtt = dynamic_cast<Name *>(att);
1860
1861 if(nameAtt != NULL)
1862 {
1863 if(nameAtt->getFieldPtr()->getValue().empty())
1864 {
1865 nameAtt->editFieldPtr()->getValue().assign(
1866 _pMaterialHelper->getName());
1867 }
1868 }
1869 }
1870 else
1871 {
1872 setName(attCon, _pMaterialHelper->getName());
1873 }
1874 }
1875
1876 // END Material name hack
1877
1878 }
1879
1880
1881 #ifdef OSG_DEBUG_VRML
1882 // decIndent();
1883
1884 indentLog(getIndent(), PINFO);
1885 PINFO << "End Appearance " << std::endl;
1886 #endif
1887 }
1888
1889 /*-------------------------------------------------------------------------*/
1890 /* Field Value */
1891
1892 /*-------------------------------------------------------------------------*/
1893 /* Dump */
1894
1895 void VRMLAppearanceHelper::dump(const Char8 *)
1896 {
1897 }
1898
1899 VRMLNodeHelperFactoryBase::RegisterHelper VRMLAppearanceHelper::_regHelper(
1900 &VRMLAppearanceHelper::create,
1901 "Appearance",
1902 NULL);
1903
1904
1905
1906
1907 //---------------------------------------------------------------------------
1908 // Class
1909 //---------------------------------------------------------------------------
1910
1911 VRMLNodeHelper *VRMLIndexedGeometryHelper::create(void)
1912 {
1913 return new VRMLIndexedGeometryHelper();
1914 }
1915
1916 /*-------------------------------------------------------------------------*/
1917 /* Constructors */
1918
1919 VRMLIndexedGeometryHelper::VRMLIndexedGeometryHelper(void) :
1920 Inherited ( ),
1921 _bIsFaceSet (false ),
1922 _uiPropertyIndex(Geometry::PositionsIndex)
1923 {
1924 }
1925
1926 /*-------------------------------------------------------------------------*/
1927 /* Destructor */
1928
1929 VRMLIndexedGeometryHelper::~VRMLIndexedGeometryHelper(void)
1930 {
1931 }
1932
1933 /*-------------------------------------------------------------------------*/
1934 /* Helper */
1935
1936 void VRMLIndexedGeometryHelper::init(const Char8 *szName)
1937 {
1938 Inherited::init(szName);
1939
1940 #ifdef OSG_DEBUG_VRML
1941 indentLog(getIndent(), PINFO);
1942 PINFO << "GeoDesc::init : " << szName << std::endl;
1943 #endif
1944
1945 _pNodeProto = Node ::create();
1946 _pNodeCoreProto = Geometry ::create();
1947
1948 _pGenAttProto = VRMLGenericAtt::createLocal(FCLocal::Cluster);
1949 _pGenAttProto->setInternal(true);
1950
1951 if(osgStringCaseCmp("IndexedFaceSet", szName) == 0)
1952 {
1953 _bIsFaceSet = true;
1954 }
1955 }
1956
1957 /*-------------------------------------------------------------------------*/
1958 /* Get */
1959
1960 bool VRMLIndexedGeometryHelper::prototypeAddField(const Char8 *szFieldType,
1961 const UInt32 uiFieldTypeId,
1962 const Char8 *szFieldname)
1963 {
1964 bool bFound = false;
1965
1966 if(szFieldname == NULL)
1967 return false;
1968
1969 if(osgStringCaseCmp("coord", szFieldname) == 0)
1970 {
1971 bFound = true;
1972 }
1973 else if(osgStringCaseCmp("normal", szFieldname) == 0)
1974 {
1975 bFound = true;
1976 }
1977 else if(osgStringCaseCmp("color", szFieldname) == 0)
1978 {
1979 bFound = true;
1980 }
1981 else if(osgStringCaseCmp("texCoord", szFieldname) == 0)
1982 {
1983 bFound = true;
1984 }
1985
1986 if(bFound == true)
1987 {
1988 #ifdef OSG_DEBUG_VRML
1989 indentLog(getIndent(), PINFO);
1990 PINFO << "GeoDesc::prototypeAddField : internal "
1991 << szFieldname << std::endl;
1992 #endif
1993
1994 return true;
1995 }
1996 else
1997 {
1998 return Inherited::prototypeAddField(szFieldType,
1999 uiFieldTypeId,
2000 szFieldname);
2001 }
2002 }
2003
2004
2005 void VRMLIndexedGeometryHelper::getFieldAndDesc(
2006 FieldContainer * pFC,
2007 const Char8 * szFieldname,
2008 FieldContainer *&pFieldFC,
2009 EditFieldHandlePtr &pField,
2010 const FieldDescriptionBase *&pDesc)
2011 {
2012 #ifdef OSG_DEBUG_VRML
2013 indentLog(getIndent(), PINFO);
2014 PINFO << "GeoDesc::getFieldAndDesc : request "
2015 << szFieldname
2016 << std::endl;
2017 #endif
2018
2019 if(szFieldname == NULL)
2020 return;
2021
2022 if(pFC == NULL)
2023 {
2024 if(_bProtoInterfaceDone == false)
2025 {
2026 Inherited::getField(szFieldname, pFieldFC, pField, pDesc);
2027 }
2028
2029 return;
2030 }
2031
2032 Node *pNode = dynamic_cast<Node *>(pFC);
2033
2034 if(pNode == NULL)
2035 {
2036 PWARNING << "GeoDesc::getFieldAndDesc : No Node" << std::endl;
2037 return;
2038 }
2039
2040 NodeCore *pNodeCore = pNode->getCore();
2041
2042 Geometry *pGeo = dynamic_cast<Geometry *>(pNodeCore);
2043
2044 if(pGeo == NULL)
2045 {
2046 PWARNING << "GeoDesc::getFieldAndDesc : No Geo" << std::endl;
2047 return;
2048 }
2049
2050 if(osgStringCaseCmp("coord", szFieldname) == 0)
2051 {
2052 #ifdef OSG_DEBUG_VRML
2053 indentLog(getIndent(), PINFO);
2054 PINFO << "GeoDesc::getFieldAndDesc : internal "
2055 << szFieldname << std::endl;
2056 #endif
2057
2058 pFieldFC = pGeo;
2059 pField.reset();
2060 pDesc = &_sfFCPtrDesc;
2061
2062 _uiPropertyIndex = Geometry::PositionsIndex;
2063 }
2064 else if(osgStringCaseCmp("normal", szFieldname) == 0)
2065 {
2066 #ifdef OSG_DEBUG_VRML
2067 indentLog(getIndent(), PINFO);
2068 PINFO << "GeoDesc::getFieldAndDesc : internal "
2069 << szFieldname << std::endl;
2070 #endif
2071
2072 pFieldFC = pGeo;
2073 pField.reset();
2074 pDesc = &_sfFCPtrDesc;
2075
2076 _uiPropertyIndex = Geometry::NormalsIndex;
2077 }
2078 else if(osgStringCaseCmp("color", szFieldname) == 0)
2079 {
2080 #ifdef OSG_DEBUG_VRML
2081 indentLog(getIndent(), PINFO);
2082 PINFO << "GeoDesc::getFieldAndDesc : internal "
2083 << szFieldname << std::endl;
2084 #endif
2085
2086 pFieldFC = pGeo;
2087 pField.reset();
2088 pDesc = &_sfFCPtrDesc;
2089
2090 _uiPropertyIndex = Geometry::ColorsIndex;
2091 }
2092 else if(osgStringCaseCmp("texCoord", szFieldname) == 0)
2093 {
2094 #ifdef OSG_DEBUG_VRML
2095 indentLog(getIndent(), PINFO);
2096 PINFO << "GeoDesc::getFieldAndDesc : internal "
2097 << szFieldname << std::endl;
2098 #endif
2099
2100 pFieldFC = pGeo;
2101 pField.reset();
2102 pDesc = &_sfFCPtrDesc;
2103
2104 _uiPropertyIndex = Geometry::TexCoordsIndex;
2105 }
2106 else
2107 {
2108 Inherited::getFieldAndDesc(pGeo,
2109 szFieldname,
2110 pFieldFC,
2111 pField,
2112 pDesc);
2113 }
2114 }
2115
2116 /*-------------------------------------------------------------------------*/
2117 /* Node */
2118
2119
2120
2121 void VRMLIndexedGeometryHelper::endNode(FieldContainer *pFC)
2122 {
2123 Node *pNode = NULL;
2124 Geometry *pGeo = NULL;
2125
2126 if(pFC == NULL)
2127 {
2128 return;
2129 }
2130
2131 pNode = dynamic_cast<Node *>(pFC);
2132
2133 if(pNode == NULL)
2134 {
2135 return;
2136 }
2137
2138 pGeo = dynamic_cast<Geometry *>(pNode->getCore());
2139
2140 if(pGeo == NULL)
2141 {
2142 return;
2143 }
2144
2145 EditFieldHandlePtr pField;
2146 const FieldDescriptionBase *pDesc = NULL;
2147 FieldContainer *pDummyFC = NULL;
2148
2149
2150 MFInt32 *pCoordIndex = NULL;
2151 MFInt32 *pNormalIndex = NULL;
2152 MFInt32 *pColorIndex = NULL;
2153 MFInt32 *pTexCoordIndex = NULL;
2154 SFBool *pConvex = NULL;
2155 SFBool *pCcw = NULL;
2156 SFBool *pNormalPerVertex = NULL;
2157 SFBool *pColorPerVertex = NULL;
2158 SFReal32 *pCreaseAngle = NULL;
2159
2160 Inherited::getFieldAndDesc(pFC,
2161 "coordIndex",
2162 pDummyFC,
2163 pField,
2164 pDesc);
2165
2166 if(pField != NULL)
2167 {
2168 MFInt32::EditHandlePtr pValField =
2169 boost::dynamic_pointer_cast<MFInt32::EditHandle>(pField);
2170
2171 if(pValField != NULL && pValField->isValid())
2172 {
2173 pCoordIndex = pValField->getField();
2174 }
2175 }
2176
2177 Inherited::getFieldAndDesc(pFC,
2178 "normalIndex",
2179 pDummyFC,
2180 pField,
2181 pDesc);
2182
2183 if(pField != NULL)
2184 {
2185 MFInt32::EditHandlePtr pValField =
2186 boost::dynamic_pointer_cast<MFInt32::EditHandle>(pField);
2187
2188 if(pValField != NULL && pValField->isValid())
2189 {
2190 pNormalIndex = pValField->getField();
2191 }
2192 }
2193
2194 Inherited::getFieldAndDesc(pFC,
2195 "colorIndex",
2196 pDummyFC,
2197 pField,
2198 pDesc);
2199
2200 if(pField != NULL)
2201 {
2202 MFInt32::EditHandlePtr pValField =
2203 boost::dynamic_pointer_cast<MFInt32::EditHandle>(pField);
2204
2205 if(pValField != NULL && pValField->isValid())
2206 {
2207 pColorIndex = pValField->getField();
2208 }
2209 }
2210
2211 Inherited::getFieldAndDesc(pFC,
2212 "texCoordIndex",
2213 pDummyFC,
2214 pField,
2215 pDesc);
2216
2217 if(pField != NULL)
2218 {
2219 MFInt32::EditHandlePtr pValField =
2220 boost::dynamic_pointer_cast<MFInt32::EditHandle>(pField);
2221
2222 if(pValField != NULL && pValField->isValid())
2223 {
2224 pTexCoordIndex = pValField->getField();
2225 }
2226 }
2227
2228
2229
2230 Inherited::getFieldAndDesc(pFC,
2231 "convex",
2232 pDummyFC,
2233 pField,
2234 pDesc);
2235
2236 if(pField != NULL)
2237 {
2238 SFBool::EditHandlePtr pValField =
2239 boost::dynamic_pointer_cast<SFBool::EditHandle>(pField);
2240
2241 if(pValField != NULL && pValField->isValid())
2242 {
2243 pConvex = pValField->getField();
2244 }
2245 }
2246
2247 Inherited::getFieldAndDesc(pFC,
2248 "ccw",
2249 pDummyFC,
2250 pField,
2251 pDesc);
2252
2253 if(pField != NULL)
2254 {
2255 SFBool::EditHandlePtr pValField =
2256 boost::dynamic_pointer_cast<SFBool::EditHandle>(pField);
2257
2258 if(pValField != NULL && pValField->isValid())
2259 {
2260 pCcw = pValField->getField();
2261 }
2262 }
2263
2264 Inherited::getFieldAndDesc(pFC,
2265 "normalPerVertex",
2266 pDummyFC,
2267 pField,
2268 pDesc);
2269
2270 if(pField != NULL)
2271 {
2272 SFBool::EditHandlePtr pValField =
2273 boost::dynamic_pointer_cast<SFBool::EditHandle>(pField);
2274
2275 if(pValField != NULL && pValField->isValid())
2276 {
2277 pNormalPerVertex = pValField->getField();
2278 }
2279 }
2280
2281 Inherited::getFieldAndDesc(pFC,
2282 "colorPerVertex",
2283 pDummyFC,
2284 pField,
2285 pDesc);
2286
2287 if(pField != NULL)
2288 {
2289 SFBool::EditHandlePtr pValField =
2290 boost::dynamic_pointer_cast<SFBool::EditHandle>(pField);
2291
2292 if(pValField != NULL && pValField->isValid())
2293 {
2294 pColorPerVertex = pValField->getField();
2295 }
2296 }
2297
2298 Inherited::getFieldAndDesc(pFC,
2299 "creaseAngle",
2300 pDummyFC,
2301 pField,
2302 pDesc);
2303
2304 if(pField != NULL)
2305 {
2306 SFReal32::EditHandlePtr pValField =
2307 boost::dynamic_pointer_cast<SFReal32::EditHandle>(pField);
2308
2309 if(pValField != NULL && pValField->isValid())
2310 {
2311 pCreaseAngle = pValField->getField();
2312 }
2313 }
2314
2315 if(_bIsFaceSet == true)
2316 {
2317 if(pCoordIndex != NULL &&
2318 pCoordIndex->size() > 2 &&
2319 pNormalIndex != NULL &&
2320 pColorIndex != NULL &&
2321 pTexCoordIndex != NULL &&
2322 pConvex != NULL &&
2323 pCcw != NULL &&
2324 pNormalPerVertex != NULL &&
2325 pColorPerVertex != NULL &&
2326 pCreaseAngle != NULL)
2327 {
2328 #ifdef OSG_DEBUG_VRML
2329 indentLog(getIndent(), PINFO);
2330 PINFO << "Geo create faceset " << &(*pNode) << std::endl;
2331 #endif
2332
2333 setIndexFromIndexedX3DData(pGeo,
2334 pCoordIndex ->getValues(),
2335 pNormalIndex ->getValues(),
2336 pColorIndex ->getValues(),
2337 pTexCoordIndex ->getValues(),
2338 GL_POLYGON,
2339 pConvex ->getValue() ,
2340 pCcw ->getValue() ,
2341 pNormalPerVertex->getValue() ,
2342 pColorPerVertex ->getValue() ,
2343 false); // create normal; not yet :)
2344
2345 //if (pConvex->getValue() == false)
2346 // createConvexPrimitives( pGeo );
2347
2348 // TODO: Need some option _uiOptions param
2349 //createSharedIndex( pGeo);
2350
2351 //if((0 != (_uiOptions & VRMLFile::CreateNormals) ) &&
2352 // (pGeo->getNormals() == NULL))
2353
2354 if(pGeo->getNormals() == NULL)
2355 {
2356 #ifdef OSG_DEBUG_VRML
2357 indentLog(getIndent(), PINFO);
2358 PINFO << "Geo create normals " << &(*pNode) << std::endl;
2359 #endif
2360
2361 OSG::calcVertexNormals(pGeo, pCreaseAngle->getValue());
2362 }
2363 }
2364 else
2365 {
2366 #if 0 // What's the point of doing that?
2367 PWARNING << "Invalid geometry replaced by a group" << std::endl;
2368
2369 GroupPtr pGr = Group::create();
2370
2371 MFNodePtr pGeoParents = pGeo->getParents ();
2372 MFNodePtr::iterator parentsIt = pGeoParents.begin();
2373 MFNodePtr::iterator endParents = pGeoParents.end ();
2374
2375 // this makes pGeo invalid!
2376 while(parentsIt != endParents)
2377 {
2378 (*parentsIt)->setCore(pGr);
2379
2380 ++parentsIt;
2381 }
2382 pGeo = NULL;
2383 #endif
2384 }
2385 }
2386 else
2387 {
2388 std::vector<Int32> dummyVec;
2389 bool dummybool = false;
2390
2391 if(pCoordIndex != NULL &&
2392 pCoordIndex->size() > 1 &&
2393 pColorIndex != NULL &&
2394 pColorPerVertex != NULL)
2395 {
2396 #ifdef OSG_DEBUG_VRML
2397 indentLog(getIndent(), PINFO);
2398 PINFO << "Geo create lineset " << &(*pNode) << std::endl;
2399 #endif
2400
2401 setIndexFromIndexedX3DData(pGeo,
2402 pCoordIndex ->getValues(),
2403 dummyVec ,
2404 pColorIndex ->getValues(),
2405 dummyVec ,
2406 GL_LINE_STRIP,
2407 dummybool,
2408 dummybool,
2409 dummybool,
2410 pColorPerVertex->getValue() ,
2411 false); // create normal; not yet :)
2412 }
2413 else
2414 {
2415 #if 0 // What's the point of doing that?
2416 PWARNING << "Invalid geometry replaced by a group" << std::endl;
2417
2418 GroupPtr pGr = Group::create();
2419
2420 MFNodePtr pGeoParents = pGeo->getParents ();
2421 MFNodePtr::iterator parentsIt = pGeoParents.begin();
2422 MFNodePtr::iterator endParents = pGeoParents.end ();
2423
2424 // this makes pGeo invalid!
2425 while(parentsIt != endParents)
2426 {
2427 (*parentsIt)->setCore(pGr);
2428
2429 ++parentsIt;
2430 }
2431 pGeo = NULL;
2432 #endif
2433 }
2434 }
2435
2436 #ifdef OSG_DEBUG_VRML
2437 // decIndent();
2438
2439 indentLog(getIndent(), PINFO);
2440 PINFO << "End Geo " << &(*pNode) << std::endl;
2441 #endif
2442 }
2443
2444
2445 void VRMLIndexedGeometryHelper::setContainerFieldValue(
2446 FieldContainer *pFC,
2447 const FieldDescriptionBase *pFieldDesc,
2448 FieldContainer *pFieldFC )
2449 {
2450 Geometry *pGeo =
2451 dynamic_cast<Geometry *>(pFieldFC);
2452
2453 GeoVectorProperty *pVecProp =
2454 dynamic_cast<GeoVectorProperty *>(pFC);
2455
2456 if(pGeo != NULL && pVecProp != NULL)
2457 {
2458 pGeo->setProperty(pVecProp, _uiPropertyIndex);
2459 }
2460 else
2461 {
2462 PWARNING << "GeoDesc::getFieldAndDesc : No Geo" << std::endl;
2463 }
2464 }
2465
2466 /*-------------------------------------------------------------------------*/
2467 /* Dump */
2468
2469 void VRMLIndexedGeometryHelper::dump(const Char8 *)
2470 {
2471 }
2472
2473
2474 VRMLNodeHelperFactoryBase::RegisterHelper
2475 VRMLIndexedGeometryHelper::_regHelperIFS(
2476 &VRMLIndexedGeometryHelper::create,
2477 "IndexedFaceSet",
2478 NULL);
2479
2480 VRMLNodeHelperFactoryBase::RegisterHelper
2481 VRMLIndexedGeometryHelper::_regHelperILS(
2482 &VRMLIndexedGeometryHelper::create,
2483 "IndexedLineSet",
2484 NULL);
2485
2486
2487
2488
2489
2490 //---------------------------------------------------------------------------
2491 // Class
2492 //---------------------------------------------------------------------------
2493
2494 VRMLNodeHelper *VRMLPointSetGeometryHelper::create(void)
2495 {
2496 return new VRMLPointSetGeometryHelper();
2497 }
2498
2499 /*-------------------------------------------------------------------------*/
2500 /* Constructors */
2501
2502 VRMLPointSetGeometryHelper::VRMLPointSetGeometryHelper(void) :
2503 Inherited ( ),
2504 _uiPropertyIndex(Geometry::PositionsIndex)
2505 {
2506 }
2507
2508 /*-------------------------------------------------------------------------*/
2509 /* Destructor */
2510
2511 VRMLPointSetGeometryHelper::~VRMLPointSetGeometryHelper(void)
2512 {
2513 }
2514
2515 /*-------------------------------------------------------------------------*/
2516 /* Helper */
2517
2518 void VRMLPointSetGeometryHelper::init(const Char8 *szName)
2519 {
2520 Inherited::init(szName);
2521
2522 #ifdef OSG_DEBUG_VRML
2523 indentLog(getIndent(), PINFO);
2524 PINFO << "GeoDesc::init : " << szName << std::endl;
2525 #endif
2526
2527 _pNodeProto = Node ::create();
2528 _pNodeCoreProto = Geometry ::create();
2529
2530 _pGenAttProto = VRMLGenericAtt::createLocal(FCLocal::Cluster);
2531 _pGenAttProto->setInternal(true);
2532 }
2533
2534 /*-------------------------------------------------------------------------*/
2535 /* Get */
2536
2537 bool VRMLPointSetGeometryHelper::prototypeAddField(const Char8 *szFieldType,
2538 const UInt32 uiFieldTypeId,
2539 const Char8 *szFieldname)
2540 {
2541 bool bFound = false;
2542
2543 if(szFieldname == NULL)
2544 return false;
2545
2546 if(osgStringCaseCmp("coord", szFieldname) == 0)
2547 {
2548 bFound = true;
2549 }
2550 else if(osgStringCaseCmp("color", szFieldname) == 0)
2551 {
2552 bFound = true;
2553 }
2554
2555 if(bFound == true)
2556 {
2557 #ifdef OSG_DEBUG_VRML
2558 indentLog(getIndent(), PINFO);
2559 PINFO << "GeoDesc::prototypeAddField : internal "
2560 << szFieldname << std::endl;
2561 #endif
2562
2563 return true;
2564 }
2565 else
2566 {
2567 return Inherited::prototypeAddField(szFieldType,
2568 uiFieldTypeId,
2569 szFieldname);
2570 }
2571 }
2572
2573
2574 void VRMLPointSetGeometryHelper::getFieldAndDesc(
2575 FieldContainer * pFC,
2576 const Char8 * szFieldname,
2577 FieldContainer *&pFieldFC,
2578 EditFieldHandlePtr &pField,
2579 const FieldDescriptionBase *&pDesc)
2580 {
2581 #ifdef OSG_DEBUG_VRML
2582 indentLog(getIndent(), PINFO);
2583 PINFO << "GeoDesc::getFieldAndDesc : request "
2584 << szFieldname
2585 << std::endl;
2586 #endif
2587
2588 if(szFieldname == NULL)
2589 return;
2590
2591 if(pFC == NULL)
2592 {
2593 if(_bProtoInterfaceDone == false)
2594 {
2595 Inherited::getField(szFieldname, pFieldFC, pField, pDesc);
2596 }
2597
2598 return;
2599 }
2600
2601 Node *pNode = dynamic_cast<Node *>(pFC);
2602
2603 if(pNode == NULL)
2604 {
2605 PWARNING << "GeoDesc::getFieldAndDesc : No Node" << std::endl;
2606 return;
2607 }
2608
2609 NodeCore *pNodeCore = pNode->getCore();
2610
2611 Geometry *pGeo = dynamic_cast<Geometry *>(pNodeCore);
2612
2613 if(pGeo == NULL)
2614 {
2615 PWARNING << "GeoDesc::getFieldAndDesc : No Geo" << std::endl;
2616 return;
2617 }
2618
2619 if(osgStringCaseCmp("coord", szFieldname) == 0)
2620 {
2621 #ifdef OSG_DEBUG_VRML
2622 indentLog(getIndent(), PINFO);
2623 PINFO << "GeoDesc::getFieldAndDesc : internal "
2624 << szFieldname << std::endl;
2625 #endif
2626
2627 pFieldFC = pGeo;
2628 pField.reset();
2629 pDesc = &_sfFCPtrDesc;
2630
2631 _uiPropertyIndex = Geometry::PositionsIndex;
2632 }
2633 else if(osgStringCaseCmp("color", szFieldname) == 0)
2634 {
2635 #ifdef OSG_DEBUG_VRML
2636 indentLog(getIndent(), PINFO);
2637 PINFO << "GeoDesc::getFieldAndDesc : internal "
2638 << szFieldname << std::endl;
2639 #endif
2640
2641 pFieldFC = pGeo;
2642 pField.reset();
2643 pDesc = &_sfFCPtrDesc;
2644
2645 _uiPropertyIndex = Geometry::ColorsIndex;
2646 }
2647 else
2648 {
2649 Inherited::getFieldAndDesc(pGeo,
2650 szFieldname,
2651 pFieldFC,
2652 pField,
2653 pDesc);
2654 }
2655 }
2656
2657 /*-------------------------------------------------------------------------*/
2658 /* Node */
2659
2660
2661
2662 void VRMLPointSetGeometryHelper::endNode(FieldContainer *pFC)
2663 {
2664 Node *pNode = NULL;
2665 Geometry *pGeo = NULL;
2666
2667 if(pFC == NULL)
2668 {
2669 return;
2670 }
2671
2672 pNode = dynamic_cast<Node *>(pFC);
2673
2674 if(pNode == NULL)
2675 {
2676 return;
2677 }
2678
2679 pGeo = dynamic_cast<Geometry *>(pNode->getCore());
2680
2681 if(pGeo == NULL)
2682 {
2683 return;
2684 }
2685
2686 GeoVectorProperty *pPnts = pGeo->getProperty(Geometry::PositionsIndex);
2687
2688 if(pPnts == NULL)
2689 return;
2690
2691 GeoUInt32PropertyUnrecPtr lens = GeoUInt32Property::create();
2692 GeoUInt8PropertyUnrecPtr types = GeoUInt8Property ::create();
2693
2694 types->push_back(GL_POINTS );
2695 lens ->push_back(pPnts->size());
2696
2697 pGeo->setTypes (types);
2698 pGeo->setLengths(lens );
2699
2700 #if 0
2701 EditFieldHandlePtr pField;
2702 const FieldDescriptionBase *pDesc = NULL;
2703 FieldContainer *pDummyFC = NULL;
2704
2705
2706
2707 if(_bIsFaceSet == true)
2708 {
2709 if(pCoordIndex != NULL &&
2710 pCoordIndex->size() > 2 &&
2711 pNormalIndex != NULL &&
2712 pColorIndex != NULL &&
2713 pTexCoordIndex != NULL &&
2714 pConvex != NULL &&
2715 pCcw != NULL &&
2716 pNormalPerVertex != NULL &&
2717 pColorPerVertex != NULL &&
2718 pCreaseAngle != NULL)
2719 {
2720 #ifdef OSG_DEBUG_VRML
2721 indentLog(getIndent(), PINFO);
2722 PINFO << "Geo create faceset " << &(*pNode) << std::endl;
2723 #endif
2724
2725 setIndexFromIndexedX3DData(pGeo,
2726 pCoordIndex ->getValues(),
2727 pNormalIndex ->getValues(),
2728 pColorIndex ->getValues(),
2729 pTexCoordIndex ->getValues(),
2730 GL_POLYGON,
2731 pConvex ->getValue() ,
2732 pCcw ->getValue() ,
2733 pNormalPerVertex->getValue() ,
2734 pColorPerVertex ->getValue() ,
2735 false); // create normal; not yet :)
2736
2737 //if (pConvex->getValue() == false)
2738 // createConvexPrimitives( pGeo );
2739
2740 // TODO: Need some option _uiOptions param
2741 //createSharedIndex( pGeo);
2742
2743 //if((0 != (_uiOptions & VRMLFile::CreateNormals) ) &&
2744 // (pGeo->getNormals() == NULL))
2745
2746 if(pGeo->getNormals() == NULL)
2747 {
2748 #ifdef OSG_DEBUG_VRML
2749 indentLog(getIndent(), PINFO);
2750 PINFO << "Geo create normals " << &(*pNode) << std::endl;
2751 #endif
2752
2753 OSG::calcVertexNormals(pGeo, pCreaseAngle->getValue());
2754 }
2755 }
2756 else
2757 {
2758 #if 0 // What's the point of doing that?
2759 PWARNING << "Invalid geometry replaced by a group" << std::endl;
2760
2761 GroupPtr pGr = Group::create();
2762
2763 MFNodePtr pGeoParents = pGeo->getParents ();
2764 MFNodePtr::iterator parentsIt = pGeoParents.begin();
2765 MFNodePtr::iterator endParents = pGeoParents.end ();
2766
2767 // this makes pGeo invalid!
2768 while(parentsIt != endParents)
2769 {
2770 (*parentsIt)->setCore(pGr);
2771
2772 ++parentsIt;
2773 }
2774 pGeo = NULL;
2775 #endif
2776 }
2777 }
2778 else
2779 {
2780 std::vector<Int32> dummyVec;
2781 bool dummybool = false;
2782
2783 if(pCoordIndex != NULL &&
2784 pCoordIndex->size() > 1 &&
2785 pColorIndex != NULL &&
2786 pColorPerVertex != NULL)
2787 {
2788 #ifdef OSG_DEBUG_VRML
2789 indentLog(getIndent(), PINFO);
2790 PINFO << "Geo create lineset " << &(*pNode) << std::endl;
2791 #endif
2792
2793 setIndexFromIndexedX3DData(pGeo,
2794 pCoordIndex ->getValues(),
2795 dummyVec ,
2796 pColorIndex ->getValues(),
2797 dummyVec ,
2798 GL_LINE_STRIP,
2799 dummybool,
2800 dummybool,
2801 dummybool,
2802 pColorPerVertex->getValue() ,
2803 false); // create normal; not yet :)
2804 }
2805 else
2806 {
2807 #if 0 // What's the point of doing that?
2808 PWARNING << "Invalid geometry replaced by a group" << std::endl;
2809
2810 GroupPtr pGr = Group::create();
2811
2812 MFNodePtr pGeoParents = pGeo->getParents ();
2813 MFNodePtr::iterator parentsIt = pGeoParents.begin();
2814 MFNodePtr::iterator endParents = pGeoParents.end ();
2815
2816 // this makes pGeo invalid!
2817 while(parentsIt != endParents)
2818 {
2819 (*parentsIt)->setCore(pGr);
2820
2821 ++parentsIt;
2822 }
2823 pGeo = NULL;
2824 #endif
2825 }
2826 }
2827 #endif
2828
2829 #ifdef OSG_DEBUG_VRML
2830 // decIndent();
2831
2832 indentLog(getIndent(), PINFO);
2833 PINFO << "End Geo " << &(*pNode) << std::endl;
2834 #endif
2835 }
2836
2837
2838 void VRMLPointSetGeometryHelper::setContainerFieldValue(
2839 FieldContainer *pFC,
2840 const FieldDescriptionBase *pFieldDesc,
2841 FieldContainer *pFieldFC )
2842 {
2843 Geometry *pGeo =
2844 dynamic_cast<Geometry *>(pFieldFC);
2845
2846 GeoVectorProperty *pVecProp =
2847 dynamic_cast<GeoVectorProperty *>(pFC);
2848
2849 if(pGeo != NULL && pVecProp != NULL)
2850 {
2851 pGeo->setProperty(pVecProp, _uiPropertyIndex);
2852 }
2853 else
2854 {
2855 PWARNING << "GeoDesc::getFieldAndDesc : No Geo" << std::endl;
2856 }
2857 }
2858
2859 /*-------------------------------------------------------------------------*/
2860 /* Dump */
2861
2862 void VRMLPointSetGeometryHelper::dump(const Char8 *)
2863 {
2864 }
2865
2866
2867 VRMLNodeHelperFactoryBase::RegisterHelper
2868 VRMLPointSetGeometryHelper::_regHelperPS(
2869 &VRMLPointSetGeometryHelper::create,
2870 "PointSet",
2871 NULL);
2872
2873
2874
2875
2876
2877 //---------------------------------------------------------------------------
2878 // Class
2879 //---------------------------------------------------------------------------
2880
2881 VRMLNodeHelper *VRMLGeometryPartHelper::create(void)
2882 {
2883 return new VRMLGeometryPartHelper();
2884 }
2885
2886 /*-------------------------------------------------------------------------*/
2887 /* Constructors */
2888
2889 VRMLGeometryPartHelper::VRMLGeometryPartHelper(void) :
2890 Inherited (),
2891
2892 _szVRMLPartname(),
2893 _szOSGPartname (),
2894 _szOSGProtoname()
2895 {
2896 }
2897
2898 /*-------------------------------------------------------------------------*/
2899 /* Destructor */
2900
2901 VRMLGeometryPartHelper::~VRMLGeometryPartHelper(void)
2902 {
2903 }
2904
2905 /*-------------------------------------------------------------------------*/
2906 /* Helper */
2907
2908 void VRMLGeometryPartHelper::init(const Char8 *szName)
2909 {
2910 if(osgStringCaseCmp("Coordinate", szName) == 0)
2911 {
2912 _szVRMLPartname = "point";
2913 _szOSGPartname = "values";
2914 _szOSGProtoname = "GeoPnt3fProperty";
2915 }
2916 else if(osgStringCaseCmp("Normal", szName) == 0)
2917 {
2918 _szVRMLPartname = "vector";
2919 _szOSGPartname = "values";
2920 _szOSGProtoname = "GeoVec3fProperty";
2921 }
2922 else if(osgStringCaseCmp("Color", szName) == 0)
2923 {
2924 _szVRMLPartname = "color";
2925 _szOSGPartname = "values";
2926 _szOSGProtoname = "GeoColor3fProperty";
2927 }
2928 else if(osgStringCaseCmp("TextureCoordinate", szName) == 0)
2929 {
2930 _szVRMLPartname = "point";
2931 _szOSGPartname = "values";
2932 _szOSGProtoname = "GeoVec2fProperty";
2933 }
2934
2935 #ifdef OSG_DEBUG_VRML
2936 indentLog(getIndent(), PINFO);
2937 PINFO << "GeoPartDesc::init : "
2938 << szName << " "
2939 << _szVRMLPartname << " "
2940 << _szOSGPartname << " "
2941 << _szOSGProtoname << " "
2942 << std::endl;
2943 #endif
2944
2945 _pNodeProto =
2946 FieldContainerFactory::the()->createContainer(_szOSGProtoname.c_str());
2947
2948 if(_pNodeProto == NULL)
2949 {
2950 PWARNING << "ERROR no prototype available for "
2951 << _szOSGProtoname
2952 << std::endl;
2953 }
2954
2955 _pGenAttProto = VRMLGenericAtt::createLocal(FCLocal::Cluster);
2956 _pGenAttProto->setInternal(true);
2957 }
2958
2959 /*-------------------------------------------------------------------------*/
2960 /* Field */
2961
2962 bool VRMLGeometryPartHelper::prototypeAddField(const Char8 *szFieldType,
2963 const UInt32 uiFieldTypeId,
2964 const Char8 *szFieldname)
2965 {
2966 bool bFound = false;
2967
2968 if(_szVRMLPartname == szFieldname)
2969 {
2970 #ifdef OSG_DEBUG_VRML
2971 indentLog(getIndent(), PINFO);
2972 PINFO << "GeoPartDesc::prototypeAddField : add part "
2973 << szFieldname
2974 << std::endl;
2975 #endif
2976
2977 bFound = true;
2978 }
2979
2980
2981 if(bFound == true)
2982 {
2983 return true;
2984 }
2985 else
2986 {
2987 return Inherited::prototypeAddField(szFieldType,
2988 uiFieldTypeId,
2989 szFieldname);
2990 }
2991 }
2992
2993 void VRMLGeometryPartHelper::getFieldAndDesc(
2994 FieldContainer * pFC,
2995 const Char8 * szFieldname,
2996 FieldContainer *&pFieldFC,
2997 EditFieldHandlePtr &pField,
2998 const FieldDescriptionBase *&pDesc)
2999 {
3000 #ifdef OSG_DEBUG_VRML
3001 indentLog(getIndent(), PINFO);
3002 PINFO << "VRMLGeometryPartDesc::getFieldAndDesc : looking for "
3003 << szFieldname
3004 << std::endl;
3005 #endif
3006
3007 if(szFieldname == NULL)
3008 return;
3009
3010 if(pFC == NULL)
3011 {
3012 if(_bProtoInterfaceDone == false)
3013 {
3014 Inherited::getField(szFieldname, pFieldFC, pField, pDesc);
3015 }
3016
3017 return;
3018 }
3019
3020 incIndent();
3021
3022 if(_szVRMLPartname == szFieldname)
3023 {
3024 #ifdef OSG_DEBUG_VRML
3025 indentLog(getIndent(), PINFO);
3026 PINFO << "VRMLGeometryPartDesc::getFieldAndDesc : request internal "
3027 << szFieldname
3028 << " return "
3029 << _szOSGPartname
3030 << std::endl;
3031 #endif
3032
3033 pFieldFC = pFC;
3034 pDesc = pFC->getFieldDescription(_szOSGPartname.c_str());
3035 pField = pFC->editField (_szOSGPartname.c_str());
3036
3037 if(pField == NULL)
3038 {
3039 PWARNING << "VRMLGeometryPartDesc::getFieldAndDesc : could not"
3040 << " map : "
3041 << szFieldname
3042 << " to "
3043 << _szOSGPartname
3044 << std::endl;
3045 }
3046 }
3047 else
3048 {
3049 Inherited::getFieldAndDesc(pFC,
3050 szFieldname,
3051 pFieldFC,
3052 pField,
3053 pDesc);
3054 }
3055
3056 #ifdef OSG_DEBUG_VRML
3057 decIndent();
3058 #endif
3059 }
3060
3061 /*-------------------------------------------------------------------------*/
3062 /* Node */
3063
3064 void VRMLGeometryPartHelper::mapFieldname(const std::string &,
3065 std::string &szFieldName)
3066 {
3067 szFieldName.assign("values");
3068 }
3069
3070
3071 /*-------------------------------------------------------------------------*/
3072 /* Dump */
3073
3074 void VRMLGeometryPartHelper::dump(const Char8 *)
3075 {
3076 }
3077
3078
3079 VRMLNodeHelperFactoryBase::RegisterHelper
3080 VRMLGeometryPartHelper::_regHelperCoordinate(
3081 &VRMLGeometryPartHelper::create,
3082 "Coordinate",
3083 NULL);
3084
3085 VRMLNodeHelperFactoryBase::RegisterHelper
3086 VRMLGeometryPartHelper::_regHelperNormal(
3087 &VRMLGeometryPartHelper::create,
3088 "Normal",
3089 NULL);
3090
3091 VRMLNodeHelperFactoryBase::RegisterHelper
3092 VRMLGeometryPartHelper::_regHelperColor(
3093 &VRMLGeometryPartHelper::create,
3094 "Color",
3095 NULL);
3096
3097 VRMLNodeHelperFactoryBase::RegisterHelper
3098 VRMLGeometryPartHelper::_regHelperTexCoordinate(
3099 &VRMLGeometryPartHelper::create,
3100 "TextureCoordinate",
3101 NULL);
3102
3103
3104
3105
3106 //---------------------------------------------------------------------------
3107 // Class
3108 //---------------------------------------------------------------------------
3109
3110 VRMLNodeHelper *VRMLGeometryObjectHelper::create(void)
3111 {
3112 return new VRMLGeometryObjectHelper();
3113 }
3114
3115 /*-------------------------------------------------------------------------*/
3116 /* Constructors */
3117
3118 VRMLGeometryObjectHelper::VRMLGeometryObjectHelper(void) :
3119 Inherited ( ),
3120 _eVRMLObjectType(UnknownGeo)
3121 {
3122 }
3123
3124 /*-------------------------------------------------------------------------*/
3125 /* Destructor */
3126
3127 VRMLGeometryObjectHelper::~VRMLGeometryObjectHelper(void)
3128 {
3129 }
3130
3131 /*-------------------------------------------------------------------------*/
3132 /* Helper */
3133
3134 void VRMLGeometryObjectHelper::init(const Char8 *szName)
3135 {
3136 #ifdef OSG_DEBUG_VRML
3137 indentLog(getIndent(), PINFO);
3138 PINFO << "GeoObjDesc::init : "
3139 << szName << " "
3140 << _eVRMLObjectType
3141 << std::endl;
3142 #endif
3143
3144 if(osgStringCaseCmp("Box", szName) == 0)
3145 {
3146 _eVRMLObjectType = BoxGeo;
3147 }
3148 else if(osgStringCaseCmp("Sphere", szName) == 0)
3149 {
3150 _eVRMLObjectType = SphereGeo;
3151 }
3152 else if(osgStringCaseCmp("Cone", szName) == 0)
3153 {
3154 _eVRMLObjectType = ConeGeo;
3155 }
3156 else if(osgStringCaseCmp("Cylinder", szName) == 0)
3157 {
3158 _eVRMLObjectType = CylinderGeo;
3159 }
3160 else if(osgStringCaseCmp("Teapot", szName) == 0)
3161 {
3162 _eVRMLObjectType = TeapotGeo;
3163 }
3164 else if(osgStringCaseCmp("Plane", szName) == 0)
3165 {
3166 _eVRMLObjectType = PlaneGeo;
3167 }
3168
3169 _pNodeProto = Node::create();
3170
3171 if(_pNodeProto == NULL)
3172 {
3173 PWARNING << "GeoObjDesc::init : no prototype available" << std::endl;
3174 }
3175
3176 _pGenAttProto = VRMLGenericAtt::createLocal(FCLocal::Cluster);
3177 _pGenAttProto->setInternal(true);
3178 }
3179
3180 /*-------------------------------------------------------------------------*/
3181 /* Field */
3182
3183 /*-------------------------------------------------------------------------*/
3184 /* Node */
3185
3186 void VRMLGeometryObjectHelper::endNode(FieldContainer *pFC)
3187 {
3188 EditFieldHandlePtr pField;
3189 const FieldDescriptionBase *pDesc = NULL;
3190 FieldContainer *pDummyFC = NULL;
3191 Node *pNode = NULL;
3192
3193 if(pFC == NULL)
3194 return;
3195
3196 pNode = dynamic_cast<Node *>(pFC);
3197
3198 if(pNode == NULL)
3199 return;
3200
3201 if(_eVRMLObjectType == BoxGeo)
3202 {
3203 Inherited::getFieldAndDesc(pFC,
3204 "size",
3205 pDummyFC,
3206 pField,
3207 pDesc);
3208
3209 EditFieldHandlePtr pFieldInv;
3210
3211 Inherited::getFieldAndDesc(pFC,
3212 "invert",
3213 pDummyFC,
3214 pFieldInv,
3215 pDesc);
3216
3217 if(pField != NULL)
3218 {
3219 SFVec3f::EditHandlePtr pValField =
3220 boost::dynamic_pointer_cast<SFVec3f::EditHandle>(pField);
3221
3222 SFBool::EditHandlePtr pValFieldInv =
3223 boost::dynamic_pointer_cast<SFBool::EditHandle>(pFieldInv);
3224
3225 bool bInv = pValFieldInv != NULL ?
3226 pValFieldInv->getField()->getValue() : false;
3227
3228 if(pValField != NULL && pValField->isValid())
3229 {
3230 SFVec3f *pVec = pValField->getField();
3231
3232 GeometryUnrecPtr pGeo = makeBoxGeo(pVec->getValue()[0],
3233 pVec->getValue()[1],
3234 pVec->getValue()[2],
3235 1,
3236 1,
3237 1,
3238 bInv );
3239
3240 pNode->setCore(pGeo);
3241 }
3242 }
3243 }
3244 else if(_eVRMLObjectType == ConeGeo)
3245 {
3246 SFReal32 *pBotRad = NULL;
3247 SFReal32 *pHeight = NULL;
3248 SFBool *pSide = NULL;
3249 SFBool *pBottom = NULL;
3250
3251 Inherited::getFieldAndDesc(pFC,
3252 "bottomRadius",
3253 pDummyFC,
3254 pField,
3255 pDesc);
3256
3257 if(pField != NULL)
3258 {
3259 SFReal32::EditHandlePtr pValField =
3260 boost::dynamic_pointer_cast<SFReal32::EditHandle>(pField);
3261
3262 if(pValField != NULL && pValField->isValid())
3263 {
3264 pBotRad = pValField->getField();
3265 }
3266 }
3267
3268 Inherited::getFieldAndDesc(pFC,
3269 "height",
3270 pDummyFC,
3271 pField,
3272 pDesc);
3273
3274 if(pField != NULL)
3275 {
3276 SFReal32::EditHandlePtr pValField =
3277 boost::dynamic_pointer_cast<SFReal32::EditHandle>(pField);
3278
3279 if(pValField != NULL && pValField->isValid())
3280 {
3281 pHeight = pValField->getField();
3282 }
3283 }
3284
3285 Inherited::getFieldAndDesc(pFC,
3286 "side",
3287 pDummyFC,
3288 pField,
3289 pDesc);
3290
3291 if(pField != NULL)
3292 {
3293 SFBool::EditHandlePtr pValField =
3294 boost::dynamic_pointer_cast<SFBool::EditHandle>(pField);
3295
3296 if(pValField != NULL && pValField->isValid())
3297 {
3298 pSide = pValField->getField();
3299 }
3300 }
3301
3302 Inherited::getFieldAndDesc(pFC,
3303 "bottom",
3304 pDummyFC,
3305 pField,
3306 pDesc);
3307
3308 if(pField != NULL)
3309 {
3310 SFBool::EditHandlePtr pValField =
3311 boost::dynamic_pointer_cast<SFBool::EditHandle>(pField);
3312
3313 if(pValField != NULL && pValField->isValid())
3314 {
3315 pBottom = pValField->getField();
3316 }
3317 }
3318
3319 if(pBotRad != NULL &&
3320 pHeight != NULL &&
3321 pSide != NULL &&
3322 pBottom != NULL)
3323 {
3324 #ifdef OSG_DEBUG_VRML
3325 indentLog(getIndent(), PINFO);
3326 PINFO << "VRMLGeometryObjectDesc::endNode : Create cone"
3327 << std::endl;
3328 #endif
3329
3330 GeometryUnrecPtr pGeo = makeConeGeo(pHeight->getValue(),
3331 pBotRad->getValue(),
3332 32,
3333 pSide ->getValue(),
3334 pBottom->getValue());
3335
3336 pNode->setCore(pGeo);
3337 }
3338 }
3339 else if(_eVRMLObjectType == CylinderGeo)
3340 {
3341 SFBool *pBottom = NULL;
3342 SFReal32 *pHeight = NULL;
3343 SFReal32 *pRadius = NULL;
3344 SFBool *pSide = NULL;
3345 SFBool *pTop = NULL;
3346
3347 Inherited::getFieldAndDesc(pFC,
3348 "bottom",
3349 pDummyFC,
3350 pField,
3351 pDesc);
3352
3353 if(pField != NULL)
3354 {
3355 SFBool::EditHandlePtr pValField =
3356 boost::dynamic_pointer_cast<SFBool::EditHandle>(pField);
3357
3358 if(pValField != NULL && pValField->isValid())
3359 {
3360 pBottom = pValField->getField();
3361 }
3362 }
3363
3364 Inherited::getFieldAndDesc(pFC,
3365 "height",
3366 pDummyFC,
3367 pField,
3368 pDesc);
3369
3370 if(pField != NULL)
3371 {
3372 SFReal32::EditHandlePtr pValField =
3373 boost::dynamic_pointer_cast<SFReal32::EditHandle>(pField);
3374
3375 if(pValField != NULL && pValField->isValid())
3376 {
3377 pHeight = pValField->getField();
3378 }
3379 }
3380
3381 Inherited::getFieldAndDesc(pFC,
3382 "radius",
3383 pDummyFC,
3384 pField,
3385 pDesc);
3386
3387 if(pField != NULL)
3388 {
3389 SFReal32::EditHandlePtr pValField =
3390 boost::dynamic_pointer_cast<SFReal32::EditHandle>(pField);
3391
3392 if(pValField != NULL && pValField->isValid())
3393 {
3394 pRadius = pValField->getField();
3395 }
3396 }
3397
3398 Inherited::getFieldAndDesc(pFC,
3399 "side",
3400 pDummyFC,
3401 pField,
3402 pDesc);
3403
3404 if(pField != NULL)
3405 {
3406 SFBool::EditHandlePtr pValField =
3407 boost::dynamic_pointer_cast<SFBool::EditHandle>(pField);
3408
3409 if(pValField != NULL && pValField->isValid())
3410 {
3411 pSide = pValField->getField();
3412 }
3413 }
3414
3415 Inherited::getFieldAndDesc(pFC,
3416 "top",
3417 pDummyFC,
3418 pField,
3419 pDesc);
3420
3421 if(pField != NULL)
3422 {
3423 SFBool::EditHandlePtr pValField =
3424 boost::dynamic_pointer_cast<SFBool::EditHandle>(pField);
3425
3426 if(pValField != NULL && pValField->isValid())
3427 {
3428 pTop = pValField->getField();
3429 }
3430 }
3431
3432
3433 if(pBottom != NULL &&
3434 pHeight != NULL &&
3435 pRadius != NULL &&
3436 pSide != NULL &&
3437 pTop != NULL)
3438 {
3439 #ifdef OSG_DEBUG_VRML
3440 indentLog(getIndent(), PINFO);
3441 PINFO << "VRMLGeometryObjectDesc::endNode : Create cylinder"
3442 << std::endl;
3443 #endif
3444
3445 GeometryUnrecPtr pGeo = makeCylinderGeo(pHeight->getValue(),
3446 pRadius->getValue(),
3447 32,
3448 pSide ->getValue(),
3449 pTop ->getValue(),
3450 pBottom->getValue());
3451
3452 pNode->setCore(pGeo);
3453 }
3454 }
3455 else if(_eVRMLObjectType == SphereGeo)
3456 {
3457 SFReal32 *pSize = NULL;
3458 SFInt32 *pResolution = NULL;
3459
3460 Inherited::getFieldAndDesc(pFC,
3461 "radius",
3462 pDummyFC,
3463 pField,
3464 pDesc);
3465
3466 if(pField != NULL)
3467 {
3468 SFReal32::EditHandlePtr pValField =
3469 boost::dynamic_pointer_cast<SFReal32::EditHandle>(pField);
3470
3471 if(pValField != NULL && pValField->isValid())
3472 {
3473 pSize = pValField->getField();
3474 }
3475 }
3476
3477 Inherited::getFieldAndDesc(pFC,
3478 "resolution",
3479 pDummyFC,
3480 pField,
3481 pDesc);
3482
3483 if(pField != NULL)
3484 {
3485 SFInt32::EditHandlePtr pValField =
3486 boost::dynamic_pointer_cast<SFInt32::EditHandle>(pField);
3487
3488 if(pValField != NULL && pValField->isValid())
3489 {
3490 pResolution = pValField->getField();
3491 }
3492 }
3493
3494 if(pSize != NULL && pResolution != NULL)
3495 {
3496 GeometryUnrecPtr pGeo =
3497 makeLatLongSphereGeo(pResolution->getValue(),
3498 pResolution->getValue() * 2,
3499 pSize ->getValue());
3500
3501 pNode->setCore(pGeo);
3502 }
3503 }
3504 else if(_eVRMLObjectType == TeapotGeo)
3505 {
3506 SFReal32 *pScale = NULL;
3507 SFInt32 *pDepth = NULL;
3508
3509 Inherited::getFieldAndDesc(pFC,
3510 "scale",
3511 pDummyFC,
3512 pField,
3513 pDesc);
3514
3515 if(pField != NULL)
3516 {
3517 SFReal32::EditHandlePtr pValField =
3518 boost::dynamic_pointer_cast<SFReal32::EditHandle>(pField);
3519
3520 if(pValField != NULL && pValField->isValid())
3521 {
3522 pScale = pValField->getField();
3523 }
3524 }
3525
3526 Inherited::getFieldAndDesc(pFC,
3527 "depth",
3528 pDummyFC,
3529 pField,
3530 pDesc);
3531
3532 if(pField != NULL)
3533 {
3534 SFInt32::EditHandlePtr pValField =
3535 boost::dynamic_pointer_cast<SFInt32::EditHandle>(pField);
3536
3537 if(pValField != NULL && pValField->isValid())
3538 {
3539 pDepth = pValField->getField();
3540 }
3541 }
3542
3543 GeometryUnrecPtr pGeo = makeTeapotGeo(
3544 (pDepth != NULL) ? pDepth->getValue() : 5,
3545 (pScale != NULL) ? pScale->getValue() : 1.f);
3546
3547 pNode->setCore(pGeo);
3548
3549 }
3550 else if(_eVRMLObjectType == PlaneGeo)
3551 {
3552 SFVec2s *pResolution = NULL;
3553 SFVec2f *pSize = NULL;
3554
3555 Inherited::getFieldAndDesc(pFC,
3556 "resolution",
3557 pDummyFC,
3558 pField,
3559 pDesc);
3560
3561 if(pField != NULL)
3562 {
3563 SFVec2s::EditHandlePtr pValField =
3564 boost::dynamic_pointer_cast<SFVec2s::EditHandle>(pField);
3565
3566 if(pValField != NULL && pValField->isValid())
3567 {
3568 pResolution = pValField->getField();
3569 }
3570 }
3571
3572 Inherited::getFieldAndDesc(pFC,
3573 "size",
3574 pDummyFC,
3575 pField,
3576 pDesc);
3577
3578 if(pField != NULL)
3579 {
3580 SFVec2f::EditHandlePtr pValField =
3581 boost::dynamic_pointer_cast<SFVec2f::EditHandle>(pField);
3582
3583 if(pValField != NULL && pValField->isValid())
3584 {
3585 pSize = pValField->getField();
3586 }
3587 }
3588
3589 GeometryUnrecPtr pGeo = makePlaneGeo(
3590 (pSize != NULL) ? pSize ->getValue()[0] : 1.f,
3591 (pSize != NULL) ? pSize ->getValue()[1] : 1.f,
3592 (pResolution != NULL) ? pResolution->getValue()[0] : 5,
3593 (pResolution != NULL) ? pResolution->getValue()[1] : 5);
3594
3595 pNode->setCore(pGeo);
3596
3597 }
3598 }
3599
3600 /*-------------------------------------------------------------------------*/
3601 /* Dump */
3602
3603 void VRMLGeometryObjectHelper::dump(const Char8 *)
3604 {
3605 }
3606
3607 VRMLNodeHelperFactoryBase::RegisterHelper
3608 VRMLGeometryObjectHelper::_regHelperBox(
3609 &VRMLGeometryObjectHelper::create,
3610 "Box",
3611 NULL);
3612
3613 VRMLNodeHelperFactoryBase::RegisterHelper
3614 VRMLGeometryObjectHelper::_regHelperSphere(
3615 &VRMLGeometryObjectHelper::create,
3616 "Sphere",
3617 NULL);
3618
3619 VRMLNodeHelperFactoryBase::RegisterHelper
3620 VRMLGeometryObjectHelper::_regHelperCone(
3621 &VRMLGeometryObjectHelper::create,
3622 "Cone",
3623 NULL);
3624
3625 VRMLNodeHelperFactoryBase::RegisterHelper
3626 VRMLGeometryObjectHelper::_regHelperCylinder(
3627 &VRMLGeometryObjectHelper::create,
3628 "Cylinder",
3629 NULL);
3630
3631 VRMLNodeHelperFactoryBase::RegisterHelper
3632 VRMLGeometryObjectHelper::_regHelperTeapot(
3633 &VRMLGeometryObjectHelper::create,
3634 "Teapot",
3635 NULL);
3636
3637 VRMLNodeHelperFactoryBase::RegisterHelper
3638 VRMLGeometryObjectHelper::_regHelperPlane(
3639 &VRMLGeometryObjectHelper::create,
3640 "Plane",
3641 NULL);
3642
3643
3644
3645 //---------------------------------------------------------------------------
3646 // Class
3647 //---------------------------------------------------------------------------
3648
3649 /*-------------------------------------------------------------------------*/
3650 /* Constructors */
3651
3652 VRMLTextureHelper::VRMLTextureHelper(void) :
3653 Inherited (),
3654
3655 _defaultRepeatS(),
3656 _defaultRepeatT(),
3657
3658 _repeatS (),
3659 _repeatT ()
3660 {
3661 }
3662
3663 /*-------------------------------------------------------------------------*/
3664 /* Destructor */
3665
3666 VRMLTextureHelper::~VRMLTextureHelper(void)
3667 {
3668 }
3669
3670 /*-------------------------------------------------------------------------*/
3671 /* Helper */
3672
3673 /*-------------------------------------------------------------------------*/
3674 /* Field */
3675
3676 bool VRMLTextureHelper::prototypeAddField(const Char8 *,
3677 const UInt32 ,
3678 const Char8 *szFieldname)
3679 {
3680 bool bFound = false;
3681
3682 if(osgStringCaseCmp("repeatS", szFieldname) == 0)
3683 {
3684 bFound = true;
3685 }
3686 else if(osgStringCaseCmp("repeatT", szFieldname) == 0)
3687 {
3688 bFound = true;
3689 }
3690
3691 if(bFound == true)
3692 {
3693 #ifdef OSG_DEBUG_VRML
3694 indentLog(getIndent(), PINFO);
3695 PINFO << "ImageTextureDesc::prototypeAddField : add part "
3696 << szFieldname
3697 << std::endl;
3698 #endif
3699
3700 return true;
3701 }
3702 else
3703 {
3704 return false;
3705 }
3706 }
3707
3708
3709 void VRMLTextureHelper::getFieldAndDesc(
3710 FieldContainer *,
3711 const Char8 * szFieldname,
3712 FieldContainer *&pFieldFC,
3713 EditFieldHandlePtr &pField,
3714 const FieldDescriptionBase *&pDesc)
3715 {
3716 pFieldFC = NULL;
3717 pField.reset();
3718 pDesc = NULL;
3719
3720 if(osgStringCaseCmp("repeatS", szFieldname) == 0)
3721 {
3722 if(_bProtoInterfaceDone == false)
3723 {
3724 pField = _sfBoolDesc.createEditHandler(&_defaultRepeatS,
3725 NULL );
3726 }
3727 else
3728 {
3729 pField = _sfBoolDesc.createEditHandler(&_repeatS,
3730 NULL );
3731 }
3732
3733 pDesc = &_sfBoolDesc;
3734 }
3735 else if(osgStringCaseCmp("repeatT", szFieldname) == 0)
3736 {
3737 if(_bProtoInterfaceDone == false)
3738 {
3739 pField = _sfBoolDesc.createEditHandler(&_defaultRepeatT,
3740 NULL );
3741 }
3742 else
3743 {
3744 pField = _sfBoolDesc.createEditHandler(&_repeatT,
3745 NULL );
3746 }
3747
3748 pDesc = &_sfBoolDesc;
3749 }
3750 }
3751
3752 /*-------------------------------------------------------------------------*/
3753 /* Node */
3754
3755 FieldContainerTransitPtr VRMLTextureHelper::beginNode(
3756 const Char8 *,
3757 const Char8 *,
3758 FieldContainer *)
3759 {
3760 TextureObjChunkTransitPtr returnValue = TextureObjChunk::create();
3761
3762 #ifdef OSG_DEBUG_VRML
3763 indentLog(getIndent(), PINFO);
3764 PINFO << "Begin Texture "
3765 << ((returnValue == NULL) ? "invalid obj" : "valid obj")
3766 << std::endl;
3767
3768 incIndent();
3769 #endif
3770
3771 _repeatS = _defaultRepeatS;
3772 _repeatT = _defaultRepeatT;
3773
3774 return FieldContainerTransitPtr(returnValue);
3775 }
3776
3777 void VRMLTextureHelper::endNode(FieldContainer *pFC)
3778 {
3779 #if 0
3780 TextureObjChunk *pTexture = NULL;
3781
3782 ImageUnrecPtr pImage = NULL;
3783
3784 pTexture = dynamic_cast<TextureObjChunk *>(pFC);
3785
3786
3787 if(pTexture != NULL)
3788 {
3789 for(UInt32 i = 0; i < _url.size(); ++i)
3790 {
3791 #ifdef OSG_DEBUG_VRML
3792 PNOTICE << "VRMLImageTextureDesc::endNode : Reading texture "
3793 << _url[i].c_str() << std::endl;
3794 #endif
3795
3796 #ifdef OSG_VRML_IMAGETEXTURE_MAP
3797 UrlImageMap::iterator mIt = _urlImageMap.find(_url[i]);
3798
3799 if(mIt != _urlImageMap.end())
3800 {
3801 pImage = mIt->second;
3802 }
3803 else
3804 {
3805 pImage = ImageFileHandler::the()->read(_url[i].c_str());
3806
3807 if(pImage != NULL)
3808 {
3809 _urlImageMap[_url[i]] = pImage;
3810 }
3811 }
3812 #else
3813 pImage = ImageFileHandler::the()->read(_url[0].c_str());
3814 #endif
3815
3816 if(pImage != NULL)
3817 break;
3818 }
3819
3820 if(pImage != NULL)
3821 {
3822 pImage->setForceAlphaBinary(pImage->calcIsAlphaBinary());
3823
3824 pTexture->setImage(pImage);
3825
3826 if(_repeatS.getValue() == true)
3827 {
3828 pTexture->setWrapS(GL_REPEAT);
3829 }
3830 else
3831 {
3832 pTexture->setWrapS(GL_CLAMP_TO_EDGE);
3833 }
3834 if(_repeatT.getValue() == true)
3835 {
3836 pTexture->setWrapT(GL_REPEAT);
3837 }
3838 else
3839 {
3840 pTexture->setWrapT(GL_CLAMP_TO_EDGE);
3841 }
3842 }
3843 else
3844 {
3845 PWARNING << "VRMLImageTextureDesc::endNode : "
3846 << "Couldn't read texture "
3847 << _url[0].c_str()
3848 << " !!!"
3849 << std::endl;
3850 }
3851 }
3852 else
3853 {
3854 PWARNING << "VRMLImageTextureDesc::endNode : Invalid texture ptr"
3855 << std::endl;
3856 }
3857
3858 #ifdef OSG_DEBUG_VRML
3859 decIndent();
3860
3861 indentLog(getIndent(), PINFO);
3862 PINFO << "End ImageTexture "
3863 << _url[0].c_str() << " "
3864 << _repeatS.getValue() << " "
3865 << _repeatT.getValue() << " "
3866 << &(*pFC) << std::endl;
3867 #endif
3868 #endif
3869 }
3870
3871 /*-------------------------------------------------------------------------*/
3872 /* Dump */
3873
3874 void VRMLTextureHelper::dump(const Char8 *)
3875 {
3876 }
3877
3878
3879
3880
3881 //---------------------------------------------------------------------------
3882 // Class
3883 //---------------------------------------------------------------------------
3884
3885 VRMLNodeHelper *VRMLImageTextureHelper::create(void)
3886 {
3887 return new VRMLImageTextureHelper();
3888 }
3889
3890 /*-------------------------------------------------------------------------*/
3891 /* Constructors */
3892
3893 VRMLImageTextureHelper::VRMLImageTextureHelper(void) :
3894 Inherited (),
3895
3896 _defaultURL (),
3897 _url ()
3898
3899 #ifdef OSG_VRML_IMAGETEXTURE_MAP
3900 , _urlImageMap ()
3901 #endif
3902 {
3903 }
3904
3905 /*-------------------------------------------------------------------------*/
3906 /* Destructor */
3907
3908 VRMLImageTextureHelper::~VRMLImageTextureHelper(void)
3909 {
3910 }
3911
3912 /*-------------------------------------------------------------------------*/
3913 /* Helper */
3914
3915 /*-------------------------------------------------------------------------*/
3916 /* Field */
3917
3918 bool VRMLImageTextureHelper::prototypeAddField(const Char8 *szFieldType,
3919 const UInt32 uiFieldTypeId,
3920 const Char8 *szFieldname )
3921 {
3922 bool bFound = false;
3923
3924 if(osgStringCaseCmp("url", szFieldname) == 0)
3925 {
3926 bFound = true;
3927 }
3928 else
3929 {
3930 bFound = Inherited::prototypeAddField(szFieldType,
3931 uiFieldTypeId,
3932 szFieldname);
3933 }
3934
3935 if(bFound == true)
3936 {
3937 #ifdef OSG_DEBUG_VRML
3938 indentLog(getIndent(), PINFO);
3939 PINFO << "ImageTextureDesc::prototypeAddField : add part "
3940 << szFieldname
3941 << std::endl;
3942 #endif
3943
3944 return true;
3945 }
3946 else
3947 {
3948 return false;
3949 }
3950 }
3951
3952
3953 void VRMLImageTextureHelper::getFieldAndDesc(
3954 FieldContainer * pFC,
3955 const Char8 * szFieldname,
3956 FieldContainer *&pFieldFC,
3957 EditFieldHandlePtr &pField,
3958 const FieldDescriptionBase *&pDesc)
3959 {
3960 pFieldFC = NULL;
3961 pField.reset();
3962 pDesc = NULL;
3963
3964 if(osgStringCaseCmp("url", szFieldname) == 0)
3965 {
3966 if(_bProtoInterfaceDone == false)
3967 {
3968 pField = _mfStringDesc.createEditHandler(&_defaultURL,
3969 NULL );
3970 }
3971 else
3972 {
3973 pField = _mfStringDesc.createEditHandler(&_url,
3974 NULL);
3975 }
3976
3977 pDesc = &_mfStringDesc;
3978 }
3979 else
3980 {
3981 Inherited::getFieldAndDesc(pFC,
3982 szFieldname,
3983 pFieldFC,
3984 pField,
3985 pDesc);
3986 }
3987 }
3988
3989 /*-------------------------------------------------------------------------*/
3990 /* Node */
3991
3992 FieldContainerTransitPtr VRMLImageTextureHelper::beginNode(
3993 const Char8 *szTypename,
3994 const Char8 *szName,
3995 FieldContainer *pCurrentFC)
3996 {
3997 FieldContainerTransitPtr returnValue =
3998 Inherited::beginNode(szTypename, szName, pCurrentFC);
3999
4000 #ifdef OSG_DEBUG_VRML
4001 indentLog(getIndent(), PINFO);
4002 PINFO << "Begin ImageTexture "
4003 << ((returnValue == NULL) ? "invalid obj" : "valid obj")
4004 << std::endl;
4005
4006 incIndent();
4007 #endif
4008
4009 _url.clear();
4010
4011 return returnValue;
4012 }
4013
4014 void VRMLImageTextureHelper::endNode(FieldContainer *pFC)
4015 {
4016 TextureObjChunk *pTexture = NULL;
4017
4018 ImageUnrecPtr pImage = NULL;
4019
4020 pTexture = dynamic_cast<TextureObjChunk *>(pFC);
4021
4022
4023 if(pTexture != NULL && _url.size() != 0)
4024 {
4025
4026 for(UInt32 i = 0; i < _url.size(); ++i)
4027 {
4028 #ifdef OSG_DEBUG_VRML
4029 PNOTICE << "VRMLImageTextureDesc::endNode : Reading texture "
4030 << _url[i].c_str() << std::endl;
4031 #endif
4032
4033 #ifdef OSG_VRML_IMAGETEXTURE_MAP
4034 UrlImageMap::iterator mIt = _urlImageMap.find(_url[i]);
4035
4036 if(mIt != _urlImageMap.end())
4037 {
4038 pImage = mIt->second;
4039 }
4040 else
4041 {
4042 pImage = ImageFileHandler::the()->read(_url[i].c_str());
4043
4044 if(pImage != NULL)
4045 {
4046 _urlImageMap[_url[i]] = pImage;
4047 }
4048 }
4049 #else
4050 pImage = ImageFileHandler::the()->read(_url[0].c_str());
4051 #endif
4052
4053 if(pImage != NULL)
4054 break;
4055 }
4056
4057 if(pImage != NULL)
4058 {
4059 pImage->setForceAlphaBinary(pImage->calcIsAlphaBinary());
4060
4061 pTexture->setImage(pImage);
4062
4063 if(_repeatS.getValue() == true)
4064 {
4065 pTexture->setWrapS(GL_REPEAT);
4066 }
4067 else
4068 {
4069 pTexture->setWrapS(GL_CLAMP_TO_EDGE);
4070 }
4071 if(_repeatT.getValue() == true)
4072 {
4073 pTexture->setWrapT(GL_REPEAT);
4074 }
4075 else
4076 {
4077 pTexture->setWrapT(GL_CLAMP_TO_EDGE);
4078 }
4079 }
4080 else
4081 {
4082 PWARNING << "VRMLImageTextureDesc::endNode : "
4083 << "Couldn't read texture "
4084 << _url[0].c_str()
4085 << " !!!"
4086 << std::endl;
4087 }
4088 }
4089 else
4090 {
4091 PWARNING << "VRMLImageTextureDesc::endNode : Invalid texture ptr"
4092 << std::endl;
4093 }
4094
4095 #ifdef OSG_DEBUG_VRML
4096 decIndent();
4097
4098 indentLog(getIndent(), PINFO);
4099 PINFO << "End ImageTexture "
4100 << _url[0].c_str() << " "
4101 << _repeatS.getValue() << " "
4102 << _repeatT.getValue() << " "
4103 << &(*pFC) << std::endl;
4104 #endif
4105 }
4106
4107 /*-------------------------------------------------------------------------*/
4108 /* Dump */
4109
4110 void VRMLImageTextureHelper::dump(const Char8 *)
4111 {
4112 }
4113
4114
4115 VRMLNodeHelperFactoryBase::RegisterHelper VRMLImageTextureHelper::_regHelper(
4116 &VRMLImageTextureHelper::create,
4117 "ImageTexture",
4118 NULL);
4119
4120
4121
4122
4123 //---------------------------------------------------------------------------
4124 // Class
4125 //---------------------------------------------------------------------------
4126
4127 VRMLNodeHelper *VRMLPixelTextureHelper::create(void)
4128 {
4129 return new VRMLPixelTextureHelper();
4130 }
4131
4132 /*-------------------------------------------------------------------------*/
4133 /* Constructors */
4134
4135 VRMLPixelTextureHelper::VRMLPixelTextureHelper(void) :
4136 Inherited( ),
4137 _pImage (NULL)
4138 {
4139 }
4140
4141 /*-------------------------------------------------------------------------*/
4142 /* Destructor */
4143
4144 VRMLPixelTextureHelper::~VRMLPixelTextureHelper(void)
4145 {
4146 }
4147
4148 /*-------------------------------------------------------------------------*/
4149 /* Helper */
4150
4151 void VRMLPixelTextureHelper::addImageValue(
4152 EditFieldHandlePtr ,
4153 const FieldDescriptionBase *,
4154 Image *pImage )
4155 {
4156 _pImage = pImage;
4157 }
4158
4159 /*-------------------------------------------------------------------------*/
4160 /* Field */
4161
4162 bool VRMLPixelTextureHelper::prototypeAddField(const Char8 *szFieldType,
4163 const UInt32 uiFieldTypeId,
4164 const Char8 *szFieldname )
4165 {
4166 bool bFound = false;
4167
4168 if(osgStringCaseCmp("image", szFieldname) == 0)
4169 {
4170 bFound = true;
4171 }
4172 else
4173 {
4174 bFound = Inherited::prototypeAddField(szFieldType,
4175 uiFieldTypeId,
4176 szFieldname);
4177 }
4178
4179 if(bFound == true)
4180 {
4181 #ifdef OSG_DEBUG_VRML
4182 indentLog(getIndent(), PINFO);
4183 PINFO << "ImageTextureDesc::prototypeAddField : add part "
4184 << szFieldname
4185 << std::endl;
4186 #endif
4187
4188 return true;
4189 }
4190 else
4191 {
4192 return false;
4193 }
4194 }
4195
4196
4197 void VRMLPixelTextureHelper::getFieldAndDesc(
4198 FieldContainer * pFC,
4199 const Char8 * szFieldname,
4200 FieldContainer *&pFieldFC,
4201 EditFieldHandlePtr &pField,
4202 const FieldDescriptionBase *&pDesc)
4203 {
4204 pFieldFC = NULL;
4205 pField.reset();
4206 pDesc = NULL;
4207
4208 if(osgStringCaseCmp("image", szFieldname) == 0)
4209 {
4210 pFieldFC = _pImage;
4211 pField.reset();
4212 pDesc = &_sfImagePtrDesc;
4213 }
4214 else
4215 {
4216 Inherited::getFieldAndDesc(pFC,
4217 szFieldname,
4218 pFieldFC,
4219 pField,
4220 pDesc);
4221 }
4222 }
4223
4224 /*-------------------------------------------------------------------------*/
4225 /* Node */
4226
4227 FieldContainerTransitPtr VRMLPixelTextureHelper::beginNode(
4228 const Char8 *szTypename,
4229 const Char8 *szName,
4230 FieldContainer *pCurrentFC)
4231 {
4232 FieldContainerTransitPtr returnValue =
4233 Inherited::beginNode(szTypename, szName, pCurrentFC);
4234
4235 #ifdef OSG_DEBUG_VRML
4236 indentLog(getIndent(), PINFO);
4237 PINFO << "Begin PixelTexture "
4238 << ((returnValue == NULL) ? "invalid obj" : "valid obj")
4239 << std::endl;
4240
4241 incIndent();
4242 #endif
4243
4244 return returnValue;
4245 }
4246
4247 void VRMLPixelTextureHelper::endNode(FieldContainer *pFC)
4248 {
4249 TextureObjChunk *pTexture = NULL;
4250
4251 pTexture = dynamic_cast<TextureObjChunk *>(pFC);
4252
4253
4254 if(pTexture != NULL)
4255 {
4256 if(_pImage != NULL)
4257 {
4258 _pImage->setForceAlphaBinary(_pImage->calcIsAlphaBinary());
4259
4260 pTexture->setImage(_pImage);
4261
4262 if(_repeatS.getValue() == true)
4263 {
4264 pTexture->setWrapS(GL_REPEAT);
4265 }
4266 else
4267 {
4268 pTexture->setWrapS(GL_CLAMP_TO_EDGE);
4269 }
4270 if(_repeatT.getValue() == true)
4271 {
4272 pTexture->setWrapT(GL_REPEAT);
4273 }
4274 else
4275 {
4276 pTexture->setWrapT(GL_CLAMP_TO_EDGE);
4277 }
4278 }
4279 }
4280 else
4281 {
4282 PWARNING << "VRMLPixelTextureDesc::endNode : Invalid texture ptr"
4283 << std::endl;
4284 }
4285
4286 _pImage = NULL;
4287
4288 #ifdef OSG_DEBUG_VRML
4289 decIndent();
4290
4291 indentLog(getIndent(), PINFO);
4292 PINFO << "End PixelTexture "
4293 << _repeatS.getValue() << " "
4294 << _repeatT.getValue() << " "
4295 << &(*pFC) << std::endl;
4296 #endif
4297 }
4298
4299 /*-------------------------------------------------------------------------*/
4300 /* Dump */
4301
4302 void VRMLPixelTextureHelper::dump(const Char8 *)
4303 {
4304 }
4305
4306
4307 VRMLNodeHelperFactoryBase::RegisterHelper VRMLPixelTextureHelper::_regHelper(
4308 &VRMLPixelTextureHelper::create,
4309 "PixelTexture",
4310 NULL);
4311
4312
4313
4314
4315
4316 //---------------------------------------------------------------------------
4317 // Class
4318 //---------------------------------------------------------------------------
4319
4320 VRMLNodeHelper *VRMLInlineHelper::create(void)
4321 {
4322 return new VRMLInlineHelper();
4323 }
4324
4325 /*-------------------------------------------------------------------------*/
4326 /* Constructors */
4327
4328 VRMLInlineHelper::VRMLInlineHelper(void) :
4329 Inherited()
4330 {
4331 }
4332
4333 /*-------------------------------------------------------------------------*/
4334 /* Destructor */
4335
4336 VRMLInlineHelper::~VRMLInlineHelper(void)
4337 {
4338 }
4339
4340 /*-------------------------------------------------------------------------*/
4341 /* Helper */
4342
4343 void VRMLInlineHelper::init(const Char8 *szName)
4344 {
4345 Inherited::init(szName);
4346
4347 #ifdef OSG_DEBUG_VRML
4348 indentLog(getIndent(), PINFO);
4349 PINFO << "InlineHelper::init : " << szName << std::endl;
4350 #endif
4351
4352 _pNodeProto = Node ::create();
4353 _pNodeCoreProto = Inline::create();
4354
4355 _pGenAttProto = VRMLGenericAtt::createLocal(FCLocal::Cluster);
4356 _pGenAttProto->setInternal(true);
4357 }
4358
4359 /*-------------------------------------------------------------------------*/
4360 /* Field */
4361
4362 void VRMLInlineHelper::endNode(FieldContainer *pFC)
4363 {
4364 Node *pNode = dynamic_cast<Node *>(pFC);
4365
4366 if(pNode != NULL)
4367 {
4368 Inline *pInline = dynamic_cast<Inline *>(pNode->getCore());
4369
4370 if(pInline != NULL)
4371 {
4372 pInline->postOSGLoading(NULL);
4373 }
4374 }
4375 }
4376
4377 /*-------------------------------------------------------------------------*/
4378 /* Dump */
4379
4380 void VRMLInlineHelper::dump(const Char8 *)
4381 {
4382 }
4383
4384
4385 VRMLNodeHelperFactoryBase::RegisterHelper VRMLInlineHelper::_regHelper(
4386 &VRMLInlineHelper::create,
4387 "Inline",
4388 NULL);
4389
4390
4391
4392
4393 //---------------------------------------------------------------------------
4394 // Class
4395 //---------------------------------------------------------------------------
4396
4397 VRMLNodeHelper *VRMLSwitchHelper::create(void)
4398 {
4399 return new VRMLSwitchHelper();
4400 }
4401
4402
4403 /*-------------------------------------------------------------------------*/
4404 /* Constructors */
4405
4406 VRMLSwitchHelper::VRMLSwitchHelper(void) :
4407 Inherited()
4408 {
4409 }
4410
4411 /*-------------------------------------------------------------------------*/
4412 /* Destructor */
4413
4414 VRMLSwitchHelper::~VRMLSwitchHelper(void)
4415 {
4416 }
4417
4418 /*-------------------------------------------------------------------------*/
4419 /* Helper */
4420
4421 void VRMLSwitchHelper::init(const Char8 *szName)
4422 {
4423 Inherited::init(szName);
4424
4425 #ifdef OSG_DEBUG_VRML
4426 indentLog(getIndent(), PINFO);
4427 PINFO << "SwitchHelper::init : " << szName << std::endl;
4428 #endif
4429
4430 _pNodeProto = Node ::create();
4431 _pNodeCoreProto = Switch::create();
4432
4433 _pGenAttProto = VRMLGenericAtt::createLocal(FCLocal::Cluster);
4434 _pGenAttProto->setInternal(true);
4435 }
4436
4437 /*-------------------------------------------------------------------------*/
4438 /* Get */
4439
4440 bool VRMLSwitchHelper::prototypeAddField(const Char8 *szFieldType,
4441 const UInt32 uiFieldTypeId,
4442 const Char8 *szFieldname)
4443 {
4444 bool returnValue = false;
4445
4446 #ifdef OSG_DEBUG_VRML
4447 indentLog(getIndent(), PINFO);
4448 PINFO << "VRMLSwitchHelper::prototypeAddField | add request : "
4449 << szFieldname
4450 << std::endl;
4451 #endif
4452
4453 if(szFieldname == NULL)
4454 return false;
4455
4456 incIndent();
4457
4458 if(osgStringCaseCmp("choice", szFieldname) == 0)
4459 {
4460 returnValue = true;
4461
4462 #ifdef OSG_DEBUG_VRML
4463 indentLog(getIndent(), PINFO);
4464 PINFO << "VRMLSwitchHelper::prototypeAddField | request internal : "
4465 << szFieldname
4466 << " "
4467 << std::endl;
4468 #endif
4469 }
4470
4471 if(osgStringCaseCmp("whichChoice", szFieldname) == 0)
4472 {
4473 returnValue = true;
4474
4475 #ifdef OSG_DEBUG_VRML
4476 indentLog(getIndent(), PINFO);
4477
4478 PINFO << "VRMLSwitchHelper::prototypeAddField | request internal : "
4479 << szFieldname
4480 << " "
4481 << std::endl;
4482 #endif
4483 }
4484
4485 if(returnValue == false)
4486 {
4487 returnValue = Inherited::prototypeAddField(szFieldType,
4488 uiFieldTypeId,
4489 szFieldname);
4490 }
4491
4492 #ifdef OSG_DEBUG_VRML
4493 decIndent();
4494 #endif
4495
4496 return returnValue;
4497 }
4498
4499 void VRMLSwitchHelper::getFieldAndDesc(
4500 FieldContainer * pFC,
4501 const Char8 * szFieldname,
4502 FieldContainer *&pFieldFC,
4503 EditFieldHandlePtr &pField,
4504 const FieldDescriptionBase *&pDesc)
4505 {
4506 if(szFieldname == NULL)
4507 return;
4508
4509 if(pFC == NULL)
4510 {
4511 if(_bProtoInterfaceDone == false)
4512 {
4513 Inherited::getField(szFieldname, pFieldFC, pField, pDesc);
4514 }
4515
4516 return;
4517 }
4518
4519 #ifdef OSG_DEBUG_VRML
4520 indentLog(getIndent(), PINFO);
4521 PINFO << "VRMLSwitchHelper::getFieldAndDesc : looking for "
4522 << szFieldname
4523 << std::endl;
4524
4525 incIndent();
4526 #endif
4527
4528 if(osgStringCaseCmp("choice", szFieldname) == 0)
4529 {
4530 #ifdef OSG_DEBUG_VRML
4531 indentLog(getIndent(), PINFO);
4532 PINFO << "VRMLSwitchHelper::getFieldAndDesc : request internal "
4533 << szFieldname
4534 << std::endl;
4535 #endif
4536 pFieldFC = pFC;
4537 pField = pFC->editField("children");
4538 pDesc = pFC->getFieldDescription("children");
4539 }
4540 else if(osgStringCaseCmp("whichChoice", szFieldname) == 0)
4541 {
4542 #ifdef OSG_DEBUG_VRML
4543 indentLog(getIndent(), PINFO);
4544 PINFO << "VRMLSwitchHelper::getFieldAndDesc : request internal "
4545 << szFieldname
4546 << std::endl;
4547 #endif
4548
4549 Node *pNode = dynamic_cast<Node *>(pFC);
4550
4551 if(pNode != NULL)
4552 {
4553 if(pNode->getCore() != NULL)
4554 {
4555 pFieldFC = pNode->getCore();
4556 pField = pNode->getCore()->editField("choice");
4557 pDesc = pNode->getCore()->getFieldDescription("choice");
4558 }
4559 }
4560 else
4561 {
4562 Inherited::getFieldAndDesc(pFC,
4563 szFieldname,
4564 pFC,
4565 pField,
4566 pDesc);
4567 }
4568 }
4569 else
4570 {
4571 Inherited::getFieldAndDesc(pFC,
4572 szFieldname,
4573 pFC,
4574 pField,
4575 pDesc);
4576 }
4577
4578 #ifdef OSG_DEBUG_VRML
4579 decIndent();
4580 #endif
4581 }
4582
4583 /*-------------------------------------------------------------------------*/
4584 /* Node */
4585
4586
4587 /*-------------------------------------------------------------------------*/
4588 /* Dump */
4589
4590 void VRMLSwitchHelper::dump(const Char8 *)
4591 {
4592 }
4593
4594 VRMLNodeHelperFactoryBase::RegisterHelper VRMLSwitchHelper::_regHelper(
4595 &VRMLSwitchHelper::create,
4596 "Switch",
4597 NULL);
4598
4599
4600 //---------------------------------------------------------------------------
4601 // Generic Helper with 1:1 mapping
4602 //---------------------------------------------------------------------------
4603
4604 OSG_INST_GENERICVRMLHELPER(TimeSensor);
4605
4606 template<>
4607 bool VRMLGenericHelper<TimeSensor>::initStatic(void)
4608 {
4609 return true;
4610 }
4611
4612 template<>
4613 VRMLNodeHelperFactoryBase::RegisterHelper
4614 VRMLGenericHelper<TimeSensor>::_regHelper(
4615 &VRMLGenericHelper<TimeSensor>::create,
4616 "TimeSensor",
4617 &VRMLGenericHelper<TimeSensor>::initStatic);
4618
4619 OSG_INST_GENERICVRMLHELPER(VRMLOrientationInterpolator);
4620
4621 template<>
4622 bool VRMLGenericHelper<VRMLOrientationInterpolator>::initStatic(void)
4623 {
4624 _mFieldNameMap[std::string("fraction")] = std::string("inValue" );
4625 _mFieldNameMap[std::string("value" )] = std::string("outValue");
4626
4627 return true;
4628 }
4629
4630 template<>
4631 VRMLNodeHelperFactoryBase::RegisterHelper
4632 VRMLGenericHelper<VRMLOrientationInterpolator>::_regHelper(
4633 &VRMLGenericHelper<VRMLOrientationInterpolator>::create,
4634 "OrientationInterpolator",
4635 &VRMLGenericHelper<VRMLOrientationInterpolator>::initStatic);
4636
4637
4638 OSG_INST_GENERICVRMLHELPER(VRMLPositionInterpolator);
4639
4640 template<>
4641 bool VRMLGenericHelper<VRMLPositionInterpolator>::initStatic(void)
4642 {
4643 _mFieldNameMap[std::string("fraction")] = std::string("inValue" );
4644 _mFieldNameMap[std::string("value" )] = std::string("outValue");
4645
4646 return true;
4647 }
4648
4649 template<>
4650 VRMLNodeHelperFactoryBase::RegisterHelper
4651 VRMLGenericHelper<VRMLPositionInterpolator>::_regHelper(
4652 &VRMLGenericHelper<VRMLPositionInterpolator>::create,
4653 "PositionInterpolator",
4654 &VRMLGenericHelper<VRMLPositionInterpolator>::initStatic);
4655
4656 OSG_INST_GENERICVRMLHELPER(VRMLCoordinateInterpolator);
4657
4658 template<>
4659 bool VRMLGenericHelper<VRMLCoordinateInterpolator>::initStatic(void)
4660 {
4661 _mFieldNameMap[std::string("fraction")] = std::string("inValue" );
4662 _mFieldNameMap[std::string("value" )] = std::string("outValue");
4663
4664 return true;
4665 }
4666
4667 template<>
4668 VRMLNodeHelperFactoryBase::RegisterHelper
4669 VRMLGenericHelper<VRMLCoordinateInterpolator>::_regHelper(
4670 &VRMLGenericHelper<VRMLCoordinateInterpolator>::create,
4671 "CoordinateInterpolator",
4672 &VRMLGenericHelper<VRMLCoordinateInterpolator>::initStatic);
4673
4674 OSG_INST_GENERICVRMLHELPER(VRMLNormalInterpolator);
4675
4676 template<>
4677 bool VRMLGenericHelper<VRMLNormalInterpolator>::initStatic(void)
4678 {
4679 _mFieldNameMap[std::string("fraction")] = std::string("inValue" );
4680 _mFieldNameMap[std::string("value" )] = std::string("outValue");
4681
4682 return true;
4683 }
4684
4685 template<>
4686 VRMLNodeHelperFactoryBase::RegisterHelper
4687 VRMLGenericHelper<VRMLNormalInterpolator>::_regHelper(
4688 &VRMLGenericHelper<VRMLNormalInterpolator>::create,
4689 "NormalInterpolator",
4690 &VRMLGenericHelper<VRMLNormalInterpolator>::initStatic);
4691
4692 OSG_INST_GENERICVRMLHELPER(VRMLScalarInterpolator);
4693
4694 template<>
4695 bool VRMLGenericHelper<VRMLScalarInterpolator>::initStatic(void)
4696 {
4697 _mFieldNameMap[std::string("fraction")] = std::string("inValue" );
4698 _mFieldNameMap[std::string("value" )] = std::string("outValue");
4699
4700 return true;
4701 }
4702
4703 template<>
4704 VRMLNodeHelperFactoryBase::RegisterHelper
4705 VRMLGenericHelper<VRMLScalarInterpolator>::_regHelper(
4706 &VRMLGenericHelper<VRMLScalarInterpolator>::create,
4707 "ScalarInterpolator",
4708 &VRMLGenericHelper<VRMLScalarInterpolator>::initStatic);
4709
4710 OSG_END_NAMESPACE