addons/ODE/source/IoODEWorld.c

   1 //metadoc ODEWorld copyright Jonathan Wright, 2006
   2 //metadoc ODEWorld license BSD revised
   3 /*metadoc ODEWorld description
   4 ODEWorld binding
   5 */
   6
   7 #include "IoODEWorld.h"
   8 #include "IoODEBody.h"
   9 #include "IoODEJointGroup.h"
  10 #include "IoState.h"
  11 #include "IoSeq.h"
  12 #include "IoList.h"
  13
  14 #define DATA(self) ((IoODEWorldData *)IoObject_dataPointer(self))
  15 #define WORLDID (DATA(self)->worldId)
  16
  17 IoTag *IoODEWorld_newTag(void *state)
  18 {
  19         IoTag *tag = IoTag_newWithName_("ODEWorld");
  20         IoTag_state_(tag, state);
  21         IoTag_freeFunc_(tag, (IoTagFreeFunc *)IoODEWorld_free);
  22         IoTag_cloneFunc_(tag, (IoTagCloneFunc *)IoODEWorld_rawClone);
  23         return tag;
  24 }
  25
  26 IoODEWorld *IoODEWorld_proto(void *state)
  27 {
  28         IoObject *self = IoObject_new(state);
  29         IoObject_tag_(self, IoODEWorld_newTag(state));
  30
  31         IoObject_setDataPointer_(self, calloc(1, sizeof(IoODEWorldData)));
  32
  33         WORLDID = 0;
  34         DATA(self)->bodies = 0L;
  35         DATA(self)->jointGroups = 0L;
  36
  37         IoState_registerProtoWithFunc_(state, self, IoODEWorld_proto);
  38
  39         {
  40                 IoMethodTable methodTable[] = {
  41                 {"worldId", IoODEWorld_worldId},
  42                 {"bodies", IoODEWorld_bodies},
  43                 {"jointGroups", IoODEWorld_jointGroups},
  44
  45                 {"gravity", IoODEWorld_gravity},
  46                 {"setGravity", IoODEWorld_setGravity},
  47                 {"erp", IoODEWorld_erp},
  48                 {"setErp", IoODEWorld_setErp},
  49                 {"cfm", IoODEWorld_cfm},
  50                 {"setCfm", IoODEWorld_setCfm},
  51
  52                 {"step", IoODEWorld_step},
  53                 {"quickStep", IoODEWorld_quickStep},
  54
  55                 {NULL, NULL},
  56                 };
  57                 IoObject_addMethodTable_(self, methodTable);
  58         }
  59         return self;
  60 }
  61
  62 IoODEWorld *IoODEWorld_rawClone(IoODEWorld *proto)
  63 {
  64         IoObject *self = IoObject_rawClonePrimitive(proto);
  65         IoObject_setDataPointer_(self, calloc(1, sizeof(IoODEWorldData)));
  66         WORLDID = dWorldCreate();
  67         DATA(self)->bodies = List_new();
  68         DATA(self)->jointGroups = List_new();
  69         IoObject_inlineSetSlot_to_(self, IOSYMBOL("Body"), IoODEBody_newBodyProtoWithWorld(IOSTATE, self));
  70         IoObject_inlineSetSlot_to_(self, IOSYMBOL("JointGroup"), IoODEJointGroup_newJointGroupProtoWithWorld(IOSTATE, self));
  71         return self;
  72 }
  73
  74 IoODEWorld *IoODEWorld_new(void *state)
  75 {
  76         IoODEWorld *proto = IoState_protoWithInitFunction_(state, IoODEWorld_proto);
  77         return IOCLONE(proto);
  78 }
  79
  80 void IoODEWorld_free(IoODEWorld *self)
  81 {
  82         IoODEWorld_emptyJointGroups(self);
  83
  84         if(WORLDID)
  85         {
  86                 dWorldDestroy(WORLDID);
  87                 WORLDID = 0;
  88         }
  89         if(DATA(self)->bodies)
  90         {
  91                 LIST_FOREACH(DATA(self)->bodies, i, body,
  92                         IoODEBody_worldDestroyed((IoODEBody*)body);
  93                         )
  94                 List_free(DATA(self)->bodies);
  95                 DATA(self)->bodies = 0L;
  96         }
  97         if(DATA(self)->jointGroups)
  98         {
  99                 LIST_FOREACH(DATA(self)->jointGroups, i, jointGroup,
 100                         IoODEJointGroup_worldDestoryed((IoODEJointGroup*)jointGroup);
 101                         )
 102                 List_free(DATA(self)->jointGroups);
 103                 DATA(self)->jointGroups = 0L;
 104         }
 105         free(IoObject_dataPointer(self));
 106 }
 107
 108 void IoODEWorld_mark(IoODEWorld *self)
 109 {
 110 }
 111
 112 /* ----------------------------------------------------------- */
 113
 114 dWorldID IoODEWorld_rawWorldId(IoODEWorld *self)
 115 {
 116         return WORLDID;
 117 }
 118
 119 void IoODEWorld_addBody(IoODEWorld *self, IoODEBody *body)
 120 {
 121         List_append_(DATA(self)->bodies, body);
 122 }
 123
 124 void IoODEWorld_removeBody(IoODEWorld *self, IoODEBody *body)
 125 {
 126         List_remove_(DATA(self)->bodies, body);
 127 }
 128
 129 void IoODEWorld_addJointGroup(IoODEWorld *self, IoODEJointGroup *jointGroup)
 130 {
 131         List_append_(DATA(self)->jointGroups, jointGroup);
 132 }
 133
 134 void IoODEWorld_removeJointGroup(IoODEWorld *self, IoODEJointGroup *jointGroup)
 135 {
 136         List_remove_(DATA(self)->jointGroups, jointGroup);
 137 }
 138
 139 void IoODEWorld_emptyJointGroups(IoODEWorld *self)
 140 {
 141         if(DATA(self)->jointGroups)
 142         {
 143                 LIST_FOREACH(DATA(self)->jointGroups, i, jointGroup,
 144                         IoODEJointGroup_rawEmpty((IoODEJointGroup*)jointGroup);
 145                         )
 146         }
 147 }
 148
 149 /* ----------------------------------------------------------- */
 150
 151 void IoODEWorld_assertHasWorldId(IoODEWorld *self, IoObject *locals, IoMessage *m)
 152 {
 153         IOASSERT(WORLDID, "ODE World cannot be used directly. Clone the world and use the clone.");
 154 }
 155
 156
 157 IoObject *IoODEWorld_worldId(IoODEWorld *self, IoObject *locals, IoMessage *m)
 158 {
 159         return IONUMBER((long)WORLDID);
 160 }
 161
 162 IoObject *IoODEWorld_setGravity(IoODEWorld *self, IoObject *locals, IoMessage *m)
 163 {
 164         const double x = IoMessage_locals_doubleArgAt_(m, locals, 0);
 165         const double y = IoMessage_locals_doubleArgAt_(m, locals, 1);
 166         const double z = IoMessage_locals_doubleArgAt_(m, locals, 2);
 167
 168         IoODEWorld_assertHasWorldId(self, locals, m);
 169         dWorldSetGravity(WORLDID, x, y, z);
 170         return self;
 171 }
 172
 173 IoObject *IoODEWorld_gravity(IoODEWorld *self, IoObject *locals, IoMessage *m)
 174 {
 175         dVector3 gravity;
 176         IoODEWorld_assertHasWorldId(self, locals, m);
 177
 178         dWorldGetGravity(WORLDID, gravity);
 179
 180         return IoSeq_newVec3f(IOSTATE, {gravity[0], gravity[1], gravity[2]});
 181 }
 182
 183 IoObject *IoODEWorld_step(IoODEWorld *self, IoObject *locals, IoMessage *m)
 184 {
 185         const double stepSize = IoMessage_locals_doubleArgAt_(m, locals, 0);
 186
 187         IoODEWorld_assertHasWorldId(self, locals, m);
 188         dWorldStep(WORLDID, stepSize);
 189         return self;
 190 }
 191
 192 IoObject *IoODEWorld_quickStep(IoODEWorld *self, IoObject *locals, IoMessage *m)
 193 {
 194         const double stepSize = IoMessage_locals_doubleArgAt_(m, locals, 0);
 195
 196         IoODEWorld_assertHasWorldId(self, locals, m);
 197         dWorldQuickStep(WORLDID, stepSize);
 198         return self;
 199 }
 200
 201 IoObject *IoODEWorld_stepFast1(IoODEWorld *self, IoObject *locals, IoMessage *m)
 202 {
 203         const double stepSize = IoMessage_locals_doubleArgAt_(m, locals, 0);
 204         const int maxIterations = IoMessage_locals_intArgAt_(m, locals, 1);
 205
 206         IoODEWorld_assertHasWorldId(self, locals, m);
 207         dWorldStepFast1(WORLDID, stepSize, maxIterations);
 208         return self;
 209 }
 210
 211 IoObject *IoODEWorld_bodies(IoODEWorld *self, IoObject *locals, IoMessage *m)
 212 {
 213         IoODEWorld_assertHasWorldId(self, locals, m);
 214         {
 215                 IoList *list = IoList_new(IOSTATE);
 216                 IoList_rawAddBaseList_(list, DATA(self)->bodies);
 217                 return list;
 218         }
 219 }
 220
 221 IoObject *IoODEWorld_jointGroups(IoODEWorld *self, IoObject *locals, IoMessage *m)
 222 {
 223         IoODEWorld_assertHasWorldId(self, locals, m);
 224         {
 225                 IoList *list = IoList_new(IOSTATE);
 226                 IoList_rawAddBaseList_(list, DATA(self)->jointGroups);
 227                 return list;
 228         }
 229 }
 230
 231 IoObject *IoODEWorld_erp(IoODEWorld *self, IoObject *locals, IoMessage *m)
 232 {
 233         IoODEWorld_assertHasWorldId(self, locals, m);
 234         return IONUMBER(dWorldGetERP(WORLDID));
 235 }
 236
 237 IoObject *IoODEWorld_setErp(IoODEWorld *self, IoObject *locals, IoMessage *m)
 238 {
 239         const double erp = IoMessage_locals_doubleArgAt_(m, locals, 0);
 240         IoODEWorld_assertHasWorldId(self, locals, m);
 241         dWorldSetERP(WORLDID, erp);
 242         return self;
 243 }
 244
 245 IoObject *IoODEWorld_cfm(IoODEWorld *self, IoObject *locals, IoMessage *m)
 246 {
 247         IoODEWorld_assertHasWorldId(self, locals, m);
 248         return IONUMBER(dWorldGetCFM(WORLDID));
 249 }
 250
 251 IoObject *IoODEWorld_setCfm(IoODEWorld *self, IoObject *locals, IoMessage *m)
 252 {
 253         const double cfm = IoMessage_locals_doubleArgAt_(m, locals, 0);
 254         IoODEWorld_assertHasWorldId(self, locals, m);
 255         dWorldSetCFM(WORLDID, cfm);
 256         return self;
 257 }