Mercurial > projects > chipmunkd

comparison trunk/chipmunkd/cpSpaceStep.d @ 29:80058cee1a77

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
updated to chipmunk 5.3.4
author Extrawurst
date Thu, 16 Dec 2010 00:33:06 +0100
parents 4ceef5833c8c
children
comparison
equal deleted inserted replaced
28:4541ca17975b 29:80058cee1a77
17 //import chipmunkd.constraints.cpConstraint; 17 //import chipmunkd.constraints.cpConstraint;
18 //import chipmunkd.cpSpaceQuery; 18 //import chipmunkd.cpSpaceQuery;
19 // 19 //
20 //#pragma mark Post Step Callback Functions 20 //#pragma mark Post Step Callback Functions
21 21
22 struct postStepCallback { 22 struct PostStepCallback {
23 cpPostStepFunc func; 23 cpPostStepFunc func;
24 void *obj; 24 void *obj;
25 void *data; 25 void *data;
26 } 26 }
27 27
28 static cpBool 28 static cpBool
29 postStepFuncSetEql(postStepCallback *a, postStepCallback *b){ 29 postStepFuncSetEql(PostStepCallback *a, PostStepCallback *b){
30 return a.obj == b.obj; 30 return a.obj == b.obj;
31 } 31 }
32 32
33 static void * 33 static void *
34 postStepFuncSetTrans(postStepCallback *callback, void *ignored) 34 postStepFuncSetTrans(PostStepCallback *callback, void *ignored)
35 { 35 {
36 postStepCallback *value = cast(postStepCallback *)cpmalloc(postStepCallback.sizeof); 36 PostStepCallback *value = cast(PostStepCallback *)cpmalloc(PostStepCallback.sizeof);
37 (*value) = (*callback); 37 (*value) = (*callback);
38 38
39 return value; 39 return value;
40 } 40 }
41 41
44 { 44 {
45 if(!space.postStepCallbacks){ 45 if(!space.postStepCallbacks){
46 space.postStepCallbacks = cpHashSetNew(0, cast(cpHashSetEqlFunc)&postStepFuncSetEql, cast(cpHashSetTransFunc)&postStepFuncSetTrans); 46 space.postStepCallbacks = cpHashSetNew(0, cast(cpHashSetEqlFunc)&postStepFuncSetEql, cast(cpHashSetTransFunc)&postStepFuncSetTrans);
47 } 47 }
48 48
49 postStepCallback callback = {func, obj, data}; 49 PostStepCallback callback = {func, obj, data};
50 cpHashSetInsert(space.postStepCallbacks, cast(cpHashValue)cast(size_t)obj, &callback, null); 50 cpHashSetInsert(space.postStepCallbacks, cast(cpHashValue)cast(size_t)obj, &callback, null);
51 }
52
53 void *
54 cpSpaceGetPostStepData(cpSpace *space, void *obj)
55 {
56 if(space.postStepCallbacks){
57 PostStepCallback query = {null, obj, null};
58 PostStepCallback *callback = cast(PostStepCallback *)cpHashSetFind(space.postStepCallbacks, cast(cpHashValue)cast(size_t)obj, &query);
59 return (callback ? callback.data : null);
60 } else {
61 return null;
62 }
51 } 63 }
52 64
53 //#pragma mark Contact Buffer Functions 65 //#pragma mark Contact Buffer Functions
54 66
55 enum CP_CONTACTS_BUFFER_SIZE = ((CP_BUFFER_BYTES - cpContactBufferHeader.sizeof)/cpContact.sizeof); 67 enum CP_CONTACTS_BUFFER_SIZE = ((CP_BUFFER_BYTES - cpContactBufferHeader.sizeof)/cpContact.sizeof);
251 return cpTrue; 263 return cpTrue;
252 } 264 }
253 265
254 // Hashset filter func to call and throw away post step callbacks. 266 // Hashset filter func to call and throw away post step callbacks.
255 static void 267 static void
256 postStepCallbackSetIter(postStepCallback *callback, cpSpace *space) 268 postStepCallbackSetIter(PostStepCallback *callback, cpSpace *space)
257 { 269 {
258 callback.func(space, callback.obj, callback.data); 270 callback.func(space, callback.obj, callback.data);
259 cpfree(callback); 271 cpfree(callback);
260 } 272 }
261 273
267 279
268 void 280 void
269 cpSpaceStep(cpSpace *space, cpFloat dt) 281 cpSpaceStep(cpSpace *space, cpFloat dt)
270 { 282 {
271 if(!dt) return; // don't step if the timestep is 0! 283 if(!dt) return; // don't step if the timestep is 0!
272
273 cpFloat dt_inv = 1.0f/dt; 284 cpFloat dt_inv = 1.0f/dt;
274 285
275 cpArray *bodies = space.bodies; 286 cpArray *bodies = space.bodies;
276 cpArray *constraints = space.constraints; 287 cpArray *constraints = space.constraints;
277 288
285 } 296 }
286 297
287 // Pre-cache BBoxes and shape data. 298 // Pre-cache BBoxes and shape data.
288 cpSpaceHashEach(space.activeShapes, cast(cpSpaceHashIterator)&updateBBCache, null); 299 cpSpaceHashEach(space.activeShapes, cast(cpSpaceHashIterator)&updateBBCache, null);
289 300
290 space.locked = cpTrue; 301 cpSpaceLock(space);
291 302
292 // Collide! 303 // Collide!
293 cpSpacePushFreshContactBuffer(space); 304 cpSpacePushFreshContactBuffer(space);
294 if(space.staticShapes.handleSet.entries) 305 if(space.staticShapes.handleSet.entries)
295 cpSpaceHashEach(space.activeShapes, cast(cpSpaceHashIterator)&active2staticIter, space); 306 cpSpaceHashEach(space.activeShapes, cast(cpSpaceHashIterator)&active2staticIter, space);
296 cpSpaceHashQueryRehash(space.activeShapes, cast(cpSpaceHashQueryFunc)&queryFunc, space); 307 cpSpaceHashQueryRehash(space.activeShapes, cast(cpSpaceHashQueryFunc)&queryFunc, space);
297 308
298 space.locked = cpFalse; 309 cpSpaceUnlock(space);
299 310
300 // If body sleeping is enabled, do that now. 311 // If body sleeping is enabled, do that now.
301 if(space.sleepTimeThreshold != INFINITY){ 312 if(space.sleepTimeThreshold != INFINITY){
302 cpSpaceProcessComponents(space, dt); 313 cpSpaceProcessComponents(space, dt);
303 bodies = space.bodies; // rebuilt by processContactComponents() 314 bodies = space.bodies; // rebuilt by processContactComponents()
349 cpConstraint *constraint = cast(cpConstraint *)constraints.arr[j]; 360 cpConstraint *constraint = cast(cpConstraint *)constraints.arr[j];
350 constraint.klass.applyImpulse(constraint); 361 constraint.klass.applyImpulse(constraint);
351 } 362 }
352 } 363 }
353 364
354 space.locked = cpTrue; 365 cpSpaceLock(space);
355 366
356 // run the post solve callbacks 367 // run the post solve callbacks
357 for(int i=0; i<arbiters.num; i++){ 368 for(int i=0; i<arbiters.num; i++){
358 cpArbiter *arb = cast(cpArbiter *) arbiters.arr[i]; 369 cpArbiter *arb = cast(cpArbiter *) arbiters.arr[i];
359 370
361 handler.postSolve(arb, space, handler.data); 372 handler.postSolve(arb, space, handler.data);
362 373
363 arb.state = cpArbiterState.cpArbiterStateNormal; 374 arb.state = cpArbiterState.cpArbiterStateNormal;
364 } 375 }
365 376
366 space.locked = cpFalse; 377 cpSpaceUnlock(space);
367 378
368 // Run the post step callbacks 379 // Run the post step callbacks
369 // Loop because post step callbacks may create more post step callbacks 380 // Loop because post step callbacks may create more post step callbacks
370 while(space.postStepCallbacks){ 381 while(space.postStepCallbacks){
371 cpHashSet *callbacks = space.postStepCallbacks; 382 cpHashSet *callbacks = space.postStepCallbacks;