void cpSpaceFreeChildren(cpSpace *space) { cpSpaceHashEach(space->staticShapes, &shapeFreeWrap, NULL); cpSpaceHashEach(space->activeShapes, &shapeFreeWrap, NULL); cpArrayEach(space->bodies, &bodyFreeWrap, NULL); cpArrayEach(space->joints, &jointFreeWrap, NULL); }
void cpSpaceFreeChildren(cpSpace *space) { cpSpaceHashEach(space->staticShapes, (cpSpaceHashIterator)&shapeFreeWrap, NULL); cpSpaceHashEach(space->activeShapes, (cpSpaceHashIterator)&shapeFreeWrap, NULL); cpArrayEach(space->bodies, (cpArrayIter)&bodyFreeWrap, NULL); cpArrayEach(space->constraints, (cpArrayIter)&constraintFreeWrap, NULL); }
void draw_check_objects() { cpSpace *space = Space::instance()->get(); cpSpaceHashEach(space->staticShapes, &draw_shape, (void*)space->stamp); cpSpaceHashEach(space->activeShapes, &draw_shape, (void*)space->stamp); }
void cpSpaceFreeChildren(cpSpace *space) { cpArray *components = space->sleepingComponents; while(components->num) cpBodyActivate((cpBody *)components->arr[0]); cpSpaceHashEach(space->staticShapes, (cpSpaceHashIterator)&shapeFreeWrap, NULL); cpSpaceHashEach(space->activeShapes, (cpSpaceHashIterator)&shapeFreeWrap, NULL); cpArrayEach(space->bodies, (cpArrayIter)&bodyFreeWrap, NULL); cpArrayEach(space->constraints, (cpArrayIter)&constraintFreeWrap, NULL); }
static void physics_thread() { /* Now initialize the physics engine. */ cpInitChipmunk(); space = cpSpaceNew(); do { /* But here we do care about the elapsed time. */ synchronize(&oldtime /*,&server_elapsed*/); simple_lock(&physics_lock); physics(world, space); cpSpaceHashEach(space->activeShapes, &draw_player, NULL); //cpSpaceHashEach(space->staticShapes, &draw_static, NULL); simple_unlock(&physics_lock); if(to_remove_array.length > 0) lDestroy(&to_remove_array, remove_unused); } while(!physics_exit_time); lFree(&to_remove_array); cpSpaceFreeChildren(space); cpSpaceFree(space); }
void cpSpaceStep(cpSpace *space, cpFloat dt) { if(!dt) return; // don't step if the timestep is 0! cpFloat dt_inv = 1.0f/dt; cpArray *bodies = space->bodies; cpArray *constraints = space->constraints; space->locked = 1; // Empty the arbiter list. space->arbiters->num = 0; // Integrate positions. for(int i=0; i<bodies->num; i++){ cpBody *body = (cpBody *)bodies->arr[i]; body->position_func(body, dt); } // Pre-cache BBoxes and shape data. cpSpaceHashEach(space->activeShapes, (cpSpaceHashIterator)updateBBCache, NULL); // Collide! cpSpacePushNewContactBuffer(space); cpSpaceHashEach(space->activeShapes, (cpSpaceHashIterator)active2staticIter, space); cpSpaceHashQueryRehash(space->activeShapes, (cpSpaceHashQueryFunc)queryFunc, space); // Clear out old cached arbiters and dispatch untouch functions cpHashSetFilter(space->contactSet, (cpHashSetFilterFunc)contactSetFilter, space); // Prestep the arbiters. cpArray *arbiters = space->arbiters; for(int i=0; i<arbiters->num; i++) cpArbiterPreStep((cpArbiter *)arbiters->arr[i], dt_inv); // Prestep the constraints. for(int i=0; i<constraints->num; i++){ cpConstraint *constraint = (cpConstraint *)constraints->arr[i]; constraint->klass->preStep(constraint, dt, dt_inv); } for(int i=0; i<space->elasticIterations; i++){ for(int j=0; j<arbiters->num; j++) cpArbiterApplyImpulse((cpArbiter *)arbiters->arr[j], 1.0f); for(int j=0; j<constraints->num; j++){ cpConstraint *constraint = (cpConstraint *)constraints->arr[j]; constraint->klass->applyImpulse(constraint); } } // Integrate velocities. cpFloat damping = cpfpow(1.0f/space->damping, -dt); for(int i=0; i<bodies->num; i++){ cpBody *body = (cpBody *)bodies->arr[i]; body->velocity_func(body, space->gravity, damping, dt); } for(int i=0; i<arbiters->num; i++) cpArbiterApplyCachedImpulse((cpArbiter *)arbiters->arr[i]); // run the old-style elastic solver if elastic iterations are disabled cpFloat elasticCoef = (space->elasticIterations ? 0.0f : 1.0f); // Run the impulse solver. for(int i=0; i<space->iterations; i++){ for(int j=0; j<arbiters->num; j++) cpArbiterApplyImpulse((cpArbiter *)arbiters->arr[j], elasticCoef); for(int j=0; j<constraints->num; j++){ cpConstraint *constraint = (cpConstraint *)constraints->arr[j]; constraint->klass->applyImpulse(constraint); } } space->locked = 0; // run the post solve callbacks for(int i=0; i<arbiters->num; i++){ cpArbiter *arb = (cpArbiter *) arbiters->arr[i]; cpCollisionHandler *handler = arb->handler; handler->postSolve(arb, space, handler->data); arb->state = cpArbiterStateNormal; } // Run the post step callbacks while(space->postStepCallbacks->entries){ cpHashSet *callbacks = space->postStepCallbacks; space->postStepCallbacks = cpHashSetNew(0, (cpHashSetEqlFunc)postStepFuncSetEql, (cpHashSetTransFunc)postStepFuncSetTrans); cpHashSetEach(callbacks, (cpHashSetIterFunc)postStepCallbackSetIter, space); } // cpFloat dvsq = cpvdot(space->gravity, space->gravity); // dvsq *= dt*dt * space->damping*space->damping; // for(int i=0; i<bodies->num; i++) // cpBodyMarkLowEnergy(bodies->arr[i], dvsq, space->sleepTicks); // Increment the stamp. space->stamp++; }
void cpSpaceRehashStatic(cpSpace *space) { cpSpaceHashEach(space->staticShapes, (cpSpaceHashIterator)&updateBBCache, NULL); cpSpaceHashRehash(space->staticShapes); }
void cpSpaceStep(cpSpace *space, cpFloat dt) { if(!dt) return; // don't step if the timestep is 0! cpFloat dt_inv = 1.0f/dt; cpArray *bodies = space->bodies; cpArray *constraints = space->constraints; // Empty the arbiter list. space->arbiters->num = 0; //i51AdeOsLog ( i51_LOG_DC , "for" ) ; // Integrate positions. for(int i=0; i<bodies->num; i++){ cpBody *body = (cpBody *)bodies->arr[i]; body->position_func(body, dt); } // Pre-cache BBoxes and shape data. //i51AdeOsLog ( i51_LOG_DC , "cpSpaceHashEach" ) ; cpSpaceHashEach(space->activeShapes, (cpSpaceHashIterator)updateBBCache, NULL); cpSpaceLock(space); // Collide! //i51AdeOsLog ( i51_LOG_DC , "cpSpacePushFreshContactBuffer" ) ; cpSpacePushFreshContactBuffer(space); if(space->staticShapes->handleSet->entries) cpSpaceHashEach(space->activeShapes, (cpSpaceHashIterator)active2staticIter, space); cpSpaceHashQueryRehash(space->activeShapes, (cpSpaceHashQueryFunc)queryFunc, space); cpSpaceUnlock(space); //i51AdeOsLog ( i51_LOG_DC , "sleepTimeThreshold" ) ; // If body sleeping is enabled, do that now. if(space->sleepTimeThreshold != INFINITY){ cpSpaceProcessComponents(space, dt); bodies = space->bodies; // rebuilt by processContactComponents() }/**/ // Clear out old cached arbiters and dispatch untouch functions //i51AdeOsLog ( i51_LOG_DC , "cpHashSetFilter" ) ; cpHashSetFilter(space->contactSet, (cpHashSetFilterFunc)contactSetFilter, space); // Prestep the arbiters. //i51AdeOsLog ( i51_LOG_DC , "space->arbiters" ) ; cpArray *arbiters = space->arbiters; for(int i=0; i<arbiters->num; i++) cpArbiterPreStep((cpArbiter *)arbiters->arr[i], dt_inv); // Prestep the constraints. //i51AdeOsLog ( i51_LOG_DC , "constraints->num=%d",constraints->num ) ; for(int i=0; i<constraints->num; i++){ cpConstraint *constraint = (cpConstraint *)constraints->arr[i]; //i51AdeOsLog ( i51_LOG_DC , "i=%d,preStep=%X",i,constraint->klass->preStep) ; constraint->klass->preStep(constraint, dt, dt_inv); } //i51AdeOsLog ( i51_LOG_DC , "space->elasticIterations=%d",space->elasticIterations ) ; for(int i=0; i<space->elasticIterations; i++){ for(int j=0; j<arbiters->num; j++) cpArbiterApplyImpulse((cpArbiter *)arbiters->arr[j], 1.0f); for(int j=0; j<constraints->num; j++){ cpConstraint *constraint = (cpConstraint *)constraints->arr[j]; constraint->klass->applyImpulse(constraint); } } // Integrate velocities. //i51AdeOsLog ( i51_LOG_DC , "space->damping=%d",space->damping ) ; cpFloat damping = cpfpow(1.0f/space->damping, -dt); for(int i=0; i<bodies->num; i++){ cpBody *body = (cpBody *)bodies->arr[i]; body->velocity_func(body, space->gravity, damping, dt); } //i51AdeOsLog ( i51_LOG_DC , "arbiters->num=%d",arbiters->num) ; for(int i=0; i<arbiters->num; i++) cpArbiterApplyCachedImpulse((cpArbiter *)arbiters->arr[i]); // run the old-style elastic solver if elastic iterations are disabled cpFloat elasticCoef = (space->elasticIterations ? 0.0f : 1.0f); // Run the impulse solver. //i51AdeOsLog ( i51_LOG_DC , "space->iterations=%d",space->iterations) ; for(int i=0; i<space->iterations; i++){ for(int j=0; j<arbiters->num; j++) cpArbiterApplyImpulse((cpArbiter *)arbiters->arr[j], elasticCoef); for(int j=0; j<constraints->num; j++){ cpConstraint *constraint = (cpConstraint *)constraints->arr[j]; constraint->klass->applyImpulse(constraint); } } cpSpaceLock(space); // run the post solve callbacks //i51AdeOsLog ( i51_LOG_DC , "run the post solve callbacks") ; for(int i=0; i<arbiters->num; i++){ cpArbiter *arb = (cpArbiter *) arbiters->arr[i]; cpCollisionHandler *handler = arb->handler; handler->postSolve(arb, space, handler->data); arb->state = cpArbiterStateNormal; } cpSpaceUnlock(space); // Run the post step callbacks // Loop because post step callbacks may create more post step callbacks //i51AdeOsLog ( i51_LOG_DC , "space->postStepCallbacks") ; while(space->postStepCallbacks){ cpHashSet *callbacks = space->postStepCallbacks; space->postStepCallbacks = NULL; cpHashSetEach(callbacks, (cpHashSetIterFunc)postStepCallbackSetIter, space); cpHashSetFree(callbacks); } // Increment the stamp. space->stamp++; //i51AdeOsLog ( i51_LOG_DC , "_____________OK_______________") ; }
void cpSpaceStep(cpSpace *space, cpFloat dt) { if(!dt) return; // prevents div by zero. cpFloat dt_inv = 1.0f/dt; cpArray *bodies = space->bodies; cpArray *arbiters = space->arbiters; cpArray *joints = space->joints; // Empty the arbiter list. cpHashSetReject(space->contactSet, &contactSetReject, space); space->arbiters->num = 0; // Integrate velocities. cpFloat damping = pow(1.0f/space->damping, -dt); for(int i=0; i<bodies->num; i++){ cpBody *body = (cpBody *)bodies->arr[i]; body->velocity_func(body, space->gravity, damping, dt); } // Pre-cache BBoxes and shape data. cpSpaceHashEach(space->activeShapes, &updateBBCache, NULL); // Collide! cpSpaceHashEach(space->activeShapes, &active2staticIter, space); cpSpaceHashQueryRehash(space->activeShapes, &queryFunc, space); // Prestep the arbiters. for(int i=0; i<arbiters->num; i++) cpArbiterPreStep((cpArbiter *)arbiters->arr[i], dt_inv); // Prestep the joints. for(int i=0; i<joints->num; i++){ cpJoint *joint = (cpJoint *)joints->arr[i]; joint->preStep(joint, dt_inv); } // Run the impulse solver. for(int i=0; i<space->iterations; i++){ for(int j=0; j<arbiters->num; j++) cpArbiterApplyImpulse((cpArbiter *)arbiters->arr[j]); for(int j=0; j<joints->num; j++){ cpJoint *joint = (cpJoint *)joints->arr[j]; joint->applyImpulse(joint); } } // cpFloat dvsq = cpvdot(space->gravity, space->gravity); // dvsq *= dt*dt * space->damping*space->damping; // for(int i=0; i<bodies->num; i++) // cpBodyMarkLowEnergy(bodies->arr[i], dvsq, space->sleepTicks); // Integrate positions. for(int i=0; i<bodies->num; i++){ cpBody *body = (cpBody *)bodies->arr[i]; body->position_func(body, dt); } // Increment the stamp. space->stamp++; }