int main(int, char **) { // construct the viewer. osgViewer::Viewer viewer; // add model to viewer. viewer.setSceneData( createShapes() ); return viewer.run(); }
TinkertoyWorldNode(const dart::simulation::WorldPtr& world) : dart::gui::osg::RealTimeWorldNode(world), mForceCoeff(DefaultForceCoeff), mWasSimulating(false) { mTarget = dart::gui::osg::InteractiveFrame::createShared( dart::dynamics::Frame::World()); getWorld()->addSimpleFrame(mTarget); createShapes(); createInitialToy1(); createInitialToy2(); createForceLine(); }
int main(int argc, char **argv) { osg::ArgumentParser arguments(&argc,argv); // construct the viewer. osgViewer::Viewer viewer(arguments); // add model to viewer. viewer.setSceneData( createShapes(arguments) ); // add the state manipulator viewer.addEventHandler( new osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()) ); return viewer.run(); }
void ShapeFinder::start(int newN) { int startTime = std::clock(); std::vector<std::vector<std::vector<bool>>> unique = {}; std::vector<std::vector<std::vector<bool>>> allRots = {}; n = std::min(10, std::max(1, newN)); printf("Shape Finder Started with %i tiles\n", n); for (int x = 0; x < n; x++) { blank.push_back({}); for (int y = 0; y < n; y++) { blank[x].push_back(false); } } std::vector<std::vector<bool>> grid = blank; grid[floor((float)n / 2 - 0.5)][floor((float)n / 2 - 0.5)] = true; createShapes(grid, &unique, &allRots); printf("n = %i\n", unique.size()); for (int i = 0; i < unique.size(); i++) { for (int y = 0; y < n; y++) { for (int x = 0; x < n; x++) { printf("%c", unique[i][y][x] ? 219 : ' '); } printf("\n"); } printf("\n"); } printf("n = %i\n", unique.size()); printf("%ims passed\n", std::clock() - startTime); }
int main(int argc, char *argv[]) #endif { #ifdef USE_SDL if (SDL_Init(SDL_INIT_VIDEO) < 0) { report("Can't initialize SDL\n"); return 1; } // TODO fullscreen + get screen size #ifndef __ANDROID__ width=height=700; #else width=320; height=480; // const SDL_VideoInfo* vinfo=SDL_GetVideoInfo(); // width = vinfo->current_w; // height = vinfo->current_h; // report("Detected %dx%d resolution.\n",width,height); #endif window = SDL_CreateWindow("Bezier Fragment Shader Demo", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_RESIZABLE | SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL); if(window == NULL) { report("Can't create window: %s\n", SDL_GetError()); return -1; } glcontext = SDL_GL_CreateContext(window); if(glcontext == NULL) { report("Can't create context: %s\n", SDL_GetError()); return -1; } SDL_GL_MakeCurrent(window, glcontext); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); #else glutInit(&argc,argv); glutInitWindowSize(700,700); glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE|GLUT_DEPTH); glutCreateWindow("Bezier Fragment Shader Demo"); #endif glViewport(0, 0, width, height); glClearColor(0.0, 0.0, 0.0, 0.0); glEnable(GL_DEPTH_TEST); fshader = loadShader("bezier.glsl",GL_FRAGMENT_SHADER); vshader = loadShader("bezier-vertex.glsl",GL_VERTEX_SHADER); if (!(fshader&&vshader)) { report("One of shaders failed, aborting.\n"); return -1; } program = glCreateProgram(); glAttachShader(program, fshader); glAttachShader(program, vshader); glBindAttribLocation(program, 0, "vertexPos"); glBindAttribLocation(program, 1, "bezCoordsAttr"); glLinkProgram(program); glGetProgramiv(program, GL_LINK_STATUS, &linked); if (!linked) { report("Can't link the shader\n"); return -1; } glUseProgram(program); glUniform1i(glGetUniformLocation(program, "drawFill"), 1); glUniform1i(glGetUniformLocation(program, "useBezier"), 1); glUniform1i(glGetUniformLocation(program, "drawStroke"), 1); #ifndef __ANDROID__ // glEnableClientState(GL_VERTEX_ARRAY); // Why don't they work like glEnable(A|B) did before? or am I dumb? // glEnableClientState(GL_TEXTURE_COORD_ARRAY); #endif glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); createShapes(); #ifdef USE_SDL int running = 1; timemark=SDL_GetTicks(); while(running) { if ( SDL_PollEvent(&event) > 0 ) { // SDL_WaitEvent(&event); switch(event.type) { case SDL_KEYDOWN: switch(event.key.keysym.sym) { #ifdef __ANDROID__ case SDLK_AC_SEARCH: #endif case SDLK_F1: performanceReport(); break; #ifndef __ANDROID__ case SDLK_ESCAPE: running = 0; break; #else case SDLK_AC_BACK: running = 0; break; #endif case SDLK_LEFT: Camera.beta += M_PI / 36; camera(); break; case SDLK_RIGHT: Camera.beta -= M_PI / 36; camera(); break; case SDLK_UP: Camera.alpha += M_PI / 36; camera(); break; case SDLK_DOWN: Camera.alpha -= M_PI / 36; camera(); break; default: keyb(event.key.keysym.scancode); break; } break; case SDL_MOUSEWHEEL: Camera.dist*= (event.wheel.y < 0)? 1.1 : 0.9; camera(); break; case SDL_MOUSEMOTION: if(event.motion.state == 1) motion(event.motion.xrel, event.motion.yrel); break; // Note, the first frame flickers, TODO workaround // TODO: track the real sequence of WINDOWEVENT_ENTER and WINDOWEVENT_SIZE_CHANGED events case SDL_WINDOWEVENT: if (event.window.event==SDL_WINDOWEVENT_SIZE_CHANGED) size(event.window.data1, event.window.data2); camera(); break; // handle touch events here case SDL_QUIT: running = 0; break; } } draw(); } performanceReport(); SDL_GL_MakeCurrent(NULL, NULL); SDL_GL_DeleteContext(glcontext); SDL_DestroyWindow(window); SDL_Quit(); #else glutReshapeFunc(size); glutDisplayFunc(draw); glutIdleFunc(draw); glutMouseFunc(mouse); glutMotionFunc(motion); glutSpecialFunc(keybs); glutKeyboardFunc(keyb); glutTimerFunc(TIMER_RESOLUTION,timer,0); glutMainLoop(); #endif return 0; }
WorldLinearCastMultithreadedDemo::WorldLinearCastMultithreadedDemo(hkDemoEnvironment* env) : hkDefaultPhysicsDemo(env), m_time(0), m_semaphore(0,1000) { const WorldLinearCastMultithreadedDemoVariant& variant = g_WorldLinearCastMultithreadedDemoVariants[m_variantId]; // // Setup the camera. // { hkVector4 from(0.0f, 10.0f, 30.0f); hkVector4 to (0.0f, 0.0f, 0.0f); hkVector4 up (0.0f, 1.0f, 0.0f); setupDefaultCameras(env, from, to, up); } // // Create the world. // { hkpWorldCinfo info; { info.m_gravity.set(0.0f, -9.81f, 0.0f); info.setBroadPhaseWorldSize( 100.0f ); info.m_collisionTolerance = .001f; info.m_simulationType = hkpWorldCinfo::SIMULATION_TYPE_MULTITHREADED; } m_world = new hkpWorld(info); m_world->lock(); // Register collision agents hkpAgentRegisterUtil::registerAllAgents(m_world->getCollisionDispatcher()); setupGraphics(); } // // Create the underlying landscape // hkAabb aabb; { hkVector4 scaling(1.0f, 0.3f, 1.0f ); m_groundShapeFactory.setScaling( scaling ); m_groundShapeFactory.setTriangleRadius( 0.0f ); hkpMoppBvTreeShape* groundShape = m_groundShapeFactory.createMoppShapeForSpu(); { hkpRigidBodyCinfo groundInfo; groundInfo.m_shape = groundShape; groundInfo.m_motionType = hkpMotion::MOTION_FIXED; hkpRigidBody* b = new hkpRigidBody(groundInfo); b->getCollidable()->getShape()->getAabb( b->getTransform(), 0.0f, aabb ); m_world->addEntity(b); b->removeReference(); } groundShape->removeReference(); } // Create a selection of shapes hkArray<hkpShape*> shapes; createShapes( shapes ); // We would like to ensure that each object is placed on the surface of the landscape such // that it is not penetrating and is resting on the surface. To do this we make use of world // linear casting which will allow us to shape cast our objects against the landscape. // Using the results of this cast we can easily position our objects in the desired manner. { hkPseudoRandomGenerator random(501); int xRes = 8; int yRes = 8; for (int i = 0; i < xRes * yRes; i ++ ) { // create a fixed rigid body info with a random orientation hkpRigidBodyCinfo ci; ci.m_shape = shapes[ random.getRandChar( shapes.getSize() ) ]; ci.m_motionType = hkpMotion::MOTION_FIXED; random.getRandomRotation( ci.m_rotation ); // place it above the plane ci.m_position.set( (1.8f * aabb.m_max(0)) * (-.5f + (i%xRes)/ float(xRes)), aabb.m_max(1) + 10.0f, (1.8f * aabb.m_max(2)) * (-.5f + (i/xRes)/ float(yRes)) ); // create the rigid body hkpRigidBody* b = new hkpRigidBody(ci); // To perform the linear casting we use a hkpLinearCastInput structure and // set the end position of the cast (the start position is given by the // location of our object). We then create a hkpClosestCdPointCollector // to gather the results of the cast and then ask the world to perform // the cast: { hkpLinearCastInput li; li.m_to.set( ci.m_position(0), aabb.m_min(1), ci.m_position(2) ); hkpClosestCdPointCollector hitCollector; m_world->linearCast( b->getCollidable(), li, hitCollector ); // Check for hits if ( hitCollector.hasHit() ) { hkVector4 position; position.setInterpolate4( ci.m_position, li.m_to, hitCollector.getHitContact().getDistance() ); b->setPosition( position ); } } m_world->addEntity( b ); m_rocksOnTheFloor.pushBack( b ); } } hkPseudoRandomGenerator generator(3245); // Create query objects and phantoms from shapes buildQueryObects( shapes, m_queryObjects ); // Remove shape references { for (int i = 0; i < shapes.getSize(); i++) { shapes[i]->removeReference(); shapes[i] = 0; } } m_world->unlock(); hkpCollisionQueryJobQueueUtils::registerWithJobQueue(m_jobQueue); // Special case for this demo variant: we do not allow the # of active SPUs to drop to zero as this can cause a deadlock. if ( variant.m_demoType == WorldLinearCastMultithreadedDemoVariant::MULTITHREADED_ON_SPU ) m_allowZeroActiveSpus = false; // register the default addCdPoint() function; you are free to register your own implementation here though hkpFixedBufferCdPointCollector::registerDefaultAddCdPointFunction(); }
void ShapeFinder::createShapes(std::vector<std::vector<bool>> grid, std::vector<std::vector<std::vector<bool>>>* unique, std::vector<std::vector<std::vector<bool>>>* allRots) { if (unique->size() >= counts[n - 1]) return; int relTiles[4][2] = { { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 } }; std::vector<std::pair<int, int>> tiles; for (int x = 0; x < n; x++) { for (int y = 0; y < n; y++) { if (grid[y][x] == true) { for (int i = 0; i < 4; i++) { if (x + relTiles[i][0] >= 0 && x + relTiles[i][0] < n) { if (y + relTiles[i][1] >= 0 && y + relTiles[i][1] < n) { if (!grid[y + relTiles[i][1]][x + relTiles[i][0]]) { bool stop = false; for (int v = 0; v < tiles.size(); v++) { if (tiles[v].second == x + relTiles[i][0] && tiles[v].first == y + relTiles[i][1]) { stop = true; break; } } if (!stop) { tiles.push_back({ y + relTiles[i][1], x + relTiles[i][0] }); } } } } } } } } for (int i = 0; i < tiles.size(); i++) { std::vector<std::vector<bool>> newGrid = grid; newGrid[tiles[i].first][tiles[i].second] = true; int tileNumber = 0; for (int x = 0; x < n; x++) { for (int y = 0; y < n; y++) { if (newGrid[y][x]) tileNumber++; } } if (tileNumber == n) { int topmostTile = n, leftmostTile = n; for (int y = 0; y < n; y++) { for (int x = 0; x < n; x++) { if (newGrid[y][x]) { if (x < leftmostTile) leftmostTile = x; if (y < topmostTile) topmostTile = y; } } } for (int y = topmostTile; y < n; y++) { for (int x = leftmostTile; x < n; x++) { if (newGrid[y][x]) { newGrid[y][x] = false; newGrid[y - topmostTile][x - leftmostTile] = true; } } } bool stop = false; for (int ii = 0; ii < allRots->size(); ii++) { if (newGrid == (*allRots)[ii]) { stop = true; break; } } if (stop) continue; unique->push_back(newGrid); allRots->push_back(newGrid); printf("Unique Shapes Found: %i\n", unique->size()); for (int ii = 0; ii < 3; ii++) allRots->push_back(rotate(newGrid, ii)); } else { createShapes(newGrid, unique, allRots); } } }
ShapeQueryDemo::ShapeQueryDemo(hkDemoEnvironment* env) : hkDefaultPhysicsDemo(env), m_time(0) { // Setup the camera. { hkVector4 from(0.0f, 10.0f, 30.0f); hkVector4 to (0.0f, 0.0f, 0.0f); hkVector4 up (0.0f, 1.0f, 0.0f); setupDefaultCameras(env, from, to, up); } // Create the world. { hkpWorldCinfo info; info.m_gravity.set(0.0f, -9.81f, 0.0f); info.setBroadPhaseWorldSize( 100.0f ); info.m_collisionTolerance = .001f; m_world = new hkpWorld(info); m_world->lock(); setupGraphics(); } // Register collision agents hkpAgentRegisterUtil::registerAllAgents( m_world->getCollisionDispatcher() ); // // Create the underlying landscape // hkAabb aabb; { hkVector4 scaling(1.0f, 0.3f, 1.0f ); m_groundShapeFactory.setScaling( scaling ); m_groundShapeFactory.setTriangleRadius( 0.0f ); hkpMoppBvTreeShape* groundShape = m_groundShapeFactory.createMoppShape(); { hkpRigidBodyCinfo groundInfo; groundInfo.m_shape = groundShape; groundInfo.m_motionType = hkpMotion::MOTION_FIXED; hkpRigidBody* b = new hkpRigidBody(groundInfo); b->getCollidable()->getShape()->getAabb( b->getTransform(), 0.0f, aabb ); m_world->addEntity(b); b->removeReference(); } groundShape->removeReference(); } // Create a selection of shapes hkArray<hkpShape*> shapes; createShapes( shapes ); // We would like to ensure that each object is placed on the surface of the landscape such // that it is not penetrating and is resting on the surface. To do this we make use of world // linear casting which will allow us to shape cast our objects against the landscape. // Using the results of this cast we can easily position our objects in the desired manner. { hkPseudoRandomGenerator random(501); int xRes = 8; int yRes = 8; for (int i = 0; i < xRes * yRes; i ++ ) { // create a fixed rigid body info with a random orientation hkpRigidBodyCinfo ci; ci.m_shape = shapes[ random.getRandChar( shapes.getSize() ) ]; ci.m_motionType = hkpMotion::MOTION_FIXED; random.getRandomRotation( ci.m_rotation ); // place it above the plane ci.m_position.set( (1.8f * aabb.m_max(0)) * (-.5f + (i%xRes)/ float(xRes)), aabb.m_max(1) + 10.0f, (1.8f * aabb.m_max(2)) * (-.5f + (i/xRes)/ float(yRes)) ); // create the rigid body hkpRigidBody* b = new hkpRigidBody(ci); // To perform the linear casting we use a hkpLinearCastInput structure and // set the end position of the cast (the start position is given by the // location of our object). We then create a hkpClosestCdPointCollector // to gather the results of the cast and then ask the world to perform // the cast: { hkpLinearCastInput li; li.m_to.set( ci.m_position(0), aabb.m_min(1), ci.m_position(2) ); hkpClosestCdPointCollector hitCollector; m_world->linearCast( b->getCollidable(), li, hitCollector ); // Check for hits if ( hitCollector.hasHit() ) { hkVector4 position; position.setInterpolate4( ci.m_position, li.m_to, hitCollector.getHitContact().getDistance() ); b->setPosition( position ); } } m_world->addEntity( b ); m_fixedSmallBodies.pushBack( b ); } } hkPseudoRandomGenerator generator(3245); // Create query objects and phantoms from our shapes if (m_variantId == 0) { // Only AABB phantoms are needed for the raycast variant buildAabbPhantoms( m_world, 10, m_rayCastPhantoms, generator ); } else { // Create query objects and phantoms from shapes buildQueryObects( shapes, m_queryObjects ); buildSimplePhantoms( m_world, shapes, m_simplePhantoms, generator ); buildCachingPhantoms( m_world, shapes, m_cachingPhantoms, generator ); } // Remove shape references { for (int i = 0; i < shapes.getSize(); i++) { shapes[i]->removeReference(); shapes[i] = 0; } } m_world->unlock(); }