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; }