FieldContainerTransitPtr LuaActivity::createLuaActivity( const BoostPath& FilePath )
{
    LuaActivity* Result = LuaActivity::createEmpty();
    FilePathAttachment::setFilePath(Result, FilePath);

    std::ifstream TheFile;
    TheFile.exceptions(std::fstream::failbit | std::fstream::badbit);

    try
    {
        TheFile.open(FilePath.string().c_str());
        if(TheFile)
        {
            std::ostringstream Code;
            Code << TheFile.rdbuf();
            TheFile.close();

                Result->setCode(Code.str());
        }
        return FieldContainerTransitPtr(Result);
    }
    catch(std::fstream::failure &f)
    {
        SWARNING << "LuaActivity::createLuaActivity(): Error reading file" << FilePath.string() << ": " << f.what() << std::endl;
        return FieldContainerTransitPtr(NULL);
    }

}
/*        correct type.                                                */
FieldContainerTransitPtr PyFieldAccessHandler::changePtrSField(const std::string& fieldName)
{
    EditFieldHandlePtr handle = _pPythonScript->editDynamicFieldByName(fieldName.c_str());

    FieldContainerPtrSFieldBase::EditHandlePtr sfFCPtr =
        boost::dynamic_pointer_cast<
            FieldContainerPtrSFieldBase::EditHandle>(handle);
    assert(sfFCPtr);

    FieldContainerPtrSFieldBase* field =
            static_cast<FieldContainerPtrSFieldBase *>(sfFCPtr->getField());
    return FieldContainerTransitPtr(field->getValue());
}
FieldContainerTransitPtr deepClone(
          OSG::FieldContainer const                        *src,
    const std::vector<const OSG::ReflexiveContainerType *> &shareTypes,
    const std::vector<const OSG::ReflexiveContainerType *> &ignoreTypes,
    const std::vector<OSG::UInt16>                         &shareGroupIds,
    const std::vector<OSG::UInt16>                         &ignoreGroupIds)
{
    if(src == NULL)
        return FieldContainerTransitPtr(NULL);

    const FieldContainerType &fcType  = src->getType();
    FieldContainerTransitPtr  fcClone = fcType.createContainer();

    UInt32 fCount = osgMin(fcType            .getNumFieldDescs(),
                           fcClone->getType().getNumFieldDescs() );

    for(UInt32 i = 1; i <= fCount; ++i)
    {
        const FieldDescriptionBase *fDesc = fcType.getFieldDesc(i);

        if(fDesc->isInternal())
            continue;

        GetFieldHandlePtr  srcField = src    ->getField (i);
        EditFieldHandlePtr dstField = fcClone->editField(i);

        if(dstField == NULL || dstField->isValid() == false || 
           srcField == NULL || srcField->isValid() == false)
        {
            continue;
        }

        if(srcField->isPointerField() == false)
        {
            dstField->copyValues(srcField);
        }
        else
        {
            dstField->cloneValues(srcField, 
                                  shareTypes,    
                                  ignoreTypes,
                                  shareGroupIds, 
                                  ignoreGroupIds);
        }
    }

    return fcClone;
}
FieldContainerTransitPtr OSGSceneFileType::readContainer(
    const Char8    *fileName,
          Resolver  resolver) const
{
    if(fileName == NULL)
    {
        SWARNING << "cannot read NULL file" << std::endl;
        return FieldContainerTransitPtr(NULL);
    }

    OSGLoader *_pFile = new OSGLoader(_endNodeFunctors);

    std::ifstream is(fileName, std::ios::binary);

    FieldContainerTransitPtr returnValue = 
        _pFile->scanStreamContainer(is, resolver);

    delete _pFile;

    commitChanges();

    return returnValue;
}
Esempio n. 5
0
FieldContainerTransitPtr UIFont::createFont( const BoostPath& FilePath )
{
    UIFont* Result = UIFont::createEmpty();
    FilePathAttachment::setFilePath(Result, FilePath);
    return FieldContainerTransitPtr(Result);
}