コード例 #1
0
void WordTreeScene::updatePhysics(Word* word) {
    cpShape* shape = word->getShape();
    if( shape!=NULL ) {
        cpSpaceRemoveShape(ChipmunkManager::getInstance()->getSpace(), shape);
        cpShapeDestroy(shape);
        word->setShape(NULL);
    }
    
    cpBody* body = word->getBody();
    if( body!=NULL ) {
        cpSpaceRemoveBody(ChipmunkManager::getInstance()->getSpace(), body);
        cpBodyDestroy(body);
        word->setBody(NULL);
    }
    
    CCLabelTTF* targetLabel = word->getLabel();
    CCPoint pos = targetLabel->getPosition();
    CCSize contentSize = targetLabel->getContentSize();
    
    // init body
    body = cpBodyNew(1, INFINITY);
    body->p = cpv(targetLabel->getPosition().x, targetLabel->getPosition().y);
    cpSpaceAddBody(ChipmunkManager::getInstance()->getSpace(), body);
    
    float size = MAX(targetLabel->getContentSize().width, targetLabel->getContentSize().height);
    
    shape = cpBoxShapeNew(body, size+size*0.3f, size+size*0.3f);
    cpSpaceAddShape(ChipmunkManager::getInstance()->getSpace(), shape);
    
    word->setBody(body);
    word->setShape(shape);
}
コード例 #2
0
ファイル: space.c プロジェクト: sixian/lunatic-chipmunk
int lc_space_RemoveBody(lua_State *vm){
    //space, body
    lc_space *space = lc_GetSpace(1, vm);
    if (space == NULL){
        printf("chipmunk: Object can't call :RemoveBody\n");
        return 0;
    }
    lc_body *body = lc_GetBody(2, vm);
    if (body == NULL){
        printf("space:RemoveBody(): Can't remove a object that isn't a body.\n");
        return 0;
    }
    
    char pbody[32] = {0};
    snprintf(pbody, 32, "%p", body);
    
    //Check if the body has been added to the space for be removed.
    lua_rawgeti(vm, LUA_REGISTRYINDEX, space->bodies);
    lua_getfield(vm, -1, pbody);
    if (lua_isnil(vm, -1)){
        //The body doesn't exists.
        return 0;
    }
    lua_pop(vm, 1);
    lua_pushnil(vm);
    lua_setfield(vm, -2, pbody);
    //---
    
    cpSpaceRemoveBody(space->space, body->body);
    return 0;
}
コード例 #3
0
void PhysicsBody::setDynamic(bool dynamic)
{
    if (dynamic != _dynamic)
    {
        _dynamic = dynamic;
        if (dynamic)
        {
            if (_world && _cpBody->CP_PRIVATE(space))
            {
                cpSpaceConvertBodyToDynamic(_world->_cpSpace, _cpBody, _mass, _moment);
                cpSpaceAddBody(_world->_cpSpace, _cpBody);
            }
            else
            {
                cpBodySetMass(_cpBody, _mass);
                cpBodySetMoment(_cpBody, _moment);
            }
        }
        else
        {
            if (_world && _cpBody->CP_PRIVATE(space))
            {
                cpSpaceRemoveBody(_world->_cpSpace, _cpBody);
                cpSpaceConvertBodyToStatic(_world->_cpSpace, _cpBody);
            }
            else
            {
                cpBodySetMass(_cpBody, PHYSICS_INFINITY);
                cpBodySetMoment(_cpBody, PHYSICS_INFINITY);
                cpBodySetVel(_cpBody, cpvzero);
                cpBodySetAngVel(_cpBody, 0.0);
            }
        }
    }
}
コード例 #4
0
ファイル: physics.c プロジェクト: andi2/cgame
static void _set_type(PhysicsInfo *info, PhysicsBody type)
{
    if (info->type == type)
        return; /* already set */

    info->type = type;
    switch (type)
    {
        case PB_KINEMATIC:
            info->last_pos = cpBodyGetPos(info->body);
            info->last_ang = cpBodyGetAngle(info->body);
            /* fall through */

        case PB_STATIC:
            if (!cpBodyIsStatic(info->body))
            {
                cpSpaceRemoveBody(space, info->body);
                cpSpaceConvertBodyToStatic(space, info->body);
            }
            break;

        case PB_DYNAMIC:
            cpSpaceConvertBodyToDynamic(space, info->body, info->mass, 1.0);
            cpSpaceAddBody(space, info->body);
            _recalculate_moment(info);
            break;
    }
}
コード例 #5
0
ファイル: physics.c プロジェクト: dns/CLove
static int l_physics_bodyGC(lua_State* state)
{
    l_physics_Body* body = (l_physics_Body*)lua_touserdata(state, 1);
    cpSpaceRemoveBody(body->physics->space, body->body);

	return 0;
}
コード例 #6
0
ファイル: erlmunk_space.c プロジェクト: lrascao/erlmunk
ETERM *space_remove_body(ETERM *fromp, ETERM *argp) {

    // get the args
    ETERM *space_refp = erl_element(1, argp);
    ETERM *idp = erl_element(2, argp);

    erlmunk_space *s;
    int space_id = ERL_REF_NUMBER(space_refp);
    HASH_FIND_INT(erlmunk_spaces, &space_id, s);

    int body_id = ERL_INT_VALUE(idp);
    erlmunk_body *b = NULL;
    HASH_FIND_INT(s->bodies, &body_id, b);
    if (b == NULL)
        return NULL;

    // DEBUGF(("removing body #%d\n", body_id));

    // remove the user data associated with the body
    erlmunk_body_data *data = cpBodyGetUserData(b->body);
    if (data->term != NULL)
        erl_free_compound(data->term);
    free(data);

    cpBodyEachShape(b->body, shapeRemove, NULL);
    cpSpaceRemoveBody(s->space, b->body);

    space_remove_body_hash(s, b);

    cpBodyDestroy(b->body);
    cpBodyFree(b->body);

    return NULL;
}
コード例 #7
0
ファイル: erlmunk_space.c プロジェクト: lrascao/erlmunk
ETERM *space_delete(ETERM *fromp, ETERM *argp) {

    // get the args
    ETERM *space_refp = erl_element(1, argp);

    erlmunk_space *s;
    int space_id = ERL_REF_NUMBER(space_refp);
    HASH_FIND_INT(erlmunk_spaces, &space_id, s);

    // remove all subscribers
    for(erlmunk_subscriber *subscriber = s->subscribers; subscriber != NULL;
        subscriber = subscriber->hh.next) {
        space_remove_subscriber(s, subscriber);
    }
    // remove all bodies
    for(erlmunk_body *b = s->bodies; b != NULL;
        b = b->hh.next) {
        erlmunk_body_data *data = cpBodyGetUserData(b->body);
        if (data->term != NULL)
            erl_free_compound(data->term);
        free(data);

        cpSpaceRemoveBody(s->space, b->body);
        cpBodyDestroy(b->body);
        cpBodyFree(b->body);
        space_remove_body_hash(s, b);
    }

    return NULL;
}
コード例 #8
0
ファイル: core.c プロジェクト: nicole-hedley/asteroid-game
// poststep functions to add and remove bodies 
void postStepRemoveBody ( cpSpace *space, cpBody *body, void *unused ) {
    
    cpBodyEachShape ( body, (cpBodyShapeIteratorFunc)core_destroy_out_shapes, space );
    
    cpSpaceRemoveBody ( space, body );
    core_destroy_body ( body, NULL );
}
コード例 #9
0
ファイル: lander.c プロジェクト: emsoccer/DTD-Lunar-Lander
void landerFree(Lander l, cpSpace* space)
{
    cpSpaceRemoveBody(space, l->body);
    cpSpaceRemoveShape(space, l->shape);
    
    free(l);
}
コード例 #10
0
ファイル: main.cpp プロジェクト: cyclohexanamine/shipbrain
	~Phys()
	{
		for (std::vector<Ship*>::iterator it = ship_list.begin(); it != ship_list.end(); ++it)
		{
			cpSpaceRemoveShape(space, (*it)->cpshape);
			cpSpaceRemoveBody(space, (*it)->body);
			delete *it;
		}
		ship_list.clear();
		for (std::vector<Shell*>::iterator it = shell_list.begin(); it != shell_list.end(); ++it)
		{
			cpSpaceRemoveShape(space, (*it)->cpshape);
			cpSpaceRemoveBody(space, (*it)->body);
			delete *it;
		}
		shell_list.clear();
		cpSpaceFree(space);
	}
コード例 #11
0
ファイル: Sensors.c プロジェクト: 0w/moai-dev
static void
postStepRemove(cpSpace *space, cpShape *shape, void *unused)
{
	cpSpaceRemoveBody(space, shape->body);
	cpSpaceRemoveShape(space, shape);
	
	cpBodyFree(shape->body);
	cpShapeFree(shape);
}
コード例 #12
0
ファイル: physics.c プロジェクト: outgame/CrayonPhysics
void free_body_full(cpBody *body) {
    cpBodyEachShape(body, (cpBodyShapeIteratorFunc) free_shape, NULL);
    
    point_array_free( (Body_data *) cpBodyGetUserData(body) );
	cpSpace *space = cpBodyGetSpace(body);
	cpSpaceRemoveBody(space, body);
	cpBodyDestroy(body);
    cpBodyFree(body);
}
コード例 #13
0
ファイル: world.cpp プロジェクト: damir00/zac
void World::removeHuman(Human* h) {
	cpSpaceRemoveShape(space,h->shape);
	cpSpaceRemoveBody(space,h->body);

	for(int i=0;i<humans.size();i++) {
		if(h==humans[i]) {
			humans.erase(humans.begin()+i);
			break;
		}
	}
}
コード例 #14
0
	void RigidBody2D::UnregisterFromSpace()
	{
		if (m_isRegistered)
		{
			cpSpace* space = m_world->GetHandle();
			for (cpShape* shape : m_shapes)
				cpSpaceRemoveShape(space, shape);

			if (m_handle)
				cpSpaceRemoveBody(space, m_handle);

			m_isRegistered = false;
		}
	}
コード例 #15
0
ファイル: rcpbody.cpp プロジェクト: trsquarelab/csscene
void RCPBody::destroy()
{
    // remove all shapes before removing the body
    mShapes.clear();

    if (mType != Static && RCPWorld::instance()) {
        cpSpace * space = RCPWorld::instance()->space();
        if (mBody && space) {
            cpSpaceRemoveBody(space, mBody);
            cpBodyFree(mBody);
        }
    }

    mBody = 0;
}
コード例 #16
0
ファイル: player.c プロジェクト: tjhsstgeek/MultiBT
/**
 * Removes a player object from the grid.
 * This means moving him from the playing list to the queue.
 */
int player_remove(struct player *p, struct game *g) {
	if (p->list != g->p_p) {
		//The player isn't in the playing list
		return -2;
	}
	if (linkedlist_add_last(g->p_q, p)) {
		ERR_TRACE();
		return -1;
	}
	linkedlist_remove_node(g->p_p, p->node);
	cpSpaceRemoveShape(g->cp, (struct cpShape *)&p->shape);
	cpSpaceRemoveBody(g->cp, &p->body);
	p->node = g->p_q->last;
	return 0;
}
コード例 #17
0
void TestColliderDetector::destroyCPBody(cpBody *body)
{
	cpShape *shape = body->shapeList_private;
	while(shape)
	{
		cpShape *temp = shape->next_private;
        
		cpSpaceRemoveShape(space, shape);
		cpShapeFree(shape);
        
		shape = temp;
	}
    
	cpSpaceRemoveBody(space, body);
	cpBodyFree(body);
}
コード例 #18
0
void PhysicsWorld::doRemoveBody(PhysicsBody* body)
{
    CCASSERT(body != nullptr, "the body can not be nullptr");
    
    // remove shapes
    for (auto& shape : body->getShapes())
    {
        removeShape(shape);
    }
    
    // remove body
    if (cpSpaceContainsBody(_cpSpace, body->_cpBody))
    {
        cpSpaceRemoveBody(_cpSpace, body->_cpBody);
    }
}
コード例 #19
0
 CDynamics2DSingleBodyObjectModel::~CDynamics2DSingleBodyObjectModel() {
    bool bIsStatic = cpBodyIsStatic(m_ptBody);
    /* Dispose of shapes */
    for(cpShape* pt_shape = m_ptBody->shapeList;
        pt_shape != NULL;
        pt_shape = pt_shape->next) {
       cpSpaceRemoveShape(GetDynamics2DEngine().GetPhysicsSpace(), pt_shape);
       cpShapeFree(pt_shape);
    }
    /* Dispose of body */
    if(! bIsStatic)
       cpSpaceRemoveBody(GetDynamics2DEngine().GetPhysicsSpace(), m_ptBody);
    cpBodyFree(m_ptBody);
    /* Reindex space */
    if(bIsStatic) cpSpaceReindexStatic(GetDynamics2DEngine().GetPhysicsSpace());
 }
コード例 #20
0
CDynamics2DCylinderEntity::~CDynamics2DCylinderEntity() {
    if(m_ptBody != NULL) {
        cpSpaceRemoveConstraint(m_cEngine.GetPhysicsSpace(), m_ptLinearFriction);
        cpSpaceRemoveConstraint(m_cEngine.GetPhysicsSpace(), m_ptAngularFriction);
        cpConstraintFree(m_ptLinearFriction);
        cpConstraintFree(m_ptAngularFriction);
        cpSpaceRemoveBody(m_cEngine.GetPhysicsSpace(), m_ptBody);
        cpBodyFree(m_ptBody);
        cpSpaceRemoveShape(m_cEngine.GetPhysicsSpace(), m_ptShape);
    }
    else {
        cpSpaceRemoveStaticShape(m_cEngine.GetPhysicsSpace(), m_ptShape);
        cpSpaceRehashStatic(m_cEngine.GetPhysicsSpace());
    }
    cpShapeFree(m_ptShape);
}
コード例 #21
0
	void RigidBody2D::Destroy()
	{
		cpSpace* space = m_world->GetHandle();
		for (cpShape* shape : m_shapes)
		{
			cpSpaceRemoveShape(space, shape);
			cpShapeFree(shape);
		}

		if (m_handle)
		{
			cpSpaceRemoveBody(space, m_handle);
			cpBodyFree(m_handle);
		}
		m_shapes.clear();
	}
コード例 #22
0
Body::~Body(){
	if(body){
		//clean up all constraints
		constraintsToRemove.clear();
		cpBodyEachConstraint(body, &constraintRemoveQuery, (void*)this);
		for(auto c: constraintsToRemove){
			((Constraint*)cpConstraintGetUserData(c))->constraint = nullptr;
			cpSpaceRemoveConstraint(cpConstraintGetSpace(c), c);
			cpConstraintDestroy(c);
		}

		//remove body
		cpSpaceRemoveBody(cpBodyGetSpace(body), body);
		cpBodyFree(body);
		body = nullptr;
	}
}
コード例 #23
0
GeometrySpringDynamic::~GeometrySpringDynamic()
{
	clearJoints();

	if( 0 != m_Shape && true == cpSpaceContainsShape( m_Space, m_Shape ) )
	{
		cpSpaceRemoveShape( m_Space, m_Shape );
		cpShapeFree( m_Shape );
		m_Shape = 0;
	}
	if( 0 != m_Body && true == cpSpaceContainsBody( m_Space, m_Body ) )
	{
		cpSpaceRemoveBody( m_Space, m_Body );
		cpBodyFree( m_Body );
		m_Body = 0;
	}
}
コード例 #24
0
ファイル: Slice.cpp プロジェクト: damucz/chipmunk2d
void Slice::SliceShapePostStep(cpSpace *space, cpShape *shape, struct SliceContext *context)
{
	cpVect a = context->a;
	cpVect b = context->b;
	
	// Clipping plane normal and distance.
	cpVect n = cpvnormalize(cpvperp(cpvsub(b, a)));
	cpFloat dist = cpvdot(a, n);
	
	ClipPoly(space, shape, n, dist);
	ClipPoly(space, shape, cpvneg(n), -dist);
	
	cpBody *body = cpShapeGetBody(shape);
	cpSpaceRemoveShape(space, shape);
	cpSpaceRemoveBody(space, body);
	cpShapeFree(shape);
	cpBodyFree(body);
}
コード例 #25
0
ファイル: CCPhysicsBody.cpp プロジェクト: chling/artemis
void PhysicsBody::setDynamic(bool dynamic)
{
    if (dynamic != _dynamic)
    {
        _dynamic = dynamic;
        if (_world != nullptr)
        {
            if (dynamic)
            {
                cpSpaceAddBody(_world->_info->space, _info->body);
            }else
            {
                cpSpaceRemoveBody(_world->_info->space, _info->body);
            }
        }
        
    }
}
コード例 #26
0
ファイル: Unit.cpp プロジェクト: uzername/Yukkuri
Unit::~Unit()
{
	ActionTimer* timer = NULL;
	while( actionTimers != NULL ){
		timer = actionTimers;
		Timer::DeleteTimerEventById( timer->timerId );
		actionTimers = timer->next;
		delete timer, timer = NULL;
	}
	if( physShape ){
		cpSpaceRemoveShape( Phys::space, physShape );
		cpShapeFree( physShape );
	}
	if( physBody ){
		if( !cpBodyIsStatic(physBody) )
			cpSpaceRemoveBody( Phys::space, physBody );
		cpBodyFree( physBody );
	}
}
コード例 #27
0
ファイル: bomb.cpp プロジェクト: robmerrell/neon_destruction
void Bomb::destroy(cpSpace *space) {
  if (!destroyed) {
    destroyed = true;
    if (simulation_type == "DYNAMIC")
      cpSpaceRemoveShape(space, bombShape);
    else
      cpSpaceRemoveStaticShape(space, bombShape);
    
    if (simulation_type == "DYNAMIC") cpSpaceRemoveBody(space, body);
    cpShapeFree(bombShape);
    cpBodyFree(body);
  
    for (int j=0; j < PARTICLE_TOTAL; j++) {
      delete particles[j];
      particles[j] = NULL;
    }
  
    delete [] particles;
  }
}
コード例 #28
0
ファイル: Plink.c プロジェクト: Adefy/AdefyiOS
static void
update(cpSpace *space, double dt)
{
	if(ChipmunkDemoRightDown){
		cpShape *nearest = cpSpaceNearestPointQueryNearest(space, ChipmunkDemoMouse, 0.0, GRABABLE_MASK_BIT, CP_NO_GROUP, NULL);
		if(nearest){
			cpBody *body = cpShapeGetBody(nearest);
			if(cpBodyIsStatic(body)){
				cpSpaceConvertBodyToDynamic(space, body, pentagon_mass, pentagon_moment);
				cpSpaceAddBody(space, body);
			} else {
				cpSpaceRemoveBody(space, body);
				cpSpaceConvertBodyToStatic(space, body);
			}
		}
	}
	
	cpSpaceStep(space, dt);
	cpSpaceEachBody(space, &eachBody, NULL);
}
コード例 #29
0
ファイル: Player.cpp プロジェクト: ofx/dr
Player::~Player(void)
{
    delete this->m_ParticleSystem;
	delete this->m_Sprite;
	delete this->m_ParticleSprite;

    // Delete weapon in weapon slots
    for (int i = 0 ; i < NUM_WEAPON_SLOTS ; ++i)
    {
        delete this->m_Weaponslots[i];
    }
    delete this->m_Weaponslots;

    // Delete physics stuff
    cpSpace *space = this->m_Engine->GetWorld()->GetSpace();
    cpSpaceRemoveShape(space, this->m_Shape);
    cpSpaceRemoveBody(space, this->m_Body);
    cpShapeFree(this->m_Shape);
    cpBodyFree(this->m_Body);
}
コード例 #30
0
 CDynamics2DMultiBodyObjectModel::~CDynamics2DMultiBodyObjectModel() {
    /* Dispose of shapes and bodies */
    while(!m_vecBodies.empty()) {
       /* Get pointer to body */
       cpBody* ptBody = m_vecBodies.back().Body;
       /* Remove all of its shapes */
       cpShape* ptCurShape = ptBody->shapeList;
       cpShape* ptNextShape;
       while(ptCurShape) {
          ptNextShape = ptCurShape->next;
          cpSpaceRemoveShape(GetDynamics2DEngine().GetPhysicsSpace(), ptCurShape);
          cpShapeFree(ptCurShape);
          ptCurShape = ptNextShape;
       }
       /* Dispose of body */
       cpSpaceRemoveBody(GetDynamics2DEngine().GetPhysicsSpace(), ptBody);
       cpBodyFree(ptBody);
       /* Dispose of struct */
       m_vecBodies.pop_back();
    }
 }