Make use of the mspmath library

[r2c2.git] / source / designer / manipulator.cpp

diff --git a/source/designer/manipulator.cpp b/source/designer/manipulator.cpp
index 802adb16fd45942e95deb2ac7038b347cb909557..8620fe7af8a6a53e8c0a43fd960d509805fa736f 100644 (file)
--- a/source/designer/manipulator.cpp
+++ b/source/designer/manipulator.cpp
@@ -14,8 +14,7 @@ Manipulator::Manipulator(Designer &d, Input::Mouse &m, Selection &s):
        designer(d),
        mouse(m),
        selection(s),
-       mode(NONE),
-       angle(0)
+       mode(NONE)
 {
        mouse.signal_button_press.connect(sigc::bind_return(sigc::mem_fun(this, &Manipulator::button_press), false));
        mouse.signal_axis_motion.connect(sigc::bind_return(sigc::mem_fun(this, &Manipulator::axis_motion), false));
@@ -37,7 +36,7 @@ void Manipulator::start_rotate()
        if(mode)
                cancel();
 
-       rot_origin = atan2(gpointer.y-center.y, gpointer.x-center.x);
+       rot_origin = Geometry::atan2(gpointer.y-center.y, gpointer.x-center.x);
 
        mode = ROTATE;
 }
@@ -243,22 +242,15 @@ void Manipulator::connect()
                        if(abs(dz)>0.02)
                                continue;
 
-                       float adiff = sn1.rotation+M_PI-sn2.rotation;
-                       while(adiff<-M_PI)
-                               adiff += M_PI*2;
-                       while(adiff>M_PI)
-                               adiff -= M_PI*2;
-                       if(abs(adiff)>0.01)
+                       Angle adiff = wrap_balanced(sn1.rotation+Angle::half_turn()-sn2.rotation);
+                       if(abs(adiff).radians()>0.01)
                                continue;
 
-                       float c = cos(sn1.rotation);
-                       float s = sin(sn1.rotation);
-                       float dx = sn2.position.x-sn1.position.x;
-                       float dy = sn2.position.y-sn1.position.y;
-                       if(abs(dx*s-dy*c)>limit)
+                       Vector delta = rotated_vector(sn2.position-sn1.position, -sn1.rotation);
+                       if(abs(delta.y)>limit)
                                continue;
 
-                       gap = dx*c+dy*s;
+                       gap = delta.x;
                        if(gap<0)
                                continue;
 
@@ -297,7 +289,7 @@ void Manipulator::cancel()
 
        for(vector<MObject>::iterator i=objects.begin(); i!=objects.end(); ++i)
        {
-               i->object->set_position(Vector(center.x+i->pos.x, center.y+i->pos.y, center.z+i->pos.z));
+               i->object->set_position(center+i->pos);
                i->object->set_rotation(i->rot);
        }
 
@@ -305,7 +297,7 @@ void Manipulator::cancel()
                delete *i;
        extend_tracks.clear();
 
-       angle = 0;
+       angle = Angle::zero();
 
        signal_done.emit(false);
 }
@@ -321,7 +313,7 @@ void Manipulator::button_press(unsigned btn)
        {
                Mode m = mode;
                mode = NONE;
-               angle = 0;
+               angle = Angle::zero();
 
                if(m!=EXTEND)
                {
@@ -367,11 +359,10 @@ void Manipulator::axis_motion(unsigned axis, float value, float)
 
        if(mode==MOVE)
        {
-               Vector delta(gpointer.x-move_origin.x, gpointer.y-move_origin.y, 0);
-               Vector offset(center.x+delta.x, center.y+delta.y, center.z);
+               Vector offset = center+gpointer-move_origin;
                for(vector<MObject>::iterator i=objects.begin(); i!=objects.end(); ++i)
                {
-                       i->object->set_position(Vector(offset.x+i->pos.x, offset.y+i->pos.y, offset.z+i->pos.z));
+                       i->object->set_position(offset+i->pos);
                        i->object->set_rotation(i->rot);
                }
 
@@ -394,32 +385,29 @@ void Manipulator::axis_motion(unsigned axis, float value, float)
 
                if(snapped)
                {
-                       float da = snapped->object->get_rotation()-snapped->rot;
-                       float c = cos(da);
-                       float s = sin(da);
+                       Angle da = snapped->object->get_rotation()-snapped->rot;
+                       Transform trans = Transform::rotation(da, Vector(0, 0, 1));
                        const Vector &sp = snapped->object->get_position();
                        for(vector<MObject>::iterator i=objects.begin(); i!=objects.end(); ++i)
                        {
                                if(&*i==snapped)
                                        continue;
 
-                               Vector dp(i->pos.x-snapped->pos.x, i->pos.y-snapped->pos.y, 0);
-                               i->object->set_position(Vector(sp.x+c*dp.x-s*dp.y, sp.y+s*dp.x+c*dp.y, sp.z+i->pos.z-snapped->pos.z));
+                               i->object->set_position(sp+trans.transform(i->pos-snapped->pos));
                                i->object->set_rotation(i->rot+da);
                        }
                }
        }
        else if(mode==ROTATE)
        {
-               float a = atan2(gpointer.y-center.y, gpointer.x-center.x);
+               Angle a = Geometry::atan2(gpointer.y-center.y, gpointer.x-center.x);
                angle += a-rot_origin;
                rot_origin = a;
 
+               Transform trans = Transform::rotation(angle, Vector(0, 0, 1));
                for(vector<MObject>::iterator i=objects.begin(); i!=objects.end(); ++i)
                {
-                       float c = cos(angle);
-                       float s = sin(angle);
-                       i->object->set_position(Vector(center.x+c*i->pos.x-s*i->pos.y, center.y+s*i->pos.x+c*i->pos.y, center.z+i->pos.z));
+                       i->object->set_position(center+trans.transform(i->pos));
                        i->object->set_rotation(angle+i->rot);
                }
        }
@@ -430,12 +418,12 @@ void Manipulator::axis_motion(unsigned axis, float value, float)
                signal_status.emit(format("Elevation: %+.0fmm (%.0fmm)", dz*1000, (center.z+dz)*1000));
 
                for(vector<MObject>::iterator i=objects.begin(); i!=objects.end(); ++i)
-                       i->object->set_position(Vector(center.x+i->pos.x, center.y+i->pos.y, center.z+i->pos.z+dz));
+                       i->object->set_position(center+i->pos+Vector(0, 0, dz));
        }
        else if(mode==EXTEND)
        {
                Vector pos;
-               float dir = 0;
+               Angle dir;
                float length = 0;
                for(vector<MObject>::iterator i=objects.begin(); i!=objects.end(); ++i)
                {
@@ -446,18 +434,14 @@ void Manipulator::axis_motion(unsigned axis, float value, float)
                                        continue;
 
                                Snap sn = i->object->get_snap_node(j);
-                               float c = cos(sn.rotation);
-                               float s = sin(sn.rotation);
-                               float dx = gpointer.x-sn.position.x;
-                               float dy = gpointer.y-sn.position.y;
+                               Vector delta = rotated_vector(gpointer-sn.position, -sn.rotation);
 
-                               float len = dx*c+dy*s;
-                               if(len<length)
+                               if(delta.x<length)
                                        continue;
 
                                pos = sn.position;
                                dir = sn.rotation;
-                               length = len;
+                               length = delta.x;
                        }
                }
 
@@ -553,11 +537,11 @@ void Manipulator::update_objects()
                }
        }
 
-       center = Vector((minp.x+maxp.x)/2, (minp.y+maxp.y)/2, minp.z);
+       center = (minp+maxp)/2.0f;
+       center.z = minp.z;
        for(vector<MObject>::iterator i=objects.begin(); i!=objects.end(); ++i)
        {
-               const Vector &p = i->object->get_position();
-               i->pos = Vector(p.x-center.x, p.y-center.y, p.z-center.z);
+               i->pos = i->object->get_position()-center;
                i->rot = i->object->get_rotation();
        }
 }
@@ -601,7 +585,7 @@ void Manipulator::set_slope(TrackOrder &track, float z, float dz)
        }
 }
 
-vector<Track *> Manipulator::create_straight(const R2C2::Vector &start, float dir, float length, float limit)
+vector<Track *> Manipulator::create_straight(const R2C2::Vector &start, const Angle &dir, float length, float limit)
 {
        const Catalogue::TrackMap &track_types = designer.get_catalogue().get_tracks();
        std::map<float, const TrackType *> types_by_length;
@@ -662,8 +646,7 @@ vector<Track *> Manipulator::create_straight(const R2C2::Vector &start, float di
        if(!lengths.empty())
        {
                Vector pos = start;
-               float c = cos(dir);
-               float s = sin(dir);
+               Transform trans = Transform::rotation(dir, Vector(0, 0, 1));
                for(vector<float>::iterator i=lengths.begin(); i!=lengths.end(); ++i)
                {
                        Track *track = new Track(designer.get_layout(), *get_item(types_by_length, *i));
@@ -674,8 +657,7 @@ vector<Track *> Manipulator::create_straight(const R2C2::Vector &start, float di
                                track->link_to(*trks.back());
                        trks.push_back(track);
 
-                       pos.x += c**i;
-                       pos.y += s**i;
+                       pos += trans.transform(Vector(*i, 0, 0));
                }
        }