Vec.h tdm/Types.h Computations.h Mat.h TDM.h tdm/Types.h Vec.h algorithm cassert cmath cstddef type_traits CommandImplBase.h TypeDefs.h CalculateMeshLowerLODsCommand.cpp ClearBlendShapesCommand.cpp CommandSequence.cpp PruneBlendShapeTargetsCommand.cpp RemoveJointAnimationCommand.cpp RemoveJointCommand.cpp RemoveMeshCommand.cpp RenameAnimatedMapCommand.cpp RenameBlendShapeCommand.cpp RenameJointCommand.cpp RenameMeshCommand.cpp RenameResourceCommand.h RotateCommand.cpp ScaleCommand.cpp SetBlendShapeTargetDeltasCommand.cpp SetLODsCommand.cpp SetNeutralJointRotationsCommand.cpp SetNeutralJointTranslationsCommand.cpp SetSkinWeightsCommand.cpp SetVertexPositionsCommand.cpp SupportFactories.h TranslateCommand.cpp BaseImpl.h DNA.h DNACalibDNAReaderImpl.cpp DNACalibDNAReaderImpl.h DenormalizedData.h LODConstraint.cpp LODConstraint.h LODMapping.cpp LODMapping.h ReaderImpl.h SurjectiveMapping.h WriterImpl.h AnimatedMapFilter.cpp AnimatedMapFilter.h BlendShapeFilter.cpp BlendShapeFilter.h JointFilter.cpp JointFilter.h MeshFilter.cpp MeshFilter.h Remap.h BoundingBox.h Triangle.cpp Triangle.h UVBarycentricMapping.cpp UVBarycentricMapping.h Algorithm.h Computations.h Mat.h TDM.h Transforms.h Vec.h tdm::vec tdm //CopyrightEpicGames,Inc.AllRightsReserved. #pragmaonce #include"tdm/Types.h" namespacetdm{ template<dim_tL,typenameT> structvec{ usingvalue_type=T; staticconstexprdim_tdimensions(){ returnL; } value_typevalues[L]; vec():values{}{ } ~vec()=default; vec(constvec&rhs)=default; vec&operator=(constvec&rhs)=default; vec(vec&&rhs)=default; vec&operator=(vec&&rhs)=default; template<typenameU> vec(constvec<L, U>&rhs){ std::copy(std::begin(rhs.values),std::end(rhs.values),std::begin(values)); } template<typenameU> vec&operator=(constvec<L, U>&rhs){ std::copy(std::begin(rhs.values),std::end(rhs.values),std::begin(values)); return*this; } template<typename...Vs,typenamestd::enable_if<(sizeof...(Vs)==L)||(sizeof...(Vs)==0)>::type*=nullptr> vec(Vs...vs):values{vs...}{ } template<typenameU,typename...,typenamestd::enable_if<std::is_convertible<U,T>::value&&(L>1)>::type*=nullptr> explicitvec(Uv){ std::fill_n(values,dimensions(),v); } template<typenameU,typename...,typenamestd::enable_if<std::is_convertible<U,T>::value>::type*=nullptr> explicitvec(U*pv){ std::copy_n(pv,dimensions(),std::begin(values)); } T&operator[](dim_tindex){ assert(index<dimensions()); returnvalues[index]; } constT&operator[](dim_tindex)const{ assert(index<dimensions()); returnvalues[index]; } structVectorized; template<typenameF> vec&apply(Ffunc){ for(dim_ti{};i<dimensions();++i){ func(values[i],i); } return*this; } template<typenameF> constvec&apply(Ffunc)const{ for(dim_ti{};i<dimensions();++i){ func(values[i],i); } return*this; } vec&operator++(){ returnapply([](T&v,dim_t/*unused*/){ ++v; }); } vec&operator--(){ returnapply([](T&v,dim_t/*unused*/){ --v; }); } template<typenameU> vec&operator+=(Urhs){ returnapply([rhs](T&v,dim_t/*unused*/){ v+=rhs; }); } template<typenameU> vec&operator+=(constvec<L, U>&rhs){ returnapply([&rhs](T&v,dim_ti){ v+=rhs[i]; }); } vec&operator+=(constvec&rhs){ returnoperator+=<T>(rhs); } template<typenameU> vec&operator-=(Urhs){ returnapply([rhs](T&v,dim_t/*unused*/){ v-=rhs; }); } template<typenameU> vec&operator-=(constvec<L, U>&rhs){ returnapply([&rhs](T&v,dim_ti){ v-=rhs[i]; }); } vec&operator-=(constvec&rhs){ returnoperator-=<T>(rhs); } template<typenameU> vec&operator*=(Urhs){ returnapply([rhs](T&v,dim_t/*unused*/){ v*=rhs; }); } template<typenameU> vec&operator*=(constvec<L, U>&rhs){ returnapply([&rhs](T&v,dim_ti){ v*=rhs[i]; }); } vec&operator*=(constvec&rhs){ returnoperator*=<T>(rhs); } template<typenameU> vec&operator/=(Urhs){ returnapply([rhs](T&v,dim_t/*unused*/){ v/=rhs; }); } template<typenameU> vec&operator/=(constvec<L, U>&rhs){ returnapply([&rhs](T&v,dim_ti){ v/=rhs[i]; }); } vec&operator/=(constvec&rhs){ returnoperator/=<T>(rhs); } template<typename...,typenameV=T> typenamestd::enable_if<std::is_floating_point<V>::value,V>::typelength()const{ constauto&v=*this; returnstd::sqrt((v*v).sum()); } template<typename...,typenameV=T> typenamestd::enable_if<std::is_floating_point<V>::value,vec&>::typenormalize(){ returnoperator/=(length()); } vec&negate(){ returnapply([](T&v,dim_t/*unused*/){ v=-v; }); } Tsum()const{ Tretval{}; apply([&retval](constT&v,dim_t/*unused*/){ retval+=v; }); returnretval; } }; template<dim_tL,typenameT> inlinebooloperator==(constvec<L, T>&lhs,constvec<L, T>&rhs){ boolequal=true; lhs.apply([&equal,&rhs](constT&v,dim_ti){ equal=equal&&(v==rhs[i]); }); returnequal; } template<dim_tL,typenameT> inlinebooloperator!=(constvec<L, T>&lhs,constvec<L, T>&rhs){ return!(lhs==rhs); } template<dim_tL,typenameT> inlinevec<L, T>operator+(constvec<L, T>&v){ returnv; } template<dim_tL,typenameT> inlinevec<L, T>operator-(vec<L, T>v){ returnv.negate(); } template<dim_tL,typenameT,typenameU> inlinevec<L, T>operator+(constvec<L, T>&lhs,constvec<L, U>&rhs){ returnvec<L, T>(lhs)+=rhs; } template<dim_tL,typenameT,typenameU> inlinevec<L, T>operator+(constvec<L, T>&lhs,Urhs){ returnvec<L, T>(lhs)+=rhs; } template<dim_tL,typenameT,typenameU> inlinevec<L, T>operator+(Tlhs,constvec<L, U>&rhs){ returnvec<L, T>(lhs)+=rhs; } template<dim_tL,typenameT,typenameU> inlinevec<L, T>operator-(constvec<L, T>&lhs,constvec<L, U>&rhs){ returnvec<L, T>(lhs)-=rhs; } template<dim_tL,typenameT,typenameU> inlinevec<L, T>operator-(constvec<L, T>&lhs,Urhs){ returnvec<L, T>(lhs)-=rhs; } template<dim_tL,typenameT,typenameU> inlinevec<L, T>operator-(Tlhs,constvec<L, U>&rhs){ returnvec<L, T>(lhs)-=rhs; } template<dim_tL,typenameT,typenameU> inlinevec<L, T>operator*(constvec<L, T>&lhs,constvec<L, U>&rhs){ returnvec<L, T>(lhs)*=rhs; } template<dim_tL,typenameT,typenameU> inlinetypenamestd::enable_if<std::is_arithmetic<U>::value,vec<L, T>>::typeoperator*(constvec<L, T>&lhs,Urhs){ returnvec<L, T>(lhs)*=rhs; } template<dim_tL,typenameT,typenameU> inlinetypenamestd::enable_if<std::is_arithmetic<T>::value,vec<L, T>>::typeoperator*(Tlhs,constvec<L, U>&rhs){ returnvec<L, T>(lhs)*=rhs; } template<dim_tL,typenameT,typenameU> inlinevec<L, T>operator/(constvec<L, T>&lhs,constvec<L, U>&rhs){ returnvec<L, T>(lhs)/=rhs; } template<dim_tL,typenameT,typenameU> inlinetypenamestd::enable_if<std::is_arithmetic<U>::value,vec<L, T>>::typeoperator/(constvec<L, T>&lhs,Urhs){ returnvec<L, T>(lhs)/=rhs; } template<dim_tL,typenameT,typenameU> inlinetypenamestd::enable_if<std::is_arithmetic<T>::value,vec<L, T>>::typeoperator/(Tlhs,constvec<L, U>&rhs){ returnvec<L, T>(lhs)/=rhs; } }//namespacetdm