630 lines
21 KiB
C++
630 lines
21 KiB
C++
/*
|
|
openDCM, dimensional constraint manager
|
|
Copyright (C) 2012 Stefan Troeger <stefantroeger@gmx.net>
|
|
|
|
This library is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License along
|
|
with this library; if not, write to the Free Software Foundation, Inc.,
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#ifndef GCM_MODULE_PART_H
|
|
#define GCM_MODULE_PART_H
|
|
|
|
#include "opendcm/core.hpp"
|
|
#include "opendcm/core/traits.hpp"
|
|
#include "opendcm/core/clustergraph.hpp"
|
|
#include "opendcm/core/property.hpp"
|
|
#include "opendcm/module3d.hpp"
|
|
|
|
#include <boost/mpl/assert.hpp>
|
|
#include <boost/utility/enable_if.hpp>
|
|
|
|
namespace mpl = boost::mpl;
|
|
|
|
namespace dcm {
|
|
|
|
enum { clusterPart = 110};
|
|
|
|
enum CoordinateFrame {Local, Global};
|
|
|
|
template<typename Typelist, typename ID = No_Identifier>
|
|
struct ModulePart {
|
|
|
|
template<typename Sys>
|
|
struct type {
|
|
|
|
|
|
struct Part;
|
|
struct PrepareCluster;
|
|
struct EvaljuateCluster;
|
|
typedef boost::shared_ptr<Part> Partptr;
|
|
typedef mpl::map2< mpl::pair<remove, boost::function<void (Partptr) > >,
|
|
mpl::pair<recalculated, boost::function<void (Partptr) > > > PartSignal;
|
|
|
|
typedef ID Identifier;
|
|
|
|
class Part_base : public Object<Sys, Part, PartSignal > {
|
|
protected:
|
|
|
|
#ifdef USE_LOGGING
|
|
src::logger log;
|
|
#endif
|
|
|
|
//check if we have module3d in this system
|
|
typedef typename system_traits<Sys>::template getModule<details::m3d>::type module3d;
|
|
BOOST_MPL_ASSERT((mpl::not_<boost::is_same<module3d, mpl::void_> >));
|
|
|
|
//define what we need
|
|
typedef typename module3d::Geometry3D Geometry3D;
|
|
typedef boost::shared_ptr<Geometry3D> Geom;
|
|
|
|
typedef typename boost::make_variant_over< Typelist >::type Variant;
|
|
typedef Object<Sys, Part, PartSignal> base;
|
|
typedef typename Sys::Kernel Kernel;
|
|
typedef typename Sys::Cluster Cluster;
|
|
typedef typename Kernel::number_type Scalar;
|
|
typedef typename Kernel::Transform3D Transform;
|
|
|
|
struct cloner : boost::static_visitor<void> {
|
|
|
|
Variant variant;
|
|
cloner(Variant& v) : variant(v) {};
|
|
|
|
template<typename T>
|
|
void operator()(T& t) {
|
|
variant = geometry_clone_traits<T>()(t);
|
|
};
|
|
};
|
|
|
|
//visitor to write the calculated value into the variant
|
|
struct apply_visitor : public boost::static_visitor<void> {
|
|
|
|
apply_visitor(Transform& t) : m_transform(t) {};
|
|
|
|
template <typename T>
|
|
void operator()(T& t) const {
|
|
(typename geometry_traits<T>::modell()).template inject<Kernel,
|
|
typename geometry_traits<T>::accessor >(t, m_transform);
|
|
}
|
|
Transform& m_transform;
|
|
};
|
|
|
|
//collect all clustergraph upstream cluster transforms
|
|
void transform_traverse(Transform& t, boost::shared_ptr<Cluster> c);
|
|
|
|
public:
|
|
using Object<Sys, Part, PartSignal >::m_system;
|
|
|
|
template<typename T>
|
|
Part_base(const T& geometry, Sys& system, boost::shared_ptr<Cluster> cluster);
|
|
|
|
template<typename Visitor>
|
|
typename Visitor::result_type apply(Visitor& vis);
|
|
|
|
template<typename T>
|
|
Geom addGeometry3D(const T& geom, CoordinateFrame frame = Global);
|
|
|
|
template<typename T>
|
|
void set(const T& geometry);
|
|
|
|
template<typename T>
|
|
T& get();
|
|
|
|
template<typename T>
|
|
T getGlobal();
|
|
|
|
virtual boost::shared_ptr<Part> clone(Sys& newSys);
|
|
|
|
public:
|
|
Variant m_geometry;
|
|
Transform m_transform;
|
|
boost::shared_ptr<Cluster> m_cluster;
|
|
|
|
void finishCalculation();
|
|
void fix(bool fix_value);
|
|
|
|
public:
|
|
//we hold a transform and need therefore a aligned new operator
|
|
EIGEN_MAKE_ALIGNED_OPERATOR_NEW
|
|
};
|
|
|
|
struct Part_id : public Part_base {
|
|
|
|
template<typename T>
|
|
Part_id(const T& geometry, Sys& system, boost::shared_ptr<typename Part_base::Cluster> cluster);
|
|
|
|
template<typename T>
|
|
typename Part_base::Geom addGeometry3D(const T& geom, Identifier id, CoordinateFrame frame = Global);
|
|
|
|
template<typename T>
|
|
void set(const T& geometry, Identifier id);
|
|
|
|
bool hasGeometry3D(Identifier id);
|
|
typename Part_base::Geom getGeometry3D(Identifier id);
|
|
|
|
Identifier& getIdentifier();
|
|
void setIdentifier(Identifier id);
|
|
};
|
|
|
|
struct Part : public mpl::if_<boost::is_same<Identifier, No_Identifier>, Part_base, Part_id>::type {
|
|
|
|
typedef typename mpl::if_<boost::is_same<Identifier, No_Identifier>, Part_base, Part_id>::type base;
|
|
|
|
template<typename T>
|
|
Part(const T& geometry, Sys& system, boost::shared_ptr<typename base::Cluster> cluster);
|
|
|
|
friend struct PrepareCluster;
|
|
friend struct EvaljuateCluster;
|
|
|
|
public:
|
|
//we hold a transform and need therefore a aligned new operator
|
|
EIGEN_MAKE_ALIGNED_OPERATOR_NEW
|
|
};
|
|
|
|
|
|
struct inheriter_base {
|
|
|
|
inheriter_base();
|
|
|
|
template<typename T>
|
|
Partptr createPart(const T& geometry);
|
|
void removePart(Partptr p);
|
|
|
|
template<typename T>
|
|
void setTransformation(const T& geom) {
|
|
|
|
typedef typename system_traits<Sys>::template getModule<details::m3d>::type module3d;
|
|
details::ClusterMath<Sys>& cm = ((Sys*)this)->m_cluster->template getProperty<typename module3d::math_prop>();
|
|
|
|
(typename geometry_traits<T>::modell()).template extract<typename Sys::Kernel,
|
|
typename geometry_traits<T>::accessor >(geom, cm.getTransform());
|
|
};
|
|
|
|
template<typename T>
|
|
T getTransformation() {
|
|
|
|
T geom;
|
|
getTransformation(geom);
|
|
return geom;
|
|
};
|
|
template<typename T>
|
|
void getTransformation(T& geom) {
|
|
|
|
typedef typename system_traits<Sys>::template getModule<details::m3d>::type module3d;
|
|
details::ClusterMath<Sys>& cm = ((Sys*)this)->m_cluster->template getProperty<typename module3d::math_prop>();
|
|
|
|
(typename geometry_traits<T>::modell()).template inject<typename Sys::Kernel,
|
|
typename geometry_traits<T>::accessor >(geom, cm.getTransform());
|
|
};
|
|
|
|
protected:
|
|
Sys* m_this;
|
|
|
|
//function object to emit remove signal too al geometry which is deleted by part deletion
|
|
struct remover {
|
|
typedef typename Sys::Cluster Cluster;
|
|
typedef typename system_traits<Sys>::template getModule<details::m3d>::type module3d;
|
|
typedef typename module3d::Geometry3D Geometry3D;
|
|
typedef boost::shared_ptr<Geometry3D> Geom;
|
|
typedef typename module3d::Constraint3D Constraint3D;
|
|
typedef boost::shared_ptr<Constraint3D> Cons;
|
|
|
|
Sys& system;
|
|
remover(Sys& s);
|
|
//see if we have a geometry or a constraint and emit the remove signal
|
|
void operator()(GlobalVertex v);
|
|
//we delete all global edges connecting to this part
|
|
void operator()(GlobalEdge e);
|
|
void operator()(boost::shared_ptr<Cluster> g) {};
|
|
};
|
|
};
|
|
|
|
struct inheriter_id : public inheriter_base {
|
|
|
|
template<typename T>
|
|
Partptr createPart(const T& geometry, Identifier id);
|
|
bool hasPart(Identifier id);
|
|
Partptr getPart(Identifier id);
|
|
};
|
|
|
|
struct inheriter : public mpl::if_<boost::is_same<Identifier, No_Identifier>, inheriter_base, inheriter_id>::type {};
|
|
|
|
typedef mpl::vector0<> properties;
|
|
typedef mpl::vector1<Part> objects;
|
|
typedef mpl::vector0<> geometries;
|
|
|
|
struct PrepareCluster : public Job<Sys> {
|
|
|
|
typedef typename Sys::Cluster Cluster;
|
|
typedef typename Sys::Kernel Kernel;
|
|
typedef typename system_traits<Sys>::template getModule<details::m3d>::type module3d;
|
|
|
|
PrepareCluster();
|
|
virtual void execute(Sys& sys);
|
|
};
|
|
|
|
struct EvaljuateCluster : public Job<Sys> {
|
|
|
|
typedef typename Sys::Cluster Cluster;
|
|
typedef typename Sys::Kernel Kernel;
|
|
typedef typename system_traits<Sys>::template getModule<details::m3d>::type module3d;
|
|
|
|
EvaljuateCluster();
|
|
virtual void execute(Sys& sys);
|
|
};
|
|
|
|
static void system_init(Sys& sys) {
|
|
sys.m_sheduler.addPreprocessJob(new PrepareCluster());
|
|
sys.m_sheduler.addPostprocessJob(new EvaljuateCluster());
|
|
};
|
|
static void system_copy(const Sys& from, Sys& into) {};
|
|
};
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
template<typename T>
|
|
ModulePart<Typelist, ID>::type<Sys>::Part_base::Part_base(const T& geometry, Sys& system, boost::shared_ptr<Cluster> cluster)
|
|
: Object<Sys, Part, PartSignal>(system), m_geometry(geometry), m_cluster(cluster) {
|
|
|
|
#ifdef USE_LOGGING
|
|
log.add_attribute("Tag", attrs::constant< std::string >("Part3D"));
|
|
#endif
|
|
|
|
(typename geometry_traits<T>::modell()).template extract<Kernel,
|
|
typename geometry_traits<T>::accessor >(geometry, m_transform);
|
|
|
|
cluster->template setProperty<typename module3d::fix_prop>(false);
|
|
|
|
//the the clustermath transform
|
|
m_cluster->template getProperty<typename module3d::math_prop>().getTransform() = m_transform;
|
|
|
|
#ifdef USE_LOGGING
|
|
BOOST_LOG(log) << "Init: "<<m_transform;
|
|
#endif
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
template<typename Visitor>
|
|
typename Visitor::result_type ModulePart<Typelist, ID>::type<Sys>::Part_base::apply(Visitor& vis) {
|
|
return boost::apply_visitor(vis, m_geometry);
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
template<typename T>
|
|
typename ModulePart<Typelist, ID>::template type<Sys>::Part_base::Geom
|
|
ModulePart<Typelist, ID>::type<Sys>::Part_base::addGeometry3D(const T& geom, CoordinateFrame frame) {
|
|
Geom g(new Geometry3D(geom, *m_system));
|
|
if(frame == Local) {
|
|
//we need to collect all transforms up to this part!
|
|
Transform t;//(m_transform);
|
|
transform_traverse(t, m_cluster);
|
|
|
|
g->transform(t);
|
|
}
|
|
|
|
fusion::vector<LocalVertex, GlobalVertex> res = m_cluster->addVertex();
|
|
m_cluster->template setObject<Geometry3D> (fusion::at_c<0> (res), g);
|
|
g->template setProperty<typename module3d::vertex_prop>(fusion::at_c<1>(res));
|
|
m_system->template objectVector<Geometry3D>().push_back(g);
|
|
|
|
return g;
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
void ModulePart<Typelist, ID>::type<Sys>::Part_base::transform_traverse(ModulePart<Typelist, ID>::type<Sys>::Part_base::Transform& t,
|
|
boost::shared_ptr<ModulePart<Typelist, ID>::type<Sys>::Part_base::Cluster> c) {
|
|
|
|
t *= c->template getProperty<typename Part_base::module3d::math_prop>().m_transform;
|
|
|
|
if(c->isRoot())
|
|
return;
|
|
|
|
transform_traverse(t, c->parent());
|
|
}
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
template<typename T>
|
|
void ModulePart<Typelist, ID>::type<Sys>::Part_base::set(const T& geometry) {
|
|
Part_base::m_geometry = geometry;
|
|
(typename geometry_traits<T>::modell()).template extract<Kernel,
|
|
typename geometry_traits<T>::accessor >(geometry, Part_base::m_transform);
|
|
|
|
//set the clustermath transform
|
|
m_cluster->template getClusterProperty<typename module3d::math_prop>().getTransform() = m_transform;
|
|
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
template<typename T>
|
|
T& ModulePart<Typelist, ID>::type<Sys>::Part_base::get() {
|
|
|
|
return get<T>(this);
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
template<typename T>
|
|
T ModulePart<Typelist, ID>::type<Sys>::Part_base::getGlobal() {
|
|
|
|
//get the successive transform
|
|
Transform t;
|
|
transform_traverse(t, m_cluster);
|
|
|
|
//put it into the user type
|
|
T ut;
|
|
(typename geometry_traits<T>::modell()).template inject<Kernel,
|
|
typename geometry_traits<T>::accessor >(ut, t);
|
|
|
|
return ut;
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
boost::shared_ptr<typename ModulePart<Typelist, ID>::template type<Sys>::Part>
|
|
ModulePart<Typelist, ID>::type<Sys>::Part_base::clone(Sys& newSys) {
|
|
|
|
//we need to reset the cluster pointer to the new system cluster
|
|
LocalVertex lv = Object<Sys, Part, PartSignal>::m_system->m_cluster->getClusterVertex(m_cluster);
|
|
GlobalVertex gv = Object<Sys, Part, PartSignal>::m_system->m_cluster->getGlobalVertex(lv);
|
|
|
|
boost::shared_ptr<Part> np = Object<Sys, Part, PartSignal>::clone(newSys);
|
|
//there may be pointer inside the variant
|
|
cloner clone_fnc(np->m_geometry);
|
|
boost::apply_visitor(clone_fnc, m_geometry);
|
|
|
|
fusion::vector<LocalVertex, boost::shared_ptr<Cluster>, bool> res = newSys.m_cluster->getLocalVertexGraph(gv);
|
|
if(!fusion::at_c<2>(res)) {
|
|
//todo: throw
|
|
return np;
|
|
}
|
|
np->m_cluster = fusion::at_c<1>(res)->getVertexCluster(fusion::at_c<0>(res));
|
|
|
|
return np;
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
void ModulePart<Typelist, ID>::type<Sys>::Part_base::finishCalculation() {
|
|
|
|
m_transform.normalize();
|
|
apply_visitor vis(m_transform);
|
|
apply(vis);
|
|
|
|
#ifdef USE_LOGGING
|
|
BOOST_LOG(log) << "New Value: "<<m_transform;
|
|
#endif
|
|
|
|
//emit the signal for new values
|
|
base::template emitSignal<recalculated>(((Part*)this)->shared_from_this());
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
void ModulePart<Typelist, ID>::type<Sys>::Part_base::fix(bool fix_value) {
|
|
m_cluster->template setProperty<typename module3d::fix_prop>(fix_value);
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
template<typename T>
|
|
ModulePart<Typelist, ID>::type<Sys>::Part_id::Part_id(const T& geometry, Sys& system, boost::shared_ptr<typename Part_base::Cluster> cluster)
|
|
: Part_base(geometry, system, cluster) {
|
|
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
template<typename T>
|
|
typename ModulePart<Typelist, ID>::template type<Sys>::Part_base::Geom
|
|
ModulePart<Typelist, ID>::type<Sys>::Part_id::addGeometry3D(const T& geom, Identifier id, CoordinateFrame frame) {
|
|
|
|
typename Part_base::Geom g = Part_base::addGeometry3D(geom, frame);
|
|
g->setIdentifier(id);
|
|
return g;
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
template<typename T>
|
|
void ModulePart<Typelist, ID>::type<Sys>::Part_id::set(const T& geometry, Identifier id) {
|
|
Part_base::set(geometry);
|
|
setIdentifier(id);
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
bool ModulePart<Typelist, ID>::type<Sys>::Part_id::hasGeometry3D(Identifier id) {
|
|
typename Part_base::Geom g = Part_base::m_system->getGeometry3D(id);
|
|
if(!g)
|
|
return false;
|
|
|
|
//get the global vertex and check if it is a child of the part cluster
|
|
GlobalVertex v = g->template getProperty<typename Part_base::module3d::vertex_prop>();
|
|
return Part_base::m_cluster->getLocalVertex(v).second;
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
typename ModulePart<Typelist, ID>::template type<Sys>::Part_base::Geom
|
|
ModulePart<Typelist, ID>::type<Sys>::Part_id::getGeometry3D(Identifier id) {
|
|
return Part_base::m_system->getGeometry3D(id);
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
typename ModulePart<Typelist, ID>::template type<Sys>::Identifier&
|
|
ModulePart<Typelist, ID>::type<Sys>::Part_id::getIdentifier() {
|
|
return this->template getProperty<id_prop<Identifier> >();
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
void ModulePart<Typelist, ID>::type<Sys>::Part_id::setIdentifier(Identifier id) {
|
|
this->template setProperty<id_prop<Identifier> >(id);
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
template<typename T>
|
|
ModulePart<Typelist, ID>::type<Sys>::Part::Part(const T& geometry, Sys& system, boost::shared_ptr<typename base::Cluster> cluster)
|
|
: mpl::if_<boost::is_same<Identifier, No_Identifier>,
|
|
Part_base, Part_id>::type(geometry, system, cluster) {
|
|
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
ModulePart<Typelist, ID>::type<Sys>::inheriter_base::inheriter_base() {
|
|
m_this = ((Sys*) this);
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
template<typename T>
|
|
typename ModulePart<Typelist, ID>::template type<Sys>::Partptr
|
|
ModulePart<Typelist, ID>::type<Sys>::inheriter_base::createPart(const T& geometry) {
|
|
|
|
typedef typename Sys::Cluster Cluster;
|
|
std::pair<boost::shared_ptr<Cluster>, LocalVertex> res = m_this->m_cluster->createCluster();
|
|
Partptr p(new Part(geometry, * ((Sys*) this), res.first));
|
|
|
|
m_this->m_cluster->template setObject<Part> (res.second, p);
|
|
m_this->push_back(p);
|
|
|
|
res.first->template setProperty<type_prop>(clusterPart);
|
|
return p;
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
void ModulePart<Typelist, ID>::type<Sys>::inheriter_base::removePart(Partptr p) {
|
|
|
|
remover r(*m_this);
|
|
m_this->m_cluster->removeCluster(p->m_cluster, r);
|
|
p->template emitSignal<remove>(p);
|
|
m_this->erase(p);
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
ModulePart<Typelist, ID>::type<Sys>::inheriter_base::remover::remover(Sys& s) : system(s) {
|
|
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
void ModulePart<Typelist, ID>::type<Sys>::inheriter_base::remover::operator()(GlobalVertex v) {
|
|
Geom g = system.m_cluster->template getObject<Geometry3D>(v);
|
|
if(g) {
|
|
g->template emitSignal<remove>(g);
|
|
system.erase(g);
|
|
}
|
|
Cons c = system.m_cluster->template getObject<Constraint3D>(v);
|
|
if(c) {
|
|
c->template emitSignal<remove>(c);
|
|
system.erase(c);
|
|
}
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
void ModulePart<Typelist, ID>::type<Sys>::inheriter_base::remover::operator()(GlobalEdge e) {
|
|
Cons c = system.m_cluster->template getObject<Constraint3D>(e);
|
|
if(c) {
|
|
c->template emitSignal<remove>(c);
|
|
system.erase(c);
|
|
}
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
template<typename T>
|
|
typename ModulePart<Typelist, ID>::template type<Sys>::Partptr
|
|
ModulePart<Typelist, ID>::type<Sys>::inheriter_id::createPart(const T& geometry, Identifier id) {
|
|
Partptr p = inheriter_base::createPart(geometry);
|
|
p->setIdentifier(id);
|
|
return p;
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
bool ModulePart<Typelist, ID>::type<Sys>::inheriter_id::hasPart(Identifier id) {
|
|
if(getPart(id))
|
|
return true;
|
|
return false;
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
typename ModulePart<Typelist, ID>::template type<Sys>::Partptr
|
|
ModulePart<Typelist, ID>::type<Sys>::inheriter_id::getPart(Identifier id) {
|
|
std::vector< Partptr >& vec = inheriter_base::m_this->template objectVector<Part>();
|
|
typedef typename std::vector<Partptr>::iterator iter;
|
|
for(iter it=vec.begin(); it!=vec.end(); it++) {
|
|
if(compare_traits<Identifier>::compare((*it)->getIdentifier(), id))
|
|
return *it;
|
|
};
|
|
return Partptr();
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
ModulePart<Typelist, ID>::type<Sys>::PrepareCluster::PrepareCluster() {
|
|
Job<Sys>::priority = 1000;
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
void ModulePart<Typelist, ID>::type<Sys>::PrepareCluster::execute(Sys& sys) {
|
|
//get all parts and set their values to the cluster's
|
|
typedef typename std::vector<Partptr>::iterator iter;
|
|
for(iter it = sys.template begin<Part>(); it != sys.template end<Part>(); it++) {
|
|
|
|
details::ClusterMath<Sys>& cm = (*it)->m_cluster->template getProperty<typename module3d::math_prop>();
|
|
cm.getTransform() = (*it)->m_transform;
|
|
};
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
ModulePart<Typelist, ID>::type<Sys>::EvaljuateCluster::EvaljuateCluster() {
|
|
Job<Sys>::priority = 1000;
|
|
};
|
|
|
|
template<typename Typelist, typename ID>
|
|
template<typename Sys>
|
|
void ModulePart<Typelist, ID>::type<Sys>::EvaljuateCluster::execute(Sys& sys) {
|
|
//get all parts and set their values to the cluster's
|
|
typedef typename std::vector<Partptr>::iterator iter;
|
|
for(iter it = sys.template begin<Part>(); it != sys.template end<Part>(); it++) {
|
|
|
|
details::ClusterMath<Sys>& cm = (*it)->m_cluster->template getProperty<typename module3d::math_prop>();
|
|
(*it)->m_transform = cm.getTransform();
|
|
(*it)->finishCalculation();
|
|
};
|
|
};
|
|
|
|
}
|
|
|
|
#endif //GCM_MODULEPART_H
|
|
|
|
|
|
|
|
|