FieldContainer *ComplexSceneManager::resolveStatic(const Char8 *szName)
{
    std::vector<FieldContainerUnrecPtr>::const_iterator gIt  = 
        _vStaticGlobals.begin();

    std::vector<FieldContainerUnrecPtr>::const_iterator gEnd = 
        _vStaticGlobals.end  ();

          AttachmentContainer *pAttCnt     = NULL;
          Node                *pNode       = NULL;
    const Char8               *szTmpName   = NULL;

    while(gIt != gEnd)
    {
        pNode = dynamic_cast<Node *>((*gIt).get());

        if(pNode != NULL)
        {
            ElementFinder oFinder;

            oFinder._szRefName = szName;

            traverse(pNode, boost::bind(&ElementFinder::enter, &oFinder, _1));

            if(oFinder._pResult != NULL)
            {
                return oFinder._pResult;
            }
         }
        
        pAttCnt = dynamic_cast<AttachmentContainer *>((*gIt).get());

        if(pAttCnt != NULL)
        {
            szTmpName = OSG::getName(pAttCnt);
           
            if(szTmpName != NULL && osgStringCmp(szTmpName, szName) == 0)
            {
                return pAttCnt;
            }
            else
            {
#if 0                                                                    
                FieldContainer *tmpVal = pAttCnt->findNamedComponent(szName);
                
                if(tmpVal != NULL)
                    return tmpVal;
#endif
            }
        }

        ++gIt;
    }

    return NULL;
}
void DrawableStatsAttachment::attachTo(AttachmentContainer *obj)
{
    if(getMFParents()->size())
    {
        FNOTICE(("GeoStatsAttachment::attachTo: "
                 "already attached, detaching!\n"));

        while(getMFParents()->size())
        {
            AttachmentContainer *p =
                dynamic_cast<AttachmentContainer *>(this->getParents(0));

            p->subChangedFunctor(&DrawableStatsAttachment::invalidateFunctor);
            p->subAttachment    (this                                       );
        }
    }

    obj->addAttachment(this);

    reset();

    obj->addChangedFunctor(&DrawableStatsAttachment::invalidateFunctor,
                           "DrawableStats invalidator");
}
/*! Fills the "pointer field" described by \a ptrField with the correct
    pointers.

    \param[in] ptrField Field to fill.
 */
void
OSBRootElement::mapPtrField(const PtrFieldInfo &ptrField)
{
    OSG_OSB_LOG(("OSBRootElement::mapPtrField\n"));

    PtrFieldInfo::PtrIdStoreConstIt   idIt       = ptrField.beginIdStore();
    PtrFieldInfo::PtrIdStoreConstIt   idEnd      = ptrField.endIdStore  ();

    PtrFieldInfo::BindingStoreConstIt bindingIt  = ptrField.beginBindingStore();
    PtrFieldInfo::BindingStoreConstIt bindingEnd = ptrField.endBindingStore  ();

    const FieldContainerIdMap        &idMap      = getIdMap();
          FieldContainerIdMapConstIt  idMapIt;
          FieldContainerIdMapConstIt  idMapEnd   = idMap.end();
        
    if(bindingIt != bindingEnd)
    {
        if(ptrField.getHandledField() == true)
        {
            FieldContainer    *fieldCon = ptrField.getContainer();
            UInt32             fieldId  = ptrField.getFieldId();
        
            EditFieldHandlePtr fHandle  = fieldCon->editField(fieldId);

            EditMapFieldHandlePtr sfMapField =
                boost::dynamic_pointer_cast<EditMapFieldHandle>(fHandle);

            if(sfMapField == NULL || sfMapField->isValid() == false)
                return;

            sfMapField->fillFrom(ptrField.getBindingStore(),
                                 ptrField.getIdStore     (),
                                 idMap);
        }
        else
        {
            Attachment          *att    = NULL;
            AttachmentContainer *attCon =
                dynamic_cast<AttachmentContainer *>(ptrField.getContainer());
            
            for(; (idIt != idEnd) && (bindingIt != bindingEnd); ++idIt, 
                                                                ++bindingIt)
            {
                if(*idIt != 0)
                {
                    idMapIt = idMap.find(*idIt);
                    
                    if(idMapIt != idMapEnd)
                    {
                        att = dynamic_cast<Attachment *>(
                            FieldContainerFactory::the()->getContainer(
                                idMapIt->second));
                    }
                    else
                    {
                        FWARNING(("OSBRootElement::mapPtrField: could not find "
                                  "FieldContainer with id [%u]\n", *idIt));
                        att = NULL;
                    }
                }
                else
                {
                    att = NULL;
                }
                
                if(att != NULL)
                {
                    OSG_OSB_LOG(("OSBRootElement::mapPtrField: adding "
                            "attchment [%u] [%u]\n",
                            att->getType().getGroupId(), *bindingIt));
                }

                attCon->addAttachment(att, *bindingIt);
            }
        }
    }
    else
    {
        FieldContainer    *fc       = NULL;
        FieldContainer    *fieldCon = ptrField.getContainer();
        UInt32             fieldId  = ptrField.getFieldId();
        
        EditFieldHandlePtr fHandle  = fieldCon->editField(fieldId);
        
        FieldContainerPtrSFieldBase::EditHandlePtr pSFHandle = 
            boost::dynamic_pointer_cast<
                FieldContainerPtrSFieldBase::EditHandle>(fHandle);
            
        FieldContainerPtrMFieldBase::EditHandlePtr pMFHandle = 
            boost::dynamic_pointer_cast<
                FieldContainerPtrMFieldBase::EditHandle>(fHandle);
        
        for(; idIt != idEnd; ++idIt)
        {
            if(*idIt != 0)
            {
                idMapIt = idMap.find(*idIt);
                
                if(idMapIt != idMapEnd)
                {
                    fc = FieldContainerFactory::the()->getContainer(
                        idMapIt->second);
                }
                else
                {
                    FWARNING(("OSBRootElement::mapPtrField: could not find "
                              "FieldContainer with (file) id [%u]\n", *idIt));
                    fc = NULL;
                }
            }
            else
            {
                fc = NULL;
            }

            if(pSFHandle != NULL && pSFHandle->isValid())
            {
                pSFHandle->set(fc);
            }
            else if(pMFHandle != NULL && pMFHandle->isValid())
            {
                pMFHandle->add(fc);
            }
            else
            {
                FWARNING(("OSBRootElement::mapPtrField: FieldHandles invalid, "
                          "can not set pointer - target fc [%u][%s] "
                          "fieldId [%u][%s] file id [%u] system id [%u]\n",
                          (fc != NULL ? fc->getId() : 0),
                          (fc != NULL ? fc->getType().getCName() : ""),
                          fieldId,
                          (fc != NULL ?
                          fc->getType().getFieldDesc(fieldId)->getCName() : ""),
                          *idIt,
                          (idMapIt != idMapEnd ? idMapIt->second : 0) ));
            }
        }
    }
}
예제 #4
0
void VRMLFile::addRoute(const Char8  *szOutNodename,
                        const Char8  *szOutFieldname,
                        const Char8  *szInNodename,
                        const Char8  *szInFieldname )
{
    if(szOutNodename == NULL || szOutFieldname == NULL ||
       szInNodename  == NULL || szInFieldname  == NULL  )
    {
        FWARNING(("addRoute missing params\n"));
    }

    FieldContainer *pSrcNode = findReference(szOutNodename);
    FieldContainer *pDstNode = findReference(szInNodename);

    AttachmentContainer *pSrc = dynamic_cast<AttachmentContainer *>(pSrcNode);
    AttachmentContainer *pDst = dynamic_cast<AttachmentContainer *>(pDstNode);

    if(pSrc == NULL)
    {
        FWARNING(("Unknow src node %s\n", szOutNodename));
        return;
    }

    if(pDstNode == NULL)
    {
        FWARNING(("Unknow dst node %s\n", szInNodename));
        return;
    }

    VRMLGenericAtt *pSrcAtt = dynamic_cast<VRMLGenericAtt *>(
        pSrc->findAttachment(VRMLGenericAtt::getClassType()));

    VRMLGenericAtt *pDstAtt = NULL;

    if(pDst != NULL)
    {
        pDstAtt = dynamic_cast<VRMLGenericAtt *>(
            pDst->findAttachment(VRMLGenericAtt::getClassType()));
    }

    if(pSrcAtt == NULL)
    {
        Node *pNode = dynamic_cast<Node *>(pSrc);

        if(pNode != NULL && pNode->getCore() != NULL)
        {
            pSrcAtt = dynamic_cast<VRMLGenericAtt *>(
                pNode->getCore()->findAttachment(
                    VRMLGenericAtt::getClassType())); 
        }
    }

    if(pDstAtt == NULL)
    {
        Node *pNode = dynamic_cast<Node *>(pDst);

        if(pNode != NULL && pNode->getCore() != NULL)
        {
            pDstAtt = dynamic_cast<VRMLGenericAtt *>(
                pNode->getCore()->findAttachment(
                    VRMLGenericAtt::getClassType())); 
        }
    }

   
    std::string szOutFName = szOutFieldname;
    std::string szInFName  = szInFieldname;

    
    std::string::size_type uiPos = szOutFName.rfind(std::string("_changed"));


    if(uiPos != std::string::npos)
    {
        szOutFName.erase(uiPos, std::string::npos);
    }
    
    uiPos = szInFName.find(std::string("set_"));

    if(uiPos != std::string::npos)
    {
        szInFName.erase(uiPos, uiPos + 4);
    }


    if(pSrcAtt != NULL)
    {
        VRMLNodeHelper *pHelper = findNodeHelper(
            pSrcAtt->getVrmlNodeTypename().c_str());

        if(pHelper != NULL)
        {
            pHelper->mapFieldname(pSrcAtt->getVrmlNodeTypename(), szOutFName);
        }
    }

    if(pSrcAtt != NULL)
    {
        VRMLNodeHelper *pHelper = findNodeHelper(
            pDstAtt->getVrmlNodeTypename().c_str());

        if(pHelper != NULL)
        {
            pHelper->mapFieldname(pDstAtt->getVrmlNodeTypename(), szInFName);
        }
    }

    addConnection(pSrc,     szOutFName.c_str(),
                  pDstNode, szInFName .c_str());
}
FieldContainer *ComplexSceneManager::findNamedComponent(
    const Char8 *szName) const
{
    MFUnrecFieldContainerPtr::const_iterator gIt  = _mfGlobals.begin();
    MFUnrecFieldContainerPtr::const_iterator gEnd = _mfGlobals.end  ();

          AttachmentContainer *pAttCnt     = NULL;
          Node                *pNode       = NULL;
    const Char8               *szTmpName   = NULL;

    if(_sfDrawManager.getValue() != NULL)
    {
        szTmpName = OSG::getName(_sfDrawManager.getValue());

        if(szTmpName != NULL && osgStringCmp(szTmpName, szName) == 0)
        {
            return _sfDrawManager.getValue();
        }

         FieldContainer *tmpVal = 
             _sfDrawManager.getValue()->findNamedComponent(szName);

         if(tmpVal != NULL)
             return tmpVal;
    }

    while(gIt != gEnd)
    {
        pNode = dynamic_cast<Node *>(*gIt);

        if(pNode != NULL)
        {
            ElementFinder oFinder;

            oFinder._szRefName = szName;

            traverse(pNode, boost::bind(&ElementFinder::enter, &oFinder, _1));

            if(oFinder._pResult != NULL)
            {
                return oFinder._pResult;
            }
         }
        
        pAttCnt = dynamic_cast<AttachmentContainer *>(*gIt);

        if(pAttCnt != NULL)
        {
            szTmpName = OSG::getName(pAttCnt);
           
            if(szTmpName != NULL && osgStringCmp(szTmpName, szName) == 0)
            {
                return pAttCnt;
            }
            else
            {
                FieldContainer *tmpVal = pAttCnt->findNamedComponent(szName);
                
                if(tmpVal != NULL)
                    return tmpVal;
            }
        }

        ++gIt;
    }

    return NULL;
}
예제 #6
0
void OSGLoader::beginFieldDecl(const Char8  *szFieldType,
                               const UInt32  uiFieldTypeId,
                               const Char8  *szFieldName  )
{
    UInt32 uiOSGFieldTypeId = mapIntExtFieldType(szFieldName, uiFieldTypeId);
    
    DynFieldContainerInterface *pIf = 
        dynamic_cast<DynFieldContainerInterface *>(_pCurrentFC.get());

    if(pIf != NULL)
    {
        GetFieldHandlePtr pField = _pCurrentFC->getField(szFieldName);

        if(pField == NULL || pField->isValid() == false)
        {
            if(uiFieldTypeId == 0)
            {
                pIf->addField(szFieldType, szFieldName);
            }
            else
            {
                pIf->addField(uiOSGFieldTypeId, szFieldName);
            }
        }

        _pCurrentField     = _pCurrentFC->editField(szFieldName);
        _pCurrentFieldDesc =
            _pCurrentFC->getType().getFieldDesc(szFieldName);
    }
    else
    {
        AttachmentContainer *pAttCnt = 
            dynamic_cast<AttachmentContainer *>(_pCurrentFC.get());

        if(pAttCnt != NULL)
        {
            OSGGenericAttUnrecPtr pGenAtt = 
                dynamic_cast<OSGGenericAtt *>(
                    pAttCnt->findAttachment(OSGGenericAtt::getClassGroupId()));

            if(pGenAtt == NULL)
            {
                pGenAtt = OSGGenericAtt::create();
                
                pAttCnt->addAttachment(pGenAtt);
            }
            
            GetFieldHandlePtr pField = pGenAtt->getField(szFieldName);

            if(pField == NULL || pField->isValid() == false)
            {
                if(uiFieldTypeId == 0)
                {
//                    pGenAtt->addField(szFieldType, szFieldName);
                }
                else
                {
                    pGenAtt->addField(uiOSGFieldTypeId, szFieldName);
                }
            }
            
            _pCurrentField     = pGenAtt->editField(szFieldName);
            _pCurrentFieldDesc =
                pGenAtt->getType().getFieldDesc(szFieldName);

        }
    }

    _fStack.push (_pCurrentField);
    _fdStack.push(_pCurrentFieldDesc);
}