spliting pmpd lib to single files

svn path=/trunk/externals/pmpd/; revision=5221

8 files changed, 364 insertions, 321 deletions

diff --git a/src/lia.c b/src/link.c
index 1293cac..459f4a2 100755
--- a/src/lia.c
+++ b/src/link.c
@@ -1,23 +1,23 @@
 #include "m_pd.h"
 #include "math.h"
 
-static t_class *liaKD_class;
+static t_class *linkKD_class;
 
-typedef struct _liaKD {
+typedef struct _linkKD {
   t_object  x_obj;
   t_float raideur, viscosite, D2, longueur, distance_old, position1,  position2, position_old1, position_old2;
   t_outlet *force1;
   t_outlet *force2;
   t_float Lmin, Lmax;

   t_symbol *x_sym;  // receive
-} t_liaKD;
+} t_linkKD;
 
-void liaKD_float(t_liaKD *x, t_floatarg f1)
+void linkKD_float(t_linkKD *x, t_floatarg f1)
 {
   x->position1 = f1;
 }
 
-void liaKD_bang(t_liaKD *x)
+void linkKD_bang(t_linkKD *x)
 {
   t_float force1, force2, distance;
 

@@ -50,7 +50,7 @@ void liaKD_bang(t_liaKD *x)
 
 }
 
-void liaKD_reset(t_liaKD *x)

+void linkKD_reset(t_linkKD *x)

 {

   x->position1 = 0;

   x->position2 = 0;

@@ -61,7 +61,7 @@ void liaKD_reset(t_liaKD *x)
   x->distance_old = x->longueur;

 }

 

-void liaKD_resetF(t_liaKD *x)

+void linkKD_resetF(t_linkKD *x)

 {

   x->position_old1 = x->position1;

   x->position_old2 = x->position2;

@@ -69,50 +69,50 @@ void liaKD_resetF(t_liaKD *x)
   x->distance_old = x->longueur;

 }

 

-void liaKD_resetl(t_liaKD *x)

+void linkKD_resetl(t_linkKD *x)

 {

   x->longueur = (x->position1 - x->position2);

 }
 
-void liaKD_setL(t_liaKD *x, t_float L)
+void linkKD_setL(t_linkKD *x, t_float L)
 {
   x->longueur = L;
 }
 
-void liaKD_setK(t_liaKD *x, t_float K)
+void linkKD_setK(t_linkKD *x, t_float K)
 {
   x->raideur = K;
 }
 
-void liaKD_setD(t_liaKD *x, t_float D)

+void linkKD_setD(t_linkKD *x, t_float D)

 {

   x->viscosite = D;

 }

 

-void liaKD_setD2(t_liaKD *x, t_float D2)

+void linkKD_setD2(t_linkKD *x, t_float D2)

 {

   x->D2 = D2;

 }

 
-void liaKD_Lmin(t_liaKD *x, t_float Lmin)

+void linkKD_Lmin(t_linkKD *x, t_float Lmin)

 {

   x->Lmin = Lmin;

 }

 

-void liaKD_Lmax(t_liaKD *x, t_float Lmax)

+void linkKD_Lmax(t_linkKD *x, t_float Lmax)

 {

   x->Lmax = Lmax;

 }

 

-static void liaKD_free(t_liaKD *x)

+static void linkKD_free(t_linkKD *x)

 {

     pd_unbind(&x->x_obj.ob_pd, x->x_sym);

 }

 
-void *liaKD_new(t_symbol *s, t_floatarg L, t_floatarg K, t_floatarg D, t_floatarg D2 )
+void *linkKD_new(t_symbol *s, t_floatarg L, t_floatarg K, t_floatarg D, t_floatarg D2 )
 {
   
-  t_liaKD *x = (t_liaKD *)pd_new(liaKD_class);
+  t_linkKD *x = (t_linkKD *)pd_new(linkKD_class);
 

   x->x_sym = s;

   pd_bind(&x->x_obj.ob_pd, s);

@@ -137,26 +137,25 @@ void *liaKD_new(t_symbol *s, t_floatarg L, t_floatarg K, t_floatarg D, t_floatar
   return (void *)x;
 }
 
-void lia_setup(void) 
+void link_setup(void) 
 {
-  liaKD_class = class_new(gensym("lia"),
-        (t_newmethod)liaKD_new,
-        (t_method)liaKD_free,

-		sizeof(t_liaKD),
+  linkKD_class = class_new(gensym("link"),
+        (t_newmethod)linkKD_new,
+        (t_method)linkKD_free,

+		sizeof(t_linkKD),
         CLASS_DEFAULT, A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

 

-  class_addcreator((t_newmethod)liaKD_new, gensym("link"), A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

-  class_addcreator((t_newmethod)liaKD_new, gensym("pmpd.link"), A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

-
-  class_addfloat(liaKD_class, liaKD_float);
-  class_addbang(liaKD_class, liaKD_bang);
-  class_addmethod(liaKD_class, (t_method)liaKD_reset, gensym("reset"), 0);

-  class_addmethod(liaKD_class, (t_method)liaKD_resetl, gensym("resetL"), 0);

-  class_addmethod(liaKD_class, (t_method)liaKD_resetF, gensym("resetF"), 0);

-  class_addmethod(liaKD_class, (t_method)liaKD_setD, gensym("setD"), A_DEFFLOAT, 0);

-  class_addmethod(liaKD_class, (t_method)liaKD_setD2, gensym("setD2"), A_DEFFLOAT, 0);
-  class_addmethod(liaKD_class, (t_method)liaKD_setK, gensym("setK"), A_DEFFLOAT, 0);
-  class_addmethod(liaKD_class, (t_method)liaKD_setL, gensym("setL"), A_DEFFLOAT, 0);

-  class_addmethod(liaKD_class, (t_method)liaKD_Lmin, gensym("setLmin"), A_DEFFLOAT, 0);

-  class_addmethod(liaKD_class, (t_method)liaKD_Lmax, gensym("setLmax"), A_DEFFLOAT, 0);
+  class_addcreator((t_newmethod)linkKD_new, gensym("lia"), A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

+
+  class_addfloat(linkKD_class, linkKD_float);
+  class_addbang(linkKD_class, linkKD_bang);
+  class_addmethod(linkKD_class, (t_method)linkKD_reset, gensym("reset"), 0);

+  class_addmethod(linkKD_class, (t_method)linkKD_resetl, gensym("resetL"), 0);

+  class_addmethod(linkKD_class, (t_method)linkKD_resetF, gensym("resetF"), 0);

+  class_addmethod(linkKD_class, (t_method)linkKD_setD, gensym("setD"), A_DEFFLOAT, 0);

+  class_addmethod(linkKD_class, (t_method)linkKD_setD2, gensym("setD2"), A_DEFFLOAT, 0);
+  class_addmethod(linkKD_class, (t_method)linkKD_setK, gensym("setK"), A_DEFFLOAT, 0);
+  class_addmethod(linkKD_class, (t_method)linkKD_setL, gensym("setL"), A_DEFFLOAT, 0);

+  class_addmethod(linkKD_class, (t_method)linkKD_Lmin, gensym("setLmin"), A_DEFFLOAT, 0);

+  class_addmethod(linkKD_class, (t_method)linkKD_Lmax, gensym("setLmax"), A_DEFFLOAT, 0);
 }
diff --git a/src/lia2D.c b/src/link2D.c
index ff5e0aa..318685d 100755
--- a/src/lia2D.c
+++ b/src/link2D.c
@@ -1,9 +1,9 @@
 #include "m_pd.h"

 #include "math.h"

 

-static t_class *lia2D_class;

+static t_class *link2D_class;

 

-typedef struct _lia2D {

+typedef struct _link2D {

   t_object  x_obj;

   t_float raideur, viscosite, D2, longueur, distance_old;

   t_float position2Dx1, position2Dx2, posx_old1, posx_old2;

@@ -12,21 +12,21 @@ typedef struct _lia2D {
   t_outlet *force1;

   t_outlet *force2;

   t_symbol *x_sym;  // receive

-} t_lia2D;

+} t_link2D;

 

-void lia2D_position2D(t_lia2D *x, t_floatarg f1, t_floatarg f2)

+void link2D_position2D(t_link2D *x, t_floatarg f1, t_floatarg f2)

 {

   x->position2Dx1 = f1;

   x->position2Dy1 = f2;

 }

 

-void lia2D_position2D2(t_lia2D *x, t_floatarg f1, t_floatarg f2)

+void link2D_position2D2(t_link2D *x, t_floatarg f1, t_floatarg f2)

 {

   x->position2Dx2 = f1;

   x->position2Dy2 = f2;

 }

 

-void lia2D_bang(t_lia2D *x)

+void link2D_bang(t_link2D *x)

 {

   t_float force, force2, forcex1, forcey1, forcex2, forcey2, distance;

   t_atom force1[2];

@@ -77,7 +77,7 @@ void lia2D_bang(t_lia2D *x)
   x->distance_old = distance;

 }

 

-void lia2D_reset(t_lia2D *x)

+void link2D_reset(t_link2D *x)

 {

   x->position2Dx1 = 0;

   x->position2Dx2 = 0;

@@ -92,7 +92,7 @@ void lia2D_reset(t_lia2D *x)
   x->distance_old = x->longueur;

 }

 

-void lia2D_resetF(t_lia2D *x)

+void link2D_resetF(t_link2D *x)

 {

 

   x->posx_old1 = x->position2Dx1;

@@ -105,56 +105,56 @@ void lia2D_resetF(t_lia2D *x)
 

 }

 

-void lia2D_resetL(t_lia2D *x)

+void link2D_resetL(t_link2D *x)

 {

   x->longueur = sqrt ( pow((x->position2Dx2-x->position2Dx1), 2) + pow((x->position2Dy2-x->position2Dy1), 2) );

 }

 

 

-void lia2D_setK(t_lia2D *x, t_float K)

+void link2D_setK(t_link2D *x, t_float K)

 {

   x->raideur = K;

 }

 

-void lia2D_setL(t_lia2D *x, t_float L)

+void link2D_setL(t_link2D *x, t_float L)

 {

   x->longueur = L;

 }

 

-void lia2D_setD(t_lia2D *x, t_float D)

+void link2D_setD(t_link2D *x, t_float D)

 {

   x->viscosite = D;

 }

 

-void lia2D_setD2(t_lia2D *x, t_float D)

+void link2D_setD2(t_link2D *x, t_float D)

 {

   x->D2 = D;

 }

 

-void lia2D_Lmin(t_lia2D *x, t_float Lmin)

+void link2D_Lmin(t_link2D *x, t_float Lmin)

 {

   x->Lmin = Lmin;

 }

 

-void lia2D_Lmax(t_lia2D *x, t_float Lmax)

+void link2D_Lmax(t_link2D *x, t_float Lmax)

 {

   x->Lmax = Lmax;

 }

 

-void lia2D_muscle(t_lia2D *x, t_float muscle)

+void link2D_muscle(t_link2D *x, t_float muscle)

 {

   x->muscle = muscle;

 }

 

-static void lia2D_free(t_lia2D *x)

+static void link2D_free(t_link2D *x)

 {

     pd_unbind(&x->x_obj.ob_pd, x->x_sym);

 }

 

-void *lia2D_new(t_symbol *s, t_floatarg l, t_floatarg K, t_floatarg D, t_floatarg D2)

+void *link2D_new(t_symbol *s, t_floatarg l, t_floatarg K, t_floatarg D, t_floatarg D2)

 {

   

-  t_lia2D *x = (t_lia2D *)pd_new(lia2D_class);

+  t_link2D *x = (t_link2D *)pd_new(link2D_class);

 

   x->x_sym = s;

   pd_bind(&x->x_obj.ob_pd, s);

@@ -184,30 +184,29 @@ void *lia2D_new(t_symbol *s, t_floatarg l, t_floatarg K, t_floatarg D, t_floatar
   return (x);

 }

 

-void lia2D_setup(void) 

+void link2D_setup(void) 

 {

 

-  lia2D_class = class_new(gensym("lia2D"),

-        (t_newmethod)lia2D_new,

-        (t_method)lia2D_free, 

-		sizeof(t_lia2D),

+  link2D_class = class_new(gensym("link2D"),

+        (t_newmethod)link2D_new,

+        (t_method)link2D_free, 

+		sizeof(t_link2D),

         CLASS_DEFAULT, A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

 

-  class_addcreator((t_newmethod)lia2D_new, gensym("link2D"), A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

-  class_addcreator((t_newmethod)lia2D_new, gensym("pmpd.link2D"), A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

-

-  class_addbang(lia2D_class, lia2D_bang);

-  class_addmethod(lia2D_class, (t_method)lia2D_reset, gensym("reset"), 0);

-  class_addmethod(lia2D_class, (t_method)lia2D_resetL, gensym("resetL"), 0);

-  class_addmethod(lia2D_class, (t_method)lia2D_resetF, gensym("resetF"), 0);

-  class_addmethod(lia2D_class, (t_method)lia2D_setD, gensym("setD"), A_DEFFLOAT, 0);

-  class_addmethod(lia2D_class, (t_method)lia2D_setD2, gensym("setD2"), A_DEFFLOAT, 0);

-  class_addmethod(lia2D_class, (t_method)lia2D_setK, gensym("setK"), A_DEFFLOAT, 0);

-  class_addmethod(lia2D_class, (t_method)lia2D_setL, gensym("setL"), A_DEFFLOAT, 0);

-  class_addmethod(lia2D_class, (t_method)lia2D_Lmin, gensym("setLmin"), A_DEFFLOAT, 0);

-  class_addmethod(lia2D_class, (t_method)lia2D_Lmax, gensym("setLmax"), A_DEFFLOAT, 0);

-  class_addmethod(lia2D_class, (t_method)lia2D_muscle, gensym("setM"), A_DEFFLOAT, 0);

-  class_addmethod(lia2D_class, (t_method)lia2D_position2D, gensym("position2D"), A_DEFFLOAT, A_DEFFLOAT, 0);

-  class_addmethod(lia2D_class, (t_method)lia2D_position2D2, gensym("position2D2"), A_DEFFLOAT, A_DEFFLOAT, 0);

+  class_addcreator((t_newmethod)link2D_new, gensym("lia2D"), A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);


+

+  class_addbang(link2D_class, link2D_bang);

+  class_addmethod(link2D_class, (t_method)link2D_reset, gensym("reset"), 0);

+  class_addmethod(link2D_class, (t_method)link2D_resetL, gensym("resetL"), 0);

+  class_addmethod(link2D_class, (t_method)link2D_resetF, gensym("resetF"), 0);

+  class_addmethod(link2D_class, (t_method)link2D_setD, gensym("setD"), A_DEFFLOAT, 0);

+  class_addmethod(link2D_class, (t_method)link2D_setD2, gensym("setD2"), A_DEFFLOAT, 0);

+  class_addmethod(link2D_class, (t_method)link2D_setK, gensym("setK"), A_DEFFLOAT, 0);

+  class_addmethod(link2D_class, (t_method)link2D_setL, gensym("setL"), A_DEFFLOAT, 0);

+  class_addmethod(link2D_class, (t_method)link2D_Lmin, gensym("setLmin"), A_DEFFLOAT, 0);

+  class_addmethod(link2D_class, (t_method)link2D_Lmax, gensym("setLmax"), A_DEFFLOAT, 0);

+  class_addmethod(link2D_class, (t_method)link2D_muscle, gensym("setM"), A_DEFFLOAT, 0);

+  class_addmethod(link2D_class, (t_method)link2D_position2D, gensym("position2D"), A_DEFFLOAT, A_DEFFLOAT, 0);

+  class_addmethod(link2D_class, (t_method)link2D_position2D2, gensym("position2D2"), A_DEFFLOAT, A_DEFFLOAT, 0);

 

 }

diff --git a/src/lia3D.c b/src/link3D.c
index 4621516..bbf0987 100755
--- a/src/lia3D.c
+++ b/src/link3D.c
@@ -1,9 +1,9 @@
 #include "m_pd.h"

 #include "math.h"

 

-static t_class *lia3D_class;

+static t_class *link3D_class;

 

-typedef struct _lia3D {

+typedef struct _link3D {

   t_object  x_obj;

   t_float raideur, viscosite, D2, longueur, distance_old;

   t_float position3Dx1, position3Dx2, posx_old1, posx_old2;

@@ -13,9 +13,9 @@ typedef struct _lia3D {
   t_outlet *force1;

   t_outlet *force2;

   t_symbol *x_sym;  // receive

-} t_lia3D;

+} t_link3D;

 

-void lia3D_position3D(t_lia3D *x, t_floatarg f1, t_floatarg f2, t_floatarg f3)

+void link3D_position3D(t_link3D *x, t_floatarg f1, t_floatarg f2, t_floatarg f3)

 {

   x->position3Dx1 = f1;

   x->position3Dy1 = f2;

@@ -23,14 +23,14 @@ void lia3D_position3D(t_lia3D *x, t_floatarg f1, t_floatarg f2, t_floatarg f3)
 

 }

 

-void lia3D_position3D2(t_lia3D *x, t_floatarg f1, t_floatarg f2, t_floatarg f3)

+void link3D_position3D2(t_link3D *x, t_floatarg f1, t_floatarg f2, t_floatarg f3)

 {

   x->position3Dx2 = f1;

   x->position3Dy2 = f2;

   x->position3Dz2 = f3;

 }

 

-void lia3D_bang(t_lia3D *x)

+void link3D_bang(t_link3D *x)

 {

   t_float force, force2, forcex1, forcey1, forcez1, forcex2, forcey2, forcez2, distance;

   t_atom force1[3];

@@ -91,7 +91,7 @@ void lia3D_bang(t_lia3D *x)
   x->distance_old = distance;

 }

 

-void lia3D_reset(t_lia3D *x)

+void link3D_reset(t_link3D *x)

 {

   x->position3Dx1 = 0;

   x->position3Dx2 = 0;

@@ -112,7 +112,7 @@ void lia3D_reset(t_lia3D *x)
 

 }

 

-void lia3D_resetF(t_lia3D *x)

+void link3D_resetF(t_link3D *x)

 {

 

   x->posx_old1 = x->position3Dx1;

@@ -128,55 +128,55 @@ void lia3D_resetF(t_lia3D *x)
 

 }

 

-void lia3D_resetL(t_lia3D *x)

+void link3D_resetL(t_link3D *x)

 {

   x->longueur = sqrt ( pow((x->position3Dx2-x->position3Dx1), 2) + pow((x->position3Dy2-x->position3Dy1),2) + pow((x->position3Dz2-x->position3Dz1), 2) );

 }

 

-void lia3D_setK(t_lia3D *x, t_float K)

+void link3D_setK(t_link3D *x, t_float K)

 {

   x->raideur = K;

 }

 

-void lia3D_setL(t_lia3D *x, t_float L)

+void link3D_setL(t_link3D *x, t_float L)

 {

   x->longueur = L;

 }

 

-void lia3D_setD(t_lia3D *x, t_float D)

+void link3D_setD(t_link3D *x, t_float D)

 {

   x->viscosite = D;

 }

 

-void lia3D_setD2(t_lia3D *x, t_float D2)

+void link3D_setD2(t_link3D *x, t_float D2)

 {

   x->D2 = D2;

 }

 

-void lia3D_Lmin(t_lia3D *x, t_float Lmin)

+void link3D_Lmin(t_link3D *x, t_float Lmin)

 {

   x->Lmin = Lmin;

 }

 

-void lia3D_Lmax(t_lia3D *x, t_float Lmax)

+void link3D_Lmax(t_link3D *x, t_float Lmax)

 {

   x->Lmax = Lmax;

 }

 

-void lia3D_muscle(t_lia3D *x, t_float muscle)

+void link3D_muscle(t_link3D *x, t_float muscle)

 {

   x->muscle = muscle;

 }

 

-static void lia3D_free(t_lia3D *x)

+static void link3D_free(t_link3D *x)

 {

     pd_unbind(&x->x_obj.ob_pd, x->x_sym);

 }

 

-void *lia3D_new(t_symbol *s, t_floatarg l, t_floatarg K, t_floatarg D, t_floatarg D2)

+void *link3D_new(t_symbol *s, t_floatarg l, t_floatarg K, t_floatarg D, t_floatarg D2)

 {

   

-  t_lia3D *x = (t_lia3D *)pd_new(lia3D_class);

+  t_link3D *x = (t_link3D *)pd_new(link3D_class);

 

   x->x_sym = s;

   pd_bind(&x->x_obj.ob_pd, s);

@@ -209,30 +209,29 @@ void *lia3D_new(t_symbol *s, t_floatarg l, t_floatarg K, t_floatarg D, t_floatar
   return (void *)x;

 }

 

-void lia3D_setup(void) 

+void link3D_setup(void) 

 {

 

-  lia3D_class = class_new(gensym("lia3D"),

-        (t_newmethod)lia3D_new,

-        (t_method)lia3D_free,

-		sizeof(t_lia3D),

+  link3D_class = class_new(gensym("link3D"),

+        (t_newmethod)link3D_new,

+        (t_method)link3D_free,

+		sizeof(t_link3D),

         CLASS_DEFAULT, A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT,  A_DEFFLOAT, 0);

 

-  class_addcreator((t_newmethod)lia3D_new, gensym("link3D"), A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

-  class_addcreator((t_newmethod)lia3D_new, gensym("pmpd.link3D"), A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

-

-  class_addbang(lia3D_class, lia3D_bang);

-  class_addmethod(lia3D_class, (t_method)lia3D_reset, gensym("reset"), 0);

-  class_addmethod(lia3D_class, (t_method)lia3D_resetL, gensym("resetL"), 0);

-  class_addmethod(lia3D_class, (t_method)lia3D_resetF, gensym("resetF"), 0);

-  class_addmethod(lia3D_class, (t_method)lia3D_setD, gensym("setD"), A_DEFFLOAT, 0);

-  class_addmethod(lia3D_class, (t_method)lia3D_setD2, gensym("setD2"), A_DEFFLOAT, 0);

-  class_addmethod(lia3D_class, (t_method)lia3D_setK, gensym("setK"), A_DEFFLOAT, 0);

-  class_addmethod(lia3D_class, (t_method)lia3D_setL, gensym("setL"), A_DEFFLOAT, 0);

-  class_addmethod(lia3D_class, (t_method)lia3D_Lmin, gensym("setLmin"), A_DEFFLOAT, 0);

-  class_addmethod(lia3D_class, (t_method)lia3D_Lmax, gensym("setLmax"), A_DEFFLOAT, 0);

-  class_addmethod(lia3D_class, (t_method)lia3D_muscle, gensym("setM"), A_DEFFLOAT, 0);

-  class_addmethod(lia3D_class, (t_method)lia3D_position3D, gensym("position3D"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

-  class_addmethod(lia3D_class, (t_method)lia3D_position3D2, gensym("position3D2"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

+  class_addcreator((t_newmethod)link3D_new, gensym("lia3D"), A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

+

+  class_addbang(link3D_class, link3D_bang);

+  class_addmethod(link3D_class, (t_method)link3D_reset, gensym("reset"), 0);

+  class_addmethod(link3D_class, (t_method)link3D_resetL, gensym("resetL"), 0);

+  class_addmethod(link3D_class, (t_method)link3D_resetF, gensym("resetF"), 0);

+  class_addmethod(link3D_class, (t_method)link3D_setD, gensym("setD"), A_DEFFLOAT, 0);

+  class_addmethod(link3D_class, (t_method)link3D_setD2, gensym("setD2"), A_DEFFLOAT, 0);

+  class_addmethod(link3D_class, (t_method)link3D_setK, gensym("setK"), A_DEFFLOAT, 0);

+  class_addmethod(link3D_class, (t_method)link3D_setL, gensym("setL"), A_DEFFLOAT, 0);

+  class_addmethod(link3D_class, (t_method)link3D_Lmin, gensym("setLmin"), A_DEFFLOAT, 0);

+  class_addmethod(link3D_class, (t_method)link3D_Lmax, gensym("setLmax"), A_DEFFLOAT, 0);

+  class_addmethod(link3D_class, (t_method)link3D_muscle, gensym("setM"), A_DEFFLOAT, 0);

+  class_addmethod(link3D_class, (t_method)link3D_position3D, gensym("position3D"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

+  class_addmethod(link3D_class, (t_method)link3D_position3D2, gensym("position3D2"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

 

 }

diff --git a/src/masse.c b/src/mass.c
index fccee2b..de1a331 100755
--- a/src/masse.c
+++ b/src/mass.c
@@ -1,19 +1,23 @@
 #include "m_pd.h"
 #include "math.h"
 
-static t_class *masse_class;
+#define max(a,b) ( ((a) > (b)) ? (a) : (b) ) 

+#define min(a,b) ( ((a) < (b)) ? (a) : (b) ) 

 
-typedef struct _masse {
+
+static t_class *mass_class;
+
+typedef struct _mass {
   t_object  x_obj;
   t_float pos_old_1, pos_old_2, Xinit;
-  t_float force, masse, dX;
+  t_float force, mass, dX;
   t_float minX, maxX;
   t_outlet *position_new, *vitesse_out, *force_out;

   t_symbol *x_sym; // receive

   unsigned int x_state; // random

   t_float x_f; // random

 
-} t_masse;
+} t_mass;
 

 static int makeseed(void)

 {

@@ -22,7 +26,7 @@ static int makeseed(void)
     return (random_nextseed & 0x7fffffff);

 }

 

-static float random_bang(t_masse *x)

+static float random_bang(t_mass *x)

 {

     int nval;

     int range = 2000000;

@@ -40,27 +44,27 @@ static float random_bang(t_masse *x)
     return (rnd);

 }

 
-void masse_minX(t_masse *x, t_floatarg f1)
+void mass_minX(t_mass *x, t_floatarg f1)
 {
   x->minX = f1;
 }
 
-void masse_maxX(t_masse *x, t_floatarg f1)
+void mass_maxX(t_mass *x, t_floatarg f1)
 {
   x->maxX = f1;
 }
 
-void masse_float(t_masse *x, t_floatarg f1)
+void mass_float(t_mass *x, t_floatarg f1)
 {
   x->force += f1;
 }
 
-void masse_bang(t_masse *x)
+void mass_bang(t_mass *x)
 {
   t_float pos_new;
 
-	if (x->masse > 0)
-  pos_new = x->force/x->masse + 2*x->pos_old_1 - x->pos_old_2;
+	if (x->mass > 0)
+  pos_new = x->force/x->mass + 2*x->pos_old_1 - x->pos_old_2;
 	else pos_new = x->pos_old_1;
 
   pos_new = max(min(x->maxX, pos_new), x->minX);

@@ -84,7 +88,7 @@ void masse_bang(t_masse *x)
 
 }
 
-void masse_reset(t_masse *x)

+void mass_reset(t_mass *x)

 {

   x->pos_old_2 = x->Xinit;

   x->pos_old_1 = x->Xinit;

@@ -94,18 +98,18 @@ void masse_reset(t_masse *x)
   outlet_float(x->position_new, x->Xinit);

 }

 

-void masse_resetF(t_masse *x)

+void mass_resetF(t_mass *x)

 {

   x->force=0;

 

 }
 
-void masse_dX(t_masse *x, t_float posX)

+void mass_dX(t_mass *x, t_float posX)

 {

   x->dX += posX;

 }

 

-void masse_setX(t_masse *x, t_float posX)

+void mass_setX(t_mass *x, t_float posX)

 {

   x->pos_old_2 = posX;			// clear history for stability (instability) problem

   x->pos_old_1 = posX;

@@ -115,25 +119,25 @@ void masse_setX(t_masse *x, t_float posX)
   outlet_float(x->position_new, posX);

 }

 

-void masse_loadbang(t_masse *x)

+void mass_loadbang(t_mass *x)

 {

   outlet_float(x->position_new, x->Xinit);

 }

 
-void masse_set_masse(t_masse *x, t_float mass)
+void mass_set_mass(t_mass *x, t_float mass)
 {
-  x->masse=mass;
+  x->mass=mass;
 }
 

-static void masse_free(t_masse *x)

+static void mass_free(t_mass *x)

 {

     pd_unbind(&x->x_obj.ob_pd, x->x_sym);

 }

 
-void *masse_new(t_symbol *s, t_floatarg M, t_floatarg X)
+void *mass_new(t_symbol *s, t_floatarg M, t_floatarg X)
 {
   
-  t_masse *x = (t_masse *)pd_new(masse_class);
+  t_mass *x = (t_mass *)pd_new(mass_class);
 

   x->x_sym = s;

   pd_bind(&x->x_obj.ob_pd, s);

@@ -147,37 +151,36 @@ void *masse_new(t_symbol *s, t_floatarg M, t_floatarg X)
   x->pos_old_1 = X;
   x->pos_old_2 = X;
   x->force=0;
-  x->masse=M;
+  x->mass=M;
 
   x->minX = -100000;
   x->maxX = 100000;
 
-  if (x->masse<=0) x->masse=1;

+  if (x->mass<=0) x->mass=1;

 

   makeseed();

 
   return (void *)x;
 }
 
-void masse_setup(void) 
+void mass_setup(void) 
 {
 
-  masse_class = class_new(gensym("masse"),
-        (t_newmethod)masse_new,
-        (t_method)masse_free,

-		sizeof(t_masse),
+  mass_class = class_new(gensym("mass"),
+        (t_newmethod)mass_new,
+        (t_method)mass_free,

+		sizeof(t_mass),
         CLASS_DEFAULT, A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT,0);

-  class_addcreator((t_newmethod)masse_new, gensym("mass"), A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT,0);

-  class_addcreator((t_newmethod)masse_new, gensym("pmpd.mass"), A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT,0);
-  class_addfloat(masse_class, masse_float);
-  class_addbang(masse_class, masse_bang);
-  class_addmethod(masse_class, (t_method)masse_set_masse, gensym("setM"), A_DEFFLOAT, 0);
-  class_addmethod(masse_class, (t_method)masse_setX, gensym("setX"), A_DEFFLOAT, 0);

-  class_addmethod(masse_class, (t_method)masse_dX, gensym("dX"), A_DEFFLOAT, 0);

-  class_addmethod(masse_class, (t_method)masse_reset, gensym("reset"), 0);

-  class_addmethod(masse_class, (t_method)masse_resetF, gensym("resetF"), 0);

-  class_addmethod(masse_class, (t_method)masse_minX, gensym("setXmin"), A_DEFFLOAT, 0);
-  class_addmethod(masse_class, (t_method)masse_maxX, gensym("setXmax"), A_DEFFLOAT, 0);
-  class_addmethod(masse_class, (t_method)masse_loadbang, gensym("loadbang"), 0);
+  class_addcreator((t_newmethod)mass_new, gensym("masse"), A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT,0);

+  class_addfloat(mass_class, mass_float);
+  class_addbang(mass_class, mass_bang);
+  class_addmethod(mass_class, (t_method)mass_set_mass, gensym("setM"), A_DEFFLOAT, 0);
+  class_addmethod(mass_class, (t_method)mass_setX, gensym("setX"), A_DEFFLOAT, 0);

+  class_addmethod(mass_class, (t_method)mass_dX, gensym("dX"), A_DEFFLOAT, 0);

+  class_addmethod(mass_class, (t_method)mass_reset, gensym("reset"), 0);

+  class_addmethod(mass_class, (t_method)mass_resetF, gensym("resetF"), 0);

+  class_addmethod(mass_class, (t_method)mass_minX, gensym("setXmin"), A_DEFFLOAT, 0);
+  class_addmethod(mass_class, (t_method)mass_maxX, gensym("setXmax"), A_DEFFLOAT, 0);
+  class_addmethod(mass_class, (t_method)mass_loadbang, gensym("loadbang"), 0);
 }
 

diff --git a/src/masse2D.c b/src/mass2D.c
index 7064cf8..bea7cd7 100755
--- a/src/masse2D.c
+++ b/src/mass2D.c
@@ -1,20 +1,23 @@
 #include "m_pd.h"

 #include "math.h"

+
+#define max(a,b) ( ((a) > (b)) ? (a) : (b) ) 

+#define min(a,b) ( ((a) < (b)) ? (a) : (b) ) 

 

-static t_class *masse2D_class;

+static t_class *mass2D_class;

 

-typedef struct _masse2D {

+typedef struct _mass2D {

   t_object  x_obj;

   t_float posX_old_1, posX_old_2, posY_old_1, posY_old_2, Xinit, Yinit;

   t_float forceX, forceY, VX, VY, dX, dY, onoff;

-  t_float masse2D, seuil, damp;

+  t_float mass2D, seuil, damp;

   t_float minX, maxX, minY, maxY;

   t_atom  pos_new[2], vitesse[3], force[3];

   t_outlet *position2D_new, *vitesse_out, *force_out;

   t_symbol *x_sym; // receive

   unsigned int x_state; // random

   t_float x_f; // random

-} t_masse2D;

+} t_mass2D;

 

 static int makeseed2D(void)

 {

@@ -23,7 +26,7 @@ static int makeseed2D(void)
     return (random_nextseed & 0x7fffffff);

 }

 

-static float random_bang2D(t_masse2D *x)

+static float random_bang2D(t_mass2D *x)

 {

     int nval;

     int range = 2000000;

@@ -41,69 +44,69 @@ static float random_bang2D(t_masse2D *x)
     return (rnd);

 }

 

-void masse2D_seuil(t_masse2D *x, t_floatarg f1)

+void mass2D_seuil(t_mass2D *x, t_floatarg f1)

 {

   x->seuil = f1;

 }

 

-void masse2D_on(t_masse2D *x)

+void mass2D_on(t_mass2D *x)

 {

   x->onoff = 1;

 }

 

-void masse2D_off(t_masse2D *x)

+void mass2D_off(t_mass2D *x)

 {

   x->onoff = 0;

 }

 

-void masse2D_minX(t_masse2D *x, t_floatarg f1)

+void mass2D_minX(t_mass2D *x, t_floatarg f1)

 {

   x->minX = f1;

 }

 

-void masse2D_maxX(t_masse2D *x, t_floatarg f1)

+void mass2D_maxX(t_mass2D *x, t_floatarg f1)

 {

   x->maxX = f1;

 }

 

-void masse2D_minY(t_masse2D *x, t_floatarg f1)

+void mass2D_minY(t_mass2D *x, t_floatarg f1)

 {

   x->minY = f1;

 }

 

-void masse2D_maxY(t_masse2D *x, t_floatarg f1)

+void mass2D_maxY(t_mass2D *x, t_floatarg f1)

 {

   x->maxY = f1;

 }

 

-void masse2D_force(t_masse2D *x, t_floatarg f1, t_floatarg f2)

+void mass2D_force(t_mass2D *x, t_floatarg f1, t_floatarg f2)

 {

   x->forceX = x->forceX+f1;

   x->forceY = x->forceY+f2;

 }

 

-void masse2D_displace(t_masse2D *x, t_floatarg f1, t_floatarg f2)

+void mass2D_displace(t_mass2D *x, t_floatarg f1, t_floatarg f2)

 {

   x->dX += f1;

   x->dY += f2;

 }

 

-void masse2D_damp(t_masse2D *x, t_floatarg f1)

+void mass2D_damp(t_mass2D *x, t_floatarg f1)

 {

   x->damp = f1;

 }

 

-void masse2D_dX(t_masse2D *x, t_floatarg f1)

+void mass2D_dX(t_mass2D *x, t_floatarg f1)

 {

   x->dX += f1;

 }

 

-void masse2D_dY(t_masse2D *x, t_floatarg f1)

+void mass2D_dY(t_mass2D *x, t_floatarg f1)

 {

   x->dY += f1;

 }

 

-void masse2D_bang(t_masse2D *x)

+void mass2D_bang(t_mass2D *x)

 {

   t_float posX_new, posY_new, vX=1, vY=1;

  if (x->onoff != 0)

@@ -139,10 +142,10 @@ void masse2D_bang(t_masse2D *x)
  	x->forceX += x->damp * ((x->posX_old_2)-(x->posX_old_1));

 	x->forceY += x->damp * ((x->posY_old_2)-(x->posY_old_1)); // damping

 

-  if (x->masse2D != 0)

+  if (x->mass2D != 0)

   {

-	  posX_new = x->forceX/x->masse2D + 2*x->posX_old_1 - x->posX_old_2;

-  	  posY_new = x->forceY/x->masse2D + 2*x->posY_old_1 - x->posY_old_2;

+	  posX_new = x->forceX/x->mass2D + 2*x->posX_old_1 - x->posX_old_2;

+  	  posY_new = x->forceY/x->mass2D + 2*x->posY_old_1 - x->posY_old_2;

   }

   else 

   {

@@ -200,7 +203,7 @@ void masse2D_bang(t_masse2D *x)
  }

 }

 

-void masse2D_reset(t_masse2D *x)

+void mass2D_reset(t_mass2D *x)

 {

   x->posX_old_2 = x->Xinit;

   x->posX_old_1 = x->Xinit;

@@ -236,7 +239,7 @@ void masse2D_reset(t_masse2D *x)
   outlet_anything(x->position2D_new, gensym("position2D"), 2, x->pos_new);

 }

 

-void masse2D_resetf(t_masse2D *x)

+void mass2D_resetf(t_mass2D *x)

 {

   x->dX=0;

   x->dY=0;

@@ -245,7 +248,7 @@ void masse2D_resetf(t_masse2D *x)
   x->forceY=0;

 }

 

-void masse2D_setXY(t_masse2D *x, t_float posX, t_float posY)

+void mass2D_setXY(t_mass2D *x, t_float posX, t_float posY)

 {

   x->posX_old_2 = posX;

   x->posX_old_1 = posX;

@@ -261,7 +264,7 @@ void masse2D_setXY(t_masse2D *x, t_float posX, t_float posY)
   outlet_anything(x->position2D_new, gensym("position2D"), 2, x->pos_new);

 }

 

-void masse2D_setX(t_masse2D *x, t_float posX)

+void mass2D_setX(t_mass2D *x, t_float posX)

 {

   x->posX_old_2 = posX;

   x->posX_old_1 = posX;

@@ -272,7 +275,7 @@ void masse2D_setX(t_masse2D *x, t_float posX)
   outlet_anything(x->position2D_new, gensym("position2D"), 2, x->pos_new);

 }

 

-void masse2D_setY(t_masse2D *x, t_float posY)

+void mass2D_setY(t_mass2D *x, t_float posY)

 {

   x->posY_old_2 = posY;

   x->posY_old_1 = posY;

@@ -283,18 +286,18 @@ void masse2D_setY(t_masse2D *x, t_float posY)
   outlet_anything(x->position2D_new, gensym("position2D"), 2, x->pos_new);

 }

 

-void masse2D_loadbang(t_masse2D *x)

+void mass2D_loadbang(t_mass2D *x)

 {

   outlet_anything(x->position2D_new, gensym("position2D"), 2, x->pos_new);

 }

 

 

-void masse2D_set_masse2D(t_masse2D *x, t_float mass)

+void mass2D_set_mass2D(t_mass2D *x, t_float mass)

 {

-  x->masse2D=mass;

+  x->mass2D=mass;

 }

 

-void masse2D_inter_ambient(t_masse2D *x, t_symbol *s, int argc, t_atom *argv)

+void mass2D_inter_ambient(t_mass2D *x, t_symbol *s, int argc, t_atom *argv)

 {

 	if (argc == 12) 

 		// 0 : FX

@@ -340,7 +343,7 @@ void masse2D_inter_ambient(t_masse2D *x, t_symbol *s, int argc, t_atom *argv)
 	}

 }

 

-void masse2D_inter_seg(t_masse2D *x, t_symbol *s, int argc, t_atom *argv)

+void mass2D_inter_seg(t_mass2D *x, t_symbol *s, int argc, t_atom *argv)

 {

 t_float a1, b1, c1, a2, b2, c2, a3, b3, c3, tmp;

 t_float posx1, posx2, posy1, posy2;

@@ -441,7 +444,7 @@ t_float profondeur, prof_max;
 	}

 }

 

-void masse2D_inter_line(t_masse2D *x, t_symbol *s, int argc, t_atom *argv)

+void mass2D_inter_line(t_mass2D *x, t_symbol *s, int argc, t_atom *argv)

 {

 t_float a1, b1, c1, tmp;

 t_float posx1, posx2, posy1, posy2;

@@ -518,7 +521,7 @@ t_float profondeur, prof_max;
 	}

 }

 

-void masse2D_inter_circle(t_masse2D *x, t_symbol *s, int argc, t_atom *argv)

+void mass2D_inter_circle(t_mass2D *x, t_symbol *s, int argc, t_atom *argv)

 {

 t_float posx1, posy1, Nx, Ny, dx, dy, distance, Dmax, tmp;

 t_float deltaX_old, deltaY_old, distance_old ;

@@ -681,10 +684,10 @@ t_float ftx=0, fty=0;
 	}

 }

 

-void *masse2D_new(t_symbol *s, int argc, t_atom *argv)

+void *mass2D_new(t_symbol *s, int argc, t_atom *argv)

 {

  

-  t_masse2D *x = (t_masse2D *)pd_new(masse2D_class);

+  t_mass2D *x = (t_mass2D *)pd_new(mass2D_class);

 

   x->x_sym = atom_getsymbolarg(0, argc, argv);

   x->x_state = makeseed2D();

@@ -699,9 +702,9 @@ void *masse2D_new(t_symbol *s, int argc, t_atom *argv)
   x->forceY=0;

 

   if (argc >= 2)

-    x->masse2D = atom_getfloatarg(1, argc, argv) ;

+    x->mass2D = atom_getfloatarg(1, argc, argv) ;

   else

-    x->masse2D = 1;

+    x->mass2D = 1;

 

   x->onoff = 1;

 

@@ -762,48 +765,47 @@ void *masse2D_new(t_symbol *s, int argc, t_atom *argv)
   return (x);

 }

 

-static void masse2D_free(t_masse2D *x)

+static void mass2D_free(t_mass2D *x)

 {

     pd_unbind(&x->x_obj.ob_pd, x->x_sym);

 }

 

-void masse2D_setup(void) 

+void mass2D_setup(void) 

 {

 

-  masse2D_class = class_new(gensym("masse2D"),

-        (t_newmethod)masse2D_new,

-        (t_method)masse2D_free, sizeof(t_masse2D),

+  mass2D_class = class_new(gensym("mass2D"),

+        (t_newmethod)mass2D_new,

+        (t_method)mass2D_free, sizeof(t_mass2D),

         CLASS_DEFAULT, A_GIMME, 0);

 

-  class_addcreator((t_newmethod)masse2D_new, gensym("mass2D"), A_GIMME, 0);

-  class_addcreator((t_newmethod)masse2D_new, gensym("pmpd.mass2D"), A_GIMME, 0);

-

-  class_addbang(masse2D_class, masse2D_bang);

-

-  class_addmethod(masse2D_class, (t_method)masse2D_force, gensym("force2D"),A_DEFFLOAT, A_DEFFLOAT, 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_displace, gensym("dXY"),A_DEFFLOAT, A_DEFFLOAT, 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_dX, gensym("dX"),A_DEFFLOAT, 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_dY, gensym("dY"),A_DEFFLOAT, 0);

-

-  class_addmethod(masse2D_class, (t_method)masse2D_inter_ambient, gensym("interactor_ambient_2D"), A_GIMME, 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_inter_line, gensym("interactor_line_2D"), A_GIMME, 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_inter_seg, gensym("interactor_segment_2D"), A_GIMME, 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_inter_circle, gensym("interactor_circle_2D"), A_GIMME, 0);

-

-  class_addmethod(masse2D_class, (t_method)masse2D_seuil, gensym("setT"), A_DEFFLOAT, 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_set_masse2D, gensym("setM"), A_DEFFLOAT, 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_setX, gensym("setX"), A_DEFFLOAT, 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_setY, gensym("setY"), A_DEFFLOAT, 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_minX, gensym("setXmin"), A_DEFFLOAT, 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_minY, gensym("setYmin"), A_DEFFLOAT, 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_maxX, gensym("setXmax"), A_DEFFLOAT, 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_maxY, gensym("setYmax"), A_DEFFLOAT, 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_setXY, gensym("setXY"), A_DEFFLOAT, A_DEFFLOAT, 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_damp, gensym("setD"), A_DEFFLOAT, 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_on, gensym("on"), 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_off, gensym("off"), 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_reset, gensym("reset"), 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_resetf, gensym("resetF"), 0);

-  class_addmethod(masse2D_class, (t_method)masse2D_loadbang, gensym("loadbang"), 0);

+  class_addcreator((t_newmethod)mass2D_new, gensym("masse2D"), A_GIMME, 0);

+

+  class_addbang(mass2D_class, mass2D_bang);

+

+  class_addmethod(mass2D_class, (t_method)mass2D_force, gensym("force2D"),A_DEFFLOAT, A_DEFFLOAT, 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_displace, gensym("dXY"),A_DEFFLOAT, A_DEFFLOAT, 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_dX, gensym("dX"),A_DEFFLOAT, 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_dY, gensym("dY"),A_DEFFLOAT, 0);

+

+  class_addmethod(mass2D_class, (t_method)mass2D_inter_ambient, gensym("interactor_ambient_2D"), A_GIMME, 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_inter_line, gensym("interactor_line_2D"), A_GIMME, 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_inter_seg, gensym("interactor_segment_2D"), A_GIMME, 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_inter_circle, gensym("interactor_circle_2D"), A_GIMME, 0);

+

+  class_addmethod(mass2D_class, (t_method)mass2D_seuil, gensym("setT"), A_DEFFLOAT, 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_set_mass2D, gensym("setM"), A_DEFFLOAT, 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_setX, gensym("setX"), A_DEFFLOAT, 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_setY, gensym("setY"), A_DEFFLOAT, 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_minX, gensym("setXmin"), A_DEFFLOAT, 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_minY, gensym("setYmin"), A_DEFFLOAT, 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_maxX, gensym("setXmax"), A_DEFFLOAT, 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_maxY, gensym("setYmax"), A_DEFFLOAT, 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_setXY, gensym("setXY"), A_DEFFLOAT, A_DEFFLOAT, 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_damp, gensym("setD"), A_DEFFLOAT, 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_on, gensym("on"), 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_off, gensym("off"), 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_reset, gensym("reset"), 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_resetf, gensym("resetF"), 0);

+  class_addmethod(mass2D_class, (t_method)mass2D_loadbang, gensym("loadbang"), 0);

 

 }

diff --git a/src/masse3D.c b/src/mass3D.c
index c254102..e8e362b 100755
--- a/src/masse3D.c
+++ b/src/mass3D.c
@@ -1,20 +1,23 @@
 #include "m_pd.h"

 #include "math.h"

+
+#define max(a,b) ( ((a) > (b)) ? (a) : (b) ) 

+#define min(a,b) ( ((a) < (b)) ? (a) : (b) ) 

 

-static t_class *masse3D_class;

+static t_class *mass3D_class;

 

-typedef struct _masse3D {

+typedef struct _mass3D {

   t_object  x_obj;

   t_float posX_old_1, posX_old_2, posY_old_1, posY_old_2, posZ_old_1, posZ_old_2;

   t_float Xinit, Yinit, Zinit, forceX, forceY, forceZ, VX, VY, VZ, dX, dY, dZ;

-  t_float masse3D, seuil, onoff, damp;

+  t_float mass3D, seuil, onoff, damp;

   t_atom  pos_new[3], vitesse[4], force[4];

   t_float minX, maxX, minY, maxY, minZ, maxZ;

   t_outlet *position3D_new, *vitesse_out, *force_out;

   t_symbol *x_sym; // receive

   unsigned int x_state; // random

   t_float x_f; // random

-} t_masse3D;

+} t_mass3D;

 

 static int makeseed3D(void)

 {

@@ -23,7 +26,7 @@ static int makeseed3D(void)
     return (random_nextseed & 0x7fffffff);

 }

 

-static float random_bang3D(t_masse3D *x)

+static float random_bang3D(t_mass3D *x)

 {

     int nval;

     int range = 2000000;

@@ -41,62 +44,62 @@ static float random_bang3D(t_masse3D *x)
     return (rnd);

 }

 

-void masse3D_on(t_masse3D *x)

+void mass3D_on(t_mass3D *x)

 {

   x->onoff = 1;

 }

 

-void masse3D_off(t_masse3D *x)

+void mass3D_off(t_mass3D *x)

 {

   x->onoff = 0;

 }

 

-void masse3D_minX(t_masse3D *x, t_floatarg f1)

+void mass3D_minX(t_mass3D *x, t_floatarg f1)

 {

   x->minX = f1;

 }

 

-void masse3D_maxX(t_masse3D *x, t_floatarg f1)

+void mass3D_maxX(t_mass3D *x, t_floatarg f1)

 {

   x->maxX = f1;

 }

 

-void masse3D_minY(t_masse3D *x, t_floatarg f1)

+void mass3D_minY(t_mass3D *x, t_floatarg f1)

 {

   x->minY = f1;

 }

 

-void masse3D_maxY(t_masse3D *x, t_floatarg f1)

+void mass3D_maxY(t_mass3D *x, t_floatarg f1)

 {

   x->maxY = f1;

 }

 

-void masse3D_minZ(t_masse3D *x, t_floatarg f1)

+void mass3D_minZ(t_mass3D *x, t_floatarg f1)

 {

   x->minZ = f1;

 }

 

-void masse3D_maxZ(t_masse3D *x, t_floatarg f1)

+void mass3D_maxZ(t_mass3D *x, t_floatarg f1)

 {

   x->maxZ = f1;

 }

 

-void masse3D_seuil(t_masse3D *x, t_floatarg f1)

+void mass3D_seuil(t_mass3D *x, t_floatarg f1)

 {

   x->seuil = f1;

 }

 

-void masse3D_damp(t_masse3D *x, t_floatarg f1)

+void mass3D_damp(t_mass3D *x, t_floatarg f1)

 {

   x->damp = f1;

 }

 

-void masse3D_loadbang(t_masse3D *x, t_float posZ)

+void mass3D_loadbang(t_mass3D *x, t_float posZ)

 {

   outlet_anything(x->position3D_new, gensym("position3D"), 3, x->pos_new);

 }

 

-void masse3D_setX(t_masse3D *x, t_float posX)

+void mass3D_setX(t_mass3D *x, t_float posX)

 {

   

   x->posX_old_2 = posX;

@@ -109,7 +112,7 @@ void masse3D_setX(t_masse3D *x, t_float posX)
 

 }

 

-void masse3D_setY(t_masse3D *x, t_float posY)

+void mass3D_setY(t_mass3D *x, t_float posY)

 {

   x->posY_old_2 = posY;

   x->posY_old_1 = posY;

@@ -121,7 +124,7 @@ void masse3D_setY(t_masse3D *x, t_float posY)
 

 }

 

-void masse3D_setZ(t_masse3D *x, t_float posZ)

+void mass3D_setZ(t_mass3D *x, t_float posZ)

 {

   x->posZ_old_2 = posZ;

   x->posZ_old_1 = posZ;

@@ -133,7 +136,7 @@ void masse3D_setZ(t_masse3D *x, t_float posZ)
 

 }

 

-void masse3D_setXYZ(t_masse3D *x, t_float posX, t_float posY, t_float posZ)

+void mass3D_setXYZ(t_mass3D *x, t_float posX, t_float posY, t_float posZ)

 {

   

   x->posX_old_2 = posX;

@@ -155,42 +158,42 @@ void masse3D_setXYZ(t_masse3D *x, t_float posX, t_float posY, t_float posZ)
   outlet_anything(x->position3D_new, gensym("position3D"), 3, x->pos_new);

 }

 

-void masse3D_set_masse3D(t_masse3D *x, t_float mass)

+void mass3D_set_mass3D(t_mass3D *x, t_float mass)

 {

-  x->masse3D=mass;

+  x->mass3D=mass;

 }

 

 

-void masse3D_force(t_masse3D *x, t_floatarg f1, t_floatarg f2, t_floatarg f3)

+void mass3D_force(t_mass3D *x, t_floatarg f1, t_floatarg f2, t_floatarg f3)

 {

   x->forceX += f1;

   x->forceY += f2;

   x->forceZ += f3;

 }

 

-void masse3D_dXYZ(t_masse3D *x, t_floatarg f1, t_floatarg f2, t_floatarg f3)

+void mass3D_dXYZ(t_mass3D *x, t_floatarg f1, t_floatarg f2, t_floatarg f3)

 {

   x->dX += f1;

   x->dY += f2;

   x->dZ += f3;

 }

 

-void masse3D_dX(t_masse3D *x, t_floatarg f1 )

+void mass3D_dX(t_mass3D *x, t_floatarg f1 )

 {

   x->dX += f1;

 }

 

-void masse3D_dY(t_masse3D *x, t_floatarg f1 )

+void mass3D_dY(t_mass3D *x, t_floatarg f1 )

 {

   x->dY += f1;

 }

 

-void masse3D_dZ(t_masse3D *x, t_floatarg f1 )

+void mass3D_dZ(t_mass3D *x, t_floatarg f1 )

 {

   x->dZ += f1;

 }

 

-void masse3D_bang(t_masse3D *x)

+void mass3D_bang(t_mass3D *x)

 {

   t_float posX_new, posY_new, posZ_new, vX=1, vY=1, vZ=1;

  if (x->onoff != 0)

@@ -257,11 +260,11 @@ void masse3D_bang(t_masse3D *x)
 	x->forceY += x->damp * ((x->posY_old_2)-(x->posY_old_1)); // damping

 	x->forceZ += x->damp * ((x->posZ_old_2)-(x->posZ_old_1)); // damping

 

-  if (!(x->masse3D == 0))

+  if (!(x->mass3D == 0))

   {

-  posX_new = x->forceX/x->masse3D + 2*x->posX_old_1 - x->posX_old_2;

-  posY_new = x->forceY/x->masse3D + 2*x->posY_old_1 - x->posY_old_2;

-  posZ_new = x->forceZ/x->masse3D + 2*x->posZ_old_1 - x->posZ_old_2;

+  posX_new = x->forceX/x->mass3D + 2*x->posX_old_1 - x->posX_old_2;

+  posY_new = x->forceY/x->mass3D + 2*x->posY_old_1 - x->posY_old_2;

+  posZ_new = x->forceZ/x->mass3D + 2*x->posZ_old_1 - x->posZ_old_2;

   }

   else 

   {

@@ -337,7 +340,7 @@ void masse3D_bang(t_masse3D *x)
  }

 }

 

-void masse3D_reset(t_masse3D *x)

+void mass3D_reset(t_mass3D *x)

 {

   

   x->posX_old_2 = x->Xinit;

@@ -385,7 +388,7 @@ void masse3D_reset(t_masse3D *x)
 }

 

 

-void masse3D_resetf(t_masse3D *x)

+void mass3D_resetf(t_mass3D *x)

 {

   x->forceX=0;

   x->forceY=0;

@@ -396,7 +399,7 @@ void masse3D_resetf(t_masse3D *x)
   x->dZ=0;

 }

 

-void masse3D_inter_ambient(t_masse3D *x, t_symbol *s, int argc, t_atom *argv)

+void mass3D_inter_ambient(t_mass3D *x, t_symbol *s, int argc, t_atom *argv)

 {

 	t_float tmp;

 

@@ -463,7 +466,7 @@ void masse3D_inter_ambient(t_masse3D *x, t_symbol *s, int argc, t_atom *argv)
 	}

 }

 

-void masse3D_inter_plane(t_masse3D *x, t_symbol *s, int argc, t_atom *argv)

+void mass3D_inter_plane(t_mass3D *x, t_symbol *s, int argc, t_atom *argv)

 {

 	t_float a, b, c, d, profondeur, distance, tmp, profondeur_old;

 

@@ -559,7 +562,7 @@ void masse3D_inter_plane(t_masse3D *x, t_symbol *s, int argc, t_atom *argv)
 }

 

 

-void masse3D_inter_sphere(t_masse3D *x, t_symbol *s, int argc, t_atom *argv)

+void mass3D_inter_sphere(t_mass3D *x, t_symbol *s, int argc, t_atom *argv)

 {

 t_float posx1, posy1, posz1, Nx, Ny, Nz, dx, dy, dz, distance, Dmax, tmp;

 t_float deltaX_old, deltaY_old, deltaZ_old, distance_old ;

@@ -673,7 +676,7 @@ t_float deltaX_old, deltaY_old, deltaZ_old, distance_old ;
 }

 

 

-void masse3D_inter_circle(t_masse3D *x, t_symbol *s, int argc, t_atom *argv)

+void mass3D_inter_circle(t_mass3D *x, t_symbol *s, int argc, t_atom *argv)

 {

 	t_float a, b, c, d, profondeur, distance, tmp, profondeur_old, rayon, rayon_old;

 

@@ -766,7 +769,7 @@ void masse3D_inter_circle(t_masse3D *x, t_symbol *s, int argc, t_atom *argv)
 }

 

 

-void masse3D_inter_cylinder(t_masse3D *x, t_symbol *s, int argc, t_atom *argv)

+void mass3D_inter_cylinder(t_mass3D *x, t_symbol *s, int argc, t_atom *argv)

 {

 	t_float a, b, c, d, profondeur, profondeur_old, distance, tmp, rayon_old, rayon;

 	t_float Xb, Yb, Zb, Ta, Tb, Tc, Xb_old, Yb_old, Zb_old;

@@ -937,12 +940,12 @@ void masse3D_inter_cylinder(t_masse3D *x, t_symbol *s, int argc, t_atom *argv)
 	}

 }

 

-void *masse3D_new(t_symbol *s, int argc, t_atom *argv)

+void *mass3D_new(t_symbol *s, int argc, t_atom *argv)

 {

-  t_masse3D *x = (t_masse3D *)pd_new(masse3D_class);

+  t_mass3D *x = (t_mass3D *)pd_new(mass3D_class);

 

   x->x_sym = atom_getsymbolarg(0, argc, argv);

-  x->x_state = makeseed();

+  x->x_state = makeseed3D();

 

   pd_bind(&x->x_obj.ob_pd, atom_getsymbolarg(0, argc, argv));

 

@@ -955,9 +958,9 @@ void *masse3D_new(t_symbol *s, int argc, t_atom *argv)
   x->forceZ=0;

 

   if (argc >= 2)

-    x->masse3D = atom_getfloatarg(1, argc, argv) ;

+    x->mass3D = atom_getfloatarg(1, argc, argv) ;

   else

-    x->masse3D = 1;

+    x->mass3D = 1;

 

   x->onoff = 1;

 

@@ -1040,54 +1043,53 @@ void *masse3D_new(t_symbol *s, int argc, t_atom *argv)
   return (void *)x;

 }

 

-static void masse3D_free(t_masse3D *x)

+static void mass3D_free(t_mass3D *x)

 {

     pd_unbind(&x->x_obj.ob_pd, x->x_sym);

 }

 

 

-void masse3D_setup(void) 

+void mass3D_setup(void) 

 {

 

-  masse3D_class = class_new(gensym("masse3D"),

-        (t_newmethod)masse3D_new,

-        (t_method)masse3D_free,

-		sizeof(t_masse3D),

+  mass3D_class = class_new(gensym("mass3D"),

+        (t_newmethod)mass3D_new,

+        (t_method)mass3D_free,

+		sizeof(t_mass3D),

         CLASS_DEFAULT, A_GIMME, 0);

 

-  class_addcreator((t_newmethod)masse3D_new, gensym("mass3D"), A_GIMME, 0);

-  class_addcreator((t_newmethod)masse3D_new, gensym("pmpd.mass3D"), A_GIMME, 0);

-

-  class_addmethod(masse3D_class, (t_method)masse3D_force, gensym("force3D"),A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

-  class_addbang(masse3D_class, masse3D_bang);

-

-  class_addmethod(masse3D_class, (t_method)masse3D_dX, gensym("dX"), A_DEFFLOAT, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_dY, gensym("dY"), A_DEFFLOAT, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_dZ, gensym("dZ"), A_DEFFLOAT, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_dXYZ, gensym("dXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_setX, gensym("setX"), A_DEFFLOAT, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_setY, gensym("setY"), A_DEFFLOAT, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_setZ, gensym("setZ"), A_DEFFLOAT, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_setXYZ, gensym("setXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_minX, gensym("setXmin"), A_DEFFLOAT, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_minY, gensym("setYmin"), A_DEFFLOAT, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_maxX, gensym("setXmax"), A_DEFFLOAT, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_maxY, gensym("setYmax"), A_DEFFLOAT, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_minZ, gensym("setZmin"), A_DEFFLOAT, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_maxZ, gensym("setZmax"), A_DEFFLOAT, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_set_masse3D, gensym("setM"), A_DEFFLOAT, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_reset, gensym("reset"), 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_resetf, gensym("resetF"), 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_reset, gensym("loadbang"), 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_on, gensym("on"), 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_off, gensym("off"), 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_seuil, gensym("setT"), A_DEFFLOAT, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_damp, gensym("setD"), A_DEFFLOAT, 0);

-

-  class_addmethod(masse3D_class, (t_method)masse3D_inter_ambient, gensym("interactor_ambient_3D"), A_GIMME, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_inter_sphere, gensym("interactor_sphere_3D"), A_GIMME, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_inter_plane, gensym("interactor_plane_3D"), A_GIMME, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_inter_circle, gensym("interactor_circle_3D"), A_GIMME, 0);

-  class_addmethod(masse3D_class, (t_method)masse3D_inter_cylinder, gensym("interactor_cylinder_3D"), A_GIMME, 0);

+  class_addcreator((t_newmethod)mass3D_new, gensym("masse3D"), A_GIMME, 0);

+

+  class_addmethod(mass3D_class, (t_method)mass3D_force, gensym("force3D"),A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

+  class_addbang(mass3D_class, mass3D_bang);

+

+  class_addmethod(mass3D_class, (t_method)mass3D_dX, gensym("dX"), A_DEFFLOAT, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_dY, gensym("dY"), A_DEFFLOAT, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_dZ, gensym("dZ"), A_DEFFLOAT, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_dXYZ, gensym("dXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_setX, gensym("setX"), A_DEFFLOAT, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_setY, gensym("setY"), A_DEFFLOAT, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_setZ, gensym("setZ"), A_DEFFLOAT, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_setXYZ, gensym("setXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_minX, gensym("setXmin"), A_DEFFLOAT, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_minY, gensym("setYmin"), A_DEFFLOAT, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_maxX, gensym("setXmax"), A_DEFFLOAT, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_maxY, gensym("setYmax"), A_DEFFLOAT, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_minZ, gensym("setZmin"), A_DEFFLOAT, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_maxZ, gensym("setZmax"), A_DEFFLOAT, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_set_mass3D, gensym("setM"), A_DEFFLOAT, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_reset, gensym("reset"), 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_resetf, gensym("resetF"), 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_reset, gensym("loadbang"), 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_on, gensym("on"), 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_off, gensym("off"), 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_seuil, gensym("setT"), A_DEFFLOAT, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_damp, gensym("setD"), A_DEFFLOAT, 0);

+

+  class_addmethod(mass3D_class, (t_method)mass3D_inter_ambient, gensym("interactor_ambient_3D"), A_GIMME, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_inter_sphere, gensym("interactor_sphere_3D"), A_GIMME, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_inter_plane, gensym("interactor_plane_3D"), A_GIMME, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_inter_circle, gensym("interactor_circle_3D"), A_GIMME, 0);

+  class_addmethod(mass3D_class, (t_method)mass3D_inter_cylinder, gensym("interactor_cylinder_3D"), A_GIMME, 0);

 

 }

diff --git a/src/pmpd.c b/src/pmpd.c
index 690c1d2..78c2f7f 100755
--- a/src/pmpd.c
+++ b/src/pmpd.c
@@ -28,10 +28,11 @@
 */

 

 #ifndef VERSION

-#define VERSION "0.06"

+#define VERSION "0.07"

 #endif

 

-// #include "m_pd.h"

+#include "m_pd.h"

+#include "stdio.h"
 

 #ifndef __DATE__ 

 #define __DATE__ ""

@@ -46,7 +47,8 @@
 

 #define max(a,b) ( ((a) > (b)) ? (a) : (b) ) 

 #define min(a,b) ( ((a) < (b)) ? (a) : (b) ) 

-

+
+/*

 #include "masse.c"

 #include "lia.c"

 #include "masse2D.c"

@@ -79,9 +81,41 @@
 #include "tCylinder3D.c"

 #include "tLia3D.c"

 

-#include "pmpd~.c"

+#include "pmpd~.c"
+*/

 

 static t_class *pmpd_class;

+
+typedef struct _mass {

+	t_int Id;

+	t_float invM;

+	t_float speedX;

+	t_float posX;

+	t_float forceX;

+} foo;

+

+typedef struct _link {

+	t_int Id;

+	struct _mass *mass1;

+	struct _mass *mass2;

+	t_float Ke, K1, D1, K2, D2;

+} foo1 ;

+

+typedef struct _out {

+	// TODO ajouter un type pour diferencier les outlets en forces et celles en position

+	t_int Id;

+	t_int nbr_outlet;

+	struct _mass *mass1;

+	t_float influence;

+} foo2;

+

+typedef struct _in {

+	// TODO ajouter un type pour diferencier les inlets en forces et celles en position

+	t_int Id;

+	t_int nbr_inlet;

+	struct _mass *mass1;

+	t_float influence;

+} foo3;
 

 typedef struct _pmpd 

 {

@@ -96,9 +130,6 @@ typedef struct _pmpd
 	int nb_link, nb_mass, nb_outlet, nb_inlet, nb_in, nb_out;

 } t_pmpd;

 

-#define max(a,b) ( ((a) > (b)) ? (a) : (b) ) 

-#define min(a,b) ( ((a) < (b)) ? (a) : (b) ) 

-

 void pmpd_bang(t_pmpd *x)

 ///////////////////////////////////////////////////////////////////////////////////

 // this part is doing all the job!

@@ -330,7 +361,7 @@ void pmpd_setup(void)
 	class_addmethod(pmpd_class, (t_method)pmpd_forceX_20,  gensym("forceX_20"), A_DEFFLOAT, 0);

 	class_addmethod(pmpd_class, (t_method)pmpd_reset,  gensym("reset"), 0);

 

-

+/*

  post("");

  post("     pmpd = Physical Modeling for Pure Data");

  post("     version "VERSION);

@@ -371,5 +402,6 @@ tCircle3D_setup();
 

 pmpd_tilde_setup();

 

+*/
 }

 

diff --git a/src/pmpd~.c b/src/pmpd~.c
index ed17b68..62013a6 100755
--- a/src/pmpd~.c
+++ b/src/pmpd~.c
@@ -15,6 +15,13 @@
 

 #define max(a,b) ( ((a) > (b)) ? (a) : (b) ) 

 #define min(a,b) ( ((a) < (b)) ? (a) : (b) ) 

+
+#define nb_max_link   2000

+#define nb_max_mass   2000

+#define nb_max_out    200

+#define nb_max_in     200

+#define nb_max_outlet 20

+#define nb_max_inlet  20 // hard-coded on the methods definition
 

 static t_class *pmpd_tilde_class;

 

@@ -31,7 +38,7 @@ typedef struct _link {
 	struct _mass *mass1;

 	struct _mass *mass2;

 	t_float Ke, K1, D1, K2, D2;

-} foo1;

+} foo1 ;

 

 typedef struct _out {

 	// TODO ajouter un type pour diferencier les outlets en forces et celles en position