bool PhysicsWorld::init(Scene& scene)
{
do
{
_delayAddBodies = Array::create();
_delayRemoveBodies = Array::create();
CC_BREAK_IF(_delayAddBodies == nullptr || _delayRemoveBodies == nullptr);
_delayAddBodies->retain();
_delayRemoveBodies->retain();
_info = new PhysicsWorldInfo();
CC_BREAK_IF(_info == nullptr);
_bodies = Array::create();
CC_BREAK_IF(_bodies == nullptr);
_bodies->retain();
_scene = &scene;
cpSpaceSetGravity(_info->getSpace(), PhysicsHelper::point2cpv(_gravity));
cpSpaceSetDefaultCollisionHandler(_info->getSpace(),
(cpCollisionBeginFunc)PhysicsWorldCallback::collisionBeginCallbackFunc,
(cpCollisionPreSolveFunc)PhysicsWorldCallback::collisionPreSolveCallbackFunc,
(cpCollisionPostSolveFunc)PhysicsWorldCallback::collisionPostSolveCallbackFunc,
(cpCollisionSeparateFunc)PhysicsWorldCallback::collisionSeparateCallbackFunc,
this);
return true;
} while (false);
return false;
}
cpSpace *Slice::Init()
{
ChipmunkDemo::Init();
message = "Hold right bottom corner and slice with touch.";
space = cpSpaceNew();
cpSpaceSetIterations(space, 30);
cpSpaceSetGravity(space, cpv(0, -500));
cpSpaceSetSleepTimeThreshold(space, 0.5f);
cpSpaceSetCollisionSlop(space, 0.5f);
cpBody *body, *staticBody = cpSpaceGetStaticBody(space);
cpShape *shape;
// Create segments around the edge of the screen.
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-1000,-240), cpv(1000,-240), 0.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetFilter(shape, NOT_GRABBABLE_FILTER);
cpFloat width = 200.0f;
cpFloat height = 300.0f;
cpFloat mass = width*height*DENSITY;
cpFloat moment = cpMomentForBox(mass, width, height);
body = cpSpaceAddBody(space, cpBodyNew(mass, moment));
shape = cpSpaceAddShape(space, cpBoxShapeNew(body, width, height, 0.0));
cpShapeSetFriction(shape, 0.6f);
return space;
}
bool PhysicsWorld::init()
{
do
{
#if CC_TARGET_PLATFORM == CC_PLATFORM_WINRT || CC_TARGET_PLATFORM == CC_PLATFORM_WIN32
_cpSpace = cpSpaceNew();
#else
_cpSpace = cpHastySpaceNew();
cpHastySpaceSetThreads(_cpSpace, 0);
#endif
CC_BREAK_IF(_cpSpace == nullptr);
cpSpaceSetGravity(_cpSpace, PhysicsHelper::point2cpv(_gravity));
cpCollisionHandler *handler = cpSpaceAddDefaultCollisionHandler(_cpSpace);
handler->userData = this;
handler->beginFunc = (cpCollisionBeginFunc)PhysicsWorldCallback::collisionBeginCallbackFunc;
handler->preSolveFunc = (cpCollisionPreSolveFunc)PhysicsWorldCallback::collisionPreSolveCallbackFunc;
handler->postSolveFunc = (cpCollisionPostSolveFunc)PhysicsWorldCallback::collisionPostSolveCallbackFunc;
handler->separateFunc = (cpCollisionSeparateFunc)PhysicsWorldCallback::collisionSeparateCallbackFunc;
return true;
} while (false);
return false;
}
int l_physics_newSpace(lua_State* state)
{
moduleData.onBegin = false;
moduleData.onPostSolve = false;
moduleData.onPreSolve = false;
moduleData.onSeparate = false;
//moduleData.letBeginCollide = true;
//moduleData.letPreSolveCollide = true;
float x = l_tools_toNumberOrError(state, 1);
float y = l_tools_toNumberOrError(state, 2);
moduleData.physics = (l_physics_PhysicsData*)lua_newuserdata(state, sizeof(l_physics_PhysicsData));
moduleData.physics->physics = malloc(sizeof(physics_PhysicsData));
moduleData.physics->physics->space = cpSpaceNew();
moduleData.physics->physics->gravity = cpv(x, y);
cpSpaceSetGravity(moduleData.physics->physics->space, moduleData.physics->physics->gravity);
lua_rawgeti(state, LUA_REGISTRYINDEX, moduleData.physicsMT);
lua_setmetatable(state, -2);
return 1;
}
static cpSpace *
init(void)
{
ChipmunkDemoMessageString = "Right click and drag to change the blocks's shape.";
cpSpace *space = cpSpaceNew();
cpSpaceSetIterations(space, 30);
cpSpaceSetGravity(space, cpv(0, -500));
cpSpaceSetSleepTimeThreshold(space, 0.5f);
cpSpaceSetCollisionSlop(space, 0.5f);
cpBody *body, *staticBody = cpSpaceGetStaticBody(space);
// Create segments around the edge of the screen.
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-320,-240), cpv(320,-240), 0.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
cpFloat width = 50.0f;
cpFloat height = 70.0f;
cpFloat mass = width*height*DENSITY;
cpFloat moment = cpMomentForBox(mass, width, height);
body = cpSpaceAddBody(space, cpBodyNew(mass, moment));
shape = cpSpaceAddShape(space, cpBoxShapeNew(body, width, height));
cpShapeSetFriction(shape, 0.6f);
return space;
}
void Level::setGravity(float g_x, float g_y)
{
if (m_pSpace != NULL) {
cpVect grav = cpv((cpFloat)g_x, (cpFloat)g_y);
cpSpaceSetGravity(m_pSpace, grav);
}
}
Physics::Physics(uint32 timeStep) {
// Create an empty space.
mSpace = cpSpaceNew();
cpSpaceSetGravity(mSpace, cpv(0, 0));
cpSpaceSetDamping(mSpace, 0.5);
mTimeStep = timeStep;
mAccumulator = 0;
}
PhysicsWorld::PhysicsWorld()
{
mySpace = cpSpaceNew();
// Set default gravity
cpVect gravity = cpv(0, -10);
cpSpaceSetGravity(mySpace, gravity);
}
static cpSpace *
init(void)
{
space = cpSpaceNew();
cpSpaceSetGravity(space, cpv(0, -600));
cpBody *body;
cpShape *shape;
// We create an infinite mass rogue body to attach the line segments too
// This way we can control the rotation however we want.
rogueBoxBody = cpBodyNew(INFINITY, INFINITY);
cpBodySetAngVel(rogueBoxBody, 0.4f);
// Set up the static box.
cpVect a = cpv(-200, -200);
cpVect b = cpv(-200, 200);
cpVect c = cpv( 200, 200);
cpVect d = cpv( 200, -200);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(rogueBoxBody, a, b, 0.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(rogueBoxBody, b, c, 0.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(rogueBoxBody, c, d, 0.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(rogueBoxBody, d, a, 0.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
cpFloat mass = 1;
cpFloat width = 60;
cpFloat height = 30;
// Add the bricks.
for(int i=0; i<3; i++){
for(int j=0; j<7; j++){
body = cpSpaceAddBody(space, cpBodyNew(mass, cpMomentForBox(mass, width, height)));
cpBodySetPos(body, cpv(i*60 - 150, j*30 - 150));
shape = cpSpaceAddShape(space, cpBoxShapeNew(body, width, height));
cpShapeSetElasticity(shape, 0.0f);
cpShapeSetFriction(shape, 0.7f);
}
}
return space;
}
static cpSpace *
init(void)
{
ChipmunkDemoMessageString = "One way platforms are trivial in Chipmunk using a very simple collision callback.";
cpSpace *space = cpSpaceNew();
cpSpaceSetIterations(space, 10);
cpSpaceSetGravity(space, cpv(0, -100));
cpBody *body, *staticBody = cpSpaceGetStaticBody(space);
cpShape *shape;
// Create segments around the edge of the screen.
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-320,-240), cpv(-320,240), 0.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetFilter(shape, NOT_GRABBABLE_FILTER);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(320,-240), cpv(320,240), 0.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetFilter(shape, NOT_GRABBABLE_FILTER);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-320,-240), cpv(320,-240), 0.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetFilter(shape, NOT_GRABBABLE_FILTER);
// Add our one way segment
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-160,-100), cpv(160,-100), 10.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetCollisionType(shape, COLLISION_TYPE_ONE_WAY);
cpShapeSetFilter(shape, NOT_GRABBABLE_FILTER);
// We'll use the data pointer for the OneWayPlatform struct
platformInstance.n = cpv(0, 1); // let objects pass upwards
cpShapeSetUserData(shape, &platformInstance);
// Add a ball to test it out
cpFloat radius = 15.0f;
body = cpSpaceAddBody(space, cpBodyNew(10.0f, cpMomentForCircle(10.0f, 0.0f, radius, cpvzero)));
cpBodySetPosition(body, cpv(0, -200));
cpBodySetVelocity(body, cpv(0, 170));
shape = cpSpaceAddShape(space, cpCircleShapeNew(body, radius, cpvzero));
cpShapeSetElasticity(shape, 0.0f);
cpShapeSetFriction(shape, 0.9f);
cpShapeSetCollisionType(shape, 2);
cpCollisionHandler *handler = cpSpaceAddWildcardHandler(space, COLLISION_TYPE_ONE_WAY);
handler->preSolveFunc = PreSolve;
return space;
}
static cpSpace *
init(void)
{
ChipmunkDemoMessageString = "Sticky collisions using the cpArbiter data pointer.";
cpSpace *space = cpSpaceNew();
cpSpaceSetIterations(space, 10);
cpSpaceSetGravity(space, cpv(0, -1000));
cpSpaceSetCollisionSlop(space, 2.0);
cpBody *staticBody = cpSpaceGetStaticBody(space);
cpShape *shape;
// Create segments around the edge of the screen.
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-340,-260), cpv(-340, 260), 20.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetCollisionType(shape, COLLIDE_STICK_SENSOR);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv( 340,-260), cpv( 340, 260), 20.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetCollisionType(shape, COLLIDE_STICK_SENSOR);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-340,-260), cpv( 340,-260), 20.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetCollisionType(shape, COLLIDE_STICK_SENSOR);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-340, 260), cpv( 340, 260), 20.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetCollisionType(shape, COLLIDE_STICK_SENSOR);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
for(int i=0; i<200; i++){
cpFloat mass = 0.15f;
cpFloat radius = 10.0f;
cpBody *body = cpSpaceAddBody(space, cpBodyNew(mass, cpMomentForCircle(mass, 0.0f, radius, cpvzero)));
cpBodySetPos(body, cpv(cpflerp(-150.0f, 150.0f, frand()), cpflerp(-150.0f, 150.0f, frand())));
cpShape *shape = cpSpaceAddShape(space, cpCircleShapeNew(body, radius + STICK_SENSOR_THICKNESS, cpvzero));
cpShapeSetFriction(shape, 0.9f);
cpShapeSetCollisionType(shape, COLLIDE_STICK_SENSOR);
}
cpSpaceAddCollisionHandler(space, COLLIDE_STICK_SENSOR, COLLIDE_STICK_SENSOR, NULL, StickyPreSolve, NULL, StickySeparate, NULL);
return space;
}
static cpSpace *
init(void)
{
ChipmunkDemoMessageString = "Right click to make pentagons static/dynamic.";
cpSpace *space = cpSpaceNew();
cpSpaceSetIterations(space, 5);
cpSpaceSetGravity(space, cpv(0, -100));
cpBody *body, *staticBody = cpSpaceGetStaticBody(space);
cpShape *shape;
// Vertexes for a triangle shape.
cpVect tris[] = {
cpv(-15,-15),
cpv( 0, 10),
cpv( 15,-15),
};
// Create the static triangles.
for(int i=0; i<9; i++){
for(int j=0; j<6; j++){
cpFloat stagger = (j%2)*40;
cpVect offset = cpv(i*80 - 320 + stagger, j*70 - 240);
shape = cpSpaceAddShape(space, cpPolyShapeNew(staticBody, 3, tris, offset));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
}
}
// Create vertexes for a pentagon shape.
cpVect verts[NUM_VERTS];
for(int i=0; i<NUM_VERTS; i++){
cpFloat angle = -2*M_PI*i/((cpFloat) NUM_VERTS);
verts[i] = cpv(10*cos(angle), 10*sin(angle));
}
pentagon_mass = 1.0;
pentagon_moment = cpMomentForPoly(1.0f, NUM_VERTS, verts, cpvzero);
// Add lots of pentagons.
for(int i=0; i<300; i++){
body = cpSpaceAddBody(space, cpBodyNew(pentagon_mass, pentagon_moment));
cpFloat x = rand()/(cpFloat)RAND_MAX*640 - 320;
cpBodySetPos(body, cpv(x, 350));
shape = cpSpaceAddShape(space, cpPolyShapeNew(body, NUM_VERTS, verts, cpvzero));
cpShapeSetElasticity(shape, 0.0f);
cpShapeSetFriction(shape, 0.4f);
}
return space;
}
int lc_space_newindex(lua_State *vm){
cpSpace *space = (lc_GetSpace(1, vm))->space;
const char *key = lua_tostring(vm, 2);
if (strcmp("gravity", key) == 0 && lua_istable(vm, 3)){
cpSpaceSetGravity(space, lc_TableTocpVect(3, vm));
}
else if (strcmp("iterations", key) == 0){
cpSpaceSetIterations(space, (cpFloat)lua_tonumber(vm, 3));
}
return 0;
}
static cpSpace *
init(void)
{
cpSpace *space = cpSpaceNew();
cpSpaceSetIterations(space, 30);
cpSpaceSetGravity(space, cpv(0, -100));
cpSpaceSetSleepTimeThreshold(space, 0.5f);
cpSpaceSetCollisionSlop(space, 0.5f);
cpBody *body, *staticBody = cpSpaceGetStaticBody(space);
cpShape *shape;
// Create segments around the edge of the screen.
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-320,-240), cpv(-320,240), 0.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetFilter(shape, NOT_GRABBABLE_FILTER);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(320,-240), cpv(320,240), 0.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetFilter(shape, NOT_GRABBABLE_FILTER);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-320,-240), cpv(320,-240), 0.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetFilter(shape, NOT_GRABBABLE_FILTER);
// Add lots of boxes.
for(int i=0; i<14; i++){
for(int j=0; j<=i; j++){
body = cpSpaceAddBody(space, cpBodyNew(1.0f, cpMomentForBox(1.0f, 30.0f, 30.0f)));
cpBodySetPosition(body, cpv(j*32 - i*16, 300 - i*32));
shape = cpSpaceAddShape(space, cpBoxShapeNew(body, 30.0f, 30.0f, 0.5f));
cpShapeSetElasticity(shape, 0.0f);
cpShapeSetFriction(shape, 0.8f);
}
}
// Add a ball to make things more interesting
cpFloat radius = 15.0f;
body = cpSpaceAddBody(space, cpBodyNew(10.0f, cpMomentForCircle(10.0f, 0.0f, radius, cpvzero)));
cpBodySetPosition(body, cpv(0, -240 + radius+5));
shape = cpSpaceAddShape(space, cpCircleShapeNew(body, radius, cpvzero));
cpShapeSetElasticity(shape, 0.0f);
cpShapeSetFriction(shape, 0.9f);
return space;
}
Stage::Stage(int count, char** argv){
/*** Set up space variables ***/
envSpace = cpSpaceNew();
cpSpaceSetIterations(envSpace, 10);
cpSpaceSetGravity(envSpace, cpv(0, -1500));
PhysicsObject::space = envSpace;
// cpSpaceSetSleepTimeThreshold(envSpace, 5.0f);
/*** Set up projection and view matrices -- these numbers will probably change ***/
Obj::matProjection = glm::perspective(60.0f*3.1415f/180.0f, 1.0f, 10.0f, 18000.0f);
//mat_Projection = glm::ortho(-100.0f, 100.0f, -100.0f, 100.0f, 10.0f, 300.0f);
setCollisionHandlers(envSpace);
/** STAGE DESIGN GOES BELOW HERE **/
physicsObjects.push_back(new Platform(-1500, 1500, 1525));
physicsObjects.push_back(new Platform(-1450, 1450, -975));
physicsObjects.push_back(new Platform(150, 700, 25));
physicsObjects.push_back(new Platform(-1450, -400, 375));
physicsObjects.push_back(new Spikes(-1200, -25, 3.141592f));
physicsObjects.push_back(new Platform(-700, 1450, 825));
physicsObjects.push_back(new Wall(-200, 1500, -1475));
physicsObjects.push_back(new Ramp(1450, 4500, -975, 500));
physicsObjects.push_back(new Boulder(4200, 900));
physicsObjects.push_back(new Spears(-1750, -950));
physicsObjects.push_back(new Spikes(-800, -950));
physicsObjects.push_back(new Platform(-500, -200, -300));
boundary = new Boundary(-30000, 30000, -975, BS_SAND);
userControlObject = new Hero(-770, 800);
skybox = new Skybox(0, 0, 1);
/** STAGE DESIGN GOES ABOVE HERE **/
mat_View = glm::lookAt(glm::vec3(0.0f, 500.0f, 2000.0f), glm::vec3(-770.0f, 800.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
soundMap.insert(std::pair<std::string, Sound*>("Background", new Sound("./data/sound/bm.wav")));
soundMap.insert(std::pair<std::string, Sound*>("Jump", new Sound("./data/sound/jump.wav")));
soundMap.find("Background")->second->play(1); //play bgm
}
bool PhysicsWorld::init()
{
_info = new PhysicsWorldInfo();
cpSpaceSetGravity(_info->space, PhysicsHelper::point2cpv(_gravity));
cpSpaceSetDefaultCollisionHandler(_info->space,
PhysicsWorld::collisionBeginCallbackFunc,
PhysicsWorld::collisionPreSolveCallbackFunc,
PhysicsWorld::collisionPostSolveCallbackFunc,
PhysicsWorld::collisionSeparateCallbackFunc,
this);
return true;
}
ws::game::Scene::Scene() {
// setup lua state
// setup scene physics
// create gravity and empty space
cpVect gravity = cpv(0, -100);
space = cpSpaceNew();
cpSpaceSetGravity(space, gravity);
ground = cpSegmentShapeNew(space->staticBody, cpv(-200, 5), cpv(200, -5), 0);
cpShapeSetFriction(ground, 1);
cpSpaceAddShape(space, ground);
ws::components::LuaBehaviour::SetupLuaState();
}
fff::kitty::kitty(){
body = cpBodyNew(1.f, INFINITY);
cpBodySetUserData(body, this);
forecastspace = cpSpaceNew();
cpSpaceSetIterations(forecastspace, 100);
cpBodyInit(&forecastbody, 1.f, INFINITY);
cpSpaceSetGravity(forecastspace, (cpVect){0.f, METERSTOPIXELS(10.f)} );
cpSpaceAddBody(forecastspace, &forecastbody);
iflames = 0;
burstinflames = false;
leftimpulse = false;
rightimpulse = false;
}
int main (int argc, char **argv) {
cpSpace *space = cpSpaceNew();
cpSpaceSetGravity(space, cpv(0, GRAVITY));
cpEnableSegmentToSegmentCollisions();
cpShape *ground = cpSpaceAddShape(space, cpSegmentShapeNew(space->staticBody, cpv(0, 5), cpv(10, -5), 0));
cpShapeSetFriction(ground, 0.3);
cpBody *drawing = drawing_new(2, 7, 0);
drawing = drawing_update(space, drawing, 3, 8);
drawing = drawing_update(space, drawing, 3, 9);
drawing = drawing_update(space, drawing, 2, 9);
//cpBody *drawing = drawing_new(0, 0, 0);
//drawing = drawing_update(space, drawing, 2, 0);
//drawing = drawing_update(space, drawing, 2, 2);
//drawing = drawing_update(space, drawing, 0, 2);
print_positions(drawing);
//drawing_activate(drawing);
//print_positions(drawing);
cpVect vel, pos;
int i = 0;
for(cpFloat time = 0; time < 2; time += TIMESTEP){
pos = cpBodyGetPos(drawing);
vel = cpBodyGetVel(drawing);
printf( "Time = %2.2f Position = (%2.2f, %2.2f) Velocity = (%2.2f, %2.2f)\n",
time, pos.x, pos.y, vel.x, vel.y);
cpSpaceStep(space, TIMESTEP);
i++;
if (i == 20) {
drawing_activate(space, drawing);
print_positions(drawing);
}
}
print_positions(drawing);
free_body_full(drawing);
cpShapeFree(ground);
cpSpaceFree(space);
return EXIT_SUCCESS;
}
void PhysicsWorld::setGravity(const Vect& gravity)
{
if (_bodies != nullptr)
{
for (auto child : *_bodies)
{
PhysicsBody* body = dynamic_cast<PhysicsBody*>(child);
// reset gravity for body
if (!body->isGravityEnabled())
{
body->applyForce(-_gravity);
body->applyForce(gravity);
}
}
}
_gravity = gravity;
cpSpaceSetGravity(_info->getSpace(), PhysicsHelper::point2cpv(gravity));
}
void physics_init()
{
/* init pools, maps */
pool = entitypool_new(PhysicsInfo);
debug_draw_map = entitymap_new(false);
/* init cpSpace */
space = cpSpaceNew();
cpSpaceSetGravity(space, cpv(0, -9.8));
/* init draw stuff */
program = gfx_create_program(data_path("phypoly.vert"),
NULL,
data_path("phypoly.frag"));
glUseProgram(program);
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
gfx_bind_vertex_attrib(program, GL_FLOAT, 2, "position", Vec2, x);
}
bool PhysicsWorld::init()
{
do
{
_cpSpace = cpSpaceNew();
CC_BREAK_IF(_cpSpace == nullptr);
cpSpaceSetGravity(_cpSpace, PhysicsHelper::point2cpv(_gravity));
cpSpaceSetDefaultCollisionHandler(_cpSpace,
(cpCollisionBeginFunc)PhysicsWorldCallback::collisionBeginCallbackFunc,
(cpCollisionPreSolveFunc)PhysicsWorldCallback::collisionPreSolveCallbackFunc,
(cpCollisionPostSolveFunc)PhysicsWorldCallback::collisionPostSolveCallbackFunc,
(cpCollisionSeparateFunc)PhysicsWorldCallback::collisionSeparateCallbackFunc,
this);
return true;
} while (false);
return false;
}
static void
create_physics_objects(game_state *state)
{
switch_state_data *data = state->data->switch_data;
cpSpace *space = cpSpaceNew();
cpSpaceSetGravity(space, cpv(0, 250));
/* add borders */
cpShape *shape = NULL;
shape = cpSpaceAddShape(space, cpSegmentShapeNew(space->staticBody,
cpv(0, 0),
cpv(0, SCREEN_HEIGHT),
0));
cpShapeSetLayers(shape, L_GROUND);
shape =cpSpaceAddShape(space, cpSegmentShapeNew(space->staticBody,
cpv(0, SCREEN_HEIGHT),
cpv(SCREEN_WIDTH, SCREEN_HEIGHT),
0));
cpShapeSetLayers(shape, L_GROUND);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(space->staticBody,
cpv(SCREEN_WIDTH, SCREEN_HEIGHT),
cpv(SCREEN_WIDTH, 0),
0));
cpShapeSetLayers(shape, L_GROUND);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(space->staticBody,
cpv(SCREEN_WIDTH, 0),
cpv(0, 0),
0));
cpShapeSetLayers(shape, L_GROUND);
ent_switch *sw = ent_switch_new(space,
cpv(SCREEN_WIDTH / 2, SCREEN_HEIGHT + 2), 0);
data->space = space;
data->sw = sw;
}
int main (int argc, char *argv[]){
Gui *gui = (Gui *)malloc(sizeof(Gui));;
gui->space = cpSpaceNew();
gui->current_body = NULL;
cpSpaceSetGravity(gui->space, cpv(0, GRAVITY));
cpEnableSegmentToSegmentCollisions();
gtk_init(&argc, &argv);
initialize_window(gui);
initialize_client(gui);
pthread_t t1;
int iret1 = pthread_create(&t1, NULL, client_recv1, gui);
gtk_main();
cpSpaceFree(gui->space);
free(gui);
return 0;
}
static cpSpace *
init(void)
{
cpSpace *space = cpSpaceNew();
cpSpaceSetIterations(space, 30);
cpSpaceSetGravity(space, cpv(0, -300));
cpSpaceSetSleepTimeThreshold(space, 0.5f);
cpSpaceSetCollisionSlop(space, 0.5f);
// Add a floor.
cpShape *shape = cpSpaceAddShape(space, cpSegmentShapeNew(cpSpaceGetStaticBody(space), cpv(-600,-240), cpv(600,-240), 0.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
// Add the dominoes.
int n = 12;
for(int i=0; i<n; i++){
for(int j=0; j<(n - i); j++){
cpVect offset = cpv((j - (n - 1 - i)*0.5f)*1.5f*HEIGHT, (i + 0.5f)*(HEIGHT + 2*WIDTH) - WIDTH - 240);
add_domino(space, offset, cpFalse);
add_domino(space, cpvadd(offset, cpv(0, (HEIGHT + WIDTH)/2.0f)), cpTrue);
if(j == 0){
add_domino(space, cpvadd(offset, cpv(0.5f*(WIDTH - HEIGHT), HEIGHT + WIDTH)), cpFalse);
}
if(j != n - i - 1){
add_domino(space, cpvadd(offset, cpv(HEIGHT*0.75f, (HEIGHT + 3*WIDTH)/2.0f)), cpTrue);
} else {
add_domino(space, cpvadd(offset, cpv(0.5f*(HEIGHT - WIDTH), HEIGHT + WIDTH)), cpFalse);
}
}
}
return space;
}
ETERM *space_new(ETERM *fromp, ETERM *argp) {
// get the args
ETERM *iterationsp = erl_element(1, argp);
ETERM *gravityp = erl_element(2, argp);
ETERM *gravityxp = erl_element(1, gravityp);
ETERM *gravityyp = erl_element(2, gravityp);
// create the new space
cpSpace *space = cpSpaceNew();
cpSpaceSetIterations(space, ERL_INT_VALUE(iterationsp));
cpSpaceSetGravity(space, cpv(ERL_FLOAT_VALUE(gravityxp),
ERL_FLOAT_VALUE(gravityyp)));
cpSpaceSetSleepTimeThreshold(space, 5.0);
// add it to the hash table
ETERM *ref = erl_mk_node_ref();
erlmunk_space *s = (erlmunk_space *) malloc(sizeof(erlmunk_space));
s->id = ERL_REF_NUMBER(ref);
s->space = space;
s->subscriber_count = 0;
s->subscribers = NULL;
s->bodies = NULL;
HASH_ADD_INT(erlmunk_spaces, id, s);
ETERM *atom_ok = erl_mk_atom("ok");
ETERM **space_new_array = (ETERM **) malloc(sizeof(ETERM*) * 2);
space_new_array[0] = atom_ok;
space_new_array[1] = ref;
ETERM *space_new_tuple = erl_mk_tuple(space_new_array, 2);
free(space_new_array);
ETERM *reply_tuple = erl_mk_reply(fromp, space_new_tuple);
ETERM *gen_cast_tuple = erl_mk_gen_cast(reply_tuple);
return gen_cast_tuple;
}
/**
* Init
*/
cpSpace *init(){
// cpVect is a 2D vector and cpv() is a shortcut for initializing them.
cpVect gravity = cpv(50, 0);
// Create an empty space.
espace = cpSpaceNew();
cpSpaceSetGravity(espace, gravity);
// Add a static line segment shape for the ground.
// We'll make it slightly tilted so the ball will roll off.
// We attach it to space->staticBody to tell Chipmunk it shouldn't be movable.
cpShape *ground = cpSegmentShapeNew(espace->staticBody, cpv(420, 0), cpv(420, 640), 0);
cpShape *murGauche = cpSegmentShapeNew(espace->staticBody, cpv(0, 10), cpv(470, 10), 0);
cpShape *murDroit = cpSegmentShapeNew(espace->staticBody, cpv(0, 630), cpv(470, 630), 0);
cpShapeSetFriction(ground, 0.5);
cpShapeSetFriction(murGauche, 1);
cpShapeSetFriction(murDroit, 1);
cpSpaceAddShape(espace, ground);
cpSpaceAddShape(espace, murGauche);
cpSpaceAddShape(espace, murDroit);
return espace;
}
static cpSpace *
init(void)
{
ChipmunkDemoMessageString = "Use the arrow keys to control the machine.";
space = cpSpaceNew();
cpSpaceSetGravity(space, cpv(0, -600));
cpBody *staticBody = cpSpaceGetStaticBody(space);
cpShape *shape;
// beveling all of the line segments slightly helps prevent things from getting stuck on cracks
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-256,16), cpv(-256,300), 2.0f));
cpShapeSetElasticity(shape, 0.0f);
cpShapeSetFriction(shape, 0.5f);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-256,16), cpv(-192,0), 2.0f));
cpShapeSetElasticity(shape, 0.0f);
cpShapeSetFriction(shape, 0.5f);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-192,0), cpv(-192, -64), 2.0f));
cpShapeSetElasticity(shape, 0.0f);
cpShapeSetFriction(shape, 0.5f);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-128,-64), cpv(-128,144), 2.0f));
cpShapeSetElasticity(shape, 0.0f);
cpShapeSetFriction(shape, 0.5f);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-192,80), cpv(-192,176), 2.0f));
cpShapeSetElasticity(shape, 0.0f);
cpShapeSetFriction(shape, 0.5f);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-192,176), cpv(-128,240), 2.0f));
cpShapeSetElasticity(shape, 0.0f);
cpShapeSetFriction(shape, 0.5f);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-128,144), cpv(192,64), 2.0f));
cpShapeSetElasticity(shape, 0.0f);
cpShapeSetFriction(shape, 0.5f);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
cpVect verts[] = {
cpv(-30,-80),
cpv(-30, 80),
cpv( 30, 64),
cpv( 30,-80),
};
cpBody *plunger = cpSpaceAddBody(space, cpBodyNew(1.0f, INFINITY));
cpBodySetPos(plunger, cpv(-160,-80));
shape = cpSpaceAddShape(space, cpPolyShapeNew(plunger, 4, verts, cpvzero));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 0.5f);
cpShapeSetLayers(shape, 1);
// add balls to hopper
for(int i=0; i<numBalls; i++)
balls[i] = add_ball(cpv(-224 + i,80 + 64*i));
// add small gear
cpBody *smallGear = cpSpaceAddBody(space, cpBodyNew(10.0f, cpMomentForCircle(10.0f, 80, 0, cpvzero)));
cpBodySetPos(smallGear, cpv(-160,-160));
cpBodySetAngle(smallGear, -M_PI_2);
shape = cpSpaceAddShape(space, cpCircleShapeNew(smallGear, 80.0f, cpvzero));
cpShapeSetLayers(shape, 0);
cpSpaceAddConstraint(space, cpPivotJointNew2(staticBody, smallGear, cpv(-160,-160), cpvzero));
// add big gear
cpBody *bigGear = cpSpaceAddBody(space, cpBodyNew(40.0f, cpMomentForCircle(40.0f, 160, 0, cpvzero)));
cpBodySetPos(bigGear, cpv(80,-160));
cpBodySetAngle(bigGear, M_PI_2);
shape = cpSpaceAddShape(space, cpCircleShapeNew(bigGear, 160.0f, cpvzero));
cpShapeSetLayers(shape, 0);
cpSpaceAddConstraint(space, cpPivotJointNew2(staticBody, bigGear, cpv(80,-160), cpvzero));
// connect the plunger to the small gear.
cpSpaceAddConstraint(space, cpPinJointNew(smallGear, plunger, cpv(80,0), cpv(0,0)));
// connect the gears.
cpSpaceAddConstraint(space, cpGearJointNew(smallGear, bigGear, -M_PI_2, -2.0f));
// feeder mechanism
cpFloat bottom = -300.0f;
cpFloat top = 32.0f;
cpBody *feeder = cpSpaceAddBody(space, cpBodyNew(1.0f, cpMomentForSegment(1.0f, cpv(-224.0f, bottom), cpv(-224.0f, top))));
cpBodySetPos(feeder, cpv(-224, (bottom + top)/2.0f));
cpFloat len = top - bottom;
cpSpaceAddShape(space, cpSegmentShapeNew(feeder, cpv(0.0f, len/2.0f), cpv(0.0f, -len/2.0f), 20.0f));
cpSpaceAddConstraint(space, cpPivotJointNew2(staticBody, feeder, cpv(-224.0f, bottom), cpv(0.0f, -len/2.0f)));
cpVect anchr = cpBodyWorld2Local(feeder, cpv(-224.0f, -160.0f));
cpSpaceAddConstraint(space, cpPinJointNew(feeder, smallGear, anchr, cpv(0.0f, 80.0f)));
// motorize the second gear
motor = cpSpaceAddConstraint(space, cpSimpleMotorNew(staticBody, bigGear, 3.0f));
return space;
}
static cpSpace *
init(void)
{
ChipmunkDemoMessageString = "Control the crane by moving the mouse. Press the down arrow to release.";
space = cpSpaceNew();
cpSpaceSetIterations(space, 30);
cpSpaceSetGravity(space, cpv(0, -100));
cpSpaceSetDamping(space, 0.8);
cpBody *staticBody = cpSpaceGetStaticBody(space);
cpShape *shape;
shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-320,-240), cpv(320,-240), 0.0f));
cpShapeSetElasticity(shape, 1.0f);
cpShapeSetFriction(shape, 1.0f);
cpShapeSetLayers(shape, NOT_GRABABLE_MASK);
// Add a body for the dolly.
dollyBody = cpSpaceAddBody(space, cpBodyNew(10, INFINITY));
cpBodySetPos(dollyBody, cpv(0, 100));
// Add a block so you can see it.
cpSpaceAddShape(space, cpBoxShapeNew(dollyBody, 30, 30));
// Add a groove joint for it to move back and forth on.
cpSpaceAddConstraint(space, cpGrooveJointNew(staticBody, dollyBody, cpv(-250, 100), cpv(250, 100), cpvzero));
// Add a pivot joint to act as a servo motor controlling it's position
// By updating the anchor points of the pivot joint, you can move the dolly.
dollyServo = cpSpaceAddConstraint(space, cpPivotJointNew(staticBody, dollyBody, cpBodyGetPos(dollyBody)));
// Max force the dolly servo can generate.
cpConstraintSetMaxForce(dollyServo, 10000);
// Max speed of the dolly servo
cpConstraintSetMaxBias(dollyServo, 100);
// You can also change the error bias to control how it slows down.
//cpConstraintSetErrorBias(dollyServo, 0.2);
// Add the crane hook.
cpBody *hookBody = cpSpaceAddBody(space, cpBodyNew(1, INFINITY));
cpBodySetPos(hookBody, cpv(0, 50));
// Add a sensor shape for it. This will be used to figure out when the hook touches a box.
shape = cpSpaceAddShape(space, cpCircleShapeNew(hookBody, 10, cpvzero));
cpShapeSetSensor(shape, cpTrue);
cpShapeSetCollisionType(shape, HOOK_SENSOR);
// Add a slide joint to act as a winch motor
// By updating the max length of the joint you can make it pull up the load.
winchServo = cpSpaceAddConstraint(space, cpSlideJointNew(dollyBody, hookBody, cpvzero, cpvzero, 0, INFINITY));
// Max force the dolly servo can generate.
cpConstraintSetMaxForce(winchServo, 30000);
// Max speed of the dolly servo
cpConstraintSetMaxBias(winchServo, 60);
// TODO cleanup
// Finally a box to play with
cpBody *boxBody = cpSpaceAddBody(space, cpBodyNew(30, cpMomentForBox(30, 50, 50)));
cpBodySetPos(boxBody, cpv(200, -200));
// Add a block so you can see it.
shape = cpSpaceAddShape(space, cpBoxShapeNew(boxBody, 50, 50));
cpShapeSetFriction(shape, 0.7);
cpShapeSetCollisionType(shape, CRATE);
cpSpaceAddCollisionHandler(space, HOOK_SENSOR, CRATE, (cpCollisionBeginFunc)HookCrate, NULL, NULL, NULL, NULL);
return space;
}
int main(void){
// cpVect is a 2D vector and cpv() is a shortcut for initializing them.
cpVect gravity = cpv(0, -100);
// Create an empty space.
cpSpace *space = cpSpaceNew();
cpSpaceSetGravity(space, gravity);
// Add a static line segment shape for the ground.
// We'll make it slightly tilted so the ball will roll off.
// We attach it to space->staticBody to tell Chipmunk it shouldn't be movable.
cpShape *ground = cpSegmentShapeNew(space->staticBody, cpv(-20, 5), cpv(20, -5), 0);
cpShapeSetFriction(ground, 1);
cpSpaceAddShape(space, ground);
// Now let's make a ball that falls onto the line and rolls off.
// First we need to make a cpBody to hold the physical properties of the object.
// These include the mass, position, velocity, angle, etc. of the object.
// Then we attach collision shapes to the cpBody to give it a size and shape.
cpFloat radius = 5;
cpFloat mass = 1;
// The moment of inertia is like mass for rotation
// Use the cpMomentFor*() functions to help you approximate it.
cpFloat moment = cpMomentForCircle(mass, 0, radius, cpvzero);
// The cpSpaceAdd*() functions return the thing that you are adding.
// It's convenient to create and add an object in one line.
cpBody *ballBody = cpSpaceAddBody(space, cpBodyNew(mass, moment));
cpBodySetPos(ballBody, cpv(0, 15));
// Now we create the collision shape for the ball.
// You can create multiple collision shapes that point to the same body.
// They will all be attached to the body and move around to follow it.
cpShape *ballShape = cpSpaceAddShape(space, cpCircleShapeNew(ballBody, radius, cpvzero));
cpShapeSetFriction(ballShape, 0.7);
// Now that it's all set up, we simulate all the objects in the space by
// stepping forward through time in small increments called steps.
// It is *highly* recommended to use a fixed size time step.
cpFloat timeStep = 1.0/60.0;
for(cpFloat time = 0; time < 2; time += timeStep){
cpVect pos = cpBodyGetPos(ballBody);
cpVect vel = cpBodyGetVel(ballBody);
printf(
"Time is %5.2f. ballBody is at (%5.2f, %5.2f). It's velocity is (%5.2f, %5.2f)\n",
time, pos.x, pos.y, vel.x, vel.y
);
cpSpaceStep(space, timeStep);
}
// Clean up our objects and exit!
cpShapeFree(ballShape);
cpBodyFree(ballBody);
cpShapeFree(ground);
cpSpaceFree(space);
return 0;
}
