C++ cpShapeFree函数代码示例

void freeDll(void)
{
	
	int i;
	Variable *var;


	//Poistettaan kaikki muuttujat
	for (i = 1; i != mVariableHandler.mSize;i++)
	{
		var = mVariableHandler.mPtrArray[i];
		if (var != NULL)
		{
			switch(var->mType)
			{
			case VarTypeBody:
				cpBodyFree((cpBody*)var->mPtr);break;
			case VarTypeShape:
				cpShapeFree((cpShape*)var->mPtr);break;
			case VarTypeConstraint:
				cpConstraintFree((cpConstraint*)var->mPtr);break;
			case VarTypeDataArray:
				daFree((DataArray*)var->mPtr);break;
			}
		}
	}

	//Tuhotaan ne kaikki...
	vhDestroy(&mVariableHandler);
	cpSpaceDestroy(&mSpace);
	mState = Unloaded;
}

static void RemoveShape(cpBody *body, cpShape *shape, void *data)
{
	UNUSED(body);
	cpSpace *s = data;
	cpSpaceRemoveShape(s, shape);
	cpShapeFree(shape);
}

void MachineSystem::removePart(cpVect gridPosition)
{
    int machineNum = machinePositionToNumber(gridPosition);
    
    MachinePart *partToRemove = parts[machineNum];
    if (partToRemove) {
        
        cpBody *attachmentBody = partToRemove->getBody();
        __block cpBody *pegBody = NULL;
        cpBodyEachConstraint_b(attachmentBody, ^(cpConstraint *c) {
            if (cpConstraintGetB(c) == attachmentBody) {
                cpBody *otherBody = cpConstraintGetA(c); // the peg is always body A
                if (cpBodyGetMass(otherBody) == INFINITY)
                    pegBody = otherBody;
            }
        });
        
        assert(pegBody);
        
        int nPegs = size.x * size.y;
        // remove the attachments for this machine
        for (int i=0; i<nPegs; i++) {
            cpVect otherMachinePos = machineNumberToPosition(i);
            detachMachines(gridPosition, otherMachinePos);
        }
        
        
        partToRemove->detachFromBody(pegBody);
        
        cpBodyEachShape_b(pegBody, ^(cpShape *shape) {
            cpSpaceRemoveStaticShape(space, shape);
            cpShapeFree(shape);
        });

GameObject::~GameObject()
{
	m_resMgr.DeleteSprite(m_Sprite.ID);
	if(m_pBody)
		cpBodyFree(m_pBody);
	if(m_pShape)
		cpShapeFree(m_pShape);
}

/* A matching cleanup_tiles function to make sure
 * we free the chipmunk resources we allocated during
 * init_tiles(). Remember - Chipmunk2D is not doing any
 * garbage collection and any time we call one of the New
 * functions we need to match it with a corresponding Free
 * call when we're done.
 */
static void cleanup_tiles(struct state* state)
{
    for (size_t i = 0; i < MAX_TILES; i++) {
        if (state->tiles[i].is_active) {
            cpShapeFree(state->tiles[i].shape);
            cpBodyFree(state->tiles[i].body);
        }
    }
}

PhysicsShape::~PhysicsShape()
{
    for (auto shape : _cpShapes)
    {
        s_physicsShapeMap.erase(shape);

        cpShapeFree(shape);
    }
}

static void
postStepRemove(cpSpace *space, cpShape *shape, void *unused)
{
	cpSpaceRemoveBody(space, shape->body);
	cpSpaceRemoveShape(space, shape);
	
	cpBodyFree(shape->body);
	cpShapeFree(shape);
}

ChipmunkTestLayer::~ChipmunkTestLayer()
{
    // manually Free rogue shapes
    for( int i=0;i<4;i++) {
        cpShapeFree( _walls[i] );
    }

    cpSpaceFree( _space );

}

PhysicsShapeInfo::~PhysicsShapeInfo()
{
    for (auto shape : _shapes)
    {
        auto it = _map.find(shape);
        if (it != _map.end()) _map.erase(shape);
        
        cpShapeFree(shape);
    }
}

	static void remove_unused(void* s)
	{
		cpShape* shape = (cpShape*)s;
		chipmunk_data* p = (chipmunk_data*)shape->data;

		destroy_chipmunk_data(p, shape->body);
	
		/* The player was marked as to be deleted. The player is freed here,
		 * to avoid concurrence problems if we delete somewhere else. */
	    cpSpaceRemoveShape(space, shape);
	    cpShapeFree(shape);
	}

void GameScene::onExit()
{
	Scene::onExit();
	this->unscheduleUpdate();

	for (auto& shape : shapes)
		cpShapeFree(shape);
	shapes.clear();

	cpSpaceRemoveCollisionHandler(space, collisionTypeBall, collisionTypeWall);
	cpSpaceFree(space);
}

	void RigidBody2D::Destroy()
	{
		UnregisterFromSpace();

		cpSpace* space = m_world->GetHandle();
		for (cpShape* shape : m_shapes)
			cpShapeFree(shape);

		if (m_handle)
			cpBodyFree(m_handle);

		m_shapes.clear();
	}

ChipmunkTestLayer::~ChipmunkTestLayer()
{
#if CC_ENABLE_CHIPMUNK_INTEGRATION
    // manually Free rogue shapes
    for( int i=0;i<4;i++) {
        cpShapeFree( _walls[i] );
    }

    cpSpaceFree( _space );

    Device::setAccelerometerEnabled(false);
#endif
}

 bool CDynamics2DBoxEntity::MoveTo(const CVector3& c_position,
                                       const CQuaternion& c_orientation,
                                       bool b_check_only) {
    SInt32 nCollision;
    /* Check whether the box is movable or not */
    if(m_cBoxEntity.GetEmbodiedEntity().IsMovable()) {
       /* The box is movable */
       /* Save body position and orientation */
       cpVect tOldPos = m_ptBody->p;
       cpFloat fOldA = m_ptBody->a;
       /* Move the body to the desired position */
       m_ptBody->p = cpv(c_position.GetX(), c_position.GetY());
       CRadians cXAngle, cYAngle, cZAngle;
       c_orientation.ToEulerAngles(cZAngle, cYAngle, cXAngle);
       cpBodySetAngle(m_ptBody, cZAngle.GetValue());
       /* Create a shape sensor to test the movement */
       /* First construct the vertices */
       CVector3 cHalfSize = m_cBoxEntity.GetSize() * 0.5f;
       cpVect tVertices[] = {
          cpv(-cHalfSize.GetX(), -cHalfSize.GetY()),
          cpv(-cHalfSize.GetX(),  cHalfSize.GetY()),
          cpv( cHalfSize.GetX(),  cHalfSize.GetY()),
          cpv( cHalfSize.GetX(), -cHalfSize.GetY())
       };
       /* Then create the shape itself */
       cpShape* ptTestShape = cpPolyShapeNew(m_ptBody,
                                             4,
                                             tVertices,
                                             cpvzero);
       /* Check if there is a collision */
       nCollision = cpSpaceShapeQuery(m_cEngine.GetPhysicsSpace(), ptTestShape, NULL, NULL);
       /* Dispose of the sensor shape */
       cpShapeFree(ptTestShape);
       if(b_check_only || nCollision) {
          /* Restore old body state if there was a collision or
             it was only a check for movement */
          m_ptBody->p = tOldPos;
          cpBodySetAngle(m_ptBody, fOldA);
       }
       else {
          /* Update the active space hash if the movement is actual */
          cpSpaceReindexShape(m_cEngine.GetPhysicsSpace(), m_ptShape);
       }
    }
    else {
       /* The box is not movable, so you can't move it :-) */
       nCollision = 1;
    }
    /* The movement is allowed if there is no collision */
    return !nCollision;
 }

void GameInst::UnloadLevel()
{
	// Clear blocks
	for (auto it = m_blocks.begin(); it != m_blocks.end();)
	{
		m_Renderer.RemoveDrawableSprite((*it)->GetSprite());
		delete *it;
		it = m_blocks.erase(it);
	}

	//clear laser catchers
	/*for (auto it = Catchers.begin(); it != Catchers.end();)
	{
		it = Catchers.erase(it);
		m_Renderer.RemoveDrawableSprite((*it)->GetSprite());
	}*/

	//clear laser emitters
	for (auto it = Emitters.begin(); it != Emitters.end();)
	{
		m_Renderer.RemoveDrawableSprite((*it)->GetSprite());
		delete *it;
		it = Emitters.erase(it);
	}

	//clear physworld
	cpShapeFree(m_WorldBounds.Top);
	cpShapeFree(m_WorldBounds.Bottom);
	cpShapeFree(m_WorldBounds.Left);
	cpShapeFree(m_WorldBounds.Right);
	cpSpaceFree(m_pSpace);

	//clear player
	m_Renderer.RemoveDrawableSprite(m_pPlayer->GetSprite());
	delete m_pPlayer;
	m_pPlayer = NULL;
}