meshing recaclulation on the fly, picking, whatever

[antikythera] / src / machine.cc

diff --git a/src/machine.cc b/src/machine.cc
index 274362a..913b0b0 100644 (file)
--- a/src/machine.cc
+++ b/src/machine.cc
@@ -1,6 +1,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
+#include <float.h>
 #include <assert.h>
 #include "machine.h"
 
@@ -63,10 +64,10 @@ void Machine::calc_meshing()
                visited = new bool[ngears];
        }
 
-       // we're going to need the inverse of each gear's matrix, so let's cache it here
-       Mat4 *inv_xform = (Mat4*)alloca(ngears * sizeof *inv_xform);
+       // we're going to need the planar position of each gear on its plane, so let's cache it
+       Vec3 *ppos = (Vec3*)alloca(ngears * sizeof *ppos);
        for(int i=0; i<ngears; i++) {
-               inv_xform[i] = transpose(gears[i]->get_dir_matrix());
+               ppos[i] = gears[i]->get_planar_position();
        }
 
        for(int i=0; i<ngears; i++) {
@@ -77,14 +78,11 @@ void Machine::calc_meshing()
 
                        if(1.0 - fabs(dot(gears[i]->axis, gears[j]->axis)) < 1e-5) {
                                // co-planar, just check Z range after inverse-transforming to the XY plane
-                               Vec3 pos_i = inv_xform[i] * gears[i]->get_position();
-                               Vec3 pos_j = inv_xform[j] * gears[j]->get_position();
-
-                               if(fabs(pos_i.z - pos_j.z) > (gears[i]->thickness + gears[j]->thickness) / 2.0) {
+                               if(fabs(ppos[i].z - ppos[j].z) > (gears[i]->thickness + gears[j]->thickness) / 2.0) {
                                        continue;
                                }
                                // Z interval match, check distance
-                               float dsq = length_sq(pos_i.xy() - pos_j.xy());
+                               float dsq = length_sq(ppos[i].xy() - ppos[j].xy());
 
                                float outer_rad_sum = gears[i]->radius + gears[j]->radius;
                                float inner_rad_sum = outer_rad_sum - gears[i]->teeth_length - gears[j]->teeth_length;
@@ -107,12 +105,19 @@ void Machine::calc_meshing()
        // fix the initial angles so that teeth mesh as best as possible
        // should work in one pass as long as the gear train is not impossible
        for(int i=0; i<ngears; i++) {
+               gears[i]->init_angle = 0;
+       }
+
+       for(int i=0; i<ngears; i++) {
                for(int j=1; j<ngears; j++) {
                        if(meshing[i][j]) {
                                assert(i != j);
 
+                               Vec2 dir = normalize(ppos[j].xy() - ppos[i].xy());
+                               float rel_angle = atan2(dir.y, dir.x);
+
                                float frac_i = fmod(gears[i]->init_angle / gears[i]->get_angular_pitch() + 1.0, 1.0);
-                               float frac_j = fmod(gears[j]->init_angle / gears[j]->get_angular_pitch() + 1.0, 1.0);
+                               float frac_j = fmod((gears[j]->init_angle + rel_angle) / gears[j]->get_angular_pitch() + 1.0, 1.0);
                                float delta = frac_j - frac_i;
 
                                float correction = 0.5 - delta;
@@ -120,6 +125,12 @@ void Machine::calc_meshing()
                        }
                }
        }
+
+       /*
+       for(int i=0; i<ngears; i++) {
+               printf("init %d: %f\n", i, gears[i]->init_angle);
+       }
+       */
 }
 
 void Machine::update_gear(int idx, float angle)
@@ -128,6 +139,7 @@ void Machine::update_gear(int idx, float angle)
                if(delta_angle(angle, gears[idx]->angle) > 0.25 / gears[idx]->nteeth) {
                        fprintf(stderr, "warning: trying to transmit different values to gear %s (%d)\n",
                                        gears[idx]->name.c_str(), idx);
+                       gears[idx]->angle = 0;
                }
                return;
        }
@@ -170,6 +182,29 @@ void Machine::draw() const
        }
 }
 
+Gear *Machine::intersect_gear(const Ray &ray, HitPoint *hitp) const
+{
+       Gear *res = 0;
+       HitPoint nearest;
+       nearest.dist = FLT_MAX;
+
+       for(size_t i=0; i<gears.size(); i++) {
+               Vec3 pos = gears[i]->get_global_position();
+               float rad = gears[i]->radius;
+
+               Plane plane = Plane(pos, gears[i]->axis);
+
+               HitPoint hit;
+               if(plane.intersect(ray, &hit) && hit.dist < nearest.dist &&
+                               length_sq(hit.pos - pos) <= rad * rad) {
+                       nearest = hit;
+                       res = gears[i];
+               }
+       }
+
+       if(hitp) *hitp = nearest;
+       return res;
+}
 
 static float delta_angle(float a, float b)
 {