From c050bb9a7595860bf72e7c407ff3e8cbd7e77480 Mon Sep 17 00:00:00 2001 From: Cyrille Henry Date: Fri, 9 Apr 2004 16:55:47 +0000 Subject: This commit was generated by cvs2svn to compensate for changes in r1590, which included commits to RCS files with non-trunk default branches. svn path=/trunk/externals/pmpd/; revision=1591 --- src/iAmbient2D.c | 200 ++++++++++ src/iAmbient3D.c | 259 +++++++++++++ src/iCircle2D.c | 276 ++++++++++++++ src/iCircle3D.c | 211 +++++++++++ src/iCylinder3D.c | 292 ++++++++++++++ src/iLine2D.c | 179 +++++++++ src/iPlane3D.c | 193 ++++++++++ src/iSeg2D.c | 175 +++++++++ src/iSphere3D.c | 253 +++++++++++++ src/lia.c | 162 ++++++++ src/lia2D.c | 213 +++++++++++ src/lia3D.c | 238 ++++++++++++ src/makefile | 95 +++++ src/masse.c | 153 ++++++++ src/masse2D.c | 810 +++++++++++++++++++++++++++++++++++++++ src/masse3D.c | 1093 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/pmpd.c | 146 +++++++ src/tCircle2D.c | 113 ++++++ src/tCircle3D.c | 195 ++++++++++ src/tCube3D.c | 114 ++++++ src/tCylinder3D.c | 218 +++++++++++ src/tLia2D.c | 157 ++++++++ src/tLia3D.c | 153 ++++++++ src/tLine2D.c | 137 +++++++ src/tPlane3D.c | 175 +++++++++ src/tSeg2D.c | 139 +++++++ src/tSphere3D.c | 128 +++++++ src/tSquare2D.c | 92 +++++ 28 files changed, 6569 insertions(+) create mode 100755 src/iAmbient2D.c create mode 100755 src/iAmbient3D.c create mode 100755 src/iCircle2D.c create mode 100755 src/iCircle3D.c create mode 100755 src/iCylinder3D.c create mode 100755 src/iLine2D.c create mode 100755 src/iPlane3D.c create mode 100755 src/iSeg2D.c create mode 100755 src/iSphere3D.c create mode 100755 src/lia.c create mode 100755 src/lia2D.c create mode 100755 src/lia3D.c create mode 100755 src/makefile create mode 100755 src/masse.c create mode 100755 src/masse2D.c create mode 100755 src/masse3D.c create mode 100755 src/pmpd.c create mode 100755 src/tCircle2D.c create mode 100755 src/tCircle3D.c create mode 100755 src/tCube3D.c create mode 100755 src/tCylinder3D.c create mode 100755 src/tLia2D.c create mode 100755 src/tLia3D.c create mode 100755 src/tLine2D.c create mode 100755 src/tPlane3D.c create mode 100755 src/tSeg2D.c create mode 100755 src/tSphere3D.c create mode 100755 src/tSquare2D.c (limited to 'src') diff --git a/src/iAmbient2D.c b/src/iAmbient2D.c new file mode 100755 index 0000000..f5050ce --- /dev/null +++ b/src/iAmbient2D.c @@ -0,0 +1,200 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *iAmbient2D_class; + +typedef struct _iAmbient2D { + t_object x_obj; + t_atom force[12]; + /* + force = + forceX, + forceY, + randomFX, + randomFY, + damp, + Xmin, + Xmax, + Ymin, + Ymax, + dX, + dY; + */ + + t_outlet *force_new;// outlet + t_symbol *x_sym; // send +} t_iAmbient2D; + +void iAmbient2D_forceX(t_iAmbient2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[0]), f1); +} + +void iAmbient2D_forceY(t_iAmbient2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[1]), f1); +} + +void iAmbient2D_force(t_iAmbient2D *x, t_floatarg f1, t_floatarg f2) +{ + SETFLOAT(&(x->force[0]), f1); + SETFLOAT(&(x->force[1]), f2 ); +} + +void iAmbient2D_rndFX(t_iAmbient2D *x, t_float X) +{ + SETFLOAT(&(x->force[2]), X); +} + +void iAmbient2D_rndFY(t_iAmbient2D *x, t_float X) +{ + SETFLOAT(&(x->force[3]), X); +} + +void iAmbient2D_rndF(t_iAmbient2D *x, t_floatarg f1, t_floatarg f2) +{ + SETFLOAT(&(x->force[2]), f1); + SETFLOAT(&(x->force[3]), f2); +} + +void iAmbient2D_damp(t_iAmbient2D *x, t_float X) +{ + SETFLOAT(&(x->force[4]), X); +} + +void iAmbient2D_Xmin(t_iAmbient2D *x, t_float Xmin) +{ + SETFLOAT(&(x->force[6]), Xmin); +} + +void iAmbient2D_Xmax(t_iAmbient2D *x, t_float Xmax) +{ + SETFLOAT(&(x->force[7]), Xmax); +} + +void iAmbient2D_Ymin(t_iAmbient2D *x, t_float Ymin) +{ + SETFLOAT(&(x->force[8]), Ymin); +} + +void iAmbient2D_Ymax(t_iAmbient2D *x, t_float Ymax) +{ + SETFLOAT(&(x->force[9]), Ymax); +} + +void iAmbient2D_dXY(t_iAmbient2D *x, t_float dX, t_float dY) +{ + SETFLOAT(&(x->force[10]), dX); + SETFLOAT(&(x->force[11]), dY); +} + +void iAmbient2D_dX(t_iAmbient2D *x, t_float dX) +{ + SETFLOAT(&(x->force[10]), dX); +} + +void iAmbient2D_dY(t_iAmbient2D *x, t_float dY) +{ + SETFLOAT(&(x->force[11]), dY); +} + +void iAmbient2D_bang(t_iAmbient2D *x) +{ + if (x->x_sym->s_thing) typedmess(x->x_sym->s_thing, gensym("interactor_ambient_2D"), 12, x->force); + + outlet_anything(x->force_new, gensym("interactor_ambient_2D"), 12, x->force); +} + +void *iAmbient2D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_iAmbient2D *x = (t_iAmbient2D *)pd_new(iAmbient2D_class); + + x->x_sym = atom_getsymbolarg(0, argc, argv); + + x->force_new=outlet_new(&x->x_obj, 0); + + SETFLOAT(&(x->force[5]), 0); + + + if (argc>=12) + SETFLOAT(&(x->force[11]), atom_getfloatarg(11, argc, argv)); + else + SETFLOAT(&(x->force[11]), 0); + + if (argc>=11) + SETFLOAT(&(x->force[10]), atom_getfloatarg(10, argc, argv)); + else + SETFLOAT(&(x->force[10]), 0); + + if (argc>=10) + SETFLOAT(&(x->force[9]), atom_getfloatarg(9, argc, argv)); + else + SETFLOAT(&(x->force[9]), 100000); + + if (argc>=9) + SETFLOAT(&(x->force[8]), atom_getfloatarg(8, argc, argv)); + else + SETFLOAT(&(x->force[8]), -100000); + + if (argc>=8) + SETFLOAT(&(x->force[7]), atom_getfloatarg(7, argc, argv)); + else + SETFLOAT(&(x->force[7]), 100000); + + if (argc>=7) + SETFLOAT(&(x->force[6]), atom_getfloatarg(6, argc, argv)); + else + SETFLOAT(&(x->force[6]), -100000); + + if (argc>=6) + SETFLOAT(&(x->force[4]), atom_getfloatarg(5, argc, argv)); + else + SETFLOAT(&(x->force[4]), 0); + + if (argc>=5) + SETFLOAT(&(x->force[3]), atom_getfloatarg(4, argc, argv)); + else + SETFLOAT(&(x->force[3]), 0); + + if (argc>=4) + SETFLOAT(&(x->force[2]), atom_getfloatarg(3, argc, argv)); + else + SETFLOAT(&(x->force[2]), 0); + + if (argc>=3) + SETFLOAT(&(x->force[1]), atom_getfloatarg(2, argc, argv)); + else + SETFLOAT(&(x->force[1]), 0); + + if (argc>=2) + SETFLOAT(&(x->force[0]), atom_getfloatarg(1, argc, argv)); + else + SETFLOAT(&(x->force[0]), 0); + + return (x); +} + +void iAmbient2D_setup(void) +{ + iAmbient2D_class = class_new(gensym("iAmbient2D"), + (t_newmethod)iAmbient2D_new, + 0, sizeof(t_iAmbient2D), + CLASS_DEFAULT, A_GIMME, 0); + + class_addcreator((t_newmethod)iAmbient2D_new, gensym("pmpd.iAmbient2D"), A_GIMME, 0); + + class_addbang(iAmbient2D_class, iAmbient2D_bang); + class_addmethod(iAmbient2D_class, (t_method)iAmbient2D_force, gensym("setFXY"), A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(iAmbient2D_class, (t_method)iAmbient2D_forceX, gensym("setFX"), A_DEFFLOAT, 0); + class_addmethod(iAmbient2D_class, (t_method)iAmbient2D_forceY, gensym("setFY"), A_DEFFLOAT, 0); + class_addmethod(iAmbient2D_class, (t_method)iAmbient2D_Xmin, gensym("setXmin"), A_DEFFLOAT, 0); + class_addmethod(iAmbient2D_class, (t_method)iAmbient2D_Ymin, gensym("setYmin"), A_DEFFLOAT, 0); + class_addmethod(iAmbient2D_class, (t_method)iAmbient2D_Xmax, gensym("setXmax"), A_DEFFLOAT, 0); + class_addmethod(iAmbient2D_class, (t_method)iAmbient2D_Ymax, gensym("setYmax"), A_DEFFLOAT, 0); + class_addmethod(iAmbient2D_class, (t_method)iAmbient2D_rndFY, gensym("setRndFY"), A_DEFFLOAT, 0); + class_addmethod(iAmbient2D_class, (t_method)iAmbient2D_rndFX, gensym("setRndFX"), A_DEFFLOAT, 0); + class_addmethod(iAmbient2D_class, (t_method)iAmbient2D_damp, gensym("setD"), A_DEFFLOAT, 0); + class_addmethod(iAmbient2D_class, (t_method)iAmbient2D_dX, gensym("setdX"), A_DEFFLOAT, 0); + class_addmethod(iAmbient2D_class, (t_method)iAmbient2D_dY, gensym("setdY"), A_DEFFLOAT, 0); + class_addmethod(iAmbient2D_class, (t_method)iAmbient2D_dXY, gensym("setdXY"), A_DEFFLOAT, A_DEFFLOAT, 0); +} diff --git a/src/iAmbient3D.c b/src/iAmbient3D.c new file mode 100755 index 0000000..cd95088 --- /dev/null +++ b/src/iAmbient3D.c @@ -0,0 +1,259 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *iAmbient3D_class; + +typedef struct _iAmbient3D { + t_object x_obj; + t_atom force[17]; +/* 1 : name of the mass (send interactors informations to this masses) + 2 : FX (constant X force apply to the masses) (0) + 3 : FY (constant Y force apply to the masses) (0) + 4 : FZ (constant Z force apply to the masses) (0) + 5 : Rnd FX (random X force apply to the masses) (0) + 6 : Rnd FY (random Y force apply to the masses) (0) + 7 : Rnd FZ (random Z force apply to the masses) (0) + 8 : Damping (velocity damping of the masses) (0) + 9 : Rien + 10 : Xmin (minimum and maximum limit of the interactors) (-10000) + 9 : Xmax (a mass interact with this object only if it is inside the interactor bounds) (10000) + 10 : Ymin (-10000) + 11 : Ymax (10000) + 12 : Zmin (-10000) + 13 : Zmax (10000) + 14 : dX (displace the mass by a constant value) (0) + 15 : dY (0) + 16 : dZ (0) +*/ + t_outlet *force_new;// outlet + t_symbol *x_sym; // send +} t_iAmbient3D; + +void iAmbient3D_forceX(t_iAmbient3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[0]), f1); +} + +void iAmbient3D_forceY(t_iAmbient3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[1]), f1); +} + +void iAmbient3D_forceZ(t_iAmbient3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[2]), f1); +} + +void iAmbient3D_force(t_iAmbient3D *x, t_floatarg f1, t_floatarg f2, t_floatarg f3) +{ + SETFLOAT(&(x->force[0]), f1 ); + SETFLOAT(&(x->force[1]), f2 ); + SETFLOAT(&(x->force[2]), f3 ); +} + +void iAmbient3D_rndFX(t_iAmbient3D *x, t_float X) +{ + SETFLOAT(&(x->force[3]), X); +} + +void iAmbient3D_rndFY(t_iAmbient3D *x, t_float X) +{ + SETFLOAT(&(x->force[4]), X); +} + +void iAmbient3D_rndFZ(t_iAmbient3D *x, t_float X) +{ + SETFLOAT(&(x->force[5]), X); +} + +void iAmbient3D_rndF(t_iAmbient3D *x, t_floatarg f1, t_floatarg f2, t_floatarg f3) +{ + SETFLOAT(&(x->force[3]), f1); + SETFLOAT(&(x->force[4]), f2); + SETFLOAT(&(x->force[5]), f3); +} + +void iAmbient3D_damp(t_iAmbient3D *x, t_float X) +{ + SETFLOAT(&(x->force[6]), X); +} + + +void iAmbient3D_Xmin(t_iAmbient3D *x, t_float Xmin) +{ + SETFLOAT(&(x->force[8]), Xmin); +} + +void iAmbient3D_Xmax(t_iAmbient3D *x, t_float Xmax) +{ + SETFLOAT(&(x->force[9]), Xmax); +} + +void iAmbient3D_Ymin(t_iAmbient3D *x, t_float Ymin) +{ + SETFLOAT(&(x->force[10]), Ymin); +} + +void iAmbient3D_Ymax(t_iAmbient3D *x, t_float Ymax) +{ + SETFLOAT(&(x->force[11]), Ymax); +} + +void iAmbient3D_Zmin(t_iAmbient3D *x, t_float Zmin) +{ + SETFLOAT(&(x->force[12]), Zmin); +} + +void iAmbient3D_Zmax(t_iAmbient3D *x, t_float Zmax) +{ + SETFLOAT(&(x->force[13]), Zmax); +} + +void iAmbient3D_dXYZ(t_iAmbient3D *x, t_float dX, t_float dY, t_float dZ) +{ + SETFLOAT(&(x->force[14]), dX); + SETFLOAT(&(x->force[15]), dY); + SETFLOAT(&(x->force[16]), dZ); +} + +void iAmbient3D_dX(t_iAmbient3D *x, t_float dX) +{ + SETFLOAT(&(x->force[14]), dX); +} + +void iAmbient3D_dY(t_iAmbient3D *x, t_float dY) +{ + SETFLOAT(&(x->force[15]), dY); +} + +void iAmbient3D_dZ(t_iAmbient3D *x, t_float dZ) +{ + SETFLOAT(&(x->force[16]), dZ); +} + +void iAmbient3D_bang(t_iAmbient3D *x) +{ + if (x->x_sym->s_thing) typedmess(x->x_sym->s_thing, gensym("interactor_ambient_3D"), 17, x->force); + + outlet_anything(x->force_new, gensym("interactor_ambient_3D"), 17, x->force); +} + +void *iAmbient3D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_iAmbient3D *x = (t_iAmbient3D *)pd_new(iAmbient3D_class); + + x->x_sym = atom_getsymbolarg(0, argc, argv); + + x->force_new=outlet_new(&x->x_obj, 0); + + if (argc>=16) + SETFLOAT(&(x->force[15]), atom_getfloatarg(15, argc, argv)); + else + SETFLOAT(&(x->force[15]), 0); + + if (argc>=15) + SETFLOAT(&(x->force[14]), atom_getfloatarg(14, argc, argv)); + else + SETFLOAT(&(x->force[14]), 0); + + if (argc>=14) + SETFLOAT(&(x->force[13]), atom_getfloatarg(13, argc, argv)); + else + SETFLOAT(&(x->force[13]), 10000); + + if (argc>=13) + SETFLOAT(&(x->force[12]), atom_getfloatarg(12, argc, argv)); + else + SETFLOAT(&(x->force[12]), -10000); + + if (argc>=12) + SETFLOAT(&(x->force[11]), atom_getfloatarg(11, argc, argv)); + else + SETFLOAT(&(x->force[11]), 10000); + + if (argc>=11) + SETFLOAT(&(x->force[10]), atom_getfloatarg(10, argc, argv)); + else + SETFLOAT(&(x->force[10]), -10000); + + if (argc>=10) + SETFLOAT(&(x->force[9]), atom_getfloatarg(9, argc, argv)); + else + SETFLOAT(&(x->force[9]), 10000); + + if (argc>=9) + SETFLOAT(&(x->force[8]), atom_getfloatarg(8, argc, argv)); + else + SETFLOAT(&(x->force[8]), -10000); + + SETFLOAT(&(x->force[7]), 0); + + if (argc>=8) + SETFLOAT(&(x->force[6]), atom_getfloatarg(7, argc, argv)); + else + SETFLOAT(&(x->force[6]), 0); + + if (argc>=7) + SETFLOAT(&(x->force[5]), atom_getfloatarg(6, argc, argv)); + else + SETFLOAT(&(x->force[5]), 0); + + if (argc>=6) + SETFLOAT(&(x->force[4]), atom_getfloatarg(5, argc, argv)); + else + SETFLOAT(&(x->force[4]), 0); + + if (argc>=5) + SETFLOAT(&(x->force[3]), atom_getfloatarg(4, argc, argv)); + else + SETFLOAT(&(x->force[3]), 0); + + if (argc>=4) + SETFLOAT(&(x->force[2]), atom_getfloatarg(3, argc, argv)); + else + SETFLOAT(&(x->force[2]), 0); + + if (argc>=3) + SETFLOAT(&(x->force[1]), atom_getfloatarg(2, argc, argv)); + else + SETFLOAT(&(x->force[1]), 0); + + if (argc>=2) + SETFLOAT(&(x->force[0]), atom_getfloatarg(1, argc, argv)); + else + SETFLOAT(&(x->force[0]), 0); + + return (x); +} + +void iAmbient3D_setup(void) +{ + + iAmbient3D_class = class_new(gensym("iAmbient3D"), + (t_newmethod)iAmbient3D_new, + 0, sizeof(t_iAmbient3D), + CLASS_DEFAULT, A_GIMME, 0); + + class_addcreator((t_newmethod)iAmbient3D_new, gensym("pmpd.iAmbient3D"), A_GIMME, 0); + + class_addbang(iAmbient3D_class, iAmbient3D_bang); + class_addmethod(iAmbient3D_class, (t_method)iAmbient3D_force, gensym("setFXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(iAmbient3D_class, (t_method)iAmbient3D_forceX, gensym("setFX"), A_DEFFLOAT, 0); + class_addmethod(iAmbient3D_class, (t_method)iAmbient3D_forceY, gensym("setFY"), A_DEFFLOAT, 0); + class_addmethod(iAmbient3D_class, (t_method)iAmbient3D_forceZ, gensym("setFZ"), A_DEFFLOAT, 0); + class_addmethod(iAmbient3D_class, (t_method)iAmbient3D_Xmin, gensym("setXmin"), A_DEFFLOAT, 0); + class_addmethod(iAmbient3D_class, (t_method)iAmbient3D_Ymin, gensym("setYmin"), A_DEFFLOAT, 0); + class_addmethod(iAmbient3D_class, (t_method)iAmbient3D_Zmin, gensym("setZmin"), A_DEFFLOAT, 0); + class_addmethod(iAmbient3D_class, (t_method)iAmbient3D_Xmax, gensym("setXmax"), A_DEFFLOAT, 0); + class_addmethod(iAmbient3D_class, (t_method)iAmbient3D_Ymax, gensym("setYmax"), A_DEFFLOAT, 0); + class_addmethod(iAmbient3D_class, (t_method)iAmbient3D_Zmax, gensym("setZmax"), A_DEFFLOAT, 0); + class_addmethod(iAmbient3D_class, (t_method)iAmbient3D_rndFY, gensym("setRndFY"), A_DEFFLOAT, 0); + class_addmethod(iAmbient3D_class, (t_method)iAmbient3D_rndFX, gensym("setRndFX"), A_DEFFLOAT, 0); + class_addmethod(iAmbient3D_class, (t_method)iAmbient3D_rndFZ, gensym("setRndFZ"), A_DEFFLOAT, 0); + class_addmethod(iAmbient3D_class, (t_method)iAmbient3D_damp, gensym("setD"), A_DEFFLOAT, 0); + class_addmethod(iAmbient3D_class, (t_method)iAmbient3D_dXYZ, gensym("dXYZ"), A_DEFFLOAT, 0); + class_addmethod(iAmbient3D_class, (t_method)iAmbient3D_dX, gensym("setdX"), A_DEFFLOAT, 0); + class_addmethod(iAmbient3D_class, (t_method)iAmbient3D_dY, gensym("setdY"), A_DEFFLOAT, 0); + class_addmethod(iAmbient3D_class, (t_method)iAmbient3D_dZ, gensym("setdZ"), A_DEFFLOAT, 0); + +} diff --git a/src/iCircle2D.c b/src/iCircle2D.c new file mode 100755 index 0000000..869dd70 --- /dev/null +++ b/src/iCircle2D.c @@ -0,0 +1,276 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *iCircle2D_class; + +typedef struct _iCircle2D { + t_object x_obj; + t_atom force[20]; + t_outlet *force_new; // outlet + t_symbol *x_sym; // send + t_float posX_old, posY_old, posX, posY; // anciennes position, pour calculer la vitesse de cette interacteur. + +} t_iCircle2D; + +void iCircle2D_bang(t_iCircle2D *x) +{ + SETFLOAT(&(x->force[14]), x->posX_old); // posX_old + SETFLOAT(&(x->force[15]), x->posY_old); // posY_old + + x->posX_old = x->posX; + x->posY_old = x->posY; + + if (x->x_sym->s_thing) typedmess(x->x_sym->s_thing, gensym("interactor_circle_2D"), 20, x->force); + + outlet_anything(x->force_new, gensym("interactor_circle_2D"), 20, x->force); +} + +void iCircle2D_setXY(t_iCircle2D *x, t_float X, t_float Y) +{ + SETFLOAT(&(x->force[0]), X); + x->posX= X; + SETFLOAT(&(x->force[1]), Y); + x->posY = Y; +} + +void iCircle2D_setX(t_iCircle2D *x, t_float X) +{ + SETFLOAT(&(x->force[0]), X); + x->posX= X; +} + +void iCircle2D_setY(t_iCircle2D *x, t_float Y) +{ + SETFLOAT(&(x->force[1]), Y); + x->posY = Y; +} + +void iCircle2D_setRmin(t_iCircle2D *x, t_float X) +{ + SETFLOAT(&(x->force[2]), X); +} + +void iCircle2D_setRmax(t_iCircle2D *x, t_float X) +{ + SETFLOAT(&(x->force[3]), X); +} + +void iCircle2D_setFN(t_iCircle2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[4]), f1); +} + +void iCircle2D_setFT(t_iCircle2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[5]), f1); +} + +void iCircle2D_setKN(t_iCircle2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[6]), f1); +} + +void iCircle2D_setKT(t_iCircle2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[7]), f1); +} + +void iCircle2D_setRN(t_iCircle2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[8]), f1); +} + +void iCircle2D_setRT(t_iCircle2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[9]), f1); +} + +void iCircle2D_setDN(t_iCircle2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[10]), f1); +} + +void iCircle2D_setDT(t_iCircle2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[11]), f1); +} + +void iCircle2D_setdRN(t_iCircle2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[12]), f1); +} + +void iCircle2D_setdRT(t_iCircle2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[13]), f1); +} + +void iCircle2D_setD(t_iCircle2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[16]), f1); +} + +void iCircle2D_setG(t_iCircle2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[17]), f1); +} + +void iCircle2D_setdN(t_iCircle2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[18]), f1); +} + +void iCircle2D_setdT(t_iCircle2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[19]), f1); +} + +void *iCircle2D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_iCircle2D *x = (t_iCircle2D *)pd_new(iCircle2D_class); + + x->x_sym = atom_getsymbolarg(0, argc, argv); + + x->force_new=outlet_new(&x->x_obj, 0); + + if (argc>=19) + SETFLOAT(&(x->force[19]), atom_getfloatarg(18, argc, argv)); + else + SETFLOAT(&(x->force[19]), 0); + + if (argc>=18) + SETFLOAT(&(x->force[18]), atom_getfloatarg(17, argc, argv)); + else + SETFLOAT(&(x->force[18]), 0); + + if (argc>=17) + SETFLOAT(&(x->force[17]), atom_getfloatarg(16, argc, argv)); + else + SETFLOAT(&(x->force[17]), 0); + + if (argc>=16) + SETFLOAT(&(x->force[16]), atom_getfloatarg(15, argc, argv)); + else + SETFLOAT(&(x->force[16]), 0); + + if (argc>=15) + SETFLOAT(&(x->force[13]), atom_getfloatarg(14, argc, argv)); + else + SETFLOAT(&(x->force[13]), 0); + + if (argc>=14) + SETFLOAT(&(x->force[12]), atom_getfloatarg(13, argc, argv)); + else + SETFLOAT(&(x->force[12]), 0); + + if (argc>=13) + SETFLOAT(&(x->force[11]), atom_getfloatarg(12, argc, argv)); + else + SETFLOAT(&(x->force[11]), 0); + + if (argc>=12) + SETFLOAT(&(x->force[10]), atom_getfloatarg(11, argc, argv)); + else + SETFLOAT(&(x->force[10]), 0); + + if (argc>=11) + SETFLOAT(&(x->force[9]), atom_getfloatarg(10, argc, argv)); + else + SETFLOAT(&(x->force[9]), 0); + + if (argc>=10) + SETFLOAT(&(x->force[8]), atom_getfloatarg(9, argc, argv)); + else + SETFLOAT(&(x->force[8]), 0); + + if (argc>=9) + SETFLOAT(&(x->force[7]), atom_getfloatarg(8, argc, argv)); + else + SETFLOAT(&(x->force[7]), 0); + + if (argc>=8) + SETFLOAT(&(x->force[6]), atom_getfloatarg(7, argc, argv)); + else + SETFLOAT(&(x->force[6]), 0); + + if (argc>=7) + SETFLOAT(&(x->force[5]), atom_getfloatarg(6, argc, argv)); + else + SETFLOAT(&(x->force[5]), 0); + + if (argc>=6) + SETFLOAT(&(x->force[4]), atom_getfloatarg(5, argc, argv)); + else + SETFLOAT(&(x->force[4]), 0); + + if (argc>=5) + SETFLOAT(&(x->force[3]), atom_getfloatarg(4, argc, argv)); + else + SETFLOAT(&(x->force[3]), 1); + + if (argc>=4) + SETFLOAT(&(x->force[2]), atom_getfloatarg(3, argc, argv)); + else + SETFLOAT(&(x->force[2]), 0); + + if (argc>=3) + { + SETFLOAT(&(x->force[1]), atom_getfloatarg(2, argc, argv)); + SETFLOAT(&(x->force[15]), atom_getfloatarg(2, argc, argv)); + x->posY_old = atom_getfloatarg(2, argc, argv); + } + else + { + SETFLOAT(&(x->force[1]), 0); + SETFLOAT(&(x->force[15]), 0); + x->posY_old = 0; + } + + if (argc>=2) + { + SETFLOAT(&(x->force[0]), atom_getfloatarg(1, argc, argv)); + SETFLOAT(&(x->force[14]), atom_getfloatarg(1, argc, argv)); + x->posX_old = atom_getfloatarg(1, argc, argv); + } + else + { + SETFLOAT(&(x->force[0]), 0); + SETFLOAT(&(x->force[14]), 0); + x->posX_old = 0; + } + + return (x); +} + +void iCircle2D_setup(void) +{ + + iCircle2D_class = class_new(gensym("iCircle2D"), + (t_newmethod)iCircle2D_new, + 0, sizeof(t_iCircle2D), + CLASS_DEFAULT, A_GIMME, 0); + + class_addcreator((t_newmethod)iCircle2D_new, gensym("pmpd.iCircle2D"), A_GIMME, 0); + + class_addbang(iCircle2D_class, iCircle2D_bang); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setFN, gensym("setFN"), A_DEFFLOAT, 0); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setFT, gensym("setFT"), A_DEFFLOAT, 0); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setKN, gensym("setKN"), A_DEFFLOAT, 0); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setKT, gensym("setKT"), A_DEFFLOAT, 0); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setDN, gensym("setDN"), A_DEFFLOAT, 0); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setDT, gensym("setDT"), A_DEFFLOAT, 0); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setD, gensym("setD"), A_DEFFLOAT, 0); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setX, gensym("setX"), A_DEFFLOAT, 0); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setY, gensym("setY"), A_DEFFLOAT, 0); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setXY, gensym("setXY"), A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setRmin, gensym("setRmin"), A_DEFFLOAT, 0); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setRmax, gensym("setRmax"), A_DEFFLOAT, 0); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setRN, gensym("setRN"), A_DEFFLOAT, 0); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setRT, gensym("setRT"), A_DEFFLOAT, 0); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setdN, gensym("setdN"), A_DEFFLOAT, 0); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setdT, gensym("setdT"), A_DEFFLOAT, 0); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setdRN, gensym("setdRN"), A_DEFFLOAT, 0); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setdRT, gensym("setdRT"), A_DEFFLOAT, 0); + class_addmethod(iCircle2D_class, (t_method)iCircle2D_setG, gensym("setG"), A_DEFFLOAT, 0); + +} diff --git a/src/iCircle3D.c b/src/iCircle3D.c new file mode 100755 index 0000000..cfbc412 --- /dev/null +++ b/src/iCircle3D.c @@ -0,0 +1,211 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *iCircle3D_class; + +typedef struct _iCircle3D { + t_object x_obj; + t_atom force[14]; + t_outlet *force_new; // outlet + t_symbol *x_sym; // send + +} t_iCircle3D; + +void iCircle3D_bang(t_iCircle3D *x) +{ + if (x->x_sym->s_thing) typedmess(x->x_sym->s_thing, gensym("interactor_circle_3D"), 14, x->force); + + outlet_anything(x->force_new, gensym("interactor_circle_3D"), 14, x->force); +} + +void iCircle3D_setXYZ(t_iCircle3D *x, t_float X, t_float Y, t_float Z) +{ + SETFLOAT(&(x->force[3]), X); + SETFLOAT(&(x->force[4]), Y); + SETFLOAT(&(x->force[5]), Z); +} +void iCircle3D_setVXYZ(t_iCircle3D *x, t_float X, t_float Y, t_float Z) +{ + SETFLOAT(&(x->force[0]), X); + SETFLOAT(&(x->force[1]), Y); + SETFLOAT(&(x->force[2]), Z); +} + +void iCircle3D_setVX(t_iCircle3D *x, t_float X) +{ + SETFLOAT(&(x->force[0]), X); +} + +void iCircle3D_setVY(t_iCircle3D *x, t_float Y) +{ + SETFLOAT(&(x->force[1]), Y); +} + +void iCircle3D_setVZ(t_iCircle3D *x, t_float Z) +{ + SETFLOAT(&(x->force[2]), Z); +} +void iCircle3D_setX(t_iCircle3D *x, t_float X) +{ + SETFLOAT(&(x->force[3]), X); +} + +void iCircle3D_setY(t_iCircle3D *x, t_float Y) +{ + SETFLOAT(&(x->force[4]), Y); +} + +void iCircle3D_setZ(t_iCircle3D *x, t_float Z) +{ + SETFLOAT(&(x->force[5]), Z); +} + +void iCircle3D_setRmin(t_iCircle3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[6]), f1); +} + +void iCircle3D_setRmax(t_iCircle3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[7]), f1); +} + +void iCircle3D_setFN(t_iCircle3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[8]), f1); +} + +void iCircle3D_setKN(t_iCircle3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[9]), f1); +} + +void iCircle3D_setD(t_iCircle3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[10]), f1); +} + +void iCircle3D_setPmax(t_iCircle3D *x, t_float X) +{ + SETFLOAT(&(x->force[11]), X); +} + +void iCircle3D_setdN(t_iCircle3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[12]), f1); +} + +void iCircle3D_setdKN(t_iCircle3D *x, t_float X) +{ + SETFLOAT(&(x->force[13]), X); +} + +void *iCircle3D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_iCircle3D *x = (t_iCircle3D *)pd_new(iCircle3D_class); + + x->x_sym = atom_getsymbolarg(0, argc, argv); + + x->force_new=outlet_new(&x->x_obj, 0); + + + if (argc>=15) + SETFLOAT(&(x->force[13]), atom_getfloatarg(14, argc, argv)); + else + SETFLOAT(&(x->force[13]), 0); + + if (argc>=14) + SETFLOAT(&(x->force[12]), atom_getfloatarg(13, argc, argv)); + else + SETFLOAT(&(x->force[12]), 0); + + if (argc>=13) + SETFLOAT(&(x->force[11]), atom_getfloatarg(12, argc, argv)); + else + SETFLOAT(&(x->force[11]), 10000); + + if (argc>=12) + SETFLOAT(&(x->force[10]), atom_getfloatarg(11, argc, argv)); + else + SETFLOAT(&(x->force[10]), 0); + + if (argc>=11) + SETFLOAT(&(x->force[9]), atom_getfloatarg(10, argc, argv)); + else + SETFLOAT(&(x->force[9]), 0); + + if (argc>=10) + SETFLOAT(&(x->force[8]), atom_getfloatarg(9, argc, argv)); + else + SETFLOAT(&(x->force[8]), 0); + + if (argc>=9) + SETFLOAT(&(x->force[7]), atom_getfloatarg(8, argc, argv)); + else + SETFLOAT(&(x->force[7]), 1); + + if (argc>=8) + SETFLOAT(&(x->force[6]), atom_getfloatarg(7, argc, argv)); + else + SETFLOAT(&(x->force[6]), 0); + + if (argc>=7) + SETFLOAT(&(x->force[5]), atom_getfloatarg(6, argc, argv)); + else + SETFLOAT(&(x->force[5]), 0); + + if (argc>=6) + SETFLOAT(&(x->force[4]), atom_getfloatarg(5, argc, argv)); + else + SETFLOAT(&(x->force[4]), 0); + + if (argc>=5) + SETFLOAT(&(x->force[3]), atom_getfloatarg(4, argc, argv)); + else + SETFLOAT(&(x->force[3]), 0); + + if (argc>=4) + SETFLOAT(&(x->force[2]), atom_getfloatarg(3, argc, argv)); + else + SETFLOAT(&(x->force[2]), 0); + + if (argc>=3) + SETFLOAT(&(x->force[1]), atom_getfloatarg(2, argc, argv)); + else + SETFLOAT(&(x->force[1]), 0); + + if (argc>=2) + SETFLOAT(&(x->force[0]), atom_getfloatarg(1, argc, argv)); + else + SETFLOAT(&(x->force[0]), 1); + + return (x); +} + +void iCircle3D_setup(void) +{ + iCircle3D_class = class_new(gensym("iCircle3D"), + (t_newmethod)iCircle3D_new, + 0, sizeof(t_iCircle3D), + CLASS_DEFAULT, A_GIMME, 0); + + class_addcreator((t_newmethod)iCircle3D_new, gensym("pmpd.iCircle3D"), A_GIMME, 0); + + class_addbang(iCircle3D_class, iCircle3D_bang); + class_addmethod(iCircle3D_class, (t_method)iCircle3D_setVX, gensym("setVX"), A_DEFFLOAT, 0); + class_addmethod(iCircle3D_class, (t_method)iCircle3D_setVY, gensym("setVY"), A_DEFFLOAT, 0); + class_addmethod(iCircle3D_class, (t_method)iCircle3D_setVZ, gensym("setVZ"), A_DEFFLOAT, 0); + class_addmethod(iCircle3D_class, (t_method)iCircle3D_setX, gensym("setX"), A_DEFFLOAT, 0); + class_addmethod(iCircle3D_class, (t_method)iCircle3D_setY, gensym("setY"), A_DEFFLOAT, 0); + class_addmethod(iCircle3D_class, (t_method)iCircle3D_setZ, gensym("setZ"), A_DEFFLOAT, 0); + class_addmethod(iCircle3D_class, (t_method)iCircle3D_setRmin, gensym("setRmin"), A_DEFFLOAT, 0); + class_addmethod(iCircle3D_class, (t_method)iCircle3D_setRmax, gensym("setRmax"), A_DEFFLOAT, 0); + class_addmethod(iCircle3D_class, (t_method)iCircle3D_setXYZ, gensym("setXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(iCircle3D_class, (t_method)iCircle3D_setVXYZ, gensym("setVXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(iCircle3D_class, (t_method)iCircle3D_setPmax, gensym("setPmax"), A_DEFFLOAT, 0); + class_addmethod(iCircle3D_class, (t_method)iCircle3D_setFN, gensym("setFN"), A_DEFFLOAT, 0); + class_addmethod(iCircle3D_class, (t_method)iCircle3D_setKN, gensym("setKN"), A_DEFFLOAT, 0); + class_addmethod(iCircle3D_class, (t_method)iCircle3D_setdN, gensym("setdN"), A_DEFFLOAT, 0); + class_addmethod(iCircle3D_class, (t_method)iCircle3D_setdKN, gensym("setdKN"), A_DEFFLOAT, 0); + class_addmethod(iCircle3D_class, (t_method)iCircle3D_setD, gensym("setD"), A_DEFFLOAT, 0); +} diff --git a/src/iCylinder3D.c b/src/iCylinder3D.c new file mode 100755 index 0000000..59336bf --- /dev/null +++ b/src/iCylinder3D.c @@ -0,0 +1,292 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *iCylinder3D_class; + +typedef struct _iCylinder3D { + t_object x_obj; + t_atom force[21]; + t_outlet *force_new; // outlet + t_symbol *x_sym; // send + +} t_iCylinder3D; + + + +void iCylinder3D_bang(t_iCylinder3D *x) +{ + if (x->x_sym->s_thing) typedmess(x->x_sym->s_thing, gensym("interactor_cylinder_3D"), 21, x->force); + + outlet_anything(x->force_new, gensym("interactor_cylinder_3D"), 21, x->force); +} + +void iCylinder3D_setXYZ(t_iCylinder3D *x, t_float X, t_float Y, t_float Z) +{ + SETFLOAT(&(x->force[3]), X); + SETFLOAT(&(x->force[4]), Y); + SETFLOAT(&(x->force[5]), Z); +} +void iCylinder3D_setVXYZ(t_iCylinder3D *x, t_float X, t_float Y, t_float Z) +{ + SETFLOAT(&(x->force[0]), X); + SETFLOAT(&(x->force[1]), Y); + SETFLOAT(&(x->force[2]), Z); +} + +void iCylinder3D_setVX(t_iCylinder3D *x, t_float X) +{ + SETFLOAT(&(x->force[0]), X); +} + +void iCylinder3D_setVY(t_iCylinder3D *x, t_float Y) +{ + SETFLOAT(&(x->force[1]), Y); +} + +void iCylinder3D_setVZ(t_iCylinder3D *x, t_float Z) +{ + SETFLOAT(&(x->force[2]), Z); +} +void iCylinder3D_setX(t_iCylinder3D *x, t_float X) +{ + SETFLOAT(&(x->force[3]), X); +} + +void iCylinder3D_setY(t_iCylinder3D *x, t_float Y) +{ + SETFLOAT(&(x->force[4]), Y); +} + +void iCylinder3D_setZ(t_iCylinder3D *x, t_float Z) +{ + SETFLOAT(&(x->force[5]), Z); +} + +void iCylinder3D_setRmin(t_iCylinder3D *x, t_float X) +{ + SETFLOAT(&(x->force[6]), X); +} + +void iCylinder3D_setRmax(t_iCylinder3D *x, t_float X) +{ + SETFLOAT(&(x->force[7]), X); +} + +void iCylinder3D_setFN(t_iCylinder3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[8]), f1); +} + +void iCylinder3D_setKN(t_iCylinder3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[9]), f1); +} + +void iCylinder3D_setD(t_iCylinder3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[10]), f1); +} + +void iCylinder3D_setRN(t_iCylinder3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[11]), f1); +} + +void iCylinder3D_setG(t_iCylinder3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[12]), f1); +} + +void iCylinder3D_setPmin(t_iCylinder3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[13]), f1); +} + +void iCylinder3D_setPmax(t_iCylinder3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[14]), f1); +} + +void iCylinder3D_setFT(t_iCylinder3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[15]), f1); +} + +void iCylinder3D_setKT(t_iCylinder3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[16]), f1); +} + +void iCylinder3D_setdN(t_iCylinder3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[17]), f1); +} + +void iCylinder3D_setdT(t_iCylinder3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[18]), f1); +} + +void iCylinder3D_setdKN(t_iCylinder3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[19]), f1); +} + +void iCylinder3D_setdKT(t_iCylinder3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[20]), f1); +} + +void *iCylinder3D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_iCylinder3D *x = (t_iCylinder3D *)pd_new(iCylinder3D_class); + + x->x_sym = atom_getsymbolarg(0, argc, argv); + + x->force_new=outlet_new(&x->x_obj, 0); + + + if (argc>=22) + SETFLOAT(&(x->force[20]), atom_getfloatarg(21, argc, argv)); + else + SETFLOAT(&(x->force[20]), 0); + + if (argc>=21) + SETFLOAT(&(x->force[19]), atom_getfloatarg(20, argc, argv)); + else + SETFLOAT(&(x->force[19]), 0); + + if (argc>=20) + SETFLOAT(&(x->force[18]), atom_getfloatarg(19, argc, argv)); + else + SETFLOAT(&(x->force[18]), 0); + + if (argc>=19) + SETFLOAT(&(x->force[17]), atom_getfloatarg(18, argc, argv)); + else + SETFLOAT(&(x->force[17]), 0); + + if (argc>=18) + SETFLOAT(&(x->force[16]), atom_getfloatarg(17, argc, argv)); + else + SETFLOAT(&(x->force[16]), 0); + + if (argc>=17) + SETFLOAT(&(x->force[15]), atom_getfloatarg(16, argc, argv)); + else + SETFLOAT(&(x->force[15]), 0); + + if (argc>=16) + SETFLOAT(&(x->force[14]), atom_getfloatarg(15, argc, argv)); + else + SETFLOAT(&(x->force[14]), 1000); + + if (argc>=15) + SETFLOAT(&(x->force[13]), atom_getfloatarg(14, argc, argv)); + else + SETFLOAT(&(x->force[13]), -1000); + + if (argc>=14) + SETFLOAT(&(x->force[12]), atom_getfloatarg(13, argc, argv)); + else + SETFLOAT(&(x->force[12]), 0); + + if (argc>=13) + SETFLOAT(&(x->force[11]), atom_getfloatarg(12, argc, argv)); + else + SETFLOAT(&(x->force[11]), 0); + + if (argc>=12) + SETFLOAT(&(x->force[10]), atom_getfloatarg(11, argc, argv)); + else + SETFLOAT(&(x->force[10]), 0); + + if (argc>=11) + SETFLOAT(&(x->force[9]), atom_getfloatarg(10, argc, argv)); + else + SETFLOAT(&(x->force[9]), 0); + + if (argc>=10) + SETFLOAT(&(x->force[8]), atom_getfloatarg(9, argc, argv)); + else + SETFLOAT(&(x->force[8]), 0); + + if (argc>=9) + SETFLOAT(&(x->force[7]), atom_getfloatarg(8, argc, argv)); + else + SETFLOAT(&(x->force[7]), 1); + + if (argc>=8) + SETFLOAT(&(x->force[6]), atom_getfloatarg(7, argc, argv)); + else + SETFLOAT(&(x->force[6]), 0); + + if (argc>=7) + SETFLOAT(&(x->force[5]), atom_getfloatarg(6, argc, argv)); + else + SETFLOAT(&(x->force[5]), 0); + + if (argc>=6) + SETFLOAT(&(x->force[4]), atom_getfloatarg(5, argc, argv)); + else + SETFLOAT(&(x->force[4]), 0); + + if (argc>=5) + SETFLOAT(&(x->force[3]), atom_getfloatarg(4, argc, argv)); + else + SETFLOAT(&(x->force[3]), 0); + + if (argc>=4) + SETFLOAT(&(x->force[2]), atom_getfloatarg(3, argc, argv)); + else + SETFLOAT(&(x->force[2]), 0); + + if (argc>=3) + SETFLOAT(&(x->force[1]), atom_getfloatarg(2, argc, argv)); + else + SETFLOAT(&(x->force[1]), 0); + + if (argc>=2) + SETFLOAT(&(x->force[0]), atom_getfloatarg(1, argc, argv)); + else + SETFLOAT(&(x->force[0]), 1); + + return (x); +} + +void iCylinder3D_setup(void) +{ + + iCylinder3D_class = class_new(gensym("iCylinder3D"), + (t_newmethod)iCylinder3D_new, + 0, sizeof(t_iCylinder3D), + CLASS_DEFAULT, A_GIMME, 0); + + class_addcreator((t_newmethod)iCylinder3D_new, gensym("pmpd.iCylinder3D"), A_GIMME, 0); + + class_addbang(iCylinder3D_class, iCylinder3D_bang); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setVX, gensym("setVX"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setVY, gensym("setVY"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setVZ, gensym("setVZ"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setX, gensym("setX"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setY, gensym("setY"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setZ, gensym("setZ"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setRmin, gensym("setRmin"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setRmax, gensym("setRmax"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setXYZ, gensym("setXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setVXYZ, gensym("setVXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setPmin, gensym("setPmin"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setPmax, gensym("setPmax"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setFN, gensym("setFN"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setKN, gensym("setKN"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setRN, gensym("setRN"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setG, gensym("setG"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setD, gensym("setD"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setFT, gensym("setFT"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setKT, gensym("setKT"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setdN, gensym("setdN"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setdT, gensym("setdT"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setdKN, gensym("setdKN"), A_DEFFLOAT, 0); + class_addmethod(iCylinder3D_class, (t_method)iCylinder3D_setdKT, gensym("setdKT"), A_DEFFLOAT, 0); + +} diff --git a/src/iLine2D.c b/src/iLine2D.c new file mode 100755 index 0000000..d188d92 --- /dev/null +++ b/src/iLine2D.c @@ -0,0 +1,179 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *iLine2D_class; + +typedef struct _iLine2D { + t_object x_obj; + t_atom force[12]; + t_outlet *force_new;// outlet + t_symbol *x_sym; // send +} t_iLine2D; + + + +void iLine2D_bang(t_iLine2D *x) +{ + if (x->x_sym->s_thing) typedmess(x->x_sym->s_thing, gensym("interactor_line_2D"), 12, x->force); + + outlet_anything(x->force_new, gensym("interactor_line_2D"), 12, x->force); +} + +void iLine2D_X1(t_iLine2D *x, t_float Xmax) +{ + SETFLOAT(&(x->force[0]), Xmax); +} + +void iLine2D_Y1(t_iLine2D *x, t_float Ymax) +{ + SETFLOAT(&(x->force[1]), Ymax); +} + +void iLine2D_X2(t_iLine2D *x, t_float X) +{ + SETFLOAT(&(x->force[2]), X); +} + +void iLine2D_Y2(t_iLine2D *x, t_float X) +{ + SETFLOAT(&(x->force[3]), X); +} + +void iLine2D_setPmax(t_iLine2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[4]), f1); +} + +void iLine2D_setFN(t_iLine2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[5]), f1); +} + +void iLine2D_setFT(t_iLine2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[6]), f1); +} + +void iLine2D_setKN(t_iLine2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[7]), f1); +} + +void iLine2D_setDN(t_iLine2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[8]), f1); +} + +void iLine2D_setDT(t_iLine2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[9]), f1); +} + +void iLine2D_setdN(t_iLine2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[10]), f1); +} + +void iLine2D_setdT(t_iLine2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[11]), f1); +} + +void *iLine2D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_iLine2D *x = (t_iLine2D *)pd_new(iLine2D_class); + + x->x_sym = atom_getsymbolarg(0, argc, argv); + + x->force_new=outlet_new(&x->x_obj, 0); + + + if (argc>=13) + SETFLOAT(&(x->force[11]), atom_getfloatarg(12, argc, argv)); + else + SETFLOAT(&(x->force[11]), 0); + + if (argc>=12) + SETFLOAT(&(x->force[10]), atom_getfloatarg(11, argc, argv)); + else + SETFLOAT(&(x->force[10]), 0); + + if (argc>=11) + SETFLOAT(&(x->force[9]), atom_getfloatarg(10, argc, argv)); + else + SETFLOAT(&(x->force[9]), 0); + + if (argc>=10) + SETFLOAT(&(x->force[8]), atom_getfloatarg(9, argc, argv)); + else + SETFLOAT(&(x->force[8]), 0); + + if (argc>=9) + SETFLOAT(&(x->force[7]), atom_getfloatarg(8, argc, argv)); + else + SETFLOAT(&(x->force[7]), 0); + + if (argc>=8) + SETFLOAT(&(x->force[6]), atom_getfloatarg(7, argc, argv)); + else + SETFLOAT(&(x->force[6]), 0); + + if (argc>=7) + SETFLOAT(&(x->force[5]), atom_getfloatarg(6, argc, argv)); + else + SETFLOAT(&(x->force[5]), 0); + + if (argc>=6) + SETFLOAT(&(x->force[4]), atom_getfloatarg(5, argc, argv)); + else + SETFLOAT(&(x->force[4]), 1); + + if (argc>=5) + SETFLOAT(&(x->force[3]), atom_getfloatarg(4, argc, argv)); + else + SETFLOAT(&(x->force[3]), 0); + + if (argc>=4) + SETFLOAT(&(x->force[2]), atom_getfloatarg(3, argc, argv)); + else + SETFLOAT(&(x->force[2]), 1); + + if (argc>=3) + SETFLOAT(&(x->force[1]), atom_getfloatarg(2, argc, argv)); + else + SETFLOAT(&(x->force[1]), 0); + + if (argc>=2) + SETFLOAT(&(x->force[0]), atom_getfloatarg(1, argc, argv)); + else + SETFLOAT(&(x->force[0]), -1); + + return (x); +} + +void iLine2D_setup(void) +{ + + iLine2D_class = class_new(gensym("iLine2D"), + (t_newmethod)iLine2D_new, + 0, sizeof(t_iLine2D), + CLASS_DEFAULT, A_GIMME, 0); + + class_addcreator((t_newmethod)iLine2D_new, gensym("pmpd.iLine2D"), A_GIMME, 0); + + class_addbang(iLine2D_class, iLine2D_bang); + class_addmethod(iLine2D_class, (t_method)iLine2D_setPmax, gensym("setPmax"), A_DEFFLOAT, 0); + class_addmethod(iLine2D_class, (t_method)iLine2D_setFN, gensym("setFN"), A_DEFFLOAT, 0); + class_addmethod(iLine2D_class, (t_method)iLine2D_setFT, gensym("setFT"), A_DEFFLOAT, 0); + class_addmethod(iLine2D_class, (t_method)iLine2D_setKN, gensym("setKN"), A_DEFFLOAT, 0); + class_addmethod(iLine2D_class, (t_method)iLine2D_setDN, gensym("setDN"), A_DEFFLOAT, 0); + class_addmethod(iLine2D_class, (t_method)iLine2D_setDT, gensym("setDT"), A_DEFFLOAT, 0); + class_addmethod(iLine2D_class, (t_method)iLine2D_setdN, gensym("setdN"), A_DEFFLOAT, 0); + class_addmethod(iLine2D_class, (t_method)iLine2D_setdT, gensym("setdT"), A_DEFFLOAT, 0); + class_addmethod(iLine2D_class, (t_method)iLine2D_X1, gensym("setX1"), A_DEFFLOAT, 0); + class_addmethod(iLine2D_class, (t_method)iLine2D_Y1, gensym("setY1"), A_DEFFLOAT, 0); + class_addmethod(iLine2D_class, (t_method)iLine2D_X2, gensym("setX2"), A_DEFFLOAT, 0); + class_addmethod(iLine2D_class, (t_method)iLine2D_Y2, gensym("setY2"), A_DEFFLOAT, 0); + + +} diff --git a/src/iPlane3D.c b/src/iPlane3D.c new file mode 100755 index 0000000..f9be065 --- /dev/null +++ b/src/iPlane3D.c @@ -0,0 +1,193 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *iPlane3D_class; + +typedef struct _iPlane3D { + t_object x_obj; + t_atom force[12]; + t_outlet *force_new; // outlet + t_symbol *x_sym; // send + +} t_iPlane3D; + + + +void iPlane3D_bang(t_iPlane3D *x) +{ + if (x->x_sym->s_thing) typedmess(x->x_sym->s_thing, gensym("interactor_plane_3D"), 12, x->force); + + outlet_anything(x->force_new, gensym("interactor_plane_3D"), 12, x->force); +} + +void iPlane3D_setXYZ(t_iPlane3D *x, t_float X, t_float Y, t_float Z) +{ + SETFLOAT(&(x->force[3]), X); + SETFLOAT(&(x->force[4]), Y); + SETFLOAT(&(x->force[5]), Z); +} +void iPlane3D_setVXYZ(t_iPlane3D *x, t_float X, t_float Y, t_float Z) +{ + SETFLOAT(&(x->force[0]), X); + SETFLOAT(&(x->force[1]), Y); + SETFLOAT(&(x->force[2]), Z); +} + +void iPlane3D_setVX(t_iPlane3D *x, t_float X) +{ + SETFLOAT(&(x->force[0]), X); +} + +void iPlane3D_setVY(t_iPlane3D *x, t_float Y) +{ + SETFLOAT(&(x->force[1]), Y); +} + +void iPlane3D_setVZ(t_iPlane3D *x, t_float Z) +{ + SETFLOAT(&(x->force[2]), Z); +} +void iPlane3D_setX(t_iPlane3D *x, t_float X) +{ + SETFLOAT(&(x->force[3]), X); +} + +void iPlane3D_setY(t_iPlane3D *x, t_float Y) +{ + SETFLOAT(&(x->force[4]), Y); +} + +void iPlane3D_setZ(t_iPlane3D *x, t_float Z) +{ + SETFLOAT(&(x->force[5]), Z); +} + +void iPlane3D_setFN(t_iPlane3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[6]), f1); +} + +void iPlane3D_setKN(t_iPlane3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[7]), f1); +} + +void iPlane3D_setD(t_iPlane3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[8]), f1); +} + +void iPlane3D_setP(t_iPlane3D *x, t_float X) +{ + SETFLOAT(&(x->force[9]), X); +} + +void iPlane3D_setdN(t_iPlane3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[10]), f1); +} + +void iPlane3D_setdKN(t_iPlane3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[11]), f1); +} + +void *iPlane3D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_iPlane3D *x = (t_iPlane3D *)pd_new(iPlane3D_class); + + x->x_sym = atom_getsymbolarg(0, argc, argv); + + x->force_new=outlet_new(&x->x_obj, 0); + + + if (argc>=13) + SETFLOAT(&(x->force[11]), atom_getfloatarg(12, argc, argv)); + else + SETFLOAT(&(x->force[11]), 0); + + if (argc>=12) + SETFLOAT(&(x->force[10]), atom_getfloatarg(11, argc, argv)); + else + SETFLOAT(&(x->force[10]), 0); + + if (argc>=11) + SETFLOAT(&(x->force[9]), atom_getfloatarg(10, argc, argv)); + else + SETFLOAT(&(x->force[9]), 10000); + + if (argc>=10) + SETFLOAT(&(x->force[8]), atom_getfloatarg(9, argc, argv)); + else + SETFLOAT(&(x->force[8]), 0); + + if (argc>=9) + SETFLOAT(&(x->force[7]), atom_getfloatarg(8, argc, argv)); + else + SETFLOAT(&(x->force[7]), 0); + + if (argc>=8) + SETFLOAT(&(x->force[6]), atom_getfloatarg(7, argc, argv)); + else + SETFLOAT(&(x->force[6]), 0); + + if (argc>=7) + SETFLOAT(&(x->force[5]), atom_getfloatarg(6, argc, argv)); + else + SETFLOAT(&(x->force[5]), 0); + + if (argc>=6) + SETFLOAT(&(x->force[4]), atom_getfloatarg(5, argc, argv)); + else + SETFLOAT(&(x->force[4]), 0); + + if (argc>=5) + SETFLOAT(&(x->force[3]), atom_getfloatarg(4, argc, argv)); + else + SETFLOAT(&(x->force[3]), 0); + + if (argc>=4) + SETFLOAT(&(x->force[2]), atom_getfloatarg(3, argc, argv)); + else + SETFLOAT(&(x->force[2]), 0); + + if (argc>=3) + SETFLOAT(&(x->force[1]), atom_getfloatarg(2, argc, argv)); + else + SETFLOAT(&(x->force[1]), 0); + + if (argc>=2) + SETFLOAT(&(x->force[0]), atom_getfloatarg(1, argc, argv)); + else + SETFLOAT(&(x->force[0]), 1); + + return (x); +} + +void iPlane3D_setup(void) +{ + + iPlane3D_class = class_new(gensym("iPlane3D"), + (t_newmethod)iPlane3D_new, + 0, sizeof(t_iPlane3D), + CLASS_DEFAULT, A_GIMME, 0); + + class_addcreator((t_newmethod)iPlane3D_new, gensym("pmpd.iPlane3D"), A_GIMME, 0); + + class_addbang(iPlane3D_class, iPlane3D_bang); + class_addmethod(iPlane3D_class, (t_method)iPlane3D_setVX, gensym("setVX"), A_DEFFLOAT, 0); + class_addmethod(iPlane3D_class, (t_method)iPlane3D_setVY, gensym("setVY"), A_DEFFLOAT, 0); + class_addmethod(iPlane3D_class, (t_method)iPlane3D_setVZ, gensym("setVZ"), A_DEFFLOAT, 0); + class_addmethod(iPlane3D_class, (t_method)iPlane3D_setX, gensym("setX"), A_DEFFLOAT, 0); + class_addmethod(iPlane3D_class, (t_method)iPlane3D_setY, gensym("setY"), A_DEFFLOAT, 0); + class_addmethod(iPlane3D_class, (t_method)iPlane3D_setZ, gensym("setZ"), A_DEFFLOAT, 0); + class_addmethod(iPlane3D_class, (t_method)iPlane3D_setXYZ, gensym("setXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(iPlane3D_class, (t_method)iPlane3D_setVXYZ, gensym("setVXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(iPlane3D_class, (t_method)iPlane3D_setP, gensym("setPmax"), A_DEFFLOAT, 0); + class_addmethod(iPlane3D_class, (t_method)iPlane3D_setFN, gensym("setFN"), A_DEFFLOAT, 0); + class_addmethod(iPlane3D_class, (t_method)iPlane3D_setKN, gensym("setKN"), A_DEFFLOAT, 0); + class_addmethod(iPlane3D_class, (t_method)iPlane3D_setdKN, gensym("setdKN"), A_DEFFLOAT, 0); + class_addmethod(iPlane3D_class, (t_method)iPlane3D_setD, gensym("setD"), A_DEFFLOAT, 0); + class_addmethod(iPlane3D_class, (t_method)iPlane3D_setdN, gensym("setdN"), A_DEFFLOAT, 0); + +} diff --git a/src/iSeg2D.c b/src/iSeg2D.c new file mode 100755 index 0000000..77c740b --- /dev/null +++ b/src/iSeg2D.c @@ -0,0 +1,175 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *iSeg2D_class; + +typedef struct _iSeg2D { + t_object x_obj; + t_atom force[12]; + t_outlet *force_new;// outlet + t_symbol *x_sym; // send +} t_iSeg2D; + +void iSeg2D_bang(t_iSeg2D *x) +{ + if (x->x_sym->s_thing) typedmess(x->x_sym->s_thing, gensym("interactor_segment_2D"), 12, x->force); + + outlet_anything(x->force_new, gensym("interactor_segment_2D"), 12, x->force); +} + +void iSeg2D_X1(t_iSeg2D *x, t_float Xmax) +{ + SETFLOAT(&(x->force[0]), Xmax); +} + +void iSeg2D_Y1(t_iSeg2D *x, t_float Ymax) +{ + SETFLOAT(&(x->force[1]), Ymax); +} + +void iSeg2D_X2(t_iSeg2D *x, t_float X) +{ + SETFLOAT(&(x->force[2]), X); +} + +void iSeg2D_Y2(t_iSeg2D *x, t_float X) +{ + SETFLOAT(&(x->force[3]), X); +} + +void iSeg2D_setPmax(t_iSeg2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[4]), f1); +} + +void iSeg2D_setFN(t_iSeg2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[5]), f1); +} + +void iSeg2D_setFT(t_iSeg2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[6]), f1); +} + +void iSeg2D_setKN(t_iSeg2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[7]), f1); +} + +void iSeg2D_setDN(t_iSeg2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[8]), f1); +} + +void iSeg2D_setDT(t_iSeg2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[9]), f1); +} + +void iSeg2D_setdN(t_iSeg2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[10]), f1); +} + +void iSeg2D_setdT(t_iSeg2D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[11]), f1); +} + +void *iSeg2D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_iSeg2D *x = (t_iSeg2D *)pd_new(iSeg2D_class); + + x->x_sym = atom_getsymbolarg(0, argc, argv); + + x->force_new=outlet_new(&x->x_obj, 0); + + + if (argc>=13) + SETFLOAT(&(x->force[11]), atom_getfloatarg(12, argc, argv)); + else + SETFLOAT(&(x->force[11]), 0); + + if (argc>=12) + SETFLOAT(&(x->force[10]), atom_getfloatarg(11, argc, argv)); + else + SETFLOAT(&(x->force[10]), 0); + + if (argc>=11) + SETFLOAT(&(x->force[9]), atom_getfloatarg(10, argc, argv)); + else + SETFLOAT(&(x->force[9]), 0); + + if (argc>=10) + SETFLOAT(&(x->force[8]), atom_getfloatarg(9, argc, argv)); + else + SETFLOAT(&(x->force[8]), 0); + + if (argc>=9) + SETFLOAT(&(x->force[7]), atom_getfloatarg(8, argc, argv)); + else + SETFLOAT(&(x->force[7]), 0); + + if (argc>=8) + SETFLOAT(&(x->force[6]), atom_getfloatarg(7, argc, argv)); + else + SETFLOAT(&(x->force[6]), 0); + + if (argc>=7) + SETFLOAT(&(x->force[5]), atom_getfloatarg(6, argc, argv)); + else + SETFLOAT(&(x->force[5]), 0); + + if (argc>=6) + SETFLOAT(&(x->force[4]), atom_getfloatarg(5, argc, argv)); + else + SETFLOAT(&(x->force[4]), 1); + + if (argc>=5) + SETFLOAT(&(x->force[3]), atom_getfloatarg(4, argc, argv)); + else + SETFLOAT(&(x->force[3]), 0); + + if (argc>=4) + SETFLOAT(&(x->force[2]), atom_getfloatarg(3, argc, argv)); + else + SETFLOAT(&(x->force[2]), 1); + + if (argc>=3) + SETFLOAT(&(x->force[1]), atom_getfloatarg(2, argc, argv)); + else + SETFLOAT(&(x->force[1]), 0); + + if (argc>=2) + SETFLOAT(&(x->force[0]), atom_getfloatarg(1, argc, argv)); + else + SETFLOAT(&(x->force[0]), -1); + + return (x); +} + +void iSeg2D_setup(void) +{ + + iSeg2D_class = class_new(gensym("iSeg2D"), + (t_newmethod)iSeg2D_new, + 0, sizeof(t_iSeg2D), + CLASS_DEFAULT, A_GIMME, 0); + + class_addcreator((t_newmethod)iSeg2D_new, gensym("pmpd.iSeg2D"), A_GIMME, 0); + + class_addbang(iSeg2D_class, iSeg2D_bang); + class_addmethod(iSeg2D_class, (t_method)iSeg2D_setPmax, gensym("setPmax"), A_DEFFLOAT, 0); + class_addmethod(iSeg2D_class, (t_method)iSeg2D_setFN, gensym("setFN"), A_DEFFLOAT, 0); + class_addmethod(iSeg2D_class, (t_method)iSeg2D_setFT, gensym("setFT"), A_DEFFLOAT, 0); + class_addmethod(iSeg2D_class, (t_method)iSeg2D_setKN, gensym("setKN"), A_DEFFLOAT, 0); + class_addmethod(iSeg2D_class, (t_method)iSeg2D_setDN, gensym("setDN"), A_DEFFLOAT, 0); + class_addmethod(iSeg2D_class, (t_method)iSeg2D_setDT, gensym("setDT"), A_DEFFLOAT, 0); + class_addmethod(iSeg2D_class, (t_method)iSeg2D_setdN, gensym("setdN"), A_DEFFLOAT, 0); + class_addmethod(iSeg2D_class, (t_method)iSeg2D_setdT, gensym("setdT"), A_DEFFLOAT, 0); + class_addmethod(iSeg2D_class, (t_method)iSeg2D_X1, gensym("setX1"), A_DEFFLOAT, 0); + class_addmethod(iSeg2D_class, (t_method)iSeg2D_Y1, gensym("setY1"), A_DEFFLOAT, 0); + class_addmethod(iSeg2D_class, (t_method)iSeg2D_X2, gensym("setX2"), A_DEFFLOAT, 0); + class_addmethod(iSeg2D_class, (t_method)iSeg2D_Y2, gensym("setY2"), A_DEFFLOAT, 0); +} diff --git a/src/iSphere3D.c b/src/iSphere3D.c new file mode 100755 index 0000000..5b84171 --- /dev/null +++ b/src/iSphere3D.c @@ -0,0 +1,253 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *iSphere3D_class; + +typedef struct _iSphere3D { + t_object x_obj; + t_atom force[17]; + // = Xcentre, Ycentre, .., Rmin, Rmax, Fnormal, K normal, F/R normal, DampNormal, dN, posX_old, posY_old, posZ_old, lia_damp, f/R2 + t_outlet *force_new; // outlet + t_symbol *x_sym; // send + t_float posX_old, posY_old, posZ_old, posX, posY, posZ; // anciennes position, pour calculer la vitesse de cette interacteur. + +} t_iSphere3D; + + + +void iSphere3D_bang(t_iSphere3D *x) +{ + + SETFLOAT(&(x->force[10]), x->posX_old); // posX_old + SETFLOAT(&(x->force[11]), x->posY_old); // posY_old + SETFLOAT(&(x->force[12]), x->posZ_old); // posZ_old + + x->posX_old = x->posX; + x->posY_old = x->posY; + x->posZ_old = x->posZ; + + if (x->x_sym->s_thing) typedmess(x->x_sym->s_thing, gensym("interactor_sphere_3D"), 17, x->force); + + outlet_anything(x->force_new, gensym("interactor_sphere_3D"), 17, x->force); +} + +void iSphere3D_setXYZ(t_iSphere3D *x, t_float X, t_float Y, t_float Z) +{ + SETFLOAT(&(x->force[0]), X); + x->posX= X; + SETFLOAT(&(x->force[1]), Y); + x->posY = Y; + SETFLOAT(&(x->force[2]), Z); + x->posZ = Z; +} + +void iSphere3D_setX(t_iSphere3D *x, t_float X) +{ + SETFLOAT(&(x->force[0]), X); + x->posX= X; +} + +void iSphere3D_setY(t_iSphere3D *x, t_float Y) +{ + SETFLOAT(&(x->force[1]), Y); + x->posY = Y; +} + +void iSphere3D_setZ(t_iSphere3D *x, t_float Z) +{ + SETFLOAT(&(x->force[2]), Z); + x->posZ = Z; +} + +void iSphere3D_setRmin(t_iSphere3D *x, t_float X) +{ + SETFLOAT(&(x->force[3]), X); +} + +void iSphere3D_setRmax(t_iSphere3D *x, t_float X) +{ + SETFLOAT(&(x->force[4]), X); +} + +void iSphere3D_setFN(t_iSphere3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[5]), f1); +} + +void iSphere3D_setKN(t_iSphere3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[6]), f1); +} + +void iSphere3D_setFRN(t_iSphere3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[7]), f1); +} + + +void iSphere3D_setDN(t_iSphere3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[8]), f1); +} + +void iSphere3D_setdN(t_iSphere3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[9]), f1); +} + +void iSphere3D_setG(t_iSphere3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[13]), f1); +} + +void iSphere3D_setdKN(t_iSphere3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[14]), f1); +} + +void iSphere3D_setdRN(t_iSphere3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[15]), f1); +} + +void iSphere3D_setdGN(t_iSphere3D *x, t_floatarg f1) +{ + SETFLOAT(&(x->force[16]), f1); +} + +void *iSphere3D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_iSphere3D *x = (t_iSphere3D *)pd_new(iSphere3D_class); + + x->x_sym = atom_getsymbolarg(0, argc, argv); + + x->force_new=outlet_new(&x->x_obj, 0); + + if (argc>=15) + SETFLOAT(&(x->force[16]), atom_getfloatarg(14, argc, argv)); + else + SETFLOAT(&(x->force[16]), 0); + + if (argc>=14) + SETFLOAT(&(x->force[15]), atom_getfloatarg(13, argc, argv)); + else + SETFLOAT(&(x->force[15]), 0); + + if (argc>=13) + SETFLOAT(&(x->force[14]), atom_getfloatarg(12, argc, argv)); + else + SETFLOAT(&(x->force[14]), 0); + + if (argc>=12) + SETFLOAT(&(x->force[13]), atom_getfloatarg(11, argc, argv)); + else + SETFLOAT(&(x->force[13]), 0); + + if (argc>=11) + SETFLOAT(&(x->force[9]), atom_getfloatarg(10, argc, argv)); + else + SETFLOAT(&(x->force[9]), 0); + + if (argc>=10) + SETFLOAT(&(x->force[8]), atom_getfloatarg(9, argc, argv)); + else + SETFLOAT(&(x->force[8]), 0); + + if (argc>=9) + SETFLOAT(&(x->force[7]), atom_getfloatarg(8, argc, argv)); + else + SETFLOAT(&(x->force[7]), 0); + + if (argc>=8) + SETFLOAT(&(x->force[6]), atom_getfloatarg(7, argc, argv)); + else + SETFLOAT(&(x->force[6]), 0); + + if (argc>=7) + SETFLOAT(&(x->force[5]), atom_getfloatarg(6, argc, argv)); + else + SETFLOAT(&(x->force[5]), 0); + + if (argc>=6) + SETFLOAT(&(x->force[4]), atom_getfloatarg(5, argc, argv)); + else + SETFLOAT(&(x->force[4]), 1); + + if (argc>=5) + SETFLOAT(&(x->force[3]), atom_getfloatarg(4, argc, argv)); + else + SETFLOAT(&(x->force[3]), 0); + + if (argc>=4) + { + SETFLOAT(&(x->force[12]), atom_getfloatarg(3, argc, argv)); + SETFLOAT(&(x->force[2]), atom_getfloatarg(3, argc, argv)); + x->posZ_old = atom_getfloatarg(3, argc, argv); + } + else + { + SETFLOAT(&(x->force[12]), 0); + SETFLOAT(&(x->force[2]), 0); + x->posZ_old = 0; + } + + if (argc>=3) + { + SETFLOAT(&(x->force[11]), atom_getfloatarg(2, argc, argv)); + SETFLOAT(&(x->force[1]), atom_getfloatarg(2, argc, argv)); + x->posY_old = atom_getfloatarg(2, argc, argv); + + } + else + { + SETFLOAT(&(x->force[1]), 0); + SETFLOAT(&(x->force[11]), 0); + x->posY_old = 0; + } + + if (argc>=2) + { + SETFLOAT(&(x->force[10]), atom_getfloatarg(1, argc, argv)); + SETFLOAT(&(x->force[0]), atom_getfloatarg(1, argc, argv)); + x->posX_old = atom_getfloatarg(1, argc, argv); + } + else + { + SETFLOAT(&(x->force[10]), 0); + SETFLOAT(&(x->force[0]), 0); + x->posX_old = 0; + } + + return (x); +} + +void iSphere3D_setup(void) +{ + + iSphere3D_class = class_new(gensym("iSphere3D"), + (t_newmethod)iSphere3D_new, + 0, sizeof(t_iSphere3D), + CLASS_DEFAULT, A_GIMME, 0); + + class_addcreator((t_newmethod)iSphere3D_new, gensym("pmpd.iSphere3D"), A_GIMME, 0); + + class_addbang(iSphere3D_class, iSphere3D_bang); + class_addmethod(iSphere3D_class, (t_method)iSphere3D_setFN, gensym("setFN"), A_DEFFLOAT, 0); + class_addmethod(iSphere3D_class, (t_method)iSphere3D_setKN, gensym("setKN"), A_DEFFLOAT, 0); + class_addmethod(iSphere3D_class, (t_method)iSphere3D_setDN, gensym("setDN"), A_DEFFLOAT, 0); + class_addmethod(iSphere3D_class, (t_method)iSphere3D_setX, gensym("setX"), A_DEFFLOAT, 0); + class_addmethod(iSphere3D_class, (t_method)iSphere3D_setY, gensym("setY"), A_DEFFLOAT, 0); + class_addmethod(iSphere3D_class, (t_method)iSphere3D_setZ, gensym("setZ"), A_DEFFLOAT, 0); + class_addmethod(iSphere3D_class, (t_method)iSphere3D_setXYZ, gensym("setXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(iSphere3D_class, (t_method)iSphere3D_setRmin, gensym("setRmin"), A_DEFFLOAT, 0); + class_addmethod(iSphere3D_class, (t_method)iSphere3D_setRmax, gensym("setRmax"), A_DEFFLOAT, 0); + class_addmethod(iSphere3D_class, (t_method)iSphere3D_setFRN, gensym("setFRN"), A_DEFFLOAT, 0); + class_addmethod(iSphere3D_class, (t_method)iSphere3D_setdN, gensym("setdN"), A_DEFFLOAT, 0); + class_addmethod(iSphere3D_class, (t_method)iSphere3D_setdRN, gensym("setdRN"), A_DEFFLOAT, 0); + class_addmethod(iSphere3D_class, (t_method)iSphere3D_setG, gensym("setG"), A_DEFFLOAT, 0); + class_addmethod(iSphere3D_class, (t_method)iSphere3D_setdKN, gensym("setdKN"), A_DEFFLOAT, 0); + class_addmethod(iSphere3D_class, (t_method)iSphere3D_setdGN, gensym("setdGN"), A_DEFFLOAT, 0); + +} + + diff --git a/src/lia.c b/src/lia.c new file mode 100755 index 0000000..1293cac --- /dev/null +++ b/src/lia.c @@ -0,0 +1,162 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *liaKD_class; + +typedef struct _liaKD { + 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; + +void liaKD_float(t_liaKD *x, t_floatarg f1) +{ + x->position1 = f1; +} + +void liaKD_bang(t_liaKD *x) +{ + t_float force1, force2, distance; + + distance = (x->position2 - x->position1); +//distance = abs(x->position2 - x->position1); + if (distance<0) distance = -distance; + + force1 = x->raideur*(distance-(x->longueur)) + x->viscosite*(distance - x->distance_old) ; + + x->distance_old = distance; + + if (distance > x->Lmax) force1=0; + if (distance < x->Lmin) force1=0; + + if (distance != 0) + { + force1 = force1 * (x->position2 - x->position1) / distance; + } + + force2 = -force1 + (x->position_old2 - x->position2)*x->D2; + force1 += (x->position_old1 - x->position1)*x->D2; + // masse damping + + outlet_float(x->force1, force1); + outlet_float(x->force2, force2); + + + x->position_old1 = x->position1; + x->position_old2 = x->position2; + +} + +void liaKD_reset(t_liaKD *x) +{ + x->position1 = 0; + x->position2 = 0; + + x->position_old1 = 0; + x->position_old2 = 0; + + x->distance_old = x->longueur; +} + +void liaKD_resetF(t_liaKD *x) +{ + x->position_old1 = x->position1; + x->position_old2 = x->position2; + + x->distance_old = x->longueur; +} + +void liaKD_resetl(t_liaKD *x) +{ + x->longueur = (x->position1 - x->position2); +} + +void liaKD_setL(t_liaKD *x, t_float L) +{ + x->longueur = L; +} + +void liaKD_setK(t_liaKD *x, t_float K) +{ + x->raideur = K; +} + +void liaKD_setD(t_liaKD *x, t_float D) +{ + x->viscosite = D; +} + +void liaKD_setD2(t_liaKD *x, t_float D2) +{ + x->D2 = D2; +} + +void liaKD_Lmin(t_liaKD *x, t_float Lmin) +{ + x->Lmin = Lmin; +} + +void liaKD_Lmax(t_liaKD *x, t_float Lmax) +{ + x->Lmax = Lmax; +} + +static void liaKD_free(t_liaKD *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 ) +{ + + t_liaKD *x = (t_liaKD *)pd_new(liaKD_class); + + x->x_sym = s; + pd_bind(&x->x_obj.ob_pd, s); + + floatinlet_new(&x->x_obj, &x->position2); + + x->force1=outlet_new(&x->x_obj, 0); + x->force2=outlet_new(&x->x_obj, 0); + + x->position1 = 0; + x->position2 = 0; + + x->raideur=K; + x->viscosite=D; + x->D2=D2; + + x->Lmin= 0; + x->Lmax= 10000; + + x->longueur=L; + + return (void *)x; +} + +void lia_setup(void) +{ + liaKD_class = class_new(gensym("lia"), + (t_newmethod)liaKD_new, + (t_method)liaKD_free, + sizeof(t_liaKD), + 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); +} diff --git a/src/lia2D.c b/src/lia2D.c new file mode 100755 index 0000000..ff5e0aa --- /dev/null +++ b/src/lia2D.c @@ -0,0 +1,213 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *lia2D_class; + +typedef struct _lia2D { + t_object x_obj; + t_float raideur, viscosite, D2, longueur, distance_old; + t_float position2Dx1, position2Dx2, posx_old1, posx_old2; + t_float position2Dy1, position2Dy2, posy_old1, posy_old2; + t_float Lmin, Lmax, muscle; + t_outlet *force1; + t_outlet *force2; + t_symbol *x_sym; // receive +} t_lia2D; + +void lia2D_position2D(t_lia2D *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) +{ + x->position2Dx2 = f1; + x->position2Dy2 = f2; +} + +void lia2D_bang(t_lia2D *x) +{ + t_float force, force2, forcex1, forcey1, forcex2, forcey2, distance; + t_atom force1[2]; + + distance = sqrt ( pow((x->position2Dx2-x->position2Dx1), 2) + pow((x->position2Dy2-x->position2Dy1), 2) ); + + force = ( x->raideur*(distance-(x->longueur * x->muscle)) ) + ( x->viscosite*(distance-x->distance_old) ); + + if (distance > x->Lmax) force=0; + if (distance < x->Lmin) force=0; + + if (distance != 0) + { + forcex1 = force * (x->position2Dx2 - x->position2Dx1) / distance; + forcey1 = force * (x->position2Dy2 - x->position2Dy1) / distance; + } + else + { + forcex1 = 0; + forcey1 = 0 ; + } + + forcex2 = -forcex1; + forcey2 = -forcey1; + + forcex1 += (x->posx_old1 - x->position2Dx1)*x->D2; + forcey1 += (x->posy_old1 - x->position2Dy1)*x->D2; + + forcex2 += (x->posx_old2 - x->position2Dx2)*x->D2; + forcey2 += (x->posy_old2 - x->position2Dy2)*x->D2; + + SETFLOAT(&(force1[0]), forcex2 ); + SETFLOAT(&(force1[1]), forcey2 ); + + outlet_anything(x->force2, gensym("force2D"), 2, force1); + + SETFLOAT(&(force1[0]), forcex1 ); + SETFLOAT(&(force1[1]), forcey1 ); + + outlet_anything(x->force1, gensym("force2D"), 2, force1); + + x->posx_old2 = x->position2Dx2; + x->posx_old1 = x->position2Dx1; + + x->posy_old2 = x->position2Dy2; + x->posy_old1 = x->position2Dy1; + + x->distance_old = distance; +} + +void lia2D_reset(t_lia2D *x) +{ + x->position2Dx1 = 0; + x->position2Dx2 = 0; + x->posx_old1 = 0; + x->posx_old2 = 0; + + x->position2Dy1 = 0; + x->position2Dy2 = 0; + x->posy_old1 = 0; + x->posy_old2 = 0; + + x->distance_old = x->longueur; +} + +void lia2D_resetF(t_lia2D *x) +{ + + x->posx_old1 = x->position2Dx1; + x->posx_old2 = x->position2Dx2; + + x->posy_old1 = x->position2Dy1; + x->posy_old2 = x->position2Dy2; + + x->distance_old = x->longueur; + +} + +void lia2D_resetL(t_lia2D *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) +{ + x->raideur = K; +} + +void lia2D_setL(t_lia2D *x, t_float L) +{ + x->longueur = L; +} + +void lia2D_setD(t_lia2D *x, t_float D) +{ + x->viscosite = D; +} + +void lia2D_setD2(t_lia2D *x, t_float D) +{ + x->D2 = D; +} + +void lia2D_Lmin(t_lia2D *x, t_float Lmin) +{ + x->Lmin = Lmin; +} + +void lia2D_Lmax(t_lia2D *x, t_float Lmax) +{ + x->Lmax = Lmax; +} + +void lia2D_muscle(t_lia2D *x, t_float muscle) +{ + x->muscle = muscle; +} + +static void lia2D_free(t_lia2D *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) +{ + + t_lia2D *x = (t_lia2D *)pd_new(lia2D_class); + + x->x_sym = s; + pd_bind(&x->x_obj.ob_pd, s); + + inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("position2D"), gensym("position2D2")); + + x->force1=outlet_new(&x->x_obj, 0); + x->force2=outlet_new(&x->x_obj, 0); + + x->position2Dx1 = 0; + x->position2Dx2 = 0; + x->position2Dy1 = 0; + x->position2Dy2 = 0; + + x->raideur=K; + x->viscosite=D; + x->longueur = l; + + x->D2=D2; + + x->Lmin= 0; + x->Lmax= 10000; + x->muscle= 1; + + x->distance_old = x->longueur; + + return (x); +} + +void lia2D_setup(void) +{ + + lia2D_class = class_new(gensym("lia2D"), + (t_newmethod)lia2D_new, + (t_method)lia2D_free, + sizeof(t_lia2D), + 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); + +} diff --git a/src/lia3D.c b/src/lia3D.c new file mode 100755 index 0000000..4621516 --- /dev/null +++ b/src/lia3D.c @@ -0,0 +1,238 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *lia3D_class; + +typedef struct _lia3D { + t_object x_obj; + t_float raideur, viscosite, D2, longueur, distance_old; + t_float position3Dx1, position3Dx2, posx_old1, posx_old2; + t_float position3Dy1, position3Dy2, posy_old1, posy_old2; + t_float position3Dz1, position3Dz2, posz_old1, posz_old2; + t_float Lmin, Lmax, muscle; + t_outlet *force1; + t_outlet *force2; + t_symbol *x_sym; // receive +} t_lia3D; + +void lia3D_position3D(t_lia3D *x, t_floatarg f1, t_floatarg f2, t_floatarg f3) +{ + x->position3Dx1 = f1; + x->position3Dy1 = f2; + x->position3Dz1 = f3; + +} + +void lia3D_position3D2(t_lia3D *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) +{ + t_float force, force2, forcex1, forcey1, forcez1, forcex2, forcey2, forcez2, distance; + t_atom force1[3]; + + distance = sqrt ( pow((x->position3Dx2-x->position3Dx1), 2) + pow((x->position3Dy2-x->position3Dy1),2) + pow((x->position3Dz2-x->position3Dz1), 2) ); + + force = ( x->raideur*(distance-(x->longueur * x->muscle)) ) + ( x->viscosite*(distance-x->distance_old) ); + + if (distance > x->Lmax) force=0; + if (distance < x->Lmin) force=0; + + if (distance != 0) + { + forcex1 = force * (x->position3Dx2 - x->position3Dx1) / distance; + forcey1 = force * (x->position3Dy2 - x->position3Dy1) / distance; + forcez1 = force * (x->position3Dz2 - x->position3Dz1) / distance; + } + else + { + forcex1 = 0; + forcey1 = 0; + forcez1 = 0; + } + + forcex2 = -forcex1; + forcey2 = -forcey1; + forcez2 = -forcez1; + + forcex1 += (x->posx_old1 - x->position3Dx1)*x->D2; + forcey1 += (x->posy_old1 - x->position3Dy1)*x->D2; + forcez1 += (x->posz_old1 - x->position3Dz1)*x->D2; + + forcex2 += (x->posx_old2 - x->position3Dx2)*x->D2; + forcey2 += (x->posy_old2 - x->position3Dy2)*x->D2; + forcez2 += (x->posz_old2 - x->position3Dz2)*x->D2; + + + SETFLOAT(&(force1[0]), forcex1 ); + SETFLOAT(&(force1[1]), forcey1 ); + SETFLOAT(&(force1[2]), forcez1 ); + outlet_anything(x->force1, gensym("force3D"), 3, force1); + + SETFLOAT(&(force1[0]), forcex2 ); + SETFLOAT(&(force1[1]), forcey2 ); + SETFLOAT(&(force1[2]), forcez2 ); + + outlet_anything(x->force2, gensym("force3D"), 3, force1); + + x->posx_old2 = x->position3Dx2; + x->posx_old1 = x->position3Dx1; + + x->posy_old2 = x->position3Dy2; + x->posy_old1 = x->position3Dy1; + + x->posz_old2 = x->position3Dz2; + x->posz_old1 = x->position3Dz1; + + x->distance_old = distance; +} + +void lia3D_reset(t_lia3D *x) +{ + x->position3Dx1 = 0; + x->position3Dx2 = 0; + x->posx_old1 = 0; + x->posx_old2 = 0; + + x->position3Dy1 = 0; + x->position3Dy2 = 0; + x->posy_old1 = 0; + x->posy_old2 = 0; + + x->position3Dz1 = 0; + x->position3Dz2 = 0; + x->posz_old1 = 0; + x->posz_old2 = 0; + + x->distance_old = x->longueur; + +} + +void lia3D_resetF(t_lia3D *x) +{ + + x->posx_old1 = x->position3Dx1; + x->posx_old2 = x->position3Dx2; + + x->posy_old1 = x->position3Dy1; + x->posy_old2 = x->position3Dy2; + + x->posz_old1 = x->position3Dz1; + x->posz_old2 = x->position3Dz2; + + x->distance_old = x->longueur; + +} + +void lia3D_resetL(t_lia3D *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) +{ + x->raideur = K; +} + +void lia3D_setL(t_lia3D *x, t_float L) +{ + x->longueur = L; +} + +void lia3D_setD(t_lia3D *x, t_float D) +{ + x->viscosite = D; +} + +void lia3D_setD2(t_lia3D *x, t_float D2) +{ + x->D2 = D2; +} + +void lia3D_Lmin(t_lia3D *x, t_float Lmin) +{ + x->Lmin = Lmin; +} + +void lia3D_Lmax(t_lia3D *x, t_float Lmax) +{ + x->Lmax = Lmax; +} + +void lia3D_muscle(t_lia3D *x, t_float muscle) +{ + x->muscle = muscle; +} + +static void lia3D_free(t_lia3D *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) +{ + + t_lia3D *x = (t_lia3D *)pd_new(lia3D_class); + + x->x_sym = s; + pd_bind(&x->x_obj.ob_pd, s); + + inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("position3D"), gensym("position3D2")); + + x->force1=outlet_new(&x->x_obj, 0); + x->force2=outlet_new(&x->x_obj, 0); + + x->position3Dx1 = 0; + x->position3Dx2 = 0; + x->position3Dy1 = 0; + x->position3Dy2 = 0; + x->position3Dz1 = 0; + x->position3Dz2 = 0; + + x->raideur = K; + x->viscosite = D; + x->longueur = l; + + x->D2 = D2; + + x->Lmin= 0; + x->Lmax= 10000; + + x->distance_old = x->longueur; + + x->muscle = 1; + + return (void *)x; +} + +void lia3D_setup(void) +{ + + lia3D_class = class_new(gensym("lia3D"), + (t_newmethod)lia3D_new, + (t_method)lia3D_free, + sizeof(t_lia3D), + 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); + +} diff --git a/src/makefile b/src/makefile new file mode 100755 index 0000000..32ef4e0 --- /dev/null +++ b/src/makefile @@ -0,0 +1,95 @@ +current: + echo make pd_linux, pd_nt, pd_darwin + +clean: ; rm -f *.pd_linux *.o + +# ----------------------- NT ----------------------- + +pd_nt: pmpd.dll + +.SUFFIXES: .dll + +PDNTCFLAGS = /W3 /WX /DNT /DPD /nologo +VC="C:\Program Files\Microsoft Visual Studio\Vc98" + +PDNTINCLUDE = /I. /I\tcl\include /I\pds\win32\pd36\src /I$(VC)\include + +PDNTLDIR = $(VC)\lib +PDNTLIB = $(PDNTLDIR)\libc.lib \ + $(PDNTLDIR)\oldnames.lib \ + $(PDNTLDIR)\kernel32.lib \ + \pds\win32\pd37\bin\pd.lib + +.c.dll: + cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c $*.c + link /dll /export:$*_setup $*.obj $(PDNTLIB) + +# ----------------------- IRIX 5.x ----------------------- + +pd_irix5: foo1.pd_irix5 foo2.pd_irix5 dspobj~.pd_irix5 + +.SUFFIXES: .pd_irix5 + +SGICFLAGS5 = -o32 -DPD -DUNIX -DIRIX -O2 + + +SGIINCLUDE = -I../../src/ + +.c.pd_irix5: + cc $(SGICFLAGS5) $(SGIINCLUDE) -o $*.o -c $*.c + ld -elf -shared -rdata_shared -o $*.pd_irix5 $*.o + rm $*.o + +# ----------------------- IRIX 6.x ----------------------- + +pd_irix6: foo1.pd_irix6 foo2.pd_irix6 dspobj~.pd_irix6 + +.SUFFIXES: .pd_irix6 + +SGICFLAGS6 = -n32 -DPD -DUNIX -DIRIX -DN32 -woff 1080,1064,1185 \ + -OPT:roundoff=3 -OPT:IEEE_arithmetic=3 -OPT:cray_ivdep=true \ + -Ofast=ip32 + +.c.pd_irix6: + cc $(SGICFLAGS6) $(SGIINCLUDE) -o $*.o -c $*.c + ld -IPA -n32 -shared -rdata_shared -o $*.pd_irix6 $*.o + rm $*.o + +# ----------------------- LINUX i386 ----------------------- + +pd_linux: pmpd.pd_linux + +.SUFFIXES: .pd_linux + +LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer \ + -Wall -W -Wshadow -Wstrict-prototypes -Werror \ + -Wno-unused -Wno-parentheses -Wno-switch + +LINUXINCLUDE = -I../../src + +.c.pd_linux: + cc $(LINUXCFLAGS) $(LINUXINCLUDE) -o $*.o -c $*.c + ld -export_dynamic -shared -o $*.pd_linux $*.o -lc -lm + strip --strip-unneeded $*.pd_linux + rm $*.o + +# ----------------------- Mac OS X (Darwin) ----------------------- + +pd_darwin: pmpd.pd_darwin + +.SUFFIXES: .pd_darwin + +DARWINCFLAGS = -DPD -DUNIX -DMACOSX -O2 \ + -Wall -W -Wshadow -Wstrict-prototypes \ + -Wno-unused -Wno-parentheses -Wno-switch + +# where is your m_pd.h ??? +DARWININCLUDE = -I/. -I../pd/src -I../pd/obj + +.c.pd_darwin: + cc $(DARWINCFLAGS) $(DARWININCLUDE) -o $*.o -c $*.c + cc -bundle -undefined suppress -flat_namespace -o $*.pd_darwin $*.o + rm -f $*.o ../$*.pd_darwin + ln -s $*/$*.pd_darwin .. + + diff --git a/src/masse.c b/src/masse.c new file mode 100755 index 0000000..8241854 --- /dev/null +++ b/src/masse.c @@ -0,0 +1,153 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *masse_class; + +typedef struct _masse { + t_object x_obj; + t_float pos_old_1, pos_old_2, Xinit; + t_float force, masse, dX; + t_float minX, maxX; + t_outlet *position_new, *vitesse_out, *force_out; + t_symbol *x_sym; // receive +} t_masse; + +extern t_float max(t_float, t_float); +extern t_float min(t_float, t_float); + + +void masse_minX(t_masse *x, t_floatarg f1) +{ + x->minX = f1; +} + +void masse_maxX(t_masse *x, t_floatarg f1) +{ + x->maxX = f1; +} + +void masse_float(t_masse *x, t_floatarg f1) +{ + x->force += f1; +} + +void masse_bang(t_masse *x) +{ + t_float pos_new; + + if (x->masse > 0) + pos_new = x->force/x->masse + 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); + + pos_new += x->dX; + + x->pos_old_1 += x->dX; // pour ne pas avoir d'inertie suplementaire du a ce deplacement + + outlet_float(x->vitesse_out, x->pos_old_1 - x->pos_old_2); + outlet_float(x->force_out, x->force); + outlet_float(x->position_new, pos_new); + + x->pos_old_2 = x->pos_old_1; + x->pos_old_1 = pos_new; + + x->force = 0; + x->dX = 0; + +} + +void masse_reset(t_masse *x) +{ + x->pos_old_2 = x->Xinit; + x->pos_old_1 = x->Xinit; + + x->force=0; + + outlet_float(x->position_new, x->Xinit); +} + +void masse_resetF(t_masse *x) +{ + x->force=0; +} + +void masse_dX(t_masse *x, t_float posX) +{ + x->dX += posX; +} + +void masse_setX(t_masse *x, t_float posX) +{ + x->pos_old_2 = posX; // clear hystory for stability (instability) problem + x->pos_old_1 = posX; + + x->force=0; + + outlet_float(x->position_new, posX); +} + +void masse_loadbang(t_masse *x) +{ + outlet_float(x->position_new, x->Xinit); +} + +void masse_set_masse(t_masse *x, t_float mass) +{ + x->masse=mass; +} + +static void masse_free(t_masse *x) +{ + pd_unbind(&x->x_obj.ob_pd, x->x_sym); +} + +void *masse_new(t_symbol *s, t_floatarg M, t_floatarg X) +{ + + t_masse *x = (t_masse *)pd_new(masse_class); + + x->x_sym = s; + pd_bind(&x->x_obj.ob_pd, s); + + x->position_new=outlet_new(&x->x_obj, 0); + x->force_out=outlet_new(&x->x_obj, 0); + x->vitesse_out=outlet_new(&x->x_obj, 0); + + x->Xinit=X; + + x->pos_old_1 = X; + x->pos_old_2 = X; + x->force=0; + x->masse=M; + + x->minX = -100000; + x->maxX = 100000; + + if (x->masse<=0) x->masse=1; + + return (void *)x; +} + +void masse_setup(void) +{ + + masse_class = class_new(gensym("masse"), + (t_newmethod)masse_new, + (t_method)masse_free, + sizeof(t_masse), + 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); +} + diff --git a/src/masse2D.c b/src/masse2D.c new file mode 100755 index 0000000..067a69b --- /dev/null +++ b/src/masse2D.c @@ -0,0 +1,810 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *masse2D_class; + +typedef struct _masse2D { + 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 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; + +extern t_float max(t_float, t_float); +extern t_float min(t_float, t_float); + + +static int makeseed(void) +{ + static unsigned int random_nextseed = 1489853723; + random_nextseed = random_nextseed * 435898247 + 938284287; + return (random_nextseed & 0x7fffffff); +} + +static float random_bang(t_masse2D *x) +{ + int nval; + int range = 2000000; + float rnd; + unsigned int randval = x->x_state; + x->x_state = randval = randval * 472940017 + 832416023; + nval = ((double)range) * ((double)randval) + * (1./4294967296.); + if (nval >= range) nval = range-1; + + rnd=nval; + + rnd-=1000000; + rnd=rnd/1000000.; //pour mettre entre -1 et 1; + return (rnd); +} + +void masse2D_seuil(t_masse2D *x, t_floatarg f1) +{ + x->seuil = f1; +} + +void masse2D_on(t_masse2D *x) +{ + x->onoff = 1; +} + +void masse2D_off(t_masse2D *x) +{ + x->onoff = 0; +} + +void masse2D_minX(t_masse2D *x, t_floatarg f1) +{ + x->minX = f1; +} + +void masse2D_maxX(t_masse2D *x, t_floatarg f1) +{ + x->maxX = f1; +} + +void masse2D_minY(t_masse2D *x, t_floatarg f1) +{ + x->minY = f1; +} + +void masse2D_maxY(t_masse2D *x, t_floatarg f1) +{ + x->maxY = f1; +} + +void masse2D_force(t_masse2D *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) +{ + x->dX += f1; + x->dY += f2; +} + +void masse2D_damp(t_masse2D *x, t_floatarg f1) +{ + x->damp = f1; +} + +void masse2D_dX(t_masse2D *x, t_floatarg f1) +{ + x->dX += f1; +} + +void masse2D_dY(t_masse2D *x, t_floatarg f1) +{ + x->dY += f1; +} + +void masse2D_bang(t_masse2D *x) +{ + t_float posX_new, posY_new, vX=1, vY=1; + if (x->onoff != 0) + { + + if (x->seuil > 0) + { + if (x->posY_old_1 == x->minY) // si on est en dehors de la structure -> frottement sec sur les bords + { + if (fabs(x->forceX)<=(x->seuil * -(x->forceY))) + vX = 0; // on est a l'interieur du cone de frotement, + } + + if (x->posY_old_1 == x->maxY) // si on est en dehors de la structure -> frottement sec sur les bords + { + if (fabs(x->forceX)<=(x->seuil * (x->forceY))) + vX = 0; // on est a l'interieur du cone de frotement, + } + + if (x->posX_old_1 == x->minX) // si on est en dehors de la structure -> frottement sec sur les bords + { + if (fabs(x->forceX)<=(x->seuil * -(x->forceY))) + vY = 0; // on est a l'interieur du cone de frotement, + } + + if (x->posX_old_1 == x->maxX) // si on est en dehors de la structure -> frottement sec sur les bords + { + if (fabs(x->forceX)<=(x->seuil * (x->forceY))) + vY = 0; // on est a l'interieur du cone de frotement, + } + } + + 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) + { + 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; + } + else + { + posX_new = x->posX_old_1; + posY_new = x->posY_old_1; + } + + if (vX==0) + posX_new = x->posX_old_1; // on n'a pas de mv qd on est a l'interieur du cone de frotement + if (vY==0) + posY_new = x->posY_old_1; + + posX_new = max(min(posX_new, x->maxX), x->minX); + posY_new = max(min(posY_new, x->maxY), x->minY); + + posX_new += x->dX; + posY_new += x->dY; + + x->posX_old_1 += x->dX; // pour eviter l'inertie + x->posY_old_1 += x->dY; + + SETFLOAT(&(x->pos_new[0]), posX_new ); + SETFLOAT(&(x->pos_new[1]), posY_new ); + + x->posX_old_2 = x->posX_old_1; + x->posX_old_1 = posX_new; + + x->posY_old_2 = x->posY_old_1; + x->posY_old_1 = posY_new; + + SETFLOAT(&(x->force[0]), x->forceX ); + SETFLOAT(&(x->force[1]), x->forceY ); + SETFLOAT(&(x->force[2]), sqrt( (x->forceX * x->forceX) + (x->forceY * x->forceY) )); + + x->forceX=0; + x->forceY=0; + + x->dX=0; + x->dY=0; + + x->VX = x->posX_old_1 - x->posX_old_2; + x->VY = x->posY_old_1 - x->posY_old_2; + + SETFLOAT(&(x->vitesse[0]), x->VX ); + SETFLOAT(&(x->vitesse[1]), x->VY ); + SETFLOAT(&(x->vitesse[2]), sqrt( (x->VX * x->VX) + (x->VY * x->VY) )); + + outlet_anything(x->vitesse_out, gensym("velocity2D"), 3, x->vitesse); + outlet_anything(x->force_out, gensym("force2D"), 3, x->force); + outlet_anything(x->position2D_new, gensym("position2D"), 2, x->pos_new); + } +} + +void masse2D_reset(t_masse2D *x) +{ + x->posX_old_2 = x->Xinit; + x->posX_old_1 = x->Xinit; + x->forceX=0; + + x->posY_old_2 = x->Yinit; + x->posY_old_1 = x->Yinit; + x->forceY=0; + + x->VX = 0; + x->VY = 0; + + x->dX=0; + x->dY=0; + + x->seuil=0; + + x->onoff = 1; + + SETFLOAT(&(x->pos_new[0]), x->Xinit ); + SETFLOAT(&(x->pos_new[1]), x->Yinit ); + + SETFLOAT(&(x->force[0]), 0 ); + SETFLOAT(&(x->force[1]), 0 ); + SETFLOAT(&(x->force[2]), 0 ); + + SETFLOAT(&(x->vitesse[0]), 0 ); + SETFLOAT(&(x->vitesse[1]), 0 ); + SETFLOAT(&(x->vitesse[2]), 0 ); + + outlet_anything(x->vitesse_out, gensym("velocity2D"), 3, x->vitesse); + outlet_anything(x->force_out, gensym("force2D"), 3, x->force); + outlet_anything(x->position2D_new, gensym("position2D"), 2, x->pos_new); +} + +void masse2D_resetf(t_masse2D *x) +{ + x->dX=0; + x->dY=0; + + x->forceX=0; + x->forceY=0; +} + +void masse2D_setXY(t_masse2D *x, t_float posX, t_float posY) +{ + x->posX_old_2 = posX; + x->posX_old_1 = posX; + x->forceX=0; + + x->posY_old_2 = posY; + x->posY_old_1 = posY; + x->forceY=0; + + SETFLOAT(&(x->pos_new[0]), posX ); + SETFLOAT(&(x->pos_new[1]), posY ); + + outlet_anything(x->position2D_new, gensym("position2D"), 2, x->pos_new); +} + +void masse2D_setX(t_masse2D *x, t_float posX) +{ + x->posX_old_2 = posX; + x->posX_old_1 = posX; + x->forceX=0; + + SETFLOAT(&(x->pos_new[0]), posX ); + + outlet_anything(x->position2D_new, gensym("position2D"), 2, x->pos_new); +} + +void masse2D_setY(t_masse2D *x, t_float posY) +{ + x->posY_old_2 = posY; + x->posY_old_1 = posY; + x->forceY=0; + + SETFLOAT(&(x->pos_new[1]), posY ); + + outlet_anything(x->position2D_new, gensym("position2D"), 2, x->pos_new); +} + +void masse2D_loadbang(t_masse2D *x) +{ + outlet_anything(x->position2D_new, gensym("position2D"), 2, x->pos_new); +} + + +void masse2D_set_masse2D(t_masse2D *x, t_float mass) +{ + x->masse2D=mass; +} + +void masse2D_inter_ambient(t_masse2D *x, t_symbol *s, int argc, t_atom *argv) +{ + if (argc == 12) + // 0 : FX + // 1 : FY + // 2 : RndX + // 3 : RndY + // 4 : D2 + // 5 : rien + // 6 : Xmin + // 7 : Xmax + // 8 : Ymin + // 9 : Ymax + // 10 : dX + // 11 : dY + { + if (x->posX_old_1 > atom_getfloatarg(6, argc, argv)) + { + if (x->posX_old_1 < atom_getfloatarg(7, argc, argv)) + { + if (x->posY_old_1 > atom_getfloatarg(8, argc, argv)) + { + if (x->posY_old_1 < atom_getfloatarg(9, argc, argv)) + { + x->forceX += atom_getfloatarg(0, argc, argv); + x->forceY += atom_getfloatarg(1, argc, argv); // constant + + x->forceX += random_bang(x)*atom_getfloatarg(2, argc, argv); + x->forceY += random_bang(x)*atom_getfloatarg(3, argc, argv); // random + + x->forceX += atom_getfloatarg(4, argc, argv) * ((x->posX_old_2)-(x->posX_old_1)); + x->forceY += atom_getfloatarg(4, argc, argv) * ((x->posY_old_2)-(x->posY_old_1)); // damping + + x->dX += atom_getfloatarg(10, argc, argv); + x->dY += atom_getfloatarg(11, argc, argv); // constant + } + } + } + } + } + else + { + error("bad ambient interraction message"); + } +} + +void masse2D_inter_seg(t_masse2D *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; +t_float profondeur, prof_max; + + if (argc == 12) + // 0 : posx1 + // 1 : posy1 + // 2 : posx2 + // 3 : posy2 + // 4 : profondeur max + // 5 : F CT Normal + // 6 : F CT Tengentiel + // 7 : K normal + // 8 : Damp2 normal + // 9 : Damp2 tan + // 10 : displacement Normal + // 11 : d Tan + + { + posx1 = atom_getfloatarg(0, argc, argv); + posy1 = atom_getfloatarg(1, argc, argv); + posx2 = atom_getfloatarg(2, argc, argv); + posy2 = atom_getfloatarg(3, argc, argv); + + b1 = posx2 - posx1; + a1 = -posy2 + posy1; + + if (!((a1==0) & (b1==0))) + { + + tmp = sqrt((a1*a1)+(b1*b1)); // = longueur du vecteur pour renormalisation + if (tmp !=0) + { + a1 = a1/tmp; + b1 = b1/tmp; + } + else + { + a1 = 0; + b1 = 0; + } + + c1 = a1*posx1+b1*posy1; + + profondeur = ( (a1 * x->posX_old_1) + (b1 * x->posY_old_1) ) - c1; + + if ( ( profondeur < 0) & (profondeur > - atom_getfloatarg(4, argc, argv)) ) + { + a2 = b1; + b2 = -a1; + c2 = a2*posx1+b2*posy1; + if (( (a2 * x->posX_old_1) + (b2 * x->posY_old_1) ) > c2) + { + a3 = a2; + b3 = b2; + c3 = a3*posx2+b3*posy2; + if (( (a3 * x->posX_old_1) + (b3 * x->posY_old_1) ) < c3) + { + tmp = atom_getfloatarg(5, argc, argv); // force ct normal + x->forceX += tmp * a1; + x->forceY += tmp * b1; + + tmp = atom_getfloatarg(6, argc, argv); // force ct normal + x->forceX -= tmp * b1; + x->forceY -= tmp * -a1; + + tmp = atom_getfloatarg(7, argc, argv); // force K normal + tmp *= profondeur; + x->forceX -= tmp * a1; + x->forceY -= tmp * b1; + + tmp = atom_getfloatarg(8, argc, argv); // damping2 normal + tmp *= ( x->VX * a1 + x->VY * b1 ); + x->forceX -= tmp * a1 ; + x->forceY -= tmp * b1 ; + + tmp = atom_getfloatarg(9, argc, argv); // damping2 tangentiel + tmp *= ( x->VX * b1 - x->VY * a1 ); + x->forceX -= tmp * b1 ; + x->forceY -= tmp * -a1 ; + + tmp = atom_getfloatarg(10, argc, argv); // displacement normal + x->dX += tmp * a1 ; + x->dY += tmp * b1 ; + + tmp = atom_getfloatarg(11, argc, argv); // displacement tengentiel + x->dX -= tmp * b1 ; + x->dY -= tmp * -a1 ; + } + } + } + } + } + else + { + error("bad interact_2D_segment message"); + } +} + +void masse2D_inter_line(t_masse2D *x, t_symbol *s, int argc, t_atom *argv) +{ +t_float a1, b1, c1, tmp; +t_float posx1, posx2, posy1, posy2; +t_float profondeur, prof_max; + + if (argc == 12) + // 0 : posx1 + // 1 : posy1 + // 2 : posx2 + // 3 : posy2 + // 4 : profondeur max + // 5 : F CT Normal + // 6 : F CT Tengentiel + // 7 : K normal + // 8 : Damp2 normal + // 9 : Damp2 tan + // 10 : d normal + // 11 : d tengential + { + posx1 = atom_getfloatarg(0, argc, argv); + posy1 = atom_getfloatarg(1, argc, argv); + posx2 = atom_getfloatarg(2, argc, argv); + posy2 = atom_getfloatarg(3, argc, argv); + + b1 = posx2 - posx1; + a1 = -posy2 + posy1; + + if (!((a1==0) & (b1==0))) + { + tmp = sqrt((a1*a1)+(b1*b1)); // = longueur du vecteur pour renormalisation + a1 = a1/tmp; // composante X de la normal + b1 = b1/tmp; // composante Y de la normal + c1 = a1*posx1+b1*posy1; // + + profondeur = ( (a1 * x->posX_old_1) + (b1 * x->posY_old_1) ) - c1; + if ( ( profondeur < 0) & (profondeur > - atom_getfloatarg(4, argc, argv)) ) + { + tmp = atom_getfloatarg(5, argc, argv); // force ct normal + x->forceX += tmp * a1; + x->forceY += tmp * b1; + + tmp = atom_getfloatarg(6, argc, argv); // force ct tengentiel + x->forceX -= tmp * b1; + x->forceY -= tmp * -a1; + + tmp = atom_getfloatarg(7, argc, argv); // force K normal + tmp *= profondeur ; + x->forceX -= tmp * a1; + x->forceY -= tmp * b1; + + tmp = atom_getfloatarg(8, argc, argv); // damping2 normal + tmp *= ( x->VX * a1 + x->VY * b1 ) ; + x->forceX -= tmp * a1 ; + x->forceY -= tmp * b1 ; + + tmp = atom_getfloatarg(9, argc, argv); // damping2 tangentiel + tmp *= ( x->VX * b1 - x->VY * a1 ); + x->forceX -= tmp * b1 ; + x->forceY -= tmp * -a1 ; + + tmp = atom_getfloatarg(10, argc, argv); // d normal + x->dX += tmp * a1; + x->dY += tmp * b1; + + tmp = atom_getfloatarg(11, argc, argv); // d tangentiel + x->dX -= tmp * b1; + x->dY -= tmp * -a1; + } + } + } + else + { + error("bad interact_2D_line message"); + } +} + +void masse2D_inter_circle(t_masse2D *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 ; +t_float fnx=0, fny=0; +t_float ftx=0, fty=0; + + if (argc == 20) + // 0 : Xcentre + // 1 : Ycendre + // 2 : Rmin + // 3 : Rmax + // 4 : F normal + // 5 : F tangentiel + // 6 : K normal + // 7 : K tengentiel + // 8 : F normal proportionel a 1/R + // 9 : F tengentiel proportionel a 1/R + // 10 : Damp2 normal + // 11 : Damp2 tan + // 12 : deplacement N proportionel a 1/R + // 13 : deplacement tengentiel proportionel a 1/R + // 14 : position ancienne de l'interacteur en X + // 15 : position abcienne de l'interacteur en Y + // 16 : damping de liaison + // 17 : F normal proportionel a 1/R*R + // 18 : normal displacement + // 19 : tengential displacement + + { + posx1 = atom_getfloatarg(0, argc, argv); + posy1 = atom_getfloatarg(1, argc, argv); + Nx = (x->posX_old_1)-posx1; // vecteur deplacement X + Ny = (x->posY_old_1)-posy1; // vecteur deplacement Y + + distance = sqrt((Nx * Nx)+(Ny * Ny)); // distance entre le centre de l'interaction, et le pts + + Dmax= atom_getfloatarg(3, argc, argv); // distance max de l'interaction + if ( (distance > atom_getfloatarg(2, argc, argv)) & (distance < Dmax) ) + { + Nx = Nx/distance; // composante X de la normal (normalisé) + Ny = Ny/distance; // composante Y de la normal. + + tmp = atom_getfloatarg(4, argc, argv); // force constante normal +// x->forceX += tmp * Nx; +// x->forceY += tmp * Ny; + fnx +=tmp; +// fny +=tmp; + + tmp = atom_getfloatarg(5, argc, argv); // force constante tengentiel +// x->forceX += tmp * Ny; +// x->forceY += tmp * -Nx; + ftx +=tmp; +// fty +=tmp; + + tmp = atom_getfloatarg(6, argc, argv); // force variable (K) normal + tmp *= ( Dmax-distance ); +// x->forceX += tmp * Nx ; +// x->forceY += tmp * Ny ; + fnx +=tmp; +// fny +=tmp; + + tmp = atom_getfloatarg(7, argc, argv); // force variable (K) tengentiel + tmp *= ( Dmax-distance ); +// x->forceX += tmp * Ny ; +// x->forceY += tmp * -Nx ; + ftx +=tmp; +// fty +=tmp; + + tmp = atom_getfloatarg(8, argc, argv); // force normal proportionel a 1/r + if (distance != 0) + { + tmp /= distance; +// x->forceX += tmp * Nx ; +// x->forceY += tmp * Ny ; + fnx +=tmp; +// fny +=tmp; + } + + tmp = atom_getfloatarg(9, argc, argv); // force tengentiel proportionel a 1/r + if (distance != 0) + { + tmp /= distance; +// x->forceX -= tmp * Ny ; +// x->forceY -= tmp * -Nx ; + ftx -=tmp; +// fty -=tmp; + } + + tmp = atom_getfloatarg(10, argc, argv); // damping2 normal + tmp *= ( x->VX * Nx + x->VY * Ny ); +// x->forceX -= tmp * Nx ; +// x->forceY -= tmp * Ny ; + fnx -=tmp; +// fny -=tmp; + + tmp = atom_getfloatarg(11, argc, argv); // damping2 tangentiel + tmp *= ( x->VX * Ny - x->VY * Nx ); +// x->forceX -= tmp * Ny ; +// x->forceY -= tmp * -Ny ; + ftx -=tmp; +// fty -=tmp; + + tmp = atom_getfloatarg(12, argc, argv); // d normal + if (distance != 0) + { + tmp /= distance; + x->dX += tmp * Nx ; + x->dY += tmp * Ny ; + } + + tmp = atom_getfloatarg(13, argc, argv); // d tangentiel + if (distance != 0) + { + tmp /= distance; + + x->dX -= tmp * Ny ; + x->dY -= tmp * -Nx ; + } + + tmp = atom_getfloatarg(16, argc, argv); // damping de liaison + if (tmp!= 0) + { + deltaX_old = atom_getfloatarg(14, argc, argv) - x->posX_old_2; + deltaY_old = atom_getfloatarg(15, argc, argv) - x->posY_old_2; + distance_old = sqrt( (deltaX_old * deltaX_old) + (deltaY_old * deltaY_old)); + +// x->forceX -= Nx * tmp * (distance - distance_old); +// x->forceY -= Ny * tmp * (distance - distance_old); + + tmp *= (distance - distance_old); + fnx -=tmp; +// fny -=tmp; + } + + tmp = atom_getfloatarg(17, argc, argv); // force normal proportionel a 1/r2 + if (distance != 0) + { + tmp /= (distance*distance); +// x->forceX -= tmp * Nx; +// x->forceY -= tmp * Ny; + fnx +=tmp; +// fny +=tmp; + } + + tmp = atom_getfloatarg(18, argc, argv); // deplacement constante normal + x->dX += tmp * Nx; + x->dY += tmp * Ny; + + tmp = atom_getfloatarg(19, argc, argv); // deplacement constante tengentiel + x->dX -= tmp * Ny; + x->dY -= tmp * -Nx; + + x->forceX += fnx * Nx + ftx * Ny; // optimisation, but does not change anything... + x->forceY += fnx * Ny - ftx * Nx; + } + } + else + { + error("bad interact_2D_circle message"); + } +} + +void *masse2D_new(t_symbol *s, int argc, t_atom *argv) +{ + + t_masse2D *x = (t_masse2D *)pd_new(masse2D_class); + + x->x_sym = atom_getsymbolarg(0, argc, argv); + x->x_state = makeseed(); + + pd_bind(&x->x_obj.ob_pd, atom_getsymbolarg(0, argc, argv)); + + x->position2D_new=outlet_new(&x->x_obj, 0); + x->force_out=outlet_new(&x->x_obj, 0); + x->vitesse_out=outlet_new(&x->x_obj, 0); + + x->forceX=0; + x->forceY=0; + + if (argc >= 2) + x->masse2D = atom_getfloatarg(1, argc, argv) ; + else + x->masse2D = 1; + + x->onoff = 1; + + x->VX = 0; + x->VY = 0; + + x->dX=0; + x->dY=0; + + if (argc >= 3) + x->Xinit = atom_getfloatarg(2, argc, argv); + else + x->Xinit = 0 ; + + x->posX_old_1 = x->Xinit ; + x->posX_old_2 = x->Xinit; + SETFLOAT(&(x->pos_new[0]), x->Xinit); + + if (argc >= 4) + x->Yinit = atom_getfloatarg(3, argc, argv); + else + x->Yinit = 0 ; + + x->posY_old_1 = x->Yinit ; + x->posY_old_2 = x->Yinit; + SETFLOAT(&(x->pos_new[1]), x->Yinit); + + if (argc >= 5) + x->minX = atom_getfloatarg(4, argc, argv) ; + else + x->minX = -100000; + + if (argc >= 6) + x->maxX = atom_getfloatarg(5, argc, argv) ; + else + x->maxX = 100000; + + if (argc >= 7) + x->minY = atom_getfloatarg(6, argc, argv) ; + else + x->minY = -100000; + + if (argc >= 8) + x->maxY = atom_getfloatarg(7, argc, argv) ; + else + x->maxY = 100000; + + if (argc >= 9) + x->seuil = atom_getfloatarg(8, argc, argv) ; + else + x->seuil = 0; + + if (argc >= 10) + x->damp = atom_getfloatarg(9, argc, argv) ; + else + x->damp = 0; + + return (x); +} + +static void masse2D_free(t_masse2D *x) +{ + pd_unbind(&x->x_obj.ob_pd, x->x_sym); +} + +void masse2D_setup(void) +{ + + masse2D_class = class_new(gensym("masse2D"), + (t_newmethod)masse2D_new, + (t_method)masse2D_free, sizeof(t_masse2D), + 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); + +} diff --git a/src/masse3D.c b/src/masse3D.c new file mode 100755 index 0000000..68dda3b --- /dev/null +++ b/src/masse3D.c @@ -0,0 +1,1093 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *masse3D_class; + +extern t_float max(t_float, t_float); +extern t_float min(t_float, t_float); + + +typedef struct _masse3D { + 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_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; + +void masse3D_on(t_masse3D *x) +{ + x->onoff = 1; +} + +void masse3D_off(t_masse3D *x) +{ + x->onoff = 0; +} + +void masse3D_minX(t_masse3D *x, t_floatarg f1) +{ + x->minX = f1; +} + +void masse3D_maxX(t_masse3D *x, t_floatarg f1) +{ + x->maxX = f1; +} + +void masse3D_minY(t_masse3D *x, t_floatarg f1) +{ + x->minY = f1; +} + +void masse3D_maxY(t_masse3D *x, t_floatarg f1) +{ + x->maxY = f1; +} + +void masse3D_minZ(t_masse3D *x, t_floatarg f1) +{ + x->minZ = f1; +} + +void masse3D_maxZ(t_masse3D *x, t_floatarg f1) +{ + x->maxZ = f1; +} + +void masse3D_seuil(t_masse3D *x, t_floatarg f1) +{ + x->seuil = f1; +} + +void masse3D_damp(t_masse3D *x, t_floatarg f1) +{ + x->damp = f1; +} + +void masse3D_loadbang(t_masse3D *x, t_float posZ) +{ + outlet_anything(x->position3D_new, gensym("position3D"), 3, x->pos_new); +} + +void masse3D_setX(t_masse3D *x, t_float posX) +{ + + x->posX_old_2 = posX; + x->posX_old_1 = posX; + x->forceX=0; + + SETFLOAT(&(x->pos_new[0]), posX); + + outlet_anything(x->position3D_new, gensym("position3D"), 3, x->pos_new); + +} + +void masse3D_setY(t_masse3D *x, t_float posY) +{ + x->posY_old_2 = posY; + x->posY_old_1 = posY; + x->forceY=0; + + SETFLOAT(&(x->pos_new[1]), posY); + + outlet_anything(x->position3D_new, gensym("position3D"), 3, x->pos_new); + +} + +void masse3D_setZ(t_masse3D *x, t_float posZ) +{ + x->posZ_old_2 = posZ; + x->posZ_old_1 = posZ; + x->forceZ=0; + + SETFLOAT(&(x->pos_new[2]), posZ); + + outlet_anything(x->position3D_new, gensym("position3D"), 3, x->pos_new); + +} + +void masse3D_setXYZ(t_masse3D *x, t_float posX, t_float posY, t_float posZ) +{ + + x->posX_old_2 = posX; + x->posX_old_1 = posX; + x->forceX=0; + + x->posY_old_2 = posY; + x->posY_old_1 = posY; + x->forceY=0; + + x->posZ_old_2 = posZ; + x->posZ_old_1 = posZ; + x->forceZ=0; + + SETFLOAT(&(x->pos_new[0]), posX); + SETFLOAT(&(x->pos_new[1]), posY); + SETFLOAT(&(x->pos_new[2]), posZ); + + outlet_anything(x->position3D_new, gensym("position3D"), 3, x->pos_new); +} + +void masse3D_set_masse3D(t_masse3D *x, t_float mass) +{ + x->masse3D=mass; +} + + +void masse3D_force(t_masse3D *x, t_floatarg f1, t_floatarg f2, t_floatarg f3) +{ + x->forceX = x->forceX+f1; + x->forceY = x->forceY+f2; + x->forceZ = x->forceZ+f3; +} + +void masse3D_dXYZ(t_masse3D *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 ) +{ + x->dX += f1; +} + +void masse3D_dY(t_masse3D *x, t_floatarg f1 ) +{ + x->dY += f1; +} + +void masse3D_dZ(t_masse3D *x, t_floatarg f1 ) +{ + x->dZ += f1; +} + +void masse3D_bang(t_masse3D *x) +{ + t_float posX_new, posY_new, posZ_new, vX=1, vY=1, vZ=1; + if (x->onoff != 0) + { + + if (x->seuil > 0) + { + if (x->posZ_old_1 == x->minZ) // si on est en dehors de la structure -> frottement sec sur les bords + { + if (sqrt(x->forceX*x->forceX + x->forceY*x->forceY)<=(x->seuil * -(x->forceZ))) + { + vX = 0; // on est a l'interieur du cone de frotement, + vY = 0; // on est a l'interieur du cone de frotement, + } + } + + if (x->posZ_old_1 == x->maxZ) // si on est en dehors de la structure -> frottement sec sur les bords + { + if (sqrt(x->forceX*x->forceX + x->forceY*x->forceY)<=(x->seuil * (x->forceZ))) + { + vX = 0; // on est a l'interieur du cone de frotement, + vY = 0; // on est a l'interieur du cone de frotement, + } + } + + if (x->posY_old_1 == x->minY) // si on est en dehors de la structure -> frottement sec sur les bords + { + if (sqrt(x->forceX*x->forceX + x->forceZ*x->forceZ)<=(x->seuil * -(x->forceY))) + { + vX = 0; // on est a l'interieur du cone de frotement, + vZ = 0; // on est a l'interieur du cone de frotement, + } + } + + if (x->posY_old_1 == x->maxY) // si on est en dehors de la structure -> frottement sec sur les bords + { + if (sqrt(x->forceX*x->forceX + x->forceZ*x->forceZ)<=(x->seuil * (x->forceY))) + { + vX = 0; // on est a l'interieur du cone de frotement, + vZ = 0; // on est a l'interieur du cone de frotement, + } + } + + if (x->posX_old_1 == x->minX) // si on est en dehors de la structure -> frottement sec sur les bords + { + if (sqrt(x->forceY*x->forceY + x->forceZ*x->forceZ)<=(x->seuil * -(x->forceX))) + { + vY = 0; // on est a l'interieur du cone de frotement, + vZ = 0; // on est a l'interieur du cone de frotement, + } + } + + if (x->posX_old_1 == x->maxX) // si on est en dehors de la structure -> frottement sec sur les bords + { + if (sqrt(x->forceY*x->forceY + x->forceZ*x->forceZ)<=(x->seuil * (x->forceX))) + { + vY = 0; // on est a l'interieur du cone de frotement, + vZ = 0; // on est a l'interieur du cone de frotement, + } + } + } + + 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 + x->forceZ += x->damp * ((x->posZ_old_2)-(x->posZ_old_1)); // damping + + if (!(x->masse3D == 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; + } + else + { + posX_new = x->posX_old_1; + posY_new = x->posY_old_1; + posZ_new = x->posY_old_1; + } + + + if (vX==0) + posX_new = x->posX_old_1; // on n'a pas de mv qd on est a l'interieur du cone de frotement + if (vY==0) + posY_new = x->posY_old_1; + if (vZ==0) + posZ_new = x->posZ_old_1; + + posX_new = max(min(x->maxX, posX_new), x->minX); + posY_new = max(min(x->maxY, posY_new), x->minY); + posZ_new = max(min(x->maxZ, posZ_new), x->minZ); + + + posX_new += x->dX; + posY_new += x->dY; + posZ_new += x->dZ; + + x->posX_old_1 += x->dX; + x->posY_old_1 += x->dY; + x->posZ_old_1 += x->dZ; + + SETFLOAT(&(x->pos_new[0]), posX_new ); + SETFLOAT(&(x->pos_new[1]), posY_new ); + SETFLOAT(&(x->pos_new[2]), posZ_new ); + + x->posX_old_2 = x->posX_old_1; + x->posX_old_1 = posX_new; + + x->posY_old_2 = x->posY_old_1; + x->posY_old_1 = posY_new; + + x->posZ_old_2 = x->posZ_old_1; + x->posZ_old_1 = posZ_new; + + SETFLOAT(&(x->force[0]), x->forceX ); + SETFLOAT(&(x->force[1]), x->forceY ); + SETFLOAT(&(x->force[2]), x->forceZ ); + SETFLOAT(&(x->force[3]), sqrt( (x->forceX * x->forceX) + (x->forceY * x->forceY) + (x->forceZ * x->forceZ) )); + + x->forceX=0; + x->forceY=0; + x->forceZ=0; + + x->dX=0; + x->dY=0; + x->dZ=0; + + x->VX = x->posX_old_1 - x->posX_old_2; + x->VY = x->posY_old_1 - x->posY_old_2; + x->VZ = x->posZ_old_1 - x->posZ_old_2; + + SETFLOAT(&(x->vitesse[0]), x->VX ); + SETFLOAT(&(x->vitesse[1]), x->VY ); + SETFLOAT(&(x->vitesse[2]), x->VZ ); + SETFLOAT(&(x->vitesse[3]), sqrt( (x->VX * x->VX) + (x->VY * x->VY) + (x->VZ * x->VZ) )); + + outlet_anything(x->vitesse_out, gensym("velocity3D"), 4, x->vitesse); + outlet_anything(x->force_out, gensym("force3D"), 4, x->force); + outlet_anything(x->position3D_new, gensym("position3D"), 3, x->pos_new); + } +} + +void masse3D_reset(t_masse3D *x) +{ + + x->posX_old_2 = x->Xinit; + x->posX_old_1 = x->Xinit; + x->forceX=0; + + x->posY_old_2 = x->Yinit; + x->posY_old_1 = x->Yinit; + x->forceY=0; + + x->posZ_old_2 = x->Zinit; + x->posZ_old_1 = x->Zinit; + x->forceZ=0; + + x->VX = 0; + x->VY = 0; + x->VZ = 0; + + x->dX=0; + x->dY=0; + x->dZ=0; + + x->seuil=0; + + x->onoff = 1; + + SETFLOAT(&(x->pos_new[0]), x->Xinit ); + SETFLOAT(&(x->pos_new[1]), x->Yinit ); + SETFLOAT(&(x->pos_new[2]), x->Zinit ); + + SETFLOAT(&(x->force[0]), 0 ); + SETFLOAT(&(x->force[1]), 0 ); + SETFLOAT(&(x->force[2]), 0 ); + SETFLOAT(&(x->force[3]), 0 ); + + SETFLOAT(&(x->vitesse[0]), 0 ); + SETFLOAT(&(x->vitesse[1]), 0 ); + SETFLOAT(&(x->vitesse[2]), 0 ); + SETFLOAT(&(x->vitesse[3]), 0 ); + + outlet_anything(x->vitesse_out, gensym("velocity3D"), 4, x->vitesse); + outlet_anything(x->force_out, gensym("force3D"), 4, x->force); + outlet_anything(x->position3D_new, gensym("position3D"), 3, x->pos_new); + +} + + +void masse3D_resetf(t_masse3D *x) +{ + x->forceX=0; + x->forceY=0; + x->forceZ=0; + + x->dX=0; + x->dY=0; + x->dZ=0; +} + +static int makeseed3D(void) +{ + static unsigned int random_nextseed = 1489853723; + random_nextseed = random_nextseed * 435898247 + 938284287; + return (random_nextseed & 0x7fffffff); +} + +static float random_bang3D(t_masse3D *x) +{ + int nval; + int range = 2000000; + float rnd; + unsigned int randval = x->x_state; + x->x_state = randval = randval * 472940017 + 832416023; + nval = ((double)range) * ((double)randval) + * (1./4294967296.); + if (nval >= range) nval = range-1; + + rnd=nval; + + rnd-=1000000; + rnd=rnd/1000000.; //pour mettre entre -1 et 1; + return (rnd); +} + + +void masse3D_inter_ambient(t_masse3D *x, t_symbol *s, int argc, t_atom *argv) +{ + t_float tmp; + + if (argc == 17) + // 0 : FX + // 1 : FY + // 2 : FZ + // 3 : RndX + // 4 : RndY + // 5 : RndZ + // 6 : D2 + // 7 : rien + // 8 : Xmin + // 9 : Xmax + // 10 : Ymin + // 11 : Ymax + // 12 : Zmin + // 13 : Zmax + // 14 : dX + // 15 : dY + // 16 : dZ + { + if (x->posX_old_1 > atom_getfloatarg(8, argc, argv)) + { + if (x->posX_old_1 < atom_getfloatarg(9, argc, argv)) + { + if (x->posY_old_1 > atom_getfloatarg(10, argc, argv)) + { + if (x->posY_old_1 < atom_getfloatarg(11, argc, argv)) + { + if (x->posZ_old_1 > atom_getfloatarg(12, argc, argv)) + { + if (x->posZ_old_1 < atom_getfloatarg(13, argc, argv)) + { + x->forceX += atom_getfloatarg(0, argc, argv); + x->forceY += atom_getfloatarg(1, argc, argv); // constant + x->forceZ += atom_getfloatarg(2, argc, argv); // constant + + x->forceX += random_bang3D(x)*atom_getfloatarg(3, argc, argv); + x->forceY += random_bang3D(x)*atom_getfloatarg(4, argc, argv); // random + x->forceZ += random_bang3D(x)*atom_getfloatarg(5, argc, argv); // random + + tmp = atom_getfloatarg(6, argc, argv); + if (tmp != 0) + { + x->forceX += tmp * ((x->posX_old_2)-(x->posX_old_1)); + x->forceY += tmp * ((x->posY_old_2)-(x->posY_old_1)); // damping + x->forceZ += tmp * ((x->posZ_old_2)-(x->posZ_old_1)); // damping + } + + x->dX += atom_getfloatarg(14, argc, argv); + x->dY += atom_getfloatarg(15, argc, argv); // constant + x->dZ += atom_getfloatarg(16, argc, argv); // constant + } + } + } + } + } + } + } + else + { + error("bad ambient interraction message"); + } +} + +void masse3D_inter_plane(t_masse3D *x, t_symbol *s, int argc, t_atom *argv) +{ + t_float a, b, c, d, profondeur, distance, tmp, profondeur_old; + + if (argc == 12) + // 0 : Xvector + // 1 : Yvector + // 2 : Zvector + // 3 : Xcenter + // 4 : Ycenter + // 5 : Zcenter + // 6 : FNCt + // 7 : KN + // 8 : damping de liaison (profondeur) + // 9 : Profondeur maximum + // 10 : deplacement normal X + // 11 : deplacement proportionel a P + + { + +// ax+by+cz-d=0 +// a = Xvector / |V| +// b = Yvector ... +// d est tel que aXcenter +bYcenter + cYcenter = d + + a = atom_getfloatarg(0, argc, argv); + b = atom_getfloatarg(1, argc, argv); + c = atom_getfloatarg(2, argc, argv); + + tmp = sqrt (a*a + b*b + c*c); + if (tmp != 0) + { + a /= tmp; + b /= tmp; + c /= tmp; + + } + else + { + a=1; + b=0; + c=0; + } + + d = a * atom_getfloatarg(3, argc, argv) + b * atom_getfloatarg(4, argc, argv) + c * atom_getfloatarg(5, argc, argv); +//C a optimiser : envoyer directement les coef directeur et l'offset +//C a faire pour les autres obj aussi + + profondeur = a * x->posX_old_1 + b * x->posY_old_1 + c * x->posZ_old_1 - d; + + if ( (profondeur < 0) & (profondeur > -atom_getfloatarg(9, argc, argv)) ) + { + + tmp = atom_getfloatarg(6, argc, argv); // force normal constante + + x->forceX += tmp * a; + x->forceY += tmp * b; + x->forceZ += tmp * c; + + tmp = atom_getfloatarg(7, argc, argv); // force normal proportionelle a la profondeur + tmp *= profondeur; + x->forceX -= tmp * a; + x->forceY -= tmp * b; + x->forceZ -= tmp * c; + + tmp = atom_getfloatarg(8, argc, argv); // force normal proportionelle a la profondeur + + profondeur_old = a * x->posX_old_2 + b * x->posY_old_2 + c * x->posZ_old_2 - d; + tmp *= (profondeur - profondeur_old); + x->forceX -= tmp * a; + x->forceY -= tmp * b; + x->forceZ -= tmp * c; + + + tmp = atom_getfloatarg(10, argc, argv); // deplacement normal constant + + x->dX += tmp * a; + x->dY += tmp * b; + x->dZ += tmp * c; + + tmp = atom_getfloatarg(11, argc, argv); // deplacement normal proportionel + tmp *= profondeur; + + x->dX -= tmp * a; + x->dY -= tmp * b; + x->dZ -= tmp * c; + } + + } + else + { + error("bad plane interraction message"); + } +} + + +void masse3D_inter_sphere(t_masse3D *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 ; + + if (argc == 17) + // 0 : Xcentre + // 1 : Ycendre + // 2 : Zcentre + // 3 : Rmin + // 4 : Rmax + // 5 : F normal + // 6 : K normal + // 7 : F normal proportionel a 1/R + // 8 : Damp de liason normal + // 9 : deplacement N Ct + // 10 : position ancienne de l'interacteur en X + // 11 : position abcienne de l'interacteur en Y + // 12 : position abcienne de l'interacteur en Z + // 13 : d dormal proportionel a R + // 14 : force normal proportionel a 1/R2 + // 15 : d dormal proportionel a 1/R + // 16 : d dormal proportionel a 1/R*R + + { + posx1 = atom_getfloatarg(0, argc, argv); + posy1 = atom_getfloatarg(1, argc, argv); + posz1 = atom_getfloatarg(2, argc, argv); + Nx = (x->posX_old_1)-posx1; // vecteur deplacement X + Ny = (x->posY_old_1)-posy1; // vecteur deplacement Y + Nz = (x->posZ_old_1)-posz1; // vecteur deplacement Y + + distance = sqrt((Nx * Nx)+(Ny * Ny)+(Nz * Nz)); // distance entre le centre de l'interaction, et le pts + + Nx = Nx/distance; // composante X de la normal (normalisé) + Ny = Ny/distance; // composante Y de la normal. + Nz = Nz/distance; // composante Y de la normal. + + Dmax= atom_getfloatarg(4, argc, argv); // distance max de l'interaction + if ( (distance > atom_getfloatarg(3, argc, argv)) & (distance < Dmax) ) + { + tmp = atom_getfloatarg(5, argc, argv); // force constante normal + x->forceX += tmp * Nx; + x->forceY += tmp * Ny; + x->forceZ += tmp * Nz; + + tmp = atom_getfloatarg(6, argc, argv); // force variable (K) normal + tmp *= ( Dmax-distance ); + x->forceX += tmp * Nx ; + x->forceY += tmp * Ny ; + x->forceZ += tmp * Nz ; + + tmp = atom_getfloatarg(7, argc, argv); // force normal proportionel a 1/r + if ( (distance != 0) & (tmp != 0) ) + { + tmp /= distance; + x->forceX += tmp * Nx; + x->forceY += tmp * Ny; + x->forceZ += tmp * Nz ; + } + + tmp = atom_getfloatarg(8, argc, argv); // damping2 normal + tmp *= ( x->VX * Nx + x->VY * Ny + x->VZ * Nz ); + x->forceX -= tmp * Nx ; + x->forceY -= tmp * Ny ; + x->forceZ -= tmp * Nz ; + + tmp = atom_getfloatarg(9, argc, argv); // d normal + x->dX += tmp * Nx ; + x->dY += tmp * Ny ; + x->dZ += tmp * Nz ; + + tmp = atom_getfloatarg(13, argc, argv); // force normal proportionel a 1/r2 + if ( (distance != 0) & (tmp != 0) ) + { + tmp /= (distance * distance); + x->forceX += tmp * Nx ; + x->forceY += tmp * Ny ; + x->forceZ += tmp * Nz ; + } + + tmp = atom_getfloatarg(14, argc, argv); // deplacement variable (K) normal + tmp *= ( Dmax-distance ); + x->dX += tmp * Nx ; + x->dY += tmp * Ny ; + x->dZ += tmp * Nz ; + + tmp = atom_getfloatarg(15, argc, argv); // deplacement normal proportionel a 1/r + if ( (distance != 0) & (tmp != 0) ) + { + tmp /= distance; + x->dX += tmp * Nx ; + x->dY += tmp * Ny ; + x->dZ += tmp * Nz ; + } + + tmp = atom_getfloatarg(16, argc, argv); // deplacement normal proportionel a 1/r2 + if ( (distance != 0) & (tmp != 0) ) + { + tmp /= (distance * distance); + x->dX += tmp * Nx; + x->dY += tmp * Ny; + x->dZ += tmp * Nz; + } + + } + } + else + { + error("bad interact_3D_sphere message"); + } +} + + +void masse3D_inter_circle(t_masse3D *x, t_symbol *s, int argc, t_atom *argv) +{ + t_float a, b, c, d, profondeur, distance, tmp, profondeur_old, rayon, rayon_old; + + if (argc == 14) + // 0 : Xvector + // 1 : Yvector + // 2 : Zvector + // 3 : Xcenter + // 4 : Ycenter + // 5 : Zcenter + // 6 : Rmin + // 7 : RMax + // 8 : FNCt + // 9 : KN + // 10 : damping de liaison (profondeur) + // 11 : Profondeur maximum + // 12 : dN + // 13 : dKN + + { +// ax+by+cz-d=0 +// a = Xvector / |V| +// b = Yvector ... +// d est tel que aXcenter +bYcenter + cYcenter = d + + a = atom_getfloatarg(0, argc, argv); + b = atom_getfloatarg(1, argc, argv); + c = atom_getfloatarg(2, argc, argv); + + tmp = sqrt (a*a + b*b + c*c); + if (tmp != 0) + { + a /= tmp; + b /= tmp; + c /= tmp; + } + else + { + a=1; + b=0; + c=0; + } + + d = a * atom_getfloatarg(3, argc, argv) + b * atom_getfloatarg(4, argc, argv) + c * atom_getfloatarg(5, argc, argv); + + profondeur = a * x->posX_old_1 + b * x->posY_old_1 + c * x->posZ_old_1 - d; + + rayon = sqrt ( pow(x->posX_old_1-atom_getfloatarg(3, argc, argv), 2) +pow(x->posY_old_1-atom_getfloatarg(4, argc, argv) , 2) + pow(x->posZ_old_1 - atom_getfloatarg(5, argc, argv) , 2) - profondeur*profondeur ); + + if ( (profondeur < 0) & (profondeur > - atom_getfloatarg(11, argc, argv)) & (rayon > atom_getfloatarg(6, argc, argv)) & (rayon < atom_getfloatarg(7, argc, argv))) + { + + tmp = atom_getfloatarg(8, argc, argv); // force normal constante + + x->forceX += tmp * a; + x->forceY += tmp * b; + x->forceZ += tmp * c; + + tmp = atom_getfloatarg(9, argc, argv); // force normal proportionelle a la profondeur + tmp *= profondeur; + x->forceX -= tmp * a; + x->forceY -= tmp * b; + x->forceZ -= tmp * c; + + tmp = atom_getfloatarg(10, argc, argv); // force normal proportionelle a la profondeur + + profondeur_old = a * x->posX_old_2 + b * x->posY_old_2 + c * x->posZ_old_2 - d; + tmp *= (profondeur - profondeur_old); + + x->forceX -= tmp * a; + x->forceY -= tmp * b; + x->forceZ -= tmp * c; + + tmp = atom_getfloatarg(12, argc, argv); // deplacement normal constante + x->dX += tmp * a; + x->dY += tmp * b; + x->dZ += tmp * c; + + tmp = atom_getfloatarg(13, argc, argv); // deplacement normal proportionelle a la profondeur + tmp *= profondeur; + x->dX -= tmp * a; + x->dY -= tmp * b; + x->dZ -= tmp * c; + } + } + else + { + error("bad circle interraction message"); + } +} + + +void masse3D_inter_cylinder(t_masse3D *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; + + if (argc == 21) + // 0 : Xvector + // 1 : Yvector + // 2 : Zvector + // 3 : Xcenter + // 4 : Ycenter + // 5 : Zcenter + // 6 : Rmin + // 7 : Rmax + // 8 : FNCt + // 9 : KN + // 10 : damping de liaison (rayon) + // 11 : FN 1/R + // 12 : FN 1/R2 + // 13 : Pmin + // 14 : Pmax + // 15 : FTct + // 16 : KT + // 17 : dNct + // 18 : dTct + // 19 : dKN + // 20 : dKT + + { + +// ax+by+cz-d=0 +// a = Xvector / |V| +// b = Yvector ... +// d est tel que aXcenter +bYcenter + cYcenter = d + + a = atom_getfloatarg(0, argc, argv); + b = atom_getfloatarg(1, argc, argv); + c = atom_getfloatarg(2, argc, argv); + + tmp = sqrt (a*a + b*b + c*c); + if (tmp != 0) + { + a /= tmp; + b /= tmp; + c /= tmp; + } + else + { + a=1; + b=0; + c=0; + } + + d = a * atom_getfloatarg(3, argc, argv) + b * atom_getfloatarg(4, argc, argv) + c * atom_getfloatarg(5, argc, argv); + + profondeur = a * x->posX_old_1 + b * x->posY_old_1 + c * x->posZ_old_1 - d; + + Xb = x->posX_old_1 - atom_getfloatarg(3, argc, argv) - profondeur * a; + Yb = x->posY_old_1 - atom_getfloatarg(4, argc, argv) - profondeur * b; + Zb = x->posZ_old_1 - atom_getfloatarg(5, argc, argv) - profondeur * c; + + rayon = sqrt ( pow(Xb, 2) + pow(Yb, 2) + pow(Zb, 2) ); + + if (rayon != 0) + { + Xb /= rayon; // normalisation + Yb /= rayon; + Zb /= rayon; + } + else + { + Xb = 0; // normalisation + Yb = 0; + Zb = 0; + } + + + Ta = b*Zb - c*Yb; // vecteur tengentiel = vecteur vectoriel rayon + Tb = c*Xb - a*Zb; + Tc = a*Yb - b*Xb; + + if ( (profondeur < atom_getfloatarg(14, argc, argv)) & (profondeur > atom_getfloatarg(13, argc, argv)) & (rayon < atom_getfloatarg(7, argc, argv)) & (rayon > atom_getfloatarg(6, argc, argv)) ) + { + + tmp = atom_getfloatarg(8, argc, argv); // force normal constante + + x->forceX += tmp * Xb; + x->forceY += tmp * Yb; + x->forceZ += tmp * Zb; + + tmp = atom_getfloatarg(9, argc, argv); // rigidité normal proportionelle + tmp *= ( atom_getfloatarg(7, argc, argv) - rayon ) ; + x->forceX += tmp * Xb; + x->forceY += tmp * Yb; + x->forceZ += tmp * Zb; + + tmp = atom_getfloatarg(10, argc, argv); // damping normal proportionelle a la profondeur + + profondeur_old = a * x->posX_old_2 + b * x->posY_old_2 + c * x->posZ_old_2 - d; + + Xb_old = x->posX_old_2 - atom_getfloatarg(3, argc, argv) - profondeur_old * a; + Yb_old = x->posY_old_2 - atom_getfloatarg(4, argc, argv) - profondeur_old * b; + Zb_old = x->posZ_old_2 - atom_getfloatarg(5, argc, argv) - profondeur_old * c; + + rayon_old = sqrt ( pow(Xb_old, 2) + pow(Yb_old, 2) + pow(Zb_old, 2) ); + + tmp *= (rayon - rayon_old); + + x->forceX -= tmp * Xb; + x->forceY -= tmp * Yb; + x->forceZ -= tmp * Zb; + + tmp = atom_getfloatarg(11, argc, argv); // force normal proportionne a 1/R + if (rayon != 0) + { + tmp /= rayon; + x->forceX += tmp * Xb; + x->forceY += tmp * Yb; + x->forceZ += tmp * Zb; + } + + tmp = atom_getfloatarg(12, argc, argv); // force normal proportionne a 1/R*R + if (rayon != 0) + { + tmp /= (rayon*rayon); + x->forceX += tmp * Xb; + x->forceY += tmp * Yb; + x->forceZ += tmp * Zb; + } + + tmp = atom_getfloatarg(15, argc, argv); // force tengente constante + x->forceX -= tmp * Ta; + x->forceY -= tmp * Tb; + x->forceZ -= tmp * Tc; + + tmp = atom_getfloatarg(16, argc, argv); // rigidité tengentiel proportionelle + tmp *= ( atom_getfloatarg(7, argc, argv) - rayon ) ; + x->forceX += tmp * Ta; + x->forceY += tmp * Tb; + x->forceZ += tmp * Tc; + + tmp = atom_getfloatarg(17, argc, argv); // deplacement normal constante + + x->dX += tmp * Xb; + x->dY += tmp * Yb; + x->dZ += tmp * Zb; + + tmp = atom_getfloatarg(19, argc, argv); // deplacement normal proportionelle + tmp *= ( atom_getfloatarg(7, argc, argv) - rayon ) ; + x->dX += tmp * Xb; + x->dY += tmp * Yb; + x->dZ += tmp * Zb; + + tmp = atom_getfloatarg(18, argc, argv); // deplacement tengente constante + x->dX += tmp * Ta; + x->dY += tmp * Tb; + x->dZ += tmp * Tc; + + tmp = atom_getfloatarg(20, argc, argv); // deplacement tengentiel proportionelle + tmp *= ( atom_getfloatarg(7, argc, argv) - rayon ) ; + x->dX += tmp * Ta; + x->dY += tmp * Tb; + x->dZ += tmp * Tc; + } + } + else + { + error("bad cylinder interraction message"); + } +} + +void *masse3D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_masse3D *x = (t_masse3D *)pd_new(masse3D_class); + + x->x_sym = atom_getsymbolarg(0, argc, argv); + x->x_state = makeseed(); + + pd_bind(&x->x_obj.ob_pd, atom_getsymbolarg(0, argc, argv)); + + x->position3D_new=outlet_new(&x->x_obj, 0); + x->force_out=outlet_new(&x->x_obj, 0); + x->vitesse_out=outlet_new(&x->x_obj, 0); + + x->forceX=0; + x->forceY=0; + x->forceZ=0; + + if (argc >= 2) + x->masse3D = atom_getfloatarg(1, argc, argv) ; + else + x->masse3D = 1; + + x->onoff = 1; + + x->VX = 0; + x->VY = 0; + x->VZ = 0; + + x->dX=0; + x->dY=0; + x->dZ=0; + + if (argc >= 3) + x->Xinit = atom_getfloatarg(2, argc, argv); + else + x->Xinit = 0 ; + + x->posX_old_1 = x->Xinit ; + x->posX_old_2 = x->Xinit; + SETFLOAT(&(x->pos_new[0]), x->Xinit); + + if (argc >= 4) + x->Yinit = atom_getfloatarg(3, argc, argv); + else + x->Yinit = 0 ; + + x->posY_old_1 = x->Yinit ; + x->posY_old_2 = x->Yinit; + SETFLOAT(&(x->pos_new[1]), x->Yinit); + + if (argc >= 5) + x->Zinit = atom_getfloatarg(4, argc, argv); + else + x->Zinit = 0 ; + + x->posZ_old_1 = x->Zinit ; + x->posZ_old_2 = x->Zinit; + SETFLOAT(&(x->pos_new[2]), x->Zinit); + + + if (argc >= 6) + x->minX = atom_getfloatarg(5, argc, argv) ; + else + x->minX = -100000; + + if (argc >= 7) + x->maxX = atom_getfloatarg(6, argc, argv) ; + else + x->maxX = 100000; + + if (argc >= 8) + x->minY = atom_getfloatarg(7, argc, argv) ; + else + x->minY = -100000; + + if (argc >= 9) + x->maxY = atom_getfloatarg(8, argc, argv) ; + else + x->maxY = 100000; + + if (argc >= 10) + x->minZ = atom_getfloatarg(9, argc, argv) ; + else + x->minZ = -100000; + + if (argc >= 11) + x->maxZ = atom_getfloatarg(10, argc, argv) ; + else + x->maxZ = 100000; + + if (argc >= 12) + x->seuil = atom_getfloatarg(11, argc, argv) ; + else + x->seuil = 0; + + if (argc >= 13) + x->damp = atom_getfloatarg(12, argc, argv) ; + else + x->damp = 0; + + return (void *)x; +} + +static void masse3D_free(t_masse3D *x) +{ + pd_unbind(&x->x_obj.ob_pd, x->x_sym); +} + + +void masse3D_setup(void) +{ + + masse3D_class = class_new(gensym("masse3D"), + (t_newmethod)masse3D_new, + (t_method)masse3D_free, + sizeof(t_masse3D), + 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); + +} diff --git a/src/pmpd.c b/src/pmpd.c new file mode 100755 index 0000000..9d21d64 --- /dev/null +++ b/src/pmpd.c @@ -0,0 +1,146 @@ +/* +-------------------------- pmpd ---------------------------------------- + + pmpd = physical modeling for pure data + Written by Cyrille Henry (cyrille.henry@la-kitchen.fr) + + Get sources at http://drpichon.free.fr/pure-data/physical-modeling/ + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + Based on PureData by Miller Puckette and others. + + +---------------------------------------------------------------------------- +*/ + +#ifndef VERSION +#define VERSION "0.05" +#endif + +#include "m_pd.h" + +#ifndef __DATE__ +#define __DATE__ "" +#endif + +#include "masse.c" +#include "lia.c" +#include "masse2D.c" +#include "lia2D.c" +#include "masse3D.c" +#include "lia3D.c" + +#include "iAmbient2D.c" +#include "iLine2D.c" +#include "iSeg2D.c" +#include "iCircle2D.c" + +#include "tSquare2D.c" +#include "tLine2D.c" +#include "tSeg2D.c" +#include "tCircle2D.c" +#include "tLia2D.c" + +#include "iAmbient3D.c" +#include "iSphere3D.c" +#include "iPlane3D.c" +#include "iCircle3D.c" +#include "iCylinder3D.c" + + +#include "tCube3D.c" +#include "tSphere3D.c" +#include "tPlane3D.c" +#include "tCircle3D.c" +#include "tCylinder3D.c" +#include "tLia3D.c" + +static t_class *pmpd_class; + +typedef struct _pmpd +{ + t_object x_obj; +} t_pmpd; + +t_float max(t_float x, t_float y) +{ + if (x >= y) + { + return x; + } + return y; +} + +t_float min(t_float x, t_float y) +{ + if (x <= y) + { + return x; + } + return y; +} + +void *pmpd_new(void) +{ + t_pmpd *x = (t_pmpd *)pd_new(pmpd_class); + return (void *)x; +} + +void pmpd_setup(void) +{ + pmpd_class = class_new(gensym("pmpd"), + (t_newmethod)pmpd_new, + 0, sizeof(t_pmpd),0,0); + + post(""); + post(" pmpd = Physical Modeling for Pure Data"); + post(" version "VERSION); + post(" compiled "__DATE__); + post(" Contact : cyrille.henry@la-kitchen.fr"); + post(""); + +masse_setup() ; +lia_setup() ; +masse2D_setup() ; +lia2D_setup() ; +masse3D_setup() ; +lia3D_setup() ; + +iAmbient2D_setup(); +iLine2D_setup(); +iSeg2D_setup(); +iCircle2D_setup(); + +tSquare2D_setup(); +tCircle2D_setup(); +tLine2D_setup(); +tSeg2D_setup(); +tLia2D_setup(); + +iAmbient3D_setup(); +iSphere3D_setup(); +iPlane3D_setup(); +iCircle3D_setup(); +iCylinder3D_setup(); + +tLia3D_setup(); +tCube3D_setup(); +tPlane3D_setup(); +tSphere3D_setup(); +tCylinder3D_setup(); +tCircle3D_setup(); + +} diff --git a/src/tCircle2D.c b/src/tCircle2D.c new file mode 100755 index 0000000..e4ba448 --- /dev/null +++ b/src/tCircle2D.c @@ -0,0 +1,113 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *tCircle2D_class; + +typedef struct _tCircle2D { + t_object x_obj; + t_float X, Y, Rmin, Rmax, distance_old; + t_outlet *force_new, *distance, *vitesse; // outlet +} t_tCircle2D; + + +void tCircle2D_position2D(t_tCircle2D *x, t_float X, t_float Y) +{ + + t_float tmp, vitesse; + + tmp = sqrt((X-x->X)*(X-x->X) + (Y-x->Y)*(Y-x->Y)); + + vitesse = tmp - x->distance_old ; + + x->distance_old = tmp; + + outlet_float(x->vitesse, vitesse); + + outlet_float(x->distance, tmp); + + if ( (tmp < x->Rmax) & (tmp >= x->Rmin)) + { + outlet_float(x->force_new, 1); + } + else + { + outlet_float(x->force_new, 0); + } +} + +void tCircle2D_XY(t_tCircle2D *x, t_float X, t_float Y) +{ + x->X= X; + x->Y= Y; +} + +void tCircle2D_X(t_tCircle2D *x, t_float X) +{ + x->X= X; +} + +void tCircle2D_Y(t_tCircle2D *x, t_float X) +{ + x->Y= X; +} + +void tCircle2D_Rmin(t_tCircle2D *x, t_float X) +{ + x->Rmin= X; +} + +void tCircle2D_Rmax(t_tCircle2D *x, t_float X) +{ + x->Rmax= X; +} + +void *tCircle2D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_tCircle2D *x = (t_tCircle2D *)pd_new(tCircle2D_class); + x->force_new=outlet_new(&x->x_obj, 0); + x->distance=outlet_new(&x->x_obj, 0); + x->vitesse=outlet_new(&x->x_obj, 0); + + x->distance_old = 0; + + if (argc>=4) + x->Rmax = atom_getfloatarg(3, argc, argv); + else + x->Rmax = 1; + + if (argc>=3) + x->Rmin = atom_getfloatarg(2, argc, argv); + else + x->Rmin = 0; + + if (argc>=2) + x->Y = atom_getfloatarg(1, argc, argv); + else + x->Y = 0; + + if (argc>=1) + x->X = atom_getfloatarg(0, argc, argv); + else + x->X = 0; + + return (x); +} + +void tCircle2D_setup(void) +{ + + tCircle2D_class = class_new(gensym("tCircle2D"), + (t_newmethod)tCircle2D_new, + 0, sizeof(t_tCircle2D), + CLASS_DEFAULT, A_GIMME, 0); + + class_addcreator((t_newmethod)tCircle2D_new, gensym("pmpd.tCircle2D"), A_GIMME, 0); + + class_addmethod(tCircle2D_class, (t_method)tCircle2D_position2D, gensym("position2D"), A_DEFFLOAT, A_DEFFLOAT, 0); + + class_addmethod(tCircle2D_class, (t_method)tCircle2D_XY, gensym("setXY"), A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(tCircle2D_class, (t_method)tCircle2D_X, gensym("setX"), A_DEFFLOAT, 0); + class_addmethod(tCircle2D_class, (t_method)tCircle2D_Y, gensym("setY"), A_DEFFLOAT, 0); + class_addmethod(tCircle2D_class, (t_method)tCircle2D_Rmin, gensym("setRmin"), A_DEFFLOAT, 0); + class_addmethod(tCircle2D_class, (t_method)tCircle2D_Rmax, gensym("setRmax"), A_DEFFLOAT, 0); +} diff --git a/src/tCircle3D.c b/src/tCircle3D.c new file mode 100755 index 0000000..6664d39 --- /dev/null +++ b/src/tCircle3D.c @@ -0,0 +1,195 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *tCircle3D_class; + +typedef struct _tCircle3D { + t_object x_obj; + t_float X, Y, Z, VX, VY, VZ, P, Rmin, Rmax, distance_old; + t_outlet *force_new, *distance, *vitesse;// outlet +} t_tCircle3D; + +void tCircle3D_position3D(t_tCircle3D *x, t_float X, t_float Y, t_float Z) +{ +t_float d, tmp, profondeur, vitesse; + + + + tmp = sqrt (x->VX*x->VX + x->VY*x->VY + x->VZ*x->VZ); + if (tmp != 0) + { + x->VX /= tmp; + x->VY /= tmp; + x->VZ /= tmp; + } + else + { + x->VX=1; + x->VY=0; + x->VZ=0; + } + + d = x->VX * x->X + x->VY * x->Y + x->VZ * x->Z; + + profondeur = x->VX * X + x->VY * Y + x->VZ * Z - d; + + vitesse = profondeur - x->distance_old; + x->distance_old = profondeur; + + outlet_float(x->vitesse, vitesse); + + outlet_float(x->distance, profondeur); + + if ( (profondeur < 0) & (profondeur > - x->P) ) + { + outlet_float(x->force_new, 1); + } + else + { + outlet_float(x->force_new, 0); + } + +} + +void tCircle3D_setXYZ(t_tCircle3D *x, t_float X, t_float Y, t_float Z) +{ + x->X= X; + x->Y= Y; + x->Z= Z; +} +void tCircle3D_setVXYZ(t_tCircle3D *x, t_float X, t_float Y, t_float Z) +{ + x->VX= X; + x->VY= Y; + x->VZ= Z; +} + +void tCircle3D_setVX(t_tCircle3D *x, t_float X) +{ + x->VX= X; +} + +void tCircle3D_setVY(t_tCircle3D *x, t_float Y) +{ + x->VY= Y; +} + +void tCircle3D_setVZ(t_tCircle3D *x, t_float Z) +{ + x->VZ= Z; +} +void tCircle3D_setX(t_tCircle3D *x, t_float X) +{ + x->X= X; +} + +void tCircle3D_setY(t_tCircle3D *x, t_float Y) +{ + x->Y= Y; +} + +void tCircle3D_setZ(t_tCircle3D *x, t_float Z) +{ + x->Z= Z; +} + +void tCircle3D_setP(t_tCircle3D *x, t_float X) +{ + x->P= X; +} + +void tCircle3D_setRmin(t_tCircle3D *x, t_float R) +{ + x->Rmin = R; +} + +void tCircle3D_setRmax(t_tCircle3D *x, t_float R) +{ + x->Rmax = R; +} + + +void *tCircle3D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_tCircle3D *x = (t_tCircle3D *)pd_new(tCircle3D_class); + + x->force_new=outlet_new(&x->x_obj, 0); + x->distance=outlet_new(&x->x_obj, 0); + x->vitesse=outlet_new(&x->x_obj, 0); + + x->distance_old = 0; + + if (argc>=9) + x->P= atom_getfloatarg(8, argc, argv); + else + x->P= 10000; + + if (argc>=8) + x->Z= atom_getfloatarg(7, argc, argv); + else + x->Rmax= 1; + + if (argc>=7) + x->P= atom_getfloatarg(6, argc, argv); + else + x->Rmin= 0; + + if (argc>=6) + x->Z= atom_getfloatarg(5, argc, argv); + else + x->Z= 0; + + if (argc>=5) + x->Y= atom_getfloatarg(4, argc, argv); + else + x->Y= 0; + + if (argc>=4) + x->X= atom_getfloatarg(3, argc, argv); + else + x->X= 0; + + if (argc>=3) + x->VZ= atom_getfloatarg(2, argc, argv); + else + x->VZ= 0; + + if (argc>=2) + x->VY= atom_getfloatarg(1, argc, argv); + else + x->VY= 0; + + if (argc>=1) + x->VX= atom_getfloatarg(0, argc, argv); + else + x->VX= 1; + + return (x); +} + +void tCircle3D_setup(void) +{ + + tCircle3D_class = class_new(gensym("tCircle3D"), + (t_newmethod)tCircle3D_new, + 0, sizeof(t_tCircle3D), + CLASS_DEFAULT, A_GIMME, 0); + + class_addcreator((t_newmethod)tCircle3D_new, gensym("pmpd.tCircle3D"), A_GIMME, 0); + + class_addmethod(tCircle3D_class, (t_method)tCircle3D_position3D, gensym("position3D"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + + class_addmethod(tCircle3D_class, (t_method)tCircle3D_setVX, gensym("setVX"), A_DEFFLOAT, 0); + class_addmethod(tCircle3D_class, (t_method)tCircle3D_setVY, gensym("setVY"), A_DEFFLOAT, 0); + class_addmethod(tCircle3D_class, (t_method)tCircle3D_setVZ, gensym("setVZ"), A_DEFFLOAT, 0); + class_addmethod(tCircle3D_class, (t_method)tCircle3D_setX, gensym("setX"), A_DEFFLOAT, 0); + class_addmethod(tCircle3D_class, (t_method)tCircle3D_setY, gensym("setY"), A_DEFFLOAT, 0); + class_addmethod(tCircle3D_class, (t_method)tCircle3D_setZ, gensym("setZ"), A_DEFFLOAT, 0); + class_addmethod(tCircle3D_class, (t_method)tCircle3D_setRmin, gensym("setRmin"), A_DEFFLOAT, 0); + class_addmethod(tCircle3D_class, (t_method)tCircle3D_setRmax, gensym("setRmax"), A_DEFFLOAT, 0); + class_addmethod(tCircle3D_class, (t_method)tCircle3D_setXYZ, gensym("setXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(tCircle3D_class, (t_method)tCircle3D_setVXYZ, gensym("setVXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(tCircle3D_class, (t_method)tCircle3D_setP, gensym("setPmax"), A_DEFFLOAT, 0); + + +} diff --git a/src/tCube3D.c b/src/tCube3D.c new file mode 100755 index 0000000..ce0c434 --- /dev/null +++ b/src/tCube3D.c @@ -0,0 +1,114 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *tCube3D_class; + +typedef struct _tCube3D { + t_object x_obj; + t_float Xmin, Xmax, Ymin, Ymax, Zmin, Zmax; + //extrem = Xmin, Ymin, Xmax, Ymax; + t_outlet *force_new;// outlet +} t_tCube3D; + +void tCube3D_position3D(t_tCube3D *x, t_float X, t_float Y, t_float Z) +{ + + if ((X > x->Xmin) & (X < x->Xmax) & (Y > x->Ymin) & (Y < x->Ymax) & (Z > x->Zmin) & (Z < x->Zmax) ) + { + outlet_float(x->force_new, 1); + } + else + { + outlet_float(x->force_new, 0); + } +} + +void tCube3D_Xmin(t_tCube3D *x, t_float X) +{ + x->Xmin= X; +} + +void tCube3D_Xmax(t_tCube3D *x, t_float X) +{ + x->Xmax= X; +} + +void tCube3D_Ymin(t_tCube3D *x, t_float X) +{ + x->Ymin= X; +} + +void tCube3D_Ymax(t_tCube3D *x, t_float X) +{ + x->Ymax= X; +} + +void tCube3D_Zmin(t_tCube3D *x, t_float X) +{ + x->Zmin= X; +} + +void tCube3D_Zmax(t_tCube3D *x, t_float X) +{ + x->Zmax= X; +} + +void *tCube3D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_tCube3D *x = (t_tCube3D *)pd_new(tCube3D_class); + x->force_new=outlet_new(&x->x_obj, 0); + + if (argc>=6) + x->Zmax = atom_getfloatarg(5, argc, argv); + else + x->Zmax = 1; + + if (argc>=5) + x->Zmin = atom_getfloatarg(4, argc, argv); + else + x->Zmin = -1; + + if (argc>=4) + x->Ymax = atom_getfloatarg(3, argc, argv); + else + x->Ymax = 1; + + if (argc>=3) + x->Ymin = atom_getfloatarg(2, argc, argv); + else + x->Ymin = -1; + + if (argc>=2) + x->Xmax = atom_getfloatarg(1, argc, argv); + else + x->Xmax = 1; + + if (argc>=1) + x->Xmin = atom_getfloatarg(0, argc, argv); + else + x->Xmin = -1; + + return (x); +} + +void tCube3D_setup(void) +{ + + tCube3D_class = class_new(gensym("tCube3D"), + (t_newmethod)tCube3D_new, + 0, sizeof(t_tCube3D), + CLASS_DEFAULT, A_GIMME, 0); + + class_addcreator((t_newmethod)tCube3D_new, gensym("pmpd.tCube3D"), A_GIMME, 0); + + class_addmethod(tCube3D_class, (t_method)tCube3D_position3D, gensym("position3D"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + + class_addmethod(tCube3D_class, (t_method)tCube3D_Xmin, gensym("setXmin"), A_DEFFLOAT, 0); + class_addmethod(tCube3D_class, (t_method)tCube3D_Ymin, gensym("setYmin"), A_DEFFLOAT, 0); + class_addmethod(tCube3D_class, (t_method)tCube3D_Ymin, gensym("setZmin"), A_DEFFLOAT, 0); + class_addmethod(tCube3D_class, (t_method)tCube3D_Xmax, gensym("setXmax"), A_DEFFLOAT, 0); + class_addmethod(tCube3D_class, (t_method)tCube3D_Ymax, gensym("setYmax"), A_DEFFLOAT, 0); + class_addmethod(tCube3D_class, (t_method)tCube3D_Ymax, gensym("setZmax"), A_DEFFLOAT, 0); + + +} diff --git a/src/tCylinder3D.c b/src/tCylinder3D.c new file mode 100755 index 0000000..1ccf832 --- /dev/null +++ b/src/tCylinder3D.c @@ -0,0 +1,218 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *tCylinder3D_class; + +typedef struct _tCylinder3D { + t_object x_obj; + t_float X, Y, Z, VX, VY, VZ, Pmin, Pmax, Rmin, Rmax, position_old; + t_outlet *force_new, *profondeur, *vitesse;// outlet +} t_tCylinder3D; + +void tCylinder3D_position3D(t_tCylinder3D *x, t_float X, t_float Y, t_float Z) +{ + t_float d, tmp, profondeur, Xb, Yb, Zb, rayon, vitesse; + + tmp = sqrt (x->VX*x->VX + x->VY*x->VY + x->VZ*x->VZ); + if (tmp != 0) + { + x->VX /= tmp; + x->VY /= tmp; + x->VZ /= tmp; + } + else + { + x->VX=1; + x->VY=0; + x->VZ=0; + } + + d = x->VX * x->X + x->VY * x->Y + x->VZ * x->Z; + + profondeur = x->VX * X + x->VY * Y + x->VZ * Z - d; + + Xb = X - x->X - profondeur * x->VX; + Yb = Y - x->Y - profondeur * x->VY; + Zb = Z - x->Z - profondeur * x->VZ; + + rayon = sqrt ( pow(Xb, 2) + pow(Yb, 2) + pow(Zb, 2) ); + + if ( rayon != 0 ) + { + Xb /= rayon; // normalisation + Yb /= rayon; + Zb /= rayon; + } + + vitesse = rayon - x->position_old; + x->position_old = rayon; + + outlet_float(x->vitesse, vitesse); + + outlet_float(x->profondeur, rayon); + + if ( (profondeur < x->Pmin) & (profondeur > x->Pmax) & (rayon < x->Rmax) & (rayon > x->Rmin) ) + { + outlet_float(x->force_new, 1); + } + else + { + outlet_float(x->force_new, 0); + } +//C optimiser ca : pas faire le calcul de l'orientation du cylindre a chaques fois... + +} + +void tCylinder3D_setXYZ(t_tCylinder3D *x, t_float X, t_float Y, t_float Z) +{ + x->X= X; + x->Y= Y; + x->Z= Z; +} +void tCylinder3D_setVXYZ(t_tCylinder3D *x, t_float X, t_float Y, t_float Z) +{ + x->VX= X; + x->VY= Y; + x->VZ= Z; +} + +void tCylinder3D_setVX(t_tCylinder3D *x, t_float X) +{ + x->VX= X; +} + +void tCylinder3D_setVY(t_tCylinder3D *x, t_float Y) +{ + x->VY= Y; +} + +void tCylinder3D_setVZ(t_tCylinder3D *x, t_float Z) +{ + x->VZ= Z; +} +void tCylinder3D_setX(t_tCylinder3D *x, t_float X) +{ + x->X= X; +} + +void tCylinder3D_setY(t_tCylinder3D *x, t_float Y) +{ + x->Y= Y; +} + +void tCylinder3D_setZ(t_tCylinder3D *x, t_float Z) +{ + x->Z= Z; +} + +void tCylinder3D_setPmin(t_tCylinder3D *x, t_float X) +{ + x->Pmin= X; +} + +void tCylinder3D_setPmax(t_tCylinder3D *x, t_float X) +{ + x->Pmax= X; +} + +void tCylinder3D_setRmin(t_tCylinder3D *x, t_float R) +{ + x->Rmin = R; +} + +void tCylinder3D_setRmax(t_tCylinder3D *x, t_float R) +{ + x->Rmax = R; +} + + +void *tCylinder3D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_tCylinder3D *x = (t_tCylinder3D *)pd_new(tCylinder3D_class); + + x->force_new=outlet_new(&x->x_obj, 0); + x->profondeur=outlet_new(&x->x_obj, 0); + x->vitesse=outlet_new(&x->x_obj, 0); + + x->position_old = 0; + + if (argc>=10) + x->Pmax= atom_getfloatarg(9, argc, argv); + else + x->Pmax= 1000; + + if (argc>=9) + x->Pmin= atom_getfloatarg(8, argc, argv); + else + x->Pmin= -1000; + + if (argc>=8) + x->Z= atom_getfloatarg(7, argc, argv); + else + x->Rmax= 1; + + if (argc>=7) + x->Rmin= atom_getfloatarg(6, argc, argv); + else + x->Rmin= 0; + + if (argc>=6) + x->Z= atom_getfloatarg(5, argc, argv); + else + x->Z= 0; + + if (argc>=5) + x->Y= atom_getfloatarg(4, argc, argv); + else + x->Y= 0; + + if (argc>=4) + x->X= atom_getfloatarg(3, argc, argv); + else + x->X= 0; + + if (argc>=3) + x->VZ= atom_getfloatarg(2, argc, argv); + else + x->VZ= 0; + + if (argc>=2) + x->VY= atom_getfloatarg(1, argc, argv); + else + x->VY= 0; + + if (argc>=1) + x->VX= atom_getfloatarg(0, argc, argv); + else + x->VX= 1; + + return (x); +} + +void tCylinder3D_setup(void) +{ + + tCylinder3D_class = class_new(gensym("tCylinder3D"), + (t_newmethod)tCylinder3D_new, + 0, sizeof(t_tCylinder3D), + CLASS_DEFAULT, A_GIMME, 0); + + class_addcreator((t_newmethod)tCylinder3D_new, gensym("pmpd.tCylinder3D"), A_GIMME, 0); + + class_addmethod(tCylinder3D_class, (t_method)tCylinder3D_position3D, gensym("position3D"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + + class_addmethod(tCylinder3D_class, (t_method)tCylinder3D_setVX, gensym("setVX"), A_DEFFLOAT, 0); + class_addmethod(tCylinder3D_class, (t_method)tCylinder3D_setVY, gensym("setVY"), A_DEFFLOAT, 0); + class_addmethod(tCylinder3D_class, (t_method)tCylinder3D_setVZ, gensym("setVZ"), A_DEFFLOAT, 0); + class_addmethod(tCylinder3D_class, (t_method)tCylinder3D_setX, gensym("setX"), A_DEFFLOAT, 0); + class_addmethod(tCylinder3D_class, (t_method)tCylinder3D_setY, gensym("setY"), A_DEFFLOAT, 0); + class_addmethod(tCylinder3D_class, (t_method)tCylinder3D_setZ, gensym("setZ"), A_DEFFLOAT, 0); + class_addmethod(tCylinder3D_class, (t_method)tCylinder3D_setRmin, gensym("setRmin"), A_DEFFLOAT, 0); + class_addmethod(tCylinder3D_class, (t_method)tCylinder3D_setRmax, gensym("setRmax"), A_DEFFLOAT, 0); + class_addmethod(tCylinder3D_class, (t_method)tCylinder3D_setXYZ, gensym("setXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(tCylinder3D_class, (t_method)tCylinder3D_setVXYZ, gensym("setVXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(tCylinder3D_class, (t_method)tCylinder3D_setPmin, gensym("setPmin"), A_DEFFLOAT, 0); + class_addmethod(tCylinder3D_class, (t_method)tCylinder3D_setPmax, gensym("setPmax"), A_DEFFLOAT, 0); + + +} diff --git a/src/tLia2D.c b/src/tLia2D.c new file mode 100755 index 0000000..968e5de --- /dev/null +++ b/src/tLia2D.c @@ -0,0 +1,157 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *tLia2D_class; + +typedef struct _tLia2D { + t_object x_obj; + t_float distance_old, position2Dx1, position2Dy1, position2Dx2, position2Dy2; + t_outlet *force1; + t_outlet *force2; + t_outlet *force3; + t_outlet *force4; + t_symbol *x_sym; // receive +} t_tLia2D; + +void tLia2D_reset(t_tLia2D *x) +{ +} + +void tLia2D_resetF(t_tLia2D *x) +{ +} + +void tLia2D_resetL(t_tLia2D *x) +{ +} + +void tLia2D_setK(t_tLia2D *x, t_float K) +{ +} + +void tLia2D_setL(t_tLia2D *x, t_float L) +{ +} + +void tLia2D_setD(t_tLia2D *x, t_float D) +{ +} + +void tLia2D_setD2(t_tLia2D *x, t_float D) +{ +} + +void tLia2D_Lmin(t_tLia2D *x, t_float Lmin) +{ +} + +void tLia2D_Lmax(t_tLia2D *x, t_float Lmax) +{ +} + +void tLia2D_position2D(t_tLia2D *x, t_floatarg f1, t_floatarg f2) +{ + x->position2Dx1 = f1; + x->position2Dy1 = f2; +} + +void tLia2D_position2D2(t_tLia2D *x, t_floatarg f1, t_floatarg f2) +{ + x->position2Dx2 = f1; + x->position2Dy2 = f2; +} + +void tLia2D_bang(t_tLia2D *x) +{ + t_float vitesse, distance, orientation; + t_atom force1[2]; + + distance = sqrt ( pow((x->position2Dx2-x->position2Dx1), 2) + pow((x->position2Dy2-x->position2Dy1), 2) ); + + vitesse = x->distance_old - distance; + + SETFLOAT(&(force1[0]), (x->position2Dx2 + x->position2Dx1)/ 2); + SETFLOAT(&(force1[1]), (x->position2Dy2 + x->position2Dy1)/ 2); + + outlet_anything(x->force4, gensym("position2D"), 2, force1); + + if ((x->position2Dx2-x->position2Dx1) != 0) + { + orientation = 180/3.14159 * atan((float)(x->position2Dy2 - x->position2Dy1)/(x->position2Dx2 - x->position2Dx1)); + if ((x->position2Dx2 - x->position2Dx1)<0) + orientation +=180; + if (orientation<0) + orientation +=360; + + outlet_float(x->force3, orientation); + } + else + { + if ((x->position2Dy2 - x->position2Dy1)<0) + outlet_float(x->force3,270); + else + outlet_float(x->force3,90); + } + + outlet_float(x->force2, vitesse); + + outlet_float(x->force1, distance); + + x->distance_old = distance; + +} + + +static void tLia2D_free(t_tLia2D *x) +{ + pd_unbind(&x->x_obj.ob_pd, x->x_sym); +} + +void *tLia2D_new(t_symbol *s) +{ + t_tLia2D *x = (t_tLia2D *)pd_new(tLia2D_class); + + x->x_sym = s; + pd_bind(&x->x_obj.ob_pd, s); + + inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("position2D"), gensym("position2D2")); + + x->force1=outlet_new(&x->x_obj, 0); + x->force2=outlet_new(&x->x_obj, 0); + x->force3=outlet_new(&x->x_obj, 0); + x->force4=outlet_new(&x->x_obj, 0); + + x->distance_old = 0; + + return (x); +} + +void tLia2D_setup(void) +{ + + tLia2D_class = class_new(gensym("tLia2D"), + (t_newmethod)tLia2D_new, + (t_method)tLia2D_free, + sizeof(t_tLia2D), + CLASS_DEFAULT, A_DEFSYM, 0); + + class_addcreator((t_newmethod)tLia2D_new, gensym("tLink2D"), A_DEFSYM, 0); + class_addcreator((t_newmethod)tLia2D_new, gensym("pmpd.tLink2D"), A_DEFSYM, 0); + + class_addbang(tLia2D_class, tLia2D_bang); + + class_addmethod(tLia2D_class, (t_method)tLia2D_position2D, gensym("position2D"), A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(tLia2D_class, (t_method)tLia2D_position2D2, gensym("position2D2"), A_DEFFLOAT, A_DEFFLOAT, 0); + + // only for the object not to output erreor when having the same name as the link + class_addmethod(tLia2D_class, (t_method)tLia2D_reset, gensym("reset"), 0); + class_addmethod(tLia2D_class, (t_method)tLia2D_resetL, gensym("resetL"), 0); + class_addmethod(tLia2D_class, (t_method)tLia2D_resetF, gensym("resetF"), 0); + class_addmethod(tLia2D_class, (t_method)tLia2D_setD, gensym("setD"), A_DEFFLOAT, 0); + class_addmethod(tLia2D_class, (t_method)tLia2D_setD2, gensym("setD2"), A_DEFFLOAT, 0); + class_addmethod(tLia2D_class, (t_method)tLia2D_setK, gensym("setK"), A_DEFFLOAT, 0); + class_addmethod(tLia2D_class, (t_method)tLia2D_setL, gensym("setL"), A_DEFFLOAT, 0); + class_addmethod(tLia2D_class, (t_method)tLia2D_Lmin, gensym("setLmin"), A_DEFFLOAT, 0); + class_addmethod(tLia2D_class, (t_method)tLia2D_Lmax, gensym("setLmax"), A_DEFFLOAT, 0); + +} diff --git a/src/tLia3D.c b/src/tLia3D.c new file mode 100755 index 0000000..507d113 --- /dev/null +++ b/src/tLia3D.c @@ -0,0 +1,153 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *tLia3D_class; + +typedef struct _tLia3D { + t_object x_obj; + t_float distance_old, position2Dx1, position2Dy1, position2Dz1, position2Dx2, position2Dy2, position2Dz2; + t_outlet *force1; + t_outlet *force2; + t_outlet *force3; + t_outlet *force4; + t_symbol *x_sym; // receive +} t_tLia3D; + +void tLia3D_reset(t_tLia3D *x) +{ +} + +void tLia3D_resetF(t_tLia3D *x) +{ +} + +void tLia3D_resetL(t_tLia3D *x) +{ +} + + +void tLia3D_setK(t_tLia3D *x, t_float K) +{ +} + +void tLia3D_setL(t_tLia3D *x, t_float L) +{ +} + +void tLia3D_setD(t_tLia3D *x, t_float D) +{ +} + +void tLia3D_setD2(t_tLia3D *x, t_float D) +{ +} + +void tLia3D_Lmin(t_tLia3D *x, t_float Lmin) +{ +} + +void tLia3D_Lmax(t_tLia3D *x, t_float Lmax) +{ +} + + +void tLia3D_position3D(t_tLia3D *x, t_floatarg f1, t_floatarg f2, t_floatarg f3) +{ + x->position2Dx1 = f1; + x->position2Dy1 = f2; + x->position2Dz1 = f3; +} + +void tLia3D_position3D2(t_tLia3D *x, t_floatarg f1, t_floatarg f2, t_floatarg f3) +{ + x->position2Dx2 = f1; + x->position2Dy2 = f2; + x->position2Dz2 = f3; +} + +void tLia3D_bang(t_tLia3D *x) +{ + t_float vitesse, distance, orientation; + t_atom force1[3]; + + distance = sqrt ( pow((x->position2Dx2-x->position2Dx1), 2) + pow((x->position2Dy2-x->position2Dy1), 2) + pow((x->position2Dz2-x->position2Dz1), 2) ); + + vitesse = x->distance_old - distance; + + + SETFLOAT(&(force1[0]), (x->position2Dx2 + x->position2Dx1)/ 2); + SETFLOAT(&(force1[1]), (x->position2Dy2 + x->position2Dy1)/ 2); + SETFLOAT(&(force1[2]), (x->position2Dz2 + x->position2Dz1)/ 2); + + outlet_anything(x->force4, gensym("position3D"), 3, force1); + + + SETFLOAT(&(force1[0]), (x->position2Dx2 - x->position2Dx1)/ distance); + SETFLOAT(&(force1[1]), (x->position2Dy2 - x->position2Dy1)/ distance); + SETFLOAT(&(force1[2]), (x->position2Dz2 - x->position2Dz1)/ distance); + + outlet_anything(x->force3, gensym("vector3D"), 3, force1); + + outlet_float(x->force2, vitesse); + + outlet_float(x->force1, distance); + + x->distance_old = distance; + +} + + +static void tLia3D_free(t_tLia3D *x) +{ + pd_unbind(&x->x_obj.ob_pd, x->x_sym); +} + +void *tLia3D_new(t_symbol *s) +{ + + t_tLia3D *x = (t_tLia3D *)pd_new(tLia3D_class); + + x->x_sym = s; + pd_bind(&x->x_obj.ob_pd, s); + + inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("position3D"), gensym("position3D2")); + + x->force1=outlet_new(&x->x_obj, 0); + x->force2=outlet_new(&x->x_obj, 0); + x->force3=outlet_new(&x->x_obj, 0); + x->force4=outlet_new(&x->x_obj, 0); + + x->distance_old = 0; + + return (x); +} + +void tLia3D_setup(void) +{ + + tLia3D_class = class_new(gensym("tLia3D"), + (t_newmethod)tLia3D_new, + (t_method)tLia3D_free, + sizeof(t_tLia3D), + CLASS_DEFAULT, A_DEFSYM, 0); + + class_addcreator((t_newmethod)tLia3D_new, gensym("tLink3D"), A_DEFSYM, 0); + class_addcreator((t_newmethod)tLia3D_new, gensym("pmpd.tLink3D"), A_DEFSYM, 0); + + class_addbang(tLia3D_class, tLia3D_bang); + + class_addmethod(tLia3D_class, (t_method)tLia3D_position3D, gensym("position3D"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(tLia3D_class, (t_method)tLia3D_position3D2, gensym("position3D2"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + + // only for the object not to output erreor when having the same name as the link + class_addmethod(tLia3D_class, (t_method)tLia3D_reset, gensym("reset"), 0); + class_addmethod(tLia3D_class, (t_method)tLia3D_resetL, gensym("resetL"), 0); + class_addmethod(tLia3D_class, (t_method)tLia3D_resetF, gensym("resetF"), 0); + class_addmethod(tLia3D_class, (t_method)tLia3D_setD, gensym("setD"), A_DEFFLOAT, 0); + class_addmethod(tLia3D_class, (t_method)tLia3D_setD2, gensym("setD2"), A_DEFFLOAT, 0); + class_addmethod(tLia3D_class, (t_method)tLia3D_setK, gensym("setK"), A_DEFFLOAT, 0); + class_addmethod(tLia3D_class, (t_method)tLia3D_setL, gensym("setL"), A_DEFFLOAT, 0); + class_addmethod(tLia3D_class, (t_method)tLia3D_Lmin, gensym("setLmin"), A_DEFFLOAT, 0); + class_addmethod(tLia3D_class, (t_method)tLia3D_Lmax, gensym("setLmax"), A_DEFFLOAT, 0); + +} diff --git a/src/tLine2D.c b/src/tLine2D.c new file mode 100755 index 0000000..f440bfd --- /dev/null +++ b/src/tLine2D.c @@ -0,0 +1,137 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *tLine2D_class; + +typedef struct _tLine2D { + t_object x_obj; + t_float X1, X2, Y1, Y2, P, P_old; + //extrem = Xmin, Ymin, Xmax, Ymax; + t_outlet *force_new;// outlet + t_outlet *profondeur;// outlet + t_outlet *vitesse;// outlet +} t_tLine2D; + +void tLine2D_position2D(t_tLine2D *x, t_float X, t_float Y) +{ + t_float a1, b1, c1, profondeur, tmp; + + b1 = x->X2 - x->X1; + a1 = -x->Y2 + x->Y1; + + if (!((a1==0) & (b1==0))) + { + tmp = sqrt((a1*a1)+(b1*b1)); // = longueur du vecteur pour renormalisation + a1 = a1/tmp; + b1 = b1/tmp; + c1 = a1*x->X1+b1*x->Y1; + + profondeur = ( (a1 * X) + (b1 * Y) ) - c1; + + tmp = profondeur - x->P_old; + + x->P_old = profondeur; + + outlet_float(x->vitesse, tmp); + + outlet_float(x->profondeur, profondeur); + + if ( ( profondeur < 0) & (profondeur > - x->P) ) + { + outlet_float(x->force_new, 1); + } + else + { + outlet_float(x->force_new, 0); + } + } + else + { + outlet_float(x->force_new, 0); + } + +} + +void tLine2D_Xmin(t_tLine2D *x, t_float X) +{ + x->X1= X; +} + +void tLine2D_Xmax(t_tLine2D *x, t_float X) +{ + x->X2= X; +} + +void tLine2D_Ymin(t_tLine2D *x, t_float X) +{ + x->Y1= X; +} + +void tLine2D_Ymax(t_tLine2D *x, t_float X) +{ + x->Y2= X; +} + +void tLine2D_P(t_tLine2D *x, t_float X) +{ + x->P= X; +} + +void *tLine2D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_tLine2D *x = (t_tLine2D *)pd_new(tLine2D_class); + + x->force_new=outlet_new(&x->x_obj, 0); + x->profondeur=outlet_new(&x->x_obj, 0); + x->vitesse=outlet_new(&x->x_obj, 0); + + x->P_old=0; + + if (argc>=5) + x->P = atom_getfloatarg(4, argc, argv); + else + x->P = 1; + + if (argc>=4) + x->Y2 = atom_getfloatarg(3, argc, argv); + else + x->Y2 = 0; + + if (argc>=3) + x->X2 = atom_getfloatarg(2, argc, argv); + else + x->X2 = 1; + + if (argc>=2) + x->Y1 = atom_getfloatarg(1, argc, argv); + else + x->Y1 = 0; + + + if (argc>=1) + x->X1 = atom_getfloatarg(0, argc, argv); + else + x->X1 = -1; + + return (x); +} + +void tLine2D_setup(void) +{ + + tLine2D_class = class_new(gensym("tLine2D"), + (t_newmethod)tLine2D_new, + 0, sizeof(t_tLine2D), + CLASS_DEFAULT, A_GIMME, 0); + + class_addcreator((t_newmethod)tLine2D_new, gensym("pmpd.tLine2D"), A_GIMME, 0); + + class_addmethod(tLine2D_class, (t_method)tLine2D_position2D, gensym("position2D"), A_DEFFLOAT, A_DEFFLOAT, 0); + + class_addmethod(tLine2D_class, (t_method)tLine2D_Xmin, gensym("setX1"), A_DEFFLOAT, 0); + class_addmethod(tLine2D_class, (t_method)tLine2D_Ymin, gensym("setY1"), A_DEFFLOAT, 0); + class_addmethod(tLine2D_class, (t_method)tLine2D_Xmax, gensym("setX2"), A_DEFFLOAT, 0); + class_addmethod(tLine2D_class, (t_method)tLine2D_Ymax, gensym("setY2"), A_DEFFLOAT, 0); + class_addmethod(tLine2D_class, (t_method)tLine2D_P, gensym("setPmax"), A_DEFFLOAT, 0); + +} diff --git a/src/tPlane3D.c b/src/tPlane3D.c new file mode 100755 index 0000000..3213bea --- /dev/null +++ b/src/tPlane3D.c @@ -0,0 +1,175 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *tPlane3D_class; + +typedef struct _tPlane3D { + t_object x_obj; + t_float X, Y, Z, VX, VY, VZ, P, distance_old; + t_outlet *force_new, *profondeur, *vitesse;// outlet +} t_tPlane3D; + + +void tPlane3D_position3D(t_tPlane3D *x, t_float X, t_float Y, t_float Z) +{ +t_float d, tmp, profondeur, vitesse; + + tmp = sqrt (x->VX*x->VX + x->VY*x->VY + x->VZ*x->VZ); + if (tmp != 0) + { + x->VX /= tmp; + x->VY /= tmp; + x->VZ /= tmp; + + } + else + { + x->VX=1; + x->VY=0; + x->VZ=0; + } + + d = x->VX * x->X + x->VY * x->Y + x->VZ * x->Z; + + profondeur = x->VX * X + x->VY * Y + x->VZ * Z - d; + + vitesse = profondeur - x->distance_old ; + + x->distance_old = profondeur; + + outlet_float(x->vitesse, vitesse); + + outlet_float(x->profondeur, profondeur); + + + if ( (profondeur < 0) & (profondeur > - x->P) ) + { + outlet_float(x->force_new, 1); + } + else + { + outlet_float(x->force_new, 0); + } + +} + +void tPlane3D_setXYZ(t_tPlane3D *x, t_float X, t_float Y, t_float Z) +{ + x->X= X; + x->Y= Y; + x->Z= Z; +} +void tPlane3D_setVXYZ(t_tPlane3D *x, t_float X, t_float Y, t_float Z) +{ + x->VX= X; + x->VY= Y; + x->VZ= Z; +} + +void tPlane3D_setVX(t_tPlane3D *x, t_float X) +{ + x->VX= X; +} + +void tPlane3D_setVY(t_tPlane3D *x, t_float Y) +{ + x->VY= Y; +} + +void tPlane3D_setVZ(t_tPlane3D *x, t_float Z) +{ + x->VZ= Z; +} +void tPlane3D_setX(t_tPlane3D *x, t_float X) +{ + x->X= X; +} + +void tPlane3D_setY(t_tPlane3D *x, t_float Y) +{ + x->Y= Y; +} + +void tPlane3D_setZ(t_tPlane3D *x, t_float Z) +{ + x->Z= Z; +} + +void tPlane3D_setP(t_tPlane3D *x, t_float X) +{ + x->P= X; +} + + +void *tPlane3D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_tPlane3D *x = (t_tPlane3D *)pd_new(tPlane3D_class); + + x->force_new=outlet_new(&x->x_obj, 0); + x->profondeur=outlet_new(&x->x_obj, 0); + x->vitesse=outlet_new(&x->x_obj, 0); + + x->distance_old = 0; + + if (argc>=7) + x->P= atom_getfloatarg(6, argc, argv); + else + x->P= 10000; + + if (argc>=6) + x->Z= atom_getfloatarg(5, argc, argv); + else + x->Z= 0; + + if (argc>=5) + x->Y= atom_getfloatarg(4, argc, argv); + else + x->Y= 0; + + if (argc>=4) + x->X= atom_getfloatarg(3, argc, argv); + else + x->X= 0; + + if (argc>=3) + x->VZ= atom_getfloatarg(2, argc, argv); + else + x->VZ= 0; + + if (argc>=2) + x->VY= atom_getfloatarg(1, argc, argv); + else + x->VY= 0; + + if (argc>=1) + x->VX= atom_getfloatarg(0, argc, argv); + else + x->VX= 1; + + return (x); +} + +void tPlane3D_setup(void) +{ + + tPlane3D_class = class_new(gensym("tPlane3D"), + (t_newmethod)tPlane3D_new, + 0, sizeof(t_tPlane3D), + CLASS_DEFAULT, A_GIMME, 0); + + class_addcreator((t_newmethod)tPlane3D_new, gensym("pmpd.tPlane3D"), A_GIMME, 0); + + class_addmethod(tPlane3D_class, (t_method)tPlane3D_position3D, gensym("position3D"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + + class_addmethod(tPlane3D_class, (t_method)tPlane3D_setVX, gensym("setVX"), A_DEFFLOAT, 0); + class_addmethod(tPlane3D_class, (t_method)tPlane3D_setVY, gensym("setVY"), A_DEFFLOAT, 0); + class_addmethod(tPlane3D_class, (t_method)tPlane3D_setVZ, gensym("setVZ"), A_DEFFLOAT, 0); + class_addmethod(tPlane3D_class, (t_method)tPlane3D_setX, gensym("setX"), A_DEFFLOAT, 0); + class_addmethod(tPlane3D_class, (t_method)tPlane3D_setY, gensym("setY"), A_DEFFLOAT, 0); + class_addmethod(tPlane3D_class, (t_method)tPlane3D_setZ, gensym("setZ"), A_DEFFLOAT, 0); + class_addmethod(tPlane3D_class, (t_method)tPlane3D_setXYZ, gensym("setXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(tPlane3D_class, (t_method)tPlane3D_setVXYZ, gensym("setVXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(tPlane3D_class, (t_method)tPlane3D_setP, gensym("setPmax"), A_DEFFLOAT, 0); + + +} diff --git a/src/tSeg2D.c b/src/tSeg2D.c new file mode 100755 index 0000000..7345bd7 --- /dev/null +++ b/src/tSeg2D.c @@ -0,0 +1,139 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *tSeg2D_class; + +typedef struct _tSeg2D { + t_object x_obj; + t_float X1, X2, Y1, Y2, P, P_old; + t_outlet *force_new, *profondeur, *vitesse;// outlet +} t_tSeg2D; + +void tSeg2D_position2D(t_tSeg2D *x, t_float X, t_float Y) +{ + t_float a1, b1, c1, a2, b2, c2, a3, b3, c3, profondeur, tmp; + + b1 = x->X2 - x->X1; + a1 = -x->Y2 + x->Y1; + + if (!((a1==0) & (b1==0))) + { + tmp = sqrt((a1*a1)+(b1*b1)); // = longueur du vecteur pour renormalisation + a1 = a1/tmp; + b1 = b1/tmp; + c1 = a1*x->X1+b1*x->Y1; + + profondeur = ( (a1 * X) + (b1 * Y) ) - c1; + + tmp = profondeur - x->P_old; + + x->P_old = profondeur; + + a2 = b1; + b2 = -a1; + c2 = a2*x->X1+b2*x->Y1; + + a3 = a2; + b3 = b2; + c3 = a3*x->X2+b3*x->Y2; + + outlet_float(x->vitesse, tmp); + outlet_float(x->profondeur, profondeur); + + if ( ( profondeur < 0) & (profondeur > - x->P) & (( (a2 * X) + (b2 * Y) ) > c2) & ( ((a3 * X) + (b3 * Y) ) < c3) ) + { + outlet_float(x->force_new, 1); + } + else + { + outlet_float(x->force_new, 0); + } + } + else + { + outlet_float(x->force_new, 0); + } + +} + +void tSeg2D_Xmin(t_tSeg2D *x, t_float X) +{ + x->X1= X; +} + +void tSeg2D_Xmax(t_tSeg2D *x, t_float X) +{ + x->X2= X; +} + +void tSeg2D_Ymin(t_tSeg2D *x, t_float X) +{ + x->Y1= X; +} + +void tSeg2D_Ymax(t_tSeg2D *x, t_float X) +{ + x->Y2= X; +} + +void tSeg2D_P(t_tSeg2D *x, t_float X) +{ + x->P= X; +} + +void *tSeg2D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_tSeg2D *x = (t_tSeg2D *)pd_new(tSeg2D_class); + x->force_new = outlet_new(&x->x_obj, 0); + x->profondeur =outlet_new(&x->x_obj, 0); + x->vitesse = outlet_new(&x->x_obj, 0); + + x->P_old = 0; + + if (argc>=5) + x->P = atom_getfloatarg(4, argc, argv); + else + x->P = 1; + + if (argc>=4) + x->Y2 = atom_getfloatarg(3, argc, argv); + else + x->Y2 = 0; + + if (argc>=3) + x->X2 = atom_getfloatarg(2, argc, argv); + else + x->X2 = 1; + + if (argc>=2) + x->Y1 = atom_getfloatarg(1, argc, argv); + else + x->Y1 = 0; + + if (argc>=1) + x->X1 = atom_getfloatarg(0, argc, argv); + else + x->X1 = -1; + + return (x); +} + +void tSeg2D_setup(void) +{ + + tSeg2D_class = class_new(gensym("tSeg2D"), + (t_newmethod)tSeg2D_new, + 0, sizeof(t_tSeg2D), + CLASS_DEFAULT, A_GIMME, 0); + + class_addcreator((t_newmethod)tSeg2D_new, gensym("pmpd.tSeg2D"), A_GIMME, 0); + + class_addmethod(tSeg2D_class, (t_method)tSeg2D_position2D, gensym("position2D"), A_DEFFLOAT, A_DEFFLOAT, 0); + + class_addmethod(tSeg2D_class, (t_method)tSeg2D_Xmin, gensym("setX1"), A_DEFFLOAT, 0); + class_addmethod(tSeg2D_class, (t_method)tSeg2D_Ymin, gensym("setY1"), A_DEFFLOAT, 0); + class_addmethod(tSeg2D_class, (t_method)tSeg2D_Xmax, gensym("setX2"), A_DEFFLOAT, 0); + class_addmethod(tSeg2D_class, (t_method)tSeg2D_Ymax, gensym("setY2"), A_DEFFLOAT, 0); + class_addmethod(tSeg2D_class, (t_method)tSeg2D_P, gensym("setPmax"), A_DEFFLOAT, 0); + +} diff --git a/src/tSphere3D.c b/src/tSphere3D.c new file mode 100755 index 0000000..6ef9cfa --- /dev/null +++ b/src/tSphere3D.c @@ -0,0 +1,128 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *tSphere3D_class; + +typedef struct _tSphere3D { + t_object x_obj; + t_float X, Y, Z, Rmin, Rmax, position_old; + t_outlet *force_new, *distance_out, *vitesse;// outlet +} t_tSphere3D; + +void tSphere3D_position3D(t_tSphere3D *x, t_float X, t_float Y, t_float Z) +{ +t_float distance, vitesse; + distance = sqrt ( (X - x->X)*(X - x->X) + (Y - x->Y)*(Y - x->Y) + (Z - x->Z)*(Z - x->Z)); + + vitesse = distance - x->position_old; + x->position_old = distance; + + outlet_float(x->vitesse, vitesse); + + outlet_float(x->distance_out, distance); + + if ( (distance < x->Rmax) & (distance > x->Rmin) ) + { + outlet_float(x->force_new, 1); + } + else + { + outlet_float(x->force_new, 0); + } + +} + +void tSphere3D_setXYZ(t_tSphere3D *x, t_float X, t_float Y, t_float Z) +{ + x->X= X; + x->Y= Y; + x->Z= Z; +} + +void tSphere3D_setX(t_tSphere3D *x, t_float X) +{ + x->X= X; +} + +void tSphere3D_setY(t_tSphere3D *x, t_float Y) +{ + x->Y= Y; +} + +void tSphere3D_setZ(t_tSphere3D *x, t_float Z) +{ + x->Z= Z; +} + +void tSphere3D_setRmax(t_tSphere3D *x, t_float X) +{ + x->Rmax= X; +} + +void tSphere3D_setRmin(t_tSphere3D *x, t_float X) +{ + x->Rmin= X; +} + + + +void *tSphere3D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_tSphere3D *x = (t_tSphere3D *)pd_new(tSphere3D_class); + + x->force_new=outlet_new(&x->x_obj, 0); + x->distance_out=outlet_new(&x->x_obj, 0); + x->vitesse=outlet_new(&x->x_obj, 0); + + x->position_old = 0; + + + if (argc>=5) + x->Rmax= atom_getfloatarg(4, argc, argv); + else + x->Rmax= 1; + + if (argc>=4) + x->Rmin= atom_getfloatarg(3, argc, argv); + else + x->Rmin= 0; + + if (argc>=3) + x->Z= atom_getfloatarg(2, argc, argv); + else + x->Z= 0; + + if (argc>=2) + x->Y= atom_getfloatarg(1, argc, argv); + else + x->Y= 0; + + if (argc>=1) + x->X= atom_getfloatarg(0, argc, argv); + else + x->X= 0; + + return (x); +} + +void tSphere3D_setup(void) +{ + + tSphere3D_class = class_new(gensym("tSphere3D"), + (t_newmethod)tSphere3D_new, + 0, sizeof(t_tSphere3D), + CLASS_DEFAULT, A_GIMME, 0); + + class_addcreator((t_newmethod)tSphere3D_new, gensym("pmpd.tSphere3D"), A_GIMME, 0); + + class_addmethod(tSphere3D_class, (t_method)tSphere3D_position3D, gensym("position3D"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + + class_addmethod(tSphere3D_class, (t_method)tSphere3D_setX, gensym("setX"), A_DEFFLOAT, 0); + class_addmethod(tSphere3D_class, (t_method)tSphere3D_setY, gensym("setY"), A_DEFFLOAT, 0); + class_addmethod(tSphere3D_class, (t_method)tSphere3D_setZ, gensym("setZ"), A_DEFFLOAT, 0); + class_addmethod(tSphere3D_class, (t_method)tSphere3D_setXYZ, gensym("setXYZ"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(tSphere3D_class, (t_method)tSphere3D_setRmax, gensym("setRmax"), A_DEFFLOAT, 0); + class_addmethod(tSphere3D_class, (t_method)tSphere3D_setRmin, gensym("setRmin"), A_DEFFLOAT, 0); + + +} diff --git a/src/tSquare2D.c b/src/tSquare2D.c new file mode 100755 index 0000000..4e14fa0 --- /dev/null +++ b/src/tSquare2D.c @@ -0,0 +1,92 @@ +#include "m_pd.h" +#include "math.h" + +static t_class *tSquare2D_class; + +typedef struct _tSquare2D { + t_object x_obj; + t_float Xmin, Xmax, Ymin, Ymax; + //extrem = Xmin, Ymin, Xmax, Ymax; + t_outlet *force_new;// outlet +} t_tSquare2D; + +void tSquare2D_position2D(t_tSquare2D *x, t_float X, t_float Y) +{ + + if ((X > x->Xmin) & (X < x->Xmax) & (Y > x->Ymin) & (Y < x->Ymax)) + { + outlet_float(x->force_new, 1); + } + else + { + outlet_float(x->force_new, 0); + } +} + +void tSquare2D_Xmin(t_tSquare2D *x, t_float X) +{ + x->Xmin= X; +} + +void tSquare2D_Xmax(t_tSquare2D *x, t_float X) +{ + x->Xmax= X; +} + +void tSquare2D_Ymin(t_tSquare2D *x, t_float X) +{ + x->Ymin= X; +} + +void tSquare2D_Ymax(t_tSquare2D *x, t_float X) +{ + x->Ymax= X; +} + +void *tSquare2D_new(t_symbol *s, int argc, t_atom *argv) +{ + t_tSquare2D *x = (t_tSquare2D *)pd_new(tSquare2D_class); + x->force_new=outlet_new(&x->x_obj, 0); + + if (argc>=4) + x->Ymax = atom_getfloatarg(3, argc, argv); + else + x->Ymax = 1; + + if (argc>=3) + x->Ymin = atom_getfloatarg(2, argc, argv); + else + x->Ymin = -1; + + if (argc>=2) + x->Xmax = atom_getfloatarg(1, argc, argv); + else + x->Xmax = 1; + + if (argc>=1) + x->Xmin = atom_getfloatarg(0, argc, argv); + else + x->Xmin = -1; + + return (x); +} + +void tSquare2D_setup(void) +{ + + tSquare2D_class = class_new(gensym("tSquare2D"), + (t_newmethod)tSquare2D_new, + 0, sizeof(t_tSquare2D), + CLASS_DEFAULT, A_GIMME, 0); + + class_addcreator((t_newmethod)tSquare2D_new, gensym("pmpd.tSquare2D"), A_GIMME, 0); + + class_addmethod(tSquare2D_class, (t_method)tSquare2D_position2D, gensym("position2D"), A_DEFFLOAT, A_DEFFLOAT, 0); + + class_addmethod(tSquare2D_class, (t_method)tSquare2D_Xmin, gensym("setXmin"), A_DEFFLOAT, 0); + class_addmethod(tSquare2D_class, (t_method)tSquare2D_Ymin, gensym("setYmin"), A_DEFFLOAT, 0); + class_addmethod(tSquare2D_class, (t_method)tSquare2D_Xmax, gensym("setXmax"), A_DEFFLOAT, 0); + class_addmethod(tSquare2D_class, (t_method)tSquare2D_Ymax, gensym("setYmax"), A_DEFFLOAT, 0); + + +} -- cgit v1.2.1