utils/Extd.h cstddef algorithm functional iterator set vector AnimatedMapFilter.cpp BlendShapeFilter.cpp DenormalizedData.h FilteredInputArchive.cpp JointFilter.cpp LODConstraint.cpp LODMapping.cpp MeshFilter.cpp Remap.h WriterImpl.h Extd.h algorithm cstddef functional iterator set vector DenormalizedData.h LODConstraint.cpp LODMapping.cpp WriterImpl.h AnimatedMapFilter.cpp BlendShapeFilter.cpp JointFilter.cpp MeshFilter.cpp Remap.h FilteredInputArchive.cpp Extd.h extd::impl::LUTFilter extd extd::impl EXTD_GUARD //CopyrightEpicGames,Inc.AllRightsReserved. #pragmaonce //*INDENT-OFF* #ifndefEXTD_GUARD #defineEXTD_GUARD #ifdef_MSC_VER #pragmawarning(push) #pragmawarning(disable:43654987) #endif #include<cstddef> #include<algorithm> #include<functional> #include<iterator> #include<set> #include<vector> #ifdef_MSC_VER #pragmawarning(pop) #endif namespaceextd{ template<typenameT> inlineTclamp(Tvalue,Tlow,Thigh){ returnstd::min(std::max(value,low),high); } template<typenameT> inlineTroundUp(Tnumber,Tmultiple){ return((number+multiple-1)/multiple)*multiple; } template<typenameT> inlineTinterpolate(Ta,Tb,Tweight){ returna*(static_cast<T>(1)-weight)+b*weight; } template<classTInputIterator,classT> inlineboolcontains(TInputIteratorfirst,TInputIteratorlast,constT&value){ returnstd::find(first,last,value)!=last; } template<classTContainer,classT> inlineboolcontains(constTContainer&container,constT&value){ returncontains(std::begin(container),std::end(container),value); } template<classT> inlineboolcontains(conststd::set<T>&container,constT&value){ returncontainer.find(value)!=container.end(); } template<classT,classPredicate,typename...Args> inlinevoidfilter(std::vector<T,Args...>&source,Predicatepred){ source.erase(std::remove_if(std::begin(source),std::end(source),[&source,&pred](constT&value){ constautoindex=static_cast<std::size_t>(&value-&(source.front())); return!pred(value,index); }),source.end()); } template<classTContainer,classPredicate,typename...Args> inlinevoidfilter(TContainer&source,Predicatepred){ usingvalue_type=typenameTContainer::value_type; autonewEnd=std::remove_if(std::begin(source),std::end(source),[&source,&pred](constvalue_type&value){ constautoindex=static_cast<std::size_t>(&value-source.data()); return!pred(value,index); }); constautonewSize=static_cast<std::size_t>(std::distance(source.begin(),newEnd)); source.resize(newSize); } namespaceimpl{ enumclassLUTStrategy{ ByValue, ByPosition }; template<typenameTLUT,LUTStrategyStrategy> classLUTFilter{ public: explicitLUTFilter(constTLUT&lut_):lut{lut_}{} template<typenameT,LUTStrategyChosenStrategy=Strategy> typenamestd::enable_if<ChosenStrategy==LUTStrategy::ByValue,bool>::typeoperator()(constT&value,std::size_t/*unused*/){ returncontains(lut,value); } template<typenameT,LUTStrategyChosenStrategy=Strategy> typenamestd::enable_if<ChosenStrategy==LUTStrategy::ByPosition,bool>::typeoperator()(constT&/*unused*/,std::size_tindex){ returncontains(lut,index); } private: constTLUT&lut; }; }//namespaceimpl template<typenameTLookUpTable> inlineimpl::LUTFilter<TLookUpTable, impl::LUTStrategy::ByValue>byValue(constTLookUpTable&lookUpTable){ returnimpl::LUTFilter<TLookUpTable, impl::LUTStrategy::ByValue>{lookUpTable}; } template<typenameTLookUpTable> inlineimpl::LUTFilter<TLookUpTable, impl::LUTStrategy::ByPosition>byPosition(constTLookUpTable&lookUpTable){ returnimpl::LUTFilter<TLookUpTable, impl::LUTStrategy::ByPosition>{lookUpTable}; } template<classTContainer> inlinetypenameTContainer::value_typemaxOf(constTContainer&container){ assert(!container.empty()); usingValueType=typenameTContainer::value_type; constautocompare=[](constValueType&lhs,constValueType&rhs){ returnlhs.second<rhs.second; }; constautoit=std::max_element(container.begin(),container.end(),compare); return(it==container.end()?ValueType{}:*it); } template<classTSource,classTDestination> inlinevoidcopy(constTSource&source,TDestination&destination){ std::copy(std::begin(source),std::end(source),std::back_inserter(destination)); } template<classTIterator,typenameTDistance> TIteratoradvanced(TIteratorsource,TDistancedistance){ std::advance(source,static_cast<typenamestd::iterator_traits<TIterator>::difference_type>(distance)); returnsource; } template<classTIterator,classPredicate> typenamestd::iterator_traits<TIterator>::difference_typeadvanceWhile(TIterator&it,constTIterator&end,Predicatepred){ constautostart=it; while(it!=end&&pred(*it)){ ++it; } returnstd::distance(start,it); } }//namespaceextd #endif//EXTD_GUARD //*INDENT-ON*