/** * @fn main() * @brief The main method. */ int main(int argc, char **argv) { // optionally set the resolution at startup if (argc > 1) { g_iFloWidth = g_iFloHeight = atoi(argv[1]); } // Window size. const int width = 512, height = 512; glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_ALPHA); glutInitWindowPosition(50, 50); glutInitWindowSize(width, height); glutCreateWindow("Mark's Fluid Simulator"); glutIdleFunc(Idle); glutDisplayFunc(Display); glutKeyboardFunc(Keyboard); glutMotionFunc(Motion); glutMouseFunc(Mouse); glutReshapeFunc(Reshape); glutSpecialFunc(Special); Reshape(width, height); // Init the simulation, UI, and graphics state. Initialize(); // Print some instructions. system("cls"); printf("\nFlo: Mark's GPU Fluid Simulator\n\n"); printf("Keys:\n"); printf("[`]: (tilde key) Display parameter sliders\n" "[t]: Cycle display mode (Velocity, Scalar, Pressure).\n" "[T]: Toggle display (turn it off for more accurate \n" " simulation timing.\n" "[r]: Reset fluid simulation\n" "[b]: Toggle bilinear interpolation in fragment program.\n" " (High Quality, Lower Performance)\n" "[m]: Toggle interpolated texture generation.\n" " (Lower Quality, Higher Performance)\n" "[v]: Toggle vorticity confinement.\n" "[a]: Toggle arbitrary boundaries.\n" "[c]: Toggle clearing of pressure each iteration. \n" " (With this off, solution requires fewer iterations, but\n" " has more oscillatory behavior.)\n" "[L]: Time 100 iterations and print out the result.\n" "[q]/[ESC]: Quit\n" "\n" "Mouse:\n" "Left Button: Inject Ink and perturb the fluid.\n" "Right Button: perturb the fluid w/o injecting Ink.\n" "CTRL + Left Button: Draw boundaries.\n" "\n\n\n" ); // start the framerate timer. g_timer.Start(); // Go! glutMainLoop(); return 0; }
void initMouse() { glutMouseFunc(mouseOnPress); glutMotionFunc(mousePressedMotion); }
int main(int argc, char** argv) { // Initialize Glut #ifdef __PPCGEKKO__ printf("Press 1,2,+,-,a,HOME to drop boxes. Press b to shoot a box.\nArrows camera.\n"); #else printf("Press 1-6 to drop boxes. Press w to shoot a box.\nArrows and mouse move camera.\n"); printf("Press p to pause the simulation.\n"); #endif #if defined(_XBOX) || defined(__CELLOS_LV2__) glutRemapButtonExt(0, 'w', false); // A/X to shoot box glutRemapButtonExt(1, '1', false); // B/O, X/S, Y/T shifted/unshifted to drop boxes glutRemapButtonExt(2, '2', false); glutRemapButtonExt(3, '3', false); glutRemapButtonExt(1, '4', true); glutRemapButtonExt(2, '5', true); glutRemapButtonExt(3, '6', true); #endif #ifdef __PPCGEKKO__ glutRemapButtonExt('a','1'); glutRemapButtonExt('b','w'); glutRemapButtonExt('1','2'); glutRemapButtonExt('2','3'); glutRemapButtonExt('+','4'); glutRemapButtonExt('-','5'); glutRemapButtonExt(GLUT_KEY_HOME,'6'); glutRemapButtonExt(GLUT_KEY_UP,101); glutRemapButtonExt(GLUT_KEY_DOWN,103); glutRemapButtonExt(GLUT_KEY_LEFT,100); glutRemapButtonExt(GLUT_KEY_RIGHT,102); #endif glutInit(&argc, argv); glutInitWindowSize(512, 512); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); gMainHandle = glutCreateWindow("SampleMaterials"); glutSetWindow(gMainHandle); glutDisplayFunc(RenderCallback); glutReshapeFunc(ReshapeCallback); glutIdleFunc(IdleCallback); glutKeyboardFunc(KeyboardCallback); glutSpecialFunc(ArrowKeyCallback); glutMouseFunc(MouseCallback); glutMotionFunc(MotionCallback); MotionCallback(0,0); atexit(ExitCallback); // Setup default render states glClearColor(0.3f, 0.4f, 0.5f, 1.0); glEnable(GL_DEPTH_TEST); glEnable(GL_COLOR_MATERIAL); glEnable(GL_CULL_FACE); // Setup lighting glEnable(GL_LIGHTING); float AmbientColor[] = { 0.0f, 0.1f, 0.2f, 0.0f }; glLightfv(GL_LIGHT0, GL_AMBIENT, AmbientColor); float DiffuseColor[] = { 1.0f, 1.0f, 1.0f, 0.0f }; glLightfv(GL_LIGHT0, GL_DIFFUSE, DiffuseColor); float SpecularColor[] = { 0.0f, 0.0f, 0.0f, 0.0f }; glLightfv(GL_LIGHT0, GL_SPECULAR, SpecularColor); float Position[] = { 100.0f, 100.0f, 400.0f, 1.0f }; glLightfv(GL_LIGHT0, GL_POSITION, Position); glEnable(GL_LIGHT0); // Initialize physics scene and start the application main loop if scene was created if (InitNx()) glutMainLoop(); return 0; }
void main(int argc, char **argv) { // init glut glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_MULTISAMPLE); // create the window glutCreateWindow("PQP Demo - Falling"); // set OpenGL graphics state -- material props, perspective, etc. init_viewer_window(); // set the callbacks glutDisplayFunc(cb_display); glutMouseFunc(cb_mouse); glutMotionFunc(cb_motion); glutKeyboardFunc(cb_keyboard); glutIdleFunc(cb_idle); // create models FILE *fp; int ntris, i; double a,b,c; PQP_REAL p1[3],p2[3],p3[3]; // model 1 torus1_drawn = new Model("torus1.tris"); torus1_tested = new PQP_Model(); fp = fopen("torus1.tris","r"); fscanf(fp,"%d",&ntris); torus1_tested->BeginModel(); for (i = 0; i < ntris; i++) { fscanf(fp,"%lf %lf %lf",&a,&b,&c); p1[0] = (PQP_REAL)a; p1[1] = (PQP_REAL)b; p1[2] = (PQP_REAL)c; fscanf(fp,"%lf %lf %lf",&a,&b,&c); p2[0] = (PQP_REAL)a; p2[1] = (PQP_REAL)b; p2[2] = (PQP_REAL)c; fscanf(fp,"%lf %lf %lf",&a,&b,&c); p3[0] = (PQP_REAL)a; p3[1] = (PQP_REAL)b; p3[2] = (PQP_REAL)c; torus1_tested->AddTri(p1,p2,p3,i); } torus1_tested->EndModel(); fclose(fp); // model 2 torus2_drawn = new Model("torus2.tris"); torus2_tested = new PQP_Model(); fp = fopen("torus2.tris","r"); fscanf(fp,"%d",&ntris); torus2_tested->BeginModel(); for (i = 0; i < ntris; i++) { fscanf(fp,"%lf %lf %lf",&a,&b,&c); p1[0] = (PQP_REAL)a; p1[1] = (PQP_REAL)b; p1[2] = (PQP_REAL)c; fscanf(fp,"%lf %lf %lf",&a,&b,&c); p2[0] = (PQP_REAL)a; p2[1] = (PQP_REAL)b; p2[2] = (PQP_REAL)c; fscanf(fp,"%lf %lf %lf",&a,&b,&c); p3[0] = (PQP_REAL)a; p3[1] = (PQP_REAL)b; p3[2] = (PQP_REAL)c; torus2_tested->AddTri(p1,p2,p3,i); } torus2_tested->EndModel(); fclose(fp); // load paths LoadPath(R1,T1,"torus1.path"); LoadPath(R2,T2,"torus2.path"); // print instructions printf("PQP Demo - Falling:\n" "Press:\n" "0 - no proximity query, just animation\n" "1 - collision query\n" " overlapping triangles shown in red.\n" "2 - distance query\n" " closest points connected by a line.\n" "3 - tolerance query\n" " reduce/increase tolerance with -/= keys.\n" " models turn blue when closer than the tolerance.\n" "any other key to toggle animation on/off\n"); // Enter the main loop. glutMainLoop(); }
__NS_GLK_END int main(int argc, char* argv[]) { // gltSetWorkingDirectory(argv[0]); #ifdef __USE_GLFW_MM__ #else glutInit(&argc, argv); #endif glk::GLContext *_context = glk::GLContext::getInstance(); GLMainEntrySetting(_context); #ifdef __USE_GLFW_MM__ glfwInit(); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); Size _size = _context->getWinSize(); GLFWwindow* window = glfwCreateWindow(_size.width, _size.height, "Learn-OpenGL", nullptr, nullptr); if ( ! window ) { printf("Failed to create GLFW window\n"); glfwTerminate(); return -1; } glfwMakeContextCurrent(window); glfwSetKeyCallback(window, key_callback); int width, height; glfwGetFramebufferSize(window, &width, &height); #else glutInitDisplayMode(_context->displayMode); glutInitWindowSize((int)_context->winSize.width,(int)_context->winSize.height); glutInitWindowPosition((int)_context->winPosition.x,(int)_context->winPosition.y); glutCreateWindow("FPS: 0"); glutReshapeFunc(glk::_static_onChangeSize); glutDisplayFunc(glk::_static_OnDraw); //鼠标按下释放事件 glutMouseFunc(glk::_static_mousePressCallback); glutMotionFunc(glk::_static_mouseMotionCallback); //键盘事件 glutKeyboardFunc(glk::_static_keyPressCallback); glutKeyboardUpFunc(glk::_static_keyReleaseCallback); glutSpecialFunc(glk::_static_keySpecialPressCallback); glutSpecialUpFunc(glk::_static_keySpecialReleaseCallback); #endif glewExperimental = GL_TRUE; GLenum err = glewInit(); if (GLEW_OK != err) { fprintf(stderr, "GLEW Error: %s\n", glewGetErrorString(err)); return 1; } #ifdef __USE_GLFW_MM__ glViewport(0, 0, width, height); #endif //init函数必须实现,必须调用初始化函数 _context->init(_context); #ifdef __USE_GLFW_MM__ float _origin_time = glfwGetTime(); glBindVertexArray(0); while (!glfwWindowShouldClose(window)) { float _now_time = glfwGetTime(); float _elapse_time = _now_time - _origin_time; _origin_time = _now_time; glfwPollEvents(); _context->update(_context,_elapse_time); _context->draw(_context); glfwSwapBuffers(window); } #else glutTimerFunc(34, glk::_static_OnUpdate, 0); glutMainLoop(); #endif if (_context->finalize)//程序退出时的清理 _context->finalize(_context); if (_context->userObject)//释放申请的内存 free(_context->userObject); glk::GLCacheManager::getInstance()->~GLCacheManager(); glk::EventManager::getInstance()->~EventManager(); #ifdef __USE_GLFW_MM__ glfwTerminate(); return 0; #endif return 0; }
main(int argc, char *argv[]) { GLUquadric *quad; glutInit(&argc, argv); glutInitWindowSize(winWidth, winHeight); glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_DOUBLE); (void)glutCreateWindow("locate"); glutDisplayFunc(redraw); glutReshapeFunc(reshape); glutMouseFunc(mouse); glutMotionFunc(motion); glutKeyboardFunc(key); create_menu(); glClearColor(0.0f, 0.3f, 0.0f, 0.f); /* draw a perspective scene */ glMatrixMode(GL_PROJECTION); glFrustum(-100., 100., -100., 100., 300., 600.); glMatrixMode(GL_MODELVIEW); /* look at scene from (0, 0, 450) */ gluLookAt(0., 0., 450., 0., 0., 0., 0., 1., 0.); { int i; float mat[16]; glGetFloatv(GL_MODELVIEW_MATRIX, mat); for(i = 0; i < 4; i++) printf("%f %f %f %f\n", mat[4*i+0], mat[4*i+1], mat[4*i+2], mat[4*i+3]); } glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_COLOR_MATERIAL); glCullFace(GL_BACK); glReadBuffer(GL_BACK); glDisable(GL_DITHER); CHECK_ERROR("end of main"); glNewList(1, GL_COMPILE); glutSolidCube(50.f); glEndList(); glNewList(2, GL_COMPILE); glutSolidTeapot(50.f); glEndList(); quad = gluNewQuadric(); gluQuadricTexture(quad, GL_TRUE); glNewList(3, GL_COMPILE); gluSphere(quad, 70., 20, 20); glEndList(); gluDeleteQuadric(quad); glNewList(4, GL_COMPILE); glutSolidTorus(20, 50, 20, 20); glEndList(); glNewList(5, GL_COMPILE); glPushMatrix(); glTranslatef(0.f, -80.f, 0.f); cylinder(40, 3, 20, 160); glTranslatef(0.f, 20.f, 0.f); cylinder(40, 3, 60, 20); glTranslatef(0.f, 20.f, 0.f); cylinder(40, 3, 30, 20); glTranslatef(0.f, 60.f, 0.f); cylinder(40, 3, 30, 20); glTranslatef(0.f, 20.f, 0.f); cylinder(40, 3, 60, 20); glPopMatrix(); glEndList(); glNewList(6, GL_COMPILE); glPushMatrix(); glTranslatef(0.f, -80.f, 0.f); cylinder(40, 3, 80, 160); glPopMatrix(); glEndList(); maxobject = 6; { GLubyte* tex; int texwid, texht, texcomps; tex = (GLubyte*)read_texture("../../data/spheremap.rgb", &texwid, &texht, &texcomps); glBindTexture(GL_TEXTURE_2D, 1); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, texwid, texht, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); free(tex); } { GLubyte tex2[1024]; int i; for(i = 0; i < 1024; i++) { if ((i/10)&1) tex2[i] = 0; else tex2[i] = 255; } glBindTexture(GL_TEXTURE_2D, 2); glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 1024, 1, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, tex2); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); } glutMainLoop(); return 0; }
//--Main int main(int argc, char **argv) { //set config data simConfig.setWindow(480, 640); // Initialize glut glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowSize( simConfig.getWindowWidth(), simConfig.getWindowHeight()); glutInitWindowPosition( 100, 100); // Name and create the Window glutCreateWindow("Matrix Example"); // Now that the window is created the GL context is fully set up // Because of that we can now initialize GLEW to prepare work with shaders GLenum status = glewInit(); if( status != GLEW_OK) { std::cerr << "[F] GLEW NOT INITIALIZED: "; std::cerr << glewGetErrorString(status) << std::endl; return -1; } // Set all of the callbacks to GLUT that we need //glutSetKeyRepeat(GLUT_KEY_REPEAT_OFF); //disable key spamming for now glutDisplayFunc(render);// Called when its time to display glutReshapeFunc(reshape);// Called if the window is resized glutIdleFunc(update);// Called if there is nothing else to do glutMouseFunc(mouse);// Called if there is mouse input glutKeyboardFunc(keyboard);// Called if there is keyboard input glutSpecialFunc(keyboardPlus);// for stuff without ascii access characters like arrow keys //setup inputs menuID = glutCreateMenu(menu_test); glutAddMenuEntry("quit", 1); glutAddMenuEntry("start rotation", 2); glutAddMenuEntry("stop rotation", 3); glutAttachMenu(GLUT_RIGHT_BUTTON); //misc setup simEntities.simConfig = &simConfig; // Initialize all of our resources(config, geometry) bool init = initialize(); //load model data simEntities.loadData("../bin/data/planet_data.dat"); //run our shader loader now init = init && simShaderManager.loadShaders(argc,argv); //call some other resources to initialize after the shader, separately init = init && postInitialize(); if(init) { t1 = std::chrono::high_resolution_clock::now(); glutMainLoop(); } // Clean up after ourselves cleanUp(); return 0; }
int main(int argc, char **argv) { // GLUT initialization glutInit(&argc, argv); glutInitDisplayMode(GLUT_DEPTH|GLUT_DOUBLE|GLUT_RGBA|GLUT_MULTISAMPLE); glutInitContextVersion (3, 3); glutInitContextFlags (GLUT_COMPATIBILITY_PROFILE ); glutInitWindowPosition(100,100); glutInitWindowSize(320,320); glutCreateWindow("Lighthouse3D - Assimp Demo"); // Callback Registration glutDisplayFunc(renderScene); glutReshapeFunc(changeSize); glutIdleFunc(renderScene); // Mouse and Keyboard Callbacks glutKeyboardFunc(processKeys); glutMouseFunc(processMouseButtons); glutMotionFunc(processMouseMotion); glutMouseWheelFunc ( mouseWheel ) ; // Init GLEW //glewExperimental = GL_TRUE; glewInit(); if (glewIsSupported("GL_VERSION_3_3")) printf("Ready for OpenGL 3.3\n"); else { printf("OpenGL 3.3 not supported\n"); return(1); } // Init the app (load model and textures) and OpenGL if (!init()) printf("Could not Load the Model\n"); printf ("Vendor: %s\n", glGetString (GL_VENDOR)); printf ("Renderer: %s\n", glGetString (GL_RENDERER)); printf ("Version: %s\n", glGetString (GL_VERSION)); printf ("GLSL: %s\n", glGetString (GL_SHADING_LANGUAGE_VERSION)); // return from main loop glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); // GLUT main loop glutMainLoop(); // cleaning up textureIdMap.clear(); // clear myMeshes stuff for (unsigned int i = 0; i < myMeshes.size(); ++i) { glDeleteVertexArrays(1,&(myMeshes[i].vao)); glDeleteTextures(1,&(myMeshes[i].texIndex)); glDeleteBuffers(1,&(myMeshes[i].uniformBlockIndex)); } // delete buffers glDeleteBuffers(1,&matricesUniBuffer); return(0); }
int main(int argc, char *argv[]) { // inicjalizacja biblioteki GLUT glutInit(&argc, argv); // inicjalizacja bufora ramki glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); // rozmiary głównego okna programu glutInitWindowSize(500, 500); // utworzenie głównego okna programu glutCreateWindow("Zadanie 3"); // dołączenie funkcji generującej scenę 3D glutDisplayFunc(DisplayScene); // dołączenie funkcji wywoływanej przy zmianie rozmiaru okna glutReshapeFunc(Reshape); // dołączenie funkcji obsługi klawiatury glutKeyboardFunc(Keyboard); // obsługa przycisków myszki glutMouseFunc(MouseButton); // obsługa ruchu kursora myszki glutMotionFunc(MouseMotion); // utworzenie podmenu - Planeta int MenuPlanet = glutCreateMenu(Menu); glutAddMenuEntry("Wenus", VENUS_TEX); glutAddMenuEntry("Ziemia", EARTH_TEX); glutAddMenuEntry("Mars", MARS_TEX); glutAddMenuEntry("Jowisz", JUPITER_TEX); // utworzenie podmenu - Filtr pomniejszający int MenuMinFilter = glutCreateMenu(Menu); glutAddMenuEntry("GL_NEAREST_MIPMAP_NEAREST", GL_NEAREST_MIPMAP_NEAREST); glutAddMenuEntry("GL_NEAREST_MIPMAP_LINEAR", GL_NEAREST_MIPMAP_LINEAR); glutAddMenuEntry("GL_LINEAR_MIPMAP_NEAREST", GL_LINEAR_MIPMAP_NEAREST); glutAddMenuEntry("GL_LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR); // utworzenie podmenu - Aspekt obrazu int MenuAspect = glutCreateMenu(Menu); #ifdef WIN32 glutAddMenuEntry("Aspekt obrazu - całe okno", FULL_WINDOW); #else glutAddMenuEntry("Aspekt obrazu - cale okno", FULL_WINDOW); #endif glutAddMenuEntry("Aspekt obrazu 1:1", ASPECT_1_1); // menu główne glutCreateMenu(Menu); glutAddSubMenu("Planeta", MenuPlanet); #ifdef WIN32 glutAddSubMenu("Filtr pomniejszający", MenuMinFilter); glutAddSubMenu("Aspekt obrazu", MenuAspect); glutAddMenuEntry("Wyjście", EXIT); #else glutAddSubMenu("Filtr pomniejszajacy", MenuMinFilter); glutAddSubMenu("Aspekt obrazu", MenuAspect); glutAddMenuEntry("Wyjscie", EXIT); #endif // określenie przycisku myszki obsługującego menu podręczne glutAttachMenu(GLUT_RIGHT_BUTTON); // utworzenie tekstur GenerateTextures(); // sprawdzenie i przygotowanie obsługi wybranych rozszerzeñ ExtensionSetup(); // wprowadzenie programu do obsługi pętli komunikatów glutMainLoop(); return 0; }
int main(int argc, char *argv[]) { double pos; VideoState *is; if(argc < 2) { fprintf(stderr, "Usage: test <file>\n"); exit(1); } #ifdef __MINGW32__ ptw32_processInitialize(); //ptw32_processTerminate(); #endif //XInitThreads(); is = (VideoState *)av_mallocz(sizeof(VideoState)); avcodec_register_all(); //avdevice_register_all(); avfilter_register_all(); av_register_all(); avformat_network_init(); if (USE_EVENT_MULTI_THREAD) { if ( SDLMOD_StartEventLoop(SDLMOD_INIT_EVENTTHREAD) < 0 ) { fprintf(stderr, "Could not start SDLMOD event loop (multi thread)\n"); exit(1); } } else { if ( SDLMOD_StartEventLoop(0) < 0 ) { fprintf(stderr, "Could not start SDLMOD event loop (main thread)\n"); exit(1); } } if (SDLMOD_TimerInit() != 0) { fprintf(stderr, "SDLMOD_TimerInit failed\n"); exit(1); } g_video_width = 640; g_video_height = 480; g_video_resized = 0; //screen = SDL_SetVideoMode(g_video_width, g_video_height, SDL_VIDEO_MODE_BPP, SDL_VIDEO_MODE_FLAGS); screen = SDLMOD_CreateRGBSurface(0, g_video_width, g_video_height, SDL_VIDEO_MODE_BPP, Rmask, Gmask, Bmask, Amask ); if(!screen) { fprintf(stderr, "SDL: could not set video mode - exiting\n"); exit(1); } screen_mutex = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t)); pthread_mutex_init(screen_mutex, NULL); av_strlcpy(is->filename, argv[1], sizeof(is->filename)); is->pictq_mutex = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t)); pthread_mutex_init(is->pictq_mutex, NULL); is->pictq_cond = (pthread_cond_t *)malloc(sizeof(pthread_cond_t)); pthread_cond_init(is->pictq_cond, NULL); schedule_refresh(is, 40); is->av_sync_type = AV_SYNC_VIDEO_MASTER; { int err; is->parse_tid = (pthread_t *)malloc(sizeof(pthread_t)); err = pthread_create(is->parse_tid, NULL, decodeThread, is); if (err!=0) { free(is->parse_tid); printf("can't create thread: %s\n", strerror(err)); exit(0); } } if (!is->parse_tid) { av_free(is); return -1; } av_init_packet(&flush_pkt); flush_pkt.data = (uint8_t*)"FLUSH"; #if USE_EVENT_LOOP_MT { pthread_t pid; pthread_create(&pid, NULL, event_loop, is); if (0) { pthread_join(pid, NULL); } else { #if USE_GL glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH); glutInitWindowSize(g_video_width, g_video_height); glutInitWindowPosition(0, 0); win = glutCreateWindow(TITLE); createMenu(); glutDisplayFunc(display); glutReshapeFunc(reshape); glutMouseFunc(mouse); glutMotionFunc(motion); glutIdleFunc(idle); if (initEnvironment()) { glutMainLoop(); } #else printf(">>>>>>Please input command (exit, quit, save):<<<<<<\n"); char string[256]; char* ret; while(1) { ret = gets(string); if (strcmp(string, "exit") == 0 || strcmp(string, "quit") == 0 || strcmp(string, "e") == 0 || strcmp(string, "q") == 0 ) { break; } else if (strcmp(string, "save") == 0 || strcmp(string, "s") == 0 ) { save_bmp(); printf("save_bmp() finish.\n"); } else { printf("Please input command (exit, quit, save):\n"); } } #endif } } #else event_loop(is); #endif return 0; }
/** * The entry point of the application. * * @param argc The number of command line arguments * @param argv The array of command line arguments * @return A status code */ int main(int argc, char **argv) { delay = 20; glutInit(&argc, argv); window = createWindow("Stage", 640, 480, 0, 0); glutDisplayFunc(display); glutMouseFunc(mouse); glutKeyboardFunc(keyboard); glutSpecialFunc(keySpecial); glutTimerFunc(delay, timer, 0); char* testImages[] = {"/raws/exit_2704.raw", "/raws/plain_wall.raw", "/raws/left_hallways_floor.raw", "/raws/plain_wall.raw", "/raws/plain_wall.raw", "/raws/ceiling.raw"}; CubeFactory factory; Model model; BaseCube middle; vector<Cube> cubes; vector<Hallway*> hallways; Cube nTelasRoom, nTelasRoomHallway; CubeProperties properties; GLfloat startingAngles[3]; Hallway *jmuFront, *jmuBack, *jmuRight, *jmuLeft, *jmuMiddle; Position position; startingAngles[0] = 0; startingAngles[1] = 0; startingAngles[2] = 0; properties = CubeProperties(); factory = CubeFactory(); /***Front Hallway ***/ startingAngles[1] = 90; properties.setCubeVertices(10, 10, 10); properties.setImages(FRONTH); cubes = factory.createUniformCubes(-120, 0, 45, 13, startingAngles, properties, 20, 0,0); jmuFront = new JmuFrontHallway(cubes); hallways.push_back(jmuFront); /***Back Hallway ***/ startingAngles[1] = -90; properties.setImages(BACKH); cubes = factory.createUniformCubes(-120, 0, -195, 13, startingAngles, properties, 20,0,0); jmuBack = new JmuBackHallway(cubes); hallways.push_back(jmuBack); startingAngles[1] = 0; /***Left Hallway ***/ properties.setImages(LEFTH); cubes = factory.createUniformCubes(-120, 0, 45, 13, startingAngles, properties, 0,0,-20); jmuLeft = new JmuLeftHallway(cubes); hallways.push_back(jmuLeft); /***Right Hallway ***/ properties.setImages(RIGHTH); cubes = factory.createUniformCubes(120, 0, 45, 13, startingAngles, properties, 0,0,-20); jmuRight = new JmuRightHallway(cubes); hallways.push_back(jmuRight); /***Middle Hallway ***/ properties.setCubeVertices(30, 10, 10); properties.setImages(MIDDLEH); cubes = factory.createUniformCubes(0, 0, 45, 13, startingAngles, properties, 0,0,-20); jmuMiddle = new JmuMiddleHallway(cubes); hallways.push_back(jmuMiddle); middle = BaseCube(0, 0, 55, 10.0); model = Model(hallways, middle, startingAngles); stage.addSprite(&model); stage.start(); return 0; }
int main(int argc, char **argv) { int i; if (argc > 1) { /* make sure at least 2 args, program and file */ strncpy(filename, argv[argc - 1], sizeof(filename)); /* get the last arg as the file always */ for (i = 0; i < argc; i++) { /* check for startup params */ if (strstr(argv[i], "-s")) stereo = 1; if (strstr(argv[i], "-f")) full_screen = 1; } } else { /* user only entered program name, help them */ printf("Usage: %s [-s] [-f] <obj filename>\n", argv[0]); exit(0); } glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize(1024, 768); /* Window Size If We Start In Windowed Mode */ glutCreateWindow("Wavefront Obj File Viewer"); if (full_screen) glutFullScreen(); glutDisplayFunc(Display); glutKeyboardFunc(Keyboard); getMatrix(); glClearColor(0.0, 0.0, 0.0, 0.0); glClearAccum(0.0, 0.0, 0.0, 0.0); glutReshapeFunc(Reshape); glutMouseFunc(Mouse); glutMotionFunc(Motion); glutIdleFunc(NULL); glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular); glLightfv(GL_LIGHT0, GL_POSITION, light_position); glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess); if (lighting) glEnable(GL_LIGHTING); if (lighting) glEnable(GL_LIGHT0); glDepthFunc(GL_LESS); glEnable(GL_DEPTH_TEST); glEnable(GL_NORMALIZE); glEnable(GL_TEXTURE_2D); glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); if (!pmodel) { /* load up the model */ pmodel = glmReadOBJ(filename); if (!pmodel) { printf("\nUsage: objviewV2 <-s> <obj filename>\n"); exit(0); } glmUnitize(pmodel); glmVertexNormals(pmodel, 90.0, GL_TRUE); } glutMainLoop(); return 0; }
int main (int argc, char **argv) { /* **************************************************************************************************************************** */ /* Pointeurs vers l'application */ glutInit(&argc, argv); /* Activation des buffers : Double buffer RGBA color Depth buffer */ glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH); /* Création de la fenêtre */ glutInitWindowSize(1024, 768); /* Positionnement de la fenêtre */ glutInitWindowPosition(100, 100); /* Ouverture de la fenêtre */ glutCreateWindow("TD_Animation_3D"); /* Spécification de la fontion de dessin */ glutDisplayFunc(display); /* Spécification de la fontion de redimensionnement */ glutReshapeFunc(reshape); /* Spécification des fontions de gestion du clavier */ glutKeyboardFunc(keyboardDown); glutKeyboardUpFunc(keyboardUp); glutSpecialFunc(keyboardSpecDown); glutSpecialUpFunc(keyboardSpecUp); /* Spécification des fontions de gestion de la souris */ glutMouseFunc(mouse); glutMotionFunc(motion); /* Spécification de la fonction de mise-à-jour */ glutIdleFunc(timeTick); /* **************************************************************************************************************************** */ /* Affichage des fonctions clavier */ HelpMessage(); /* **************************************************************************************************************************** */ /* Intitialisation des paramètres de l'affichage et de la fenêtre */ GLInit(); /* Intitialisation des paramètres du squelette */ SkeletInit(); /* Intitialisation de la scène cinématique */ IKInit(); /* **************************************************************************************************************************** */ /* Lancement de la boucle OpenGL */ glutMainLoop(); /* **************************************************************************************************************************** */ return 0; /* **************************************************************************************************************************** */ }
// Initialize GLUT & OpenSG and set up the scene int main (int argc, char **argv) { int i; float ca=-1,cb=-1,cc=-1; // OSG init osgInit(argc,argv); char *filename=NULL; // GLUT init glutInit(&argc, argv); glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE); int winid = glutCreateWindow("OpenSG"); glutReshapeFunc(reshape); glutDisplayFunc(display); glutMouseFunc(mouse); glutMotionFunc(motion); glutKeyboardFunc(key); // the connection between GLUT and OpenSG GLUTWindowPtr gwin= GLUTWindow::create(); gwin->setId(winid); gwin->init(); // create the scene float x,y,z; scene = Node::create(); beginEditCP(scene); scene->setCore(Group::create()); endEditCP(scene); NodePtr file; for(i=1;i<argc;++i) { if(argv[i][0] =='-') { switch(argv[i][1]) { case 'd': useFaceDistribution=true; break; case 'v': viewVolume=true; break; case 's': serverCount=atoi(&argv[i][2]); break; case 'l': loop=atoi(&argv[i][2]); break; case 'S': simulateRendering=true; break; } } else { if(argv[i][0] >='0' && argv[i][0] <='9') { if(ca==-1) ca=atoi(argv[i]); else if(cb==-1) cb=atoi(argv[i]); else if(cc==-1) cc=atoi(argv[i]); } else { filename=argv[1]; } } } if(ca == -1 && filename) { file = OSG::SceneFileHandler::the().read(filename); beginEditCP(scene); scene->addChild(file); endEditCP(scene); } else { if(ca==-1) ca=4; if(cb==-1) cb=ca; if(cc==-1) cc=cb; if(file == NullFC) { GeometryPtr geo=makeBoxGeo(.6,.6,.6,20,20,20); beginEditCP(geo); SimpleMaterialPtr mat=SimpleMaterial::create(); beginEditCP(mat); mat->setAmbient(Color3f(.4,.4,.4)); mat->setSpecular(Color3f(0,0,0)); mat->setDiffuse(Color3f(1,1,1)); endEditCP(mat); geo->setMaterial(mat); endEditCP(geo); NodePtr node; NodePtr geoNode; TransformPtr trans; for(x=-ca/2 ; x<ca/2 ; x++) for(y=-cb/2 ; y<cb/2 ; y++) for(z=-cc/2 ; z<cc/2 ; z++) { trans=Transform::create(); node=Node::create(); geoNode=Node::create(); beginEditCP(geoNode); beginEditCP(trans); beginEditCP(node); node->setCore(trans); trans->getMatrix().setTranslate(x,y,z); if(!filename) { geoNode=Node::create(); geoNode->setCore(geo); } else { geoNode = OSG::SceneFileHandler::the().read(filename); } node->addChild( geoNode ); beginEditCP(scene); scene->addChild(node); endEditCP(geoNode); endEditCP(scene); endEditCP(trans); endEditCP(node); } } } // create the SimpleSceneManager helper mgr = new MySceneManager; mgr->setWindow( gwin ); mgr->setRoot( scene ); mgr->showAll(); // GLUT main loop if(loop) glutIdleFunc(display); // glutReshapeWindow(720,576); glutReshapeWindow(1152,864); glutMainLoop(); return 0; }
int main(int argc, char **argv) { static GLfloat lightpos[] = {25.f, 50.f, -50.f, 1.f}; static GLfloat sphere_mat[] = {1.f, .5f, 0.f, 1.f}; static GLfloat cone_mat[] = {0.f, .5f, 1.f, 1.f}; GLUquadricObj *sphere, *cone, *base; glutInit(&argc, argv); glutInitWindowSize(512, 512); glutInitDisplayMode(GLUT_STENCIL | GLUT_DEPTH | GLUT_DOUBLE); (void) glutCreateWindow("csg"); glutDisplayFunc(redraw); glutKeyboardFunc(key); glutSpecialFunc(special); glutMouseFunc(mouse); glutMotionFunc(motion); glutCreateMenu(menu); glutAddMenuEntry("A only", CSG_A); glutAddMenuEntry("B only", CSG_B); glutAddMenuEntry("A or B", CSG_A_OR_B); glutAddMenuEntry("A and B", CSG_A_AND_B); glutAddMenuEntry("A sub B", CSG_A_SUB_B); glutAddMenuEntry("B sub A", CSG_B_SUB_A); glutAttachMenu(GLUT_RIGHT_BUTTON); glEnable(GL_CULL_FACE); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glLightfv(GL_LIGHT0, GL_POSITION, lightpos); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); /* make display lists for sphere and cone; for efficiency */ glNewList(SPHERE, GL_COMPILE); sphere = gluNewQuadric(); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, sphere_mat); gluSphere(sphere, 20.f, 64, 64); gluDeleteQuadric(sphere); glEndList(); glNewList(CONE, GL_COMPILE); cone = gluNewQuadric(); base = gluNewQuadric(); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, cone_mat); gluQuadricOrientation(base, GLU_INSIDE); gluDisk(base, 0., 15., 64, 1); gluCylinder(cone, 15., 0., 60., 64, 64); gluDeleteQuadric(cone); gluDeleteQuadric(base); glEndList(); glMatrixMode(GL_PROJECTION); glOrtho(-50., 50., -50., 50., -50., 50.); glMatrixMode(GL_MODELVIEW); glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }
//////////////////////////////////////////////////////////////////////////////// // Program main //////////////////////////////////////////////////////////////////////////////// int main(int argc, char **argv) { #if defined(__linux__) setenv ("DISPLAY", ":0", 0); #endif printf("%s Starting...\n\n", sSDKsample); numParticles = NUM_PARTICLES; uint gridDim = GRID_SIZE; numIterations = 0; if (argc > 1) { if (checkCmdLineFlag(argc, (const char **) argv, "n")) { numParticles = getCmdLineArgumentInt(argc, (const char **)argv, "n"); } if (checkCmdLineFlag(argc, (const char **) argv, "grid")) { gridDim = getCmdLineArgumentInt(argc, (const char **) argv, "grid"); } if (checkCmdLineFlag(argc, (const char **)argv, "file")) { getCmdLineArgumentString(argc, (const char **)argv, "file", &g_refFile); fpsLimit = frameCheckNumber; numIterations = 1; } } gridSize.x = gridSize.y = gridSize.z = gridDim; printf("grid: %d x %d x %d = %d cells\n", gridSize.x, gridSize.y, gridSize.z, gridSize.x*gridSize.y*gridSize.z); printf("particles: %d\n", numParticles); bool benchmark = checkCmdLineFlag(argc, (const char **) argv, "benchmark") != 0; if (checkCmdLineFlag(argc, (const char **) argv, "i")) { numIterations = getCmdLineArgumentInt(argc, (const char **) argv, "i"); } if (g_refFile) { cudaInit(argc, argv); } else { if (checkCmdLineFlag(argc, (const char **)argv, "device")) { printf("[%s]\n", argv[0]); printf(" Does not explicitly support -device=n in OpenGL mode\n"); printf(" To use -device=n, the sample must be running w/o OpenGL\n\n"); printf(" > %s -device=n -file=<*.bin>\n", argv[0]); printf("exiting...\n"); exit(EXIT_SUCCESS); } initGL(&argc, argv); cudaGLInit(argc, argv); } initParticleSystem(numParticles, gridSize, g_refFile==NULL); initParams(); if (!g_refFile) { initMenus(); } if (benchmark || g_refFile) { if (numIterations <= 0) { numIterations = 300; } runBenchmark(numIterations, argv[0]); } else { glutDisplayFunc(display); glutReshapeFunc(reshape); glutMouseFunc(mouse); glutMotionFunc(motion); glutKeyboardFunc(key); glutSpecialFunc(special); glutIdleFunc(idle); glutCloseFunc(cleanup); glutMainLoop(); } if (psystem) { delete psystem; } // cudaDeviceReset causes the driver to clean up all state. While // not mandatory in normal operation, it is good practice. It is also // needed to ensure correct operation when the application is being // profiled. Calling cudaDeviceReset causes all profile data to be // flushed before the application exits cudaDeviceReset(); exit(g_TotalErrors > 0 ? EXIT_FAILURE : EXIT_SUCCESS); }
// Main int main(int argc, char *argv[]) { glutInit( &argc, argv ); glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH ); glutInitWindowSize( 800, 600 ); glutCreateWindow( "Font rendering advanced tweaking" ); glutCreateMenu( NULL ); #ifndef __APPLE__ GLenum err = glewInit(); if (GLEW_OK != err) { /* Problem: glewInit failed, something is seriously wrong. */ fprintf( stderr, "Error: %s\n", glewGetErrorString(err) ); exit( EXIT_FAILURE ); } fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) ); #endif glutDisplayFunc( display ); glutReshapeFunc( reshape ); atexit( terminate ); TwInit( TW_OPENGL, NULL ); glutMouseFunc( (GLUTmousebuttonfun)TwEventMouseButtonGLUT ); glutMotionFunc( (GLUTmousemotionfun)TwEventMouseMotionGLUT ); glutPassiveMotionFunc( (GLUTmousemotionfun)TwEventMouseMotionGLUT ); glutKeyboardFunc( (GLUTkeyboardfun)TwEventKeyboardGLUT ); glutSpecialFunc( (GLUTspecialfun)TwEventSpecialGLUT ); TwGLUTModifiersFunc( glutGetModifiers ); // Create a new tweak bar bar = TwNewBar("TweakBar"); TwDefine("GLOBAL " "help = 'This example shows how to tune all font parameters.' "); TwDefine("TweakBar " "size = '280 400' " "position = '500 20' " "color = '127 127 127' " "alpha = 240 " "label = 'Parameters' " "resizable = True " "fontresizable = True " "iconifiable = True "); { TwEnumVal familyEV[NUM_FONTS] = { {VERA, "Vera"}, {VERA_MONO, "Vera Mono"}, {LUCKIEST_GUY, "Luckiest Guy"}, {SOURCE_SANS, "Source Sans Pro"}, {SOURCE_CODE, "Source Code Pro"}, {OLD_STANDARD, "Old Standard TT"}, {LOBSTER, "Lobster"} }; TwType family_type = TwDefineEnum("Family", familyEV, NUM_FONTS); TwAddVarCB(bar, "Family", family_type, set_family, get_family, NULL, "label = 'Family' " "group = 'Font' " "help = ' ' "); } TwAddVarCB(bar, "Size", TW_TYPE_FLOAT, set_size, get_size, NULL, "label = 'Size' " "group = 'Font' " "min = 6.0 " "max = 24.0 " "step = 0.05 " "help = ' ' "); TwAddVarCB(bar, "LCD filtering", TW_TYPE_BOOL32, set_lcd_filtering, get_lcd_filtering, NULL, "label = 'LCD filtering' " "group = 'Font' " "help = ' ' "); // Rendering TwAddVarCB(bar, "Kerning", TW_TYPE_BOOL32, set_kerning, get_kerning, NULL, "label = 'Kerning' " "group = 'Rendering' " "help = ' ' "); TwAddVarCB(bar, "Hinting", TW_TYPE_BOOL32, set_hinting, get_hinting, NULL, "label = 'Hinting' " "group = 'Rendering' " "help = ' ' "); // Color TwAddVarCB(bar, "Invert", TW_TYPE_BOOL32, set_invert, get_invert, NULL, "label = 'Invert' " "group = 'Color' " "help = ' ' "); // Glyph TwAddVarCB(bar, "Width", TW_TYPE_FLOAT, set_width, get_width, NULL, "label = 'Width' " "group = 'Glyph' " "min = 0.75 " "max = 1.25 " "step = 0.01 " "help = ' ' "); TwAddVarCB(bar, "Interval", TW_TYPE_FLOAT, set_interval, get_interval, NULL, "label = 'Spacing' " "group = 'Glyph' " "min = -0.2 " "max = 0.2 " "step = 0.01 " "help = ' ' " ); TwAddVarCB(bar, "Faux italic", TW_TYPE_FLOAT, set_faux_italic, get_faux_italic, NULL, "label = 'Faux italic' " "group = 'Glyph' " "min = -30.0 " "max = 30.0 " "step = 0.1 " "help = ' ' "); // Energy distribution TwAddVarCB(bar, "Primary", TW_TYPE_FLOAT, set_primary, get_primary, NULL, "label = 'Primary weight' " "group = 'Energy distribution' " "min = 0 " "max = 1 " "step = 0.01 " "help = ' ' " ); TwAddVarCB(bar, "Secondary", TW_TYPE_FLOAT, set_secondary, get_secondary, NULL, "label = 'Secondy weight' " "group = 'Energy distribution' " "min = 0 " "max = 1 " "step = 0.01 " "help = ' ' " ); TwAddVarCB(bar, "Tertiary", TW_TYPE_FLOAT, set_tertiary, get_tertiary, NULL, "label = 'Tertiary weight' " "group = 'Energy distribution' " "min = 0 " "max = 1 " "step = 0.01 " "help = ' ' " ); TwAddSeparator(bar, "", "group = 'Energy distribution' " ); TwAddVarCB(bar, "Gamma", TW_TYPE_FLOAT, set_gamma, get_gamma, NULL, "label = 'Gamma correction' " "group = 'Energy distribution' " "min = 0.50 " "max = 2.5 " "step = 0.01 " "help = ' ' "); TwAddSeparator(bar, "", ""); TwAddButton(bar, "Reset", (TwButtonCallback) reset, NULL, "help='Reset all parameters to default values.'"); TwAddSeparator(bar, "", ""); TwAddButton(bar, "Quit", (TwButtonCallback) quit, NULL, "help='Quit.'"); buffer_a = text_buffer_new( 1 ); buffer_rgb = text_buffer_new( 3 ); buffer = buffer_rgb; reset(); glutTimerFunc( 1000.0/60.0, timer, 60 ); mat4_set_identity( &projection ); mat4_set_identity( &model ); mat4_set_identity( &view ); glutMainLoop(); return EXIT_SUCCESS; }
int doMain(int argc,char **argv) { int i; char *opt; std::vector<std::string> filenames; std::vector<std::string> servers; std::string connectionType = "StreamSock"; std::string connectionParameters; int rows=1; int cols=-1; char type='M'; bool clientRendering=true; bool compose=false; std::string composerType=""; std::string autostart; for(i=1;i<argc;i++) { if(strlen(argv[i])>1 && argv[i][0]=='-') { switch(argv[i][1]) { case 'o': opt = argv[i][2] ? argv[i]+2 : argv[++i]; connectionParameters = opt; printf("connectionParameters: '%s'\n", connectionParameters.c_str()); break; case 'A': opt = argv[i][2] ? argv[i]+2 : argv[++i]; autostart = opt; break; case 'D': opt = argv[i][2] ? argv[i]+2 : argv[++i]; if(sscanf(opt,"%f,%f,%f",&ca,&cb,&cc)!=3) { std::cout << "Copy opton -D x,y,z" << std::endl; return 1; } break; case 'b': opt = argv[i][2] ? argv[i]+2 : argv[++i]; serviceInterface.assign(opt); serviceInterfaceValid = true; break; case 'B': opt = argv[i][2] ? argv[i]+2 : argv[++i]; serviceAddress.assign(opt); serviceAddressValid = true; break; case 'f': opt = argv[i][2] ? argv[i]+2 : argv[++i]; filenames.push_back(opt); printf("<%s>\n",opt); break; case 'm': connectionType="Multicast"; break; case 'r': opt = argv[i][2] ? argv[i]+2 : argv[++i]; if(sscanf(opt,"%d,%d",&rows,&cols) != 2) sscanf(opt,"%d",&rows); break; case 't': opt = argv[i][2] ? argv[i]+2 : argv[++i]; subtilesize=atoi(opt); break; #ifdef FRAMEINTERLEAVE case 'i': opt = argv[i][2] ? argv[i]+2 : argv[++i]; interleave=atoi(opt); break; #endif case 'C': compose=true; break; case 'F': type='F'; break; case 'X': type='X'; break; case 'P': type='P'; break; case 'L': { type='L'; int lpos=2; while(argv[i][lpos]) { if(argv[i][lpos] == 'B') composerType = "BinarySwapComposer"; if(argv[i][lpos] == 'P') composerType = "PipelineComposer"; if(argv[i][lpos] == 'S') composerType = "SepiaComposer"; if(argv[i][lpos] == 'p') pipelinedBufferRead = true; ++lpos; } break; } case 'M': type='M'; break; case 'I': type='I'; break; case 's': stereoMode=1; break; case 'c': stereoMode=2; break; case 'S': info=true; break; case 'e': opt = argv[i][2] ? argv[i]+2 : argv[++i]; sscanf(opt,"%f",&eyedistance); break; case 'z': opt = argv[i][2] ? argv[i]+2 : argv[++i]; sscanf(opt,"%f",&zeroparallax); break; case 'd': clientRendering=false; break; case 'v': multiport=true; break; case 'x': opt = argv[i][2] ? argv[i]+2 : argv[++i]; sscanf(opt,"%d",&serverx); break; case 'y': opt = argv[i][2] ? argv[i]+2 : argv[++i]; sscanf(opt,"%d",&servery); break; case 'a': opt = argv[i][2] ? argv[i]+2 : argv[++i]; animName=opt; loadAnim(); animate=true; break; case 'l': opt = argv[i][2] ? argv[i]+2 : argv[++i]; if(sscanf(opt,"%d,%d",&animLoops,&animLength) != 2) { animLength = 30; if(sscanf(opt,"%d",&animLoops) != 1) { animLoops = -1; } } break; case 'g': opt = argv[i][2] ? argv[i]+2 : argv[++i]; if(sscanf(opt,"%d,%d,%d,%d", &winwidth,&winheight,&winx,&winy) != 4) sscanf(opt,"%d,%d",&winwidth,&winheight); break; case 'G': opt = argv[i][2] ? argv[i]+2 : argv[++i]; connectionDestination = opt; break; case 'i': opt = argv[i][2] ? argv[i]+2 : argv[++i]; connectionInterface = opt; break; default: std::cout << argv[0] << "-ffile -m -rrows[,cols] -C -M" << std::endl; std::cout << "-m use multicast" << std::endl << "-G multicast group" << std::endl << "-i interface" << std::endl << "-b service interface" << std::endl << "-M multi display" << std::endl #ifdef FRAMEINTERLEAVE << "-I frame interleave" << std::endl #endif << "-r number of display rows" << std::endl << "-C compose" << std::endl << "-F sort-first" << std::endl << "-L sort-last" << std::endl << "-h this msg" << std::endl << "-s stereo" << std::endl << "-c red/cyan stereo" << std::endl << "-e eye distance" << std::endl << "-z zero parallax" << std::endl << "-d disable client rendering"<<std::endl << "-v use two viewports" << std::endl << "-x server x resolution" << std::endl << "-y server y resolution" << std::endl << "-t subtile size for img composition" << std::endl << "-D x,y,z duplicate geometry" << std::endl << "-A Autostart command" << std::endl << "-o connection parameter string e.g. \"TTL=8\"" << std::endl; return 0; } } else { servers.push_back(argv[i]); } } OSG::ChangeList::setReadWriteDefault(true); OSG::osgInit(argc, argv); glutInit(&argc, argv); glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE ); if(winx >=0 && winy >=0) glutInitWindowPosition(winx,winy); glutInitWindowSize(winwidth,winheight); winid = glutCreateWindow("OpenSG Cluster Client"); glutKeyboardFunc(key); glutReshapeFunc(reshape); glutDisplayFunc(display); if(animate) glutIdleFunc(display); glutMouseFunc(mouse); glutMotionFunc(motion); ract = OSG::RenderAction::create(); #ifdef OSG_OLD_RENDER_ACTION ract->setSortTrans(true); ract->setZWriteTrans(true); ract->setLocalLights(true); ract->setCorrectTwoSidedLighting(true); #endif // clear changelist from prototypes OSG::Thread::getCurrentChangeList()->clear(); // create cluster window switch(type) { case 'M': multidisplay=OSG::MultiDisplayWindow::create(); clusterWindow=multidisplay; break; case 'X': balancedmultidisplay=OSG::BalancedMultiWindow::create(); clusterWindow=balancedmultidisplay; break; case 'F': sortfirst=OSG::SortFirstWindow::create(); if(compose) sortfirst->setCompose(true); else sortfirst->setCompose(false); clusterWindow=sortfirst; break; case 'L': sortlast=OSG::SortLastWindow::create(); if(!composerType.empty()) { OSG::FieldContainerUnrecPtr fcPtr = OSG::FieldContainerFactory::the()-> createContainer(composerType.c_str()); OSG::ImageComposer *icPtr = dynamic_cast<OSG::ImageComposer *>(fcPtr.get()); if(icPtr != NULL) { if(dynamic_cast<OSG::PipelineComposer *>(icPtr) != NULL) { if(subtilesize>0) dynamic_cast<OSG::PipelineComposer *>(icPtr)->setTileSize(subtilesize); dynamic_cast<OSG::PipelineComposer *>(icPtr)->setPipelined(pipelinedBufferRead); } if(dynamic_cast<OSG::BinarySwapComposer *>(icPtr) != NULL) { if(subtilesize>0) dynamic_cast<OSG::BinarySwapComposer *>(icPtr)->setTileSize(subtilesize); } icPtr->setStatistics(info); // icPtr->setShort(false); sortlast->setComposer(icPtr); } } clusterWindow=sortlast; break; #ifdef FRAMEINTERLEAVE case 'I': frameinterleave=OSG::FrameInterleaveWindow::create(); clusterWindow=frameinterleave; if(compose) frameinterleave->setCompose(true); else frameinterleave->setCompose(false); break; #endif case 'P': sortfirst=OSG::SortFirstWindow::create(); sortfirst->setCompose(false); clusterWindow=sortfirst; break; } if(!autostart.empty()) clusterWindow->editMFAutostart()->push_back(autostart); for(i=0 ; i<int(servers.size()) ; ++i) clusterWindow->editMFServers()->push_back(servers[i]); if(cols < 0) cols = clusterWindow->getMFServers()->size32() / rows; switch(type) { case 'M': multidisplay->setHServers(cols); multidisplay->setVServers(rows); break; case 'X': balancedmultidisplay->setHServers(cols); balancedmultidisplay->setVServers(rows); // balancedmultidisplay->setShowBalancing(true); // balancedmultidisplay->setShowBalancing(info); break; } #ifdef FRAMEINTERLEAVE clusterWindow->setInterleave(interleave); #endif // create client window clientWindow=OSG::GLUTWindow::create(); // glutReshapeWindow(800,600); glutReshapeWindow(winwidth,winheight); clientWindow->setGlutId(winid); clientWindow->init(); // init scene graph init(filenames); // init client clusterWindow->setConnectionType(connectionType); // needs to be called before init()! clusterWindow->setConnectionParams(connectionParameters); if(clientRendering) { clusterWindow->setClientWindow(clientWindow); } clusterWindow->setConnectionDestination(connectionDestination); clusterWindow->setConnectionInterface(connectionInterface); clusterWindow->init(); if(serverx > 0) clusterWindow->resize(serverx,servery); else clusterWindow->resize(winwidth,winheight); clientWindow->resize(winwidth,winheight); // OSG::FieldContainerFactory::the()->dump(); OSG::commitChanges(); glutMainLoop(); return 0; }
int main(int argc, char **argv) { int i; glutInitWindowSize(600,300); glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE); for (i=1; i<argc; i++) { if(!strcmp("-noms", argv[i])) { glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); printf("forcing no multisampling\n"); } else if(!strcmp("-nomipmaps", argv[i])) { useMipmaps = 0; } else if(!strcmp("-nearest", argv[i])) { linearFiltering = 0; } } glutCreateWindow("sprite blast"); glewInit(); glutReshapeFunc(reshape); glutDisplayFunc(redraw); glutMouseFunc(mouse); glutMotionFunc(mouseMotion); glutVisibilityFunc(visible); glutKeyboardFunc(key); glutCreateMenu(menu); glutAddMenuEntry("Reset time", 0); glutAddMenuEntry("Constant", 1); glutAddMenuEntry("Linear", 2); glutAddMenuEntry("Quadratic", 3); glutAddMenuEntry("Blend on", 4); glutAddMenuEntry("Blend off", 5); glutAddMenuEntry("Threshold 1", 6); glutAddMenuEntry("Threshold 10", 7); glutAddMenuEntry("Point smooth on", 8); glutAddMenuEntry("Point smooth off", 9); glutAddMenuEntry("Point size 16", 10); glutAddMenuEntry("Point size 32", 11); glutAddMenuEntry("Point size 64", 12); glutAddMenuEntry("Toggle spin", 13); glutAddMenuEntry("200 points ", 14); glutAddMenuEntry("500 points ", 15); glutAddMenuEntry("1000 points ", 16); glutAddMenuEntry("2000 points ", 17); glutAddMenuEntry("Quit", 666); glutAttachMenu(GLUT_RIGHT_BUTTON); makePointList(); makeSprite(); glShadeModel(GL_FLAT); glEnable(GL_DEPTH_TEST); glEnable(GL_POINT_SMOOTH); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glPointSize(32.0); #ifdef GL_ARB_point_parameters glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, theQuad); #endif glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }
Window::Window(int x, int y, int w, int h, string title, int speed, double red, double green, double blue, bool read_keypresses_from_standard_input /* = false */ ) { m_x = x; m_y = y; m_w = w; m_h = h; m_title = title; m_read_keypresses_from_standard_input = read_keypresses_from_standard_input; if (speed > 100) speed = 100; if (speed < 1) speed = 1; // This formula sets up the meaning of the speed // Speed is very machine dependent, this may have to be changed // for very fast or very slow machine // special case, low speeds are really slow for debugging if (speed <= 10) clock_tick = (11 - speed) * 1000; else clock_tick = ((103 - speed) * (103 - speed))/10; // glut can be controlled by command line arguments pass to glutInit(). // In order to simplify argument parsing in gpl.cpp, command line // arguments are not passed to glutInit() int phony_argc = 1; char *phony_argv[2]; phony_argv[0] = strdup("gpl"); phony_argv[1] = 0; glutInit(&phony_argc,phony_argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(m_w,m_h); glutInitWindowPosition(m_x,m_y); glutCreateWindow(m_title.c_str()); // if we are suppose to read characters from the command line // (this is a testing/debugging tool) if (m_read_keypresses_from_standard_input) // use an idle function to read the commands glutIdleFunc(read_keypresses_from_standard_input_callback); // redraws all objects if window is changed by windowing system glutReshapeFunc(window_reshape_callback); glutVisibilityFunc(window_visibility_callback); glutDisplayFunc(draw_callback); glutTimerFunc(clock_tick, timer_callback, 0); glutKeyboardFunc(keyboard_callback); glutSpecialFunc(special_callback); glutMouseFunc(mouse_callback); glutMotionFunc(motion_callback); glutPassiveMotionFunc(passive_motion_callback); glViewport(0, 0, m_w, m_h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0, m_w, 0, m_h); glClearColor (red, green, blue, 0.0); }
int main(int argc, char* argv[]) { XnBool bChooseDevice = false; const char* csRecordingName = NULL; if (argc > 1) { if (strcmp(argv[1], "-devices") == 0) { bChooseDevice = TRUE; } else { csRecordingName = argv[1]; } } if (csRecordingName != NULL) { // check if running from a different directory. If so, we need to change directory // to the real one, so that path to INI file will be OK (for log initialization, for example) if (0 != changeDirectory(argv[0])) { return(ERR_DEVICE); } } // Xiron Init XnStatus rc = XN_STATUS_OK; EnumerationErrors errors; if (csRecordingName != NULL) { xnLogInitFromXmlFile(SAMPLE_XML_PATH); rc = openDeviceFile(argv[1]); } else if (bChooseDevice) { rc = openDeviceFromXmlWithChoice(SAMPLE_XML_PATH, errors); } else { rc = openDeviceFromXml(SAMPLE_XML_PATH, errors); } if (rc == XN_STATUS_NO_NODE_PRESENT) { XnChar strError[1024]; errors.ToString(strError, 1024); printf("%s\n", strError); closeSample(ERR_DEVICE); return (rc); } else if (rc != XN_STATUS_OK) { printf("Open failed: %s\n", xnGetStatusString(rc)); closeSample(ERR_DEVICE); } captureInit(); statisticsInit(); //reshaper.zNear = 1; //reshaper.zFar = 100; //glut_add_interactor(&reshaper); //cb.mouse_function = MouseCallback; //cb.motion_function = MotionCallback; //cb.passive_motion_function = MotionCallback; //cb.keyboard_function = KeyboardCallback; //cb.reshape_function = ReshapeCallback; //glut_add_interactor(&cb); glutInit(&argc, argv); glutInitDisplayString("stencil double rgb"); glutInitWindowSize(WIN_SIZE_X, WIN_SIZE_Y); glutCreateWindow("OpenNI Viewer"); //glutFullScreen(); glutSetCursor(GLUT_CURSOR_NONE); glutMouseFunc(MouseCallback); glutMotionFunc(MotionCallback); init_opengl(); glutIdleFunc(IdleCallback); glutDisplayFunc(drawFunctionMain); glutPassiveMotionFunc(MotionCallback); //createKeyboardMap(); //createMenu(); atexit(onExit); //Use built in hand tracker class to handle all hand movements and gestures HandTracker mainHandTracker(g_Context); m_HandTracker = &mainHandTracker; drawInit(m_HandTracker); //mainHandTracker.Init(); //mainHandTracker.Run(); xn::ImageGenerator test; g_Context.FindExistingNode(XN_NODE_TYPE_IMAGE, test); xn::DepthGenerator depth; g_Context.FindExistingNode(XN_NODE_TYPE_DEPTH, depth); depth.GetAlternativeViewPointCap().SetViewPoint(test); glutMainLoop(); return 0; }
int main(int argc, char *argv[]) { // Print a summary of the user-interface. printf("Welcome to the Adaptive Quadtree Meshing demo.\n"); printf("by Thatcher Ulrich <*****@*****.**> Copyright 2000\n\n"); printf("Use the mouse and keyboard to control the program. Here's a summary:\n"); printf(" * mouse-left plus mouse-move rotates the view orientation\n"); printf(" * mouse-right plus mouse-move moves the viewpoint\n"); printf(" * both mouse buttons plus mouse-move moves the viewpoint differently\n"); printf(" * 'w' toggles wireframe mode. Good for checking out the LOD\n"); printf(" * '0'-'9' controls the speed of viewpoint motion\n"); printf(" * 't' toggles texturing (off by default). Please try it\n"); printf(" * 'c' toggles backface culling\n"); printf(" * 'p' fixes the viewpoint at a certain altitude above the terrain\n"); printf(" * 'm' toggles motion mode\n"); printf(" * 'd' runs a 1-second benchmark and displays some performance data\n"); printf(" * '=' increases terrain detail\n"); printf(" * '-' decreases terrain detail\n"); printf("\n"); int i; root = new quadsquare(&RootCornerData); /* // Sample heightmap data. HeightMapInfo hm; hm.XOrigin = 30001; hm.ZOrigin = 30001; hm.XSize = 50; hm.ZSize = 50; hm.RowWidth = hm.XSize; hm.Scale = 0; hm.Data = new float[hm.XSize * hm.ZSize]; int i, j; for (j = 0; j < hm.ZSize; j++) { for (i = 0; i < hm.XSize; i++) { if (i == 0 || j == 0 || i == hm.XSize-1 || j == hm.ZSize - 1) hm.Data[i + j * hm.XSize] = 0; // Force boundary to 0. else hm.Data[i + j * hm.XSize] = sin(i * 0.1) * sin(j * 0.1) * 10; } } // Put some heightmap data in the quadtree. hm.Scale = 0; root->AddHeightMap(RootCornerData, hm); hm.Scale = 2; hm.XOrigin &= ~((1 << hm.Scale) - 1); hm.ZOrigin &= ~((1 << hm.Scale) - 1); root->AddHeightMap(RootCornerData, hm); hm.Scale = 6; hm.XOrigin &= ~((1 << hm.Scale) - 1); hm.ZOrigin &= ~((1 << hm.Scale) - 1); root->AddHeightMap(RootCornerData, hm); */ LoadData(); // Debug info. printf("nodes = %d\n", root->CountNodes()); printf("max error = %g\n", root->RecomputeErrorAndLighting(RootCornerData)); // Get rid of unnecessary nodes in flat-ish areas. printf("Culling unnecessary nodes (detail factor = 25)...\n"); root->StaticCullData(RootCornerData, 25); // Post-cull debug info. printf("nodes = %d\n", root->CountNodes()); printf("max error = %g\n", root->RecomputeErrorAndLighting(RootCornerData)); // Run the update function a few times before we start rendering // to disable unnecessary quadsquares, so the first frame won't // be overloaded with tons of triangles. for (i = 0; i < 10; i++) { root->Update(RootCornerData, (const float*) ViewerLoc, Detail); } // // Set up glut. // glutInit(&argc, argv); glutInitWindowSize(640, 480); glutInitWindowPosition(0, 0); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); int win_id = glutCreateWindow(argv[0]); if (win_id < 0) { printf("could not create window...exiting\n"); exit(1); } glutReshapeFunc(DisplayReshape); glutKeyboardFunc(KeyHandler); glutSpecialFunc(SpecialKeyHandler); glutMouseFunc(MouseHandler); glutMotionFunc(MotionHandler); glutIdleFunc(Idle); glutDisplayFunc(Display); glutMainLoop(); delete root; return 0; }
// main function int main(int argc,char *argv[]) { int i; int argc_regular; int argv_type; char *argv_ext; // count regular arguments for (argc_regular=0,i=1; i<argc; i++) if (*argv[i]!='-') argc_regular++; // process command line options for (i=1; i<argc; i++) if (strcmp(argv[i],"-s")==0) sw_stereo=1; else if (strcmp(argv[i],"-a")==0) sw_anaglyph=1; else if (strcmp(argv[i],"-f")==0) sw_full=1; else if (strcmp(argv[i],"-m")==0) sw_multi=1; else if (strcmp(argv[i],"-r")==0) sw_reset=1; else if (strcmp(argv[i],"-c")==0) sw_autos3tc=1; else if (strcmp(argv[i],"-b")==0) sw_bricks=1; else if (strcmp(argv[i],"-B")==0) sw_bricks=sw_mpass=1; // check arguments if ((sw_multi==0 && argc_regular!=1 && argc_regular!=2 && argc_regular!=4) || (sw_multi!=0 && argc_regular<1)) { printf("short usage: %s <url> {<options>}\n",argv[0]); printf("regular usage: %s <elev.ini> <imag.ini> {<options>}\n",argv[0]); printf("long usage: %s <url> <tileset.path> <elevation.subpath> <imagery.subpath> {<options>}\n",argv[0]); printf("multi usage: %s -m {<url> [<detail.db>]} {<options>}\n",argv[0]); printf("options: -s=stereo -a=anaglyph -f=full-screen -r=reset-cache -c=auto-s3tc\n"); exit(1); } // path setup for elevation and imagery if (sw_multi==0) if (argc_regular==4) { if (*argv[1]=='-' || sscanf(argv[1],"%s",baseurl)!=1) exit(1); if (*argv[2]=='-' || sscanf(argv[2],"%s",baseid)!=1) exit(1); if (*argv[3]=='-' || sscanf(argv[3],"%s",basepath1)!=1) exit(1); if (*argv[4]=='-' || sscanf(argv[4],"%s",basepath2)!=1) exit(1); } else if (argc_regular==2) { if (*argv[1]=='-' || sscanf(argv[1],"%s",elev)!=1) exit(1); if (*argv[2]=='-' || sscanf(argv[2],"%s",imag)!=1) exit(1); } else if (*argv[1]=='-' || sscanf(argv[1],"%s",shorturl)!=1) exit(1); // open window with GLUT: winwidth=VIEWER_WINWIDTH; winheight=VIEWER_WINHEIGHT; glutInit(&argc,argv); glutInitWindowSize(winwidth,winheight); if (sw_stereo!=0 && sw_anaglyph==0) glutInitDisplayMode(GLUT_RGB|GLUT_DEPTH|GLUT_STENCIL|GLUT_DOUBLE|GLUT_STEREO); else glutInitDisplayMode(GLUT_RGB|GLUT_DEPTH|GLUT_STENCIL|GLUT_DOUBLE); if (sw_full==0) winid=glutCreateWindow(VIEWER_WINTITLE); else glutEnterGameMode(); glutDisplayFunc(displayfunc); glutReshapeFunc(reshapefunc); glutMouseFunc(NULL); glutMotionFunc(NULL); glutKeyboardFunc(keyboardfunc); glutSpecialFunc(NULL); glutIdleFunc(displayfunc); // print unsupported OpenGL extensions miniOGL::print_unsupported_glexts(); // create the viewer object viewer=new miniview; // initialize the viewing parameters initparams(); // get a reference to the viewing parameters params=viewer->get(); // get a reference to the earth parameters eparams=viewer->getearth()->get(); // get a reference to the terrain parameters tparams=viewer->getearth()->getterrain()->get(); // load tileset (short version) if (sw_multi==0 && argc_regular==1) if (!viewer->getearth()->load(shorturl,TRUE,sw_reset)) { printf("unable to load tileset at url=%s\n",shorturl); exit(1); } // load tileset (regular version) if (sw_multi==0 && argc_regular==2) if (!viewer->getearth()->load(elev,imag,TRUE,sw_reset)) { printf("unable to load tileset from %s (resp. %s)\n",elev,imag); exit(1); } // load tileset (long version) if (sw_multi==0 && argc_regular==4) if (!viewer->getearth()->load(baseurl,baseid,basepath1,basepath2,TRUE,sw_reset)) { printf("unable to load tileset at url=%s%s%s (resp. %s)\n",baseurl,baseid,basepath1,basepath2); exit(1); } // load tileset (multi version) if (sw_multi!=0) for (i=1; i<argc; i++) if (*argv[i]!='-') { argv_type=0; argv_ext=strrchr(argv[i],'.'); if (argv_ext!=NULL) if (strlen(argv_ext)<=4) if (strcmp(argv_ext,".db")==0) argv_type=1; // identified tileset if (argv_type==0) if (!viewer->getearth()->loadLTS(argv[i],TRUE,sw_reset,VIEWER_LEVELS)) { printf("unable to load tileset at url=%s\n",argv[i]); exit(1); } // identified detail if (argv_type==1) viewer->getearth()->loaddetailtex(argv[i]); } // load optional features viewer->getearth()->loadopts(); // initialize VIS bathy map initVISbathymap(); // initialize NPR bathy map initNPRbathymap(); // initialize camera cam=new minicam(viewer->getearth()); // tell actual camera viewer->set_camera(cam); // load settings loadsettings(); // initialize waypoint addons initaddons(); // enter event loop glutMainLoop(); // never reached return(0); }
int main(int argc, char **argv) { int array_size_2d,totpoints,i; float rcol,gcol,bcol; FILE *fp_col; // The following parameters are usually read from a file, but // hard code them for the demo: ni=320; nj=112; vxin=0.04; roout=1.0; tau=0.51; // End of parameter list // Write parameters to screen printf ("ni = %d\n", ni); printf ("nj = %d\n", nj); printf ("vxin = %f\n", vxin); printf ("roout = %f\n", roout); printf ("tau = %f\n", tau); totpoints=ni*nj; array_size_2d=ni*nj*sizeof(float); // Allocate memory for arrays f0 = malloc(array_size_2d); f1 = malloc(array_size_2d); f2 = malloc(array_size_2d); f3 = malloc(array_size_2d); f4 = malloc(array_size_2d); f5 = malloc(array_size_2d); f6 = malloc(array_size_2d); f7 = malloc(array_size_2d); f8 = malloc(array_size_2d); tmpf0 = malloc(array_size_2d); tmpf1 = malloc(array_size_2d); tmpf2 = malloc(array_size_2d); tmpf3 = malloc(array_size_2d); tmpf4 = malloc(array_size_2d); tmpf5 = malloc(array_size_2d); tmpf6 = malloc(array_size_2d); tmpf7 = malloc(array_size_2d); tmpf8 = malloc(array_size_2d); plotvar = malloc(array_size_2d); plot_rgba = malloc(ni*nj*sizeof(unsigned int)); solid = malloc(ni*nj*sizeof(int)); // // Some factors used to calculate the f_equilibrium values // faceq1 = 4.f/9.f; faceq2 = 1.f/9.f; faceq3 = 1.f/36.f; // // Initialise f's by setting them to the f_equilibirum values assuming // that the whole domain is at velocity vx=vxin vy=0 and density ro=roout // for (i=0; i<totpoints; i++) { f0[i] = faceq1 * roout * (1.f - 1.5f*vxin*vxin); f1[i] = faceq2 * roout * (1.f + 3.f*vxin + 4.5f*vxin*vxin - 1.5f*vxin*vxin); f2[i] = faceq2 * roout * (1.f - 1.5f*vxin*vxin); f3[i] = faceq2 * roout * (1.f - 3.f*vxin + 4.5f*vxin*vxin - 1.5f*vxin*vxin); f4[i] = faceq2 * roout * (1.f - 1.5f*vxin*vxin); f5[i] = faceq3 * roout * (1.f + 3.f*vxin + 4.5f*vxin*vxin - 1.5f*vxin*vxin); f6[i] = faceq3 * roout * (1.f - 3.f*vxin + 4.5f*vxin*vxin - 1.5f*vxin*vxin); f7[i] = faceq3 * roout * (1.f - 3.f*vxin + 4.5f*vxin*vxin - 1.5f*vxin*vxin); f8[i] = faceq3 * roout * (1.f + 3.f*vxin + 4.5f*vxin*vxin - 1.5f*vxin*vxin); plotvar[i] = vxin; solid[i] = 1; } // // Read in colourmap data for OpenGL display // fp_col = fopen("cmap.dat","r"); if (fp_col==NULL) { printf("Error: can't open cmap.dat \n"); return 1; } // allocate memory for colourmap (stored as a linear array of int's) fscanf (fp_col, "%d", &ncol); cmap_rgba = (unsigned int *)malloc(ncol*sizeof(unsigned int)); // read colourmap and store as int's for (i=0;i<ncol;i++){ fscanf(fp_col, "%f%f%f", &rcol, &gcol, &bcol); cmap_rgba[i]=((int)(255.0f) << 24) | // convert colourmap to int ((int)(bcol * 255.0f) << 16) | ((int)(gcol * 255.0f) << 8) | ((int)(rcol * 255.0f) << 0); } fclose(fp_col); // // Iinitialise OpenGL display - use glut // glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(ni, nj); // Window of ni x nj pixels glutInitWindowPosition(50, 50); // position glutCreateWindow("2D LB"); // title // Check for OpenGL extension support printf("Loading extensions: %s\n", glewGetErrorString(glewInit())); if(!glewIsSupported( "GL_VERSION_2_0 " "GL_ARB_pixel_buffer_object " "GL_EXT_framebuffer_object " )){ fprintf(stderr, "ERROR: Support for necessary OpenGL extensions missing."); fflush(stderr); return; } // Set up view glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0,ni,0.,nj, -200.0, 200.0); // Create texture which we use to display the result and bind to gl_Tex glEnable(GL_TEXTURE_2D); glGenTextures(1, &gl_Tex); // Generate 2D texture glBindTexture(GL_TEXTURE_2D, gl_Tex); // bind to gl_Tex // texture properties: glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, ni, nj, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); // Create pixel buffer object and bind to gl_PBO. We store the data we want to // plot in memory on the graphics card - in a "pixel buffer". We can then // copy this to the texture defined above and send it to the screen glGenBuffers(1, &gl_PBO); glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, gl_PBO); printf("Buffer created.\n"); // Set the call-back functions and start the glut loop printf("Starting GLUT main loop...\n"); glutDisplayFunc(display); glutReshapeFunc(resize); glutIdleFunc(display); glutMouseFunc(mouse); glutMotionFunc(mouse_motion); glutMainLoop(); return 0; }
// Main program //***************************************************************************** int main(int argc, char** argv) { // Locals used with command line args int p = 256; // workgroup X dimension int q = 1; // workgroup Y dimension pArgc = &argc; pArgv = argv; shrQAStart(argc, argv); // latch the executable path for other funcs to use cExecutablePath = argv[0]; // start logs and show command line help shrSetLogFileName ("oclNbody.txt"); shrLog("%s Starting...\n\n", cExecutablePath); shrLog("Command line switches:\n"); shrLog(" --qatest\t\tCheck correctness of GPU execution and measure performance)\n"); shrLog(" --noprompt\t\tQuit simulation automatically after a brief period\n"); shrLog(" --n=<numbodies>\tSpecify # of bodies to simulate (default = %d)\n", numBodies); shrLog(" --double\t\tUse double precision floating point values for simulation\n"); shrLog(" --p=<workgroup X dim>\tSpecify X dimension of workgroup (default = %d)\n", p); shrLog(" --q=<workgroup Y dim>\tSpecify Y dimension of workgroup (default = %d)\n\n", q); // Get command line arguments if there are any and set vars accordingly if (argc > 0) { shrGetCmdLineArgumenti(argc, (const char**)argv, "p", &p); shrGetCmdLineArgumenti(argc, (const char**)argv, "q", &q); shrGetCmdLineArgumenti(argc, (const char**)argv, "n", &numBodies); bDouble = (shrTRUE == shrCheckCmdLineFlag(argc, (const char**)argv, "double")); bNoPrompt = shrCheckCmdLineFlag(argc, (const char**)argv, "noprompt"); bQATest = shrCheckCmdLineFlag(argc, (const char**)argv, "qatest"); } //Get the NVIDIA platform cl_int ciErrNum = oclGetPlatformID(&cpPlatform); oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup); shrLog("clGetPlatformID...\n\n"); if (bDouble) { shrLog("Double precision execution...\n\n"); } else { shrLog("Single precision execution...\n\n"); } flopsPerInteraction = bDouble ? 30 : 20; //Get all the devices shrLog("Get the Device info and select Device...\n"); ciErrNum = clGetDeviceIDs(cpPlatform, CL_DEVICE_TYPE_GPU, 0, NULL, &uiNumDevices); oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup); cdDevices = (cl_device_id *)malloc(uiNumDevices * sizeof(cl_device_id) ); ciErrNum = clGetDeviceIDs(cpPlatform, CL_DEVICE_TYPE_GPU, uiNumDevices, cdDevices, NULL); oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup); // Set target device and Query number of compute units on uiTargetDevice shrLog(" # of Devices Available = %u\n", uiNumDevices); if(shrGetCmdLineArgumentu(argc, (const char**)argv, "device", &uiTargetDevice)== shrTRUE) { uiTargetDevice = CLAMP(uiTargetDevice, 0, (uiNumDevices - 1)); } shrLog(" Using Device %u, ", uiTargetDevice); oclPrintDevName(LOGBOTH, cdDevices[uiTargetDevice]); cl_uint uiNumComputeUnits; clGetDeviceInfo(cdDevices[uiTargetDevice], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(uiNumComputeUnits), &uiNumComputeUnits, NULL); shrLog(" # of Compute Units = %u\n", uiNumComputeUnits); //Create the context shrLog("clCreateContext...\n"); cxContext = clCreateContext(0, uiNumDevsUsed, &cdDevices[uiTargetDevice], NULL, NULL, &ciErrNum); oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup); // Create a command-queue shrLog("clCreateCommandQueue...\n\n"); cqCommandQueue = clCreateCommandQueue(cxContext, cdDevices[uiTargetDevice], CL_QUEUE_PROFILING_ENABLE, &ciErrNum); oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup); // Log and config for number of bodies shrLog("Number of Bodies = %d\n", numBodies); switch (numBodies) { case 1024: activeParams.m_clusterScale = 1.52f; activeParams.m_velocityScale = 2.f; break; case 2048: activeParams.m_clusterScale = 1.56f; activeParams.m_velocityScale = 2.64f; break; case 4096: activeParams.m_clusterScale = 1.68f; activeParams.m_velocityScale = 2.98f; break; case 7680: case 8192: activeParams.m_clusterScale = 1.98f; activeParams.m_velocityScale = 2.9f; break; default: case 15360: case 16384: activeParams.m_clusterScale = 1.54f; activeParams.m_velocityScale = 8.f; break; case 30720: case 32768: activeParams.m_clusterScale = 1.44f; activeParams.m_velocityScale = 11.f; break; } if ((q * p) > 256) { p = 256 / q; shrLog("Setting p=%d to maintain %d threads per block\n", p, 256); } if ((q == 1) && (numBodies < p)) { p = numBodies; shrLog("Setting p=%d because # of bodies < p\n", p); } shrLog("Workgroup Dims = (%d x %d)\n\n", p, q); // Initialize OpenGL items if using GL if (bQATest == shrFALSE) { shrLog("Calling InitGL...\n"); InitGL(&argc, argv); } else { shrLog("Skipping InitGL...\n"); } // CL/GL interop disabled bUsePBO = (false && (bQATest == shrFALSE)); InitNbody(cdDevices[uiTargetDevice], cxContext, cqCommandQueue, numBodies, p, q, bUsePBO, bDouble); ResetSim(nbody, numBodies, NBODY_CONFIG_SHELL, bUsePBO); // init timers shrDeltaT(DEMOTIME); // timer 0 is for timing demo periods shrDeltaT(FUNCTIME); // timer 1 is for logging function delta t's shrDeltaT(FPSTIME); // timer 2 is for fps measurement // Standard simulation if (bQATest == shrFALSE) { shrLog("Running standard oclNbody simulation...\n\n"); glutDisplayFunc(DisplayGL); glutReshapeFunc(ReshapeGL); glutMouseFunc(MouseGL); glutMotionFunc(MotionGL); glutKeyboardFunc(KeyboardGL); glutSpecialFunc(SpecialGL); glutIdleFunc(IdleGL); glutMainLoop(); } // Compare to host, profile and write out file for regression analysis if (bQATest == shrTRUE) { bool bTestResults = false; shrLog("Running oclNbody Results Comparison...\n\n"); bTestResults = CompareResults(numBodies); shrLog("Profiling oclNbody...\n\n"); RunProfiling(100, (unsigned int)(p * q)); // 100 iterations shrQAFinish(argc, (const char **)argv, bTestResults ? QA_PASSED : QA_FAILED); } else { // Cleanup/exit bNoPrompt = shrTRUE; shrQAFinish2(false, *pArgc, (const char **)pArgv, QA_PASSED); } Cleanup(EXIT_SUCCESS); }
// Main int main(int argc, char *argv[]) { TwBar *bar; // Pointer to the tweak bar float axis[] = { 0.7f, 0.7f, 0.0f }; // initial model rotation float angle = 0.8f; // Initialize GLUT glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize(640, 480); glutCreateWindow("AntTweakBar simple example using GLUT"); glutCreateMenu(NULL); // Set GLUT callbacks glutDisplayFunc(Display); glutReshapeFunc(Reshape); atexit(Terminate); // Called after glutMainLoop ends // Initialize AntTweakBar TwInit(TW_OPENGL, NULL); // Set GLUT event callbacks // - Directly redirect GLUT mouse button events to AntTweakBar glutMouseFunc((GLUTmousebuttonfun)TwEventMouseButtonGLUT); // - Directly redirect GLUT mouse motion events to AntTweakBar glutMotionFunc((GLUTmousemotionfun)TwEventMouseMotionGLUT); // - Directly redirect GLUT mouse "passive" motion events to AntTweakBar (same as MouseMotion) glutPassiveMotionFunc((GLUTmousemotionfun)TwEventMouseMotionGLUT); // - Directly redirect GLUT key events to AntTweakBar glutKeyboardFunc((GLUTkeyboardfun)TwEventKeyboardGLUT); // - Directly redirect GLUT special key events to AntTweakBar glutSpecialFunc((GLUTspecialfun)TwEventSpecialGLUT); // - Send 'glutGetModifers' function pointer to AntTweakBar; // required because the GLUT key event functions do not report key modifiers states. TwGLUTModifiersFunc(glutGetModifiers); // Create some 3D objects (stored in display lists) glNewList(SHAPE_TEAPOT, GL_COMPILE); glutSolidTeapot(1.0); glEndList(); glNewList(SHAPE_TORUS, GL_COMPILE); glutSolidTorus(0.3, 1.0, 16, 32); glEndList(); glNewList(SHAPE_CONE, GL_COMPILE); glutSolidCone(1.0, 1.5, 64, 4); glEndList(); // Create a tweak bar bar = TwNewBar("TweakBar"); TwDefine(" GLOBAL help='This example shows how to integrate AntTweakBar with GLUT and OpenGL.' "); // Message added to the help bar. TwDefine(" TweakBar size='200 400' color='96 216 224' "); // change default tweak bar size and color // Add 'g_Zoom' to 'bar': this is a modifable (RW) variable of type TW_TYPE_FLOAT. Its key shortcuts are [z] and [Z]. TwAddVarRW(bar, "Zoom", TW_TYPE_FLOAT, &g_Zoom, " min=0.01 max=2.5 step=0.01 keyIncr=z keyDecr=Z help='Scale the object (1=original size).' "); // Add 'g_Rotation' to 'bar': this is a variable of type TW_TYPE_QUAT4F which defines the object's orientation TwAddVarRW(bar, "ObjRotation", TW_TYPE_QUAT4F, &g_Rotation, " label='Object rotation' opened=true help='Change the object orientation.' "); // Add callback to toggle auto-rotate mode (callback functions are defined above). TwAddVarCB(bar, "AutoRotate", TW_TYPE_BOOL32, SetAutoRotateCB, GetAutoRotateCB, NULL, " label='Auto-rotate' key=space help='Toggle auto-rotate mode.' "); // Add 'g_LightMultiplier' to 'bar': this is a variable of type TW_TYPE_FLOAT. Its key shortcuts are [+] and [-]. TwAddVarRW(bar, "Multiplier", TW_TYPE_FLOAT, &g_LightMultiplier, " label='Light booster' min=0.1 max=4 step=0.02 keyIncr='+' keyDecr='-' help='Increase/decrease the light power.' "); // Add 'g_LightDirection' to 'bar': this is a variable of type TW_TYPE_DIR3F which defines the light direction TwAddVarRW(bar, "LightDir", TW_TYPE_DIR3F, &g_LightDirection, " label='Light direction' opened=true help='Change the light direction.' "); // Add 'g_MatAmbient' to 'bar': this is a variable of type TW_TYPE_COLOR3F (3 floats color, alpha is ignored) // and is inserted into a group named 'Material'. TwAddVarRW(bar, "Ambient", TW_TYPE_COLOR3F, &g_MatAmbient, " group='Material' "); // Add 'g_MatDiffuse' to 'bar': this is a variable of type TW_TYPE_COLOR3F (3 floats color, alpha is ignored) // and is inserted into group 'Material'. TwAddVarRW(bar, "Diffuse", TW_TYPE_COLOR3F, &g_MatDiffuse, " group='Material' "); // Add the enum variable 'g_CurrentShape' to 'bar' // (before adding an enum variable, its enum type must be declared to AntTweakBar as follow) { // ShapeEV associates Shape enum values with labels that will be displayed instead of enum values TwEnumVal shapeEV[NUM_SHAPES] = { {SHAPE_TEAPOT, "Teapot"}, {SHAPE_TORUS, "Torus"}, {SHAPE_CONE, "Cone"} }; // Create a type for the enum shapeEV TwType shapeType = TwDefineEnum("ShapeType", shapeEV, NUM_SHAPES); // add 'g_CurrentShape' to 'bar': this is a variable of type ShapeType. Its key shortcuts are [<] and [>]. TwAddVarRW(bar, "Shape", shapeType, &g_CurrentShape, " keyIncr='<' keyDecr='>' help='Change object shape.' "); } // Store time g_RotateTime = GetTimeMs(); // Init rotation SetQuaternionFromAxisAngle(axis, angle, g_Rotation); SetQuaternionFromAxisAngle(axis, angle, g_RotateStart); // Call the GLUT main loop glutMainLoop(); return 0; }
int /* O - Exit status */ main(int argc, /* I - Number of command-line arguments */ char *argv[]) /* I - Command-line arguments */ { glutInit(&argc, argv); #ifdef BOOK_COVER glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE | GLUT_DEPTH); #else glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); #endif /* BOOK_COVER */ glutInitWindowSize(792, 573); glutCreateWindow("Terrain Using Vertex Culling Extension"); glutDisplayFunc(Redraw); if (glutDeviceGet(GLUT_HAS_JOYSTICK)) glutJoystickFunc(Joystick, 200); glutKeyboardFunc(Keyboard); glutMotionFunc(Motion); glutMouseFunc(Mouse); glutReshapeFunc(Resize); glutSpecialFunc(Special); BuildF16(); LandTexture = TextureLoad("land.bmp", GL_FALSE, GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR, GL_REPEAT); SkyTexture = TextureLoad("sky.bmp", GL_FALSE, GL_LINEAR, GL_LINEAR, GL_CLAMP); LoadTerrain(36, -112); puts("QUICK HELP:"); puts(""); puts("ESC - Quit"); puts("',' - Slow down, '<' - Slowest"); puts("'.' - Speed up, '>' - Fastest"); puts("'3' - Toggle terrain"); puts("'a' - Toggle aircraft"); puts("'f' - Toggle fog"); puts("'l' - Toggle lighting"); puts("'s' - Toggle sky/clouds"); puts("'t' - Toggle texturing"); puts("'w' - Toggle water"); puts("'W' - Toggle wireframe"); printf("GL_EXTENSIONS = %s\n", glGetString(GL_EXTENSIONS)); if (strstr(glGetString(GL_EXTENSIONS), "EXT_cull_vertex") != NULL) { UseCullVertex = 1; glCullParameterfvEXT = wglGetProcAddress("glCullParameterfvEXT"); } else if (strstr(glGetString(GL_EXTENSIONS), "SGI_cull_vertex") != NULL) { UseCullVertex = 1; glCullParameterfvEXT = wglGetProcAddress("glCullParameterfvSGI"); } else UseCullVertex = 0; glutMainLoop(); return (0); }
/** * POINT D'ENTREE PRINCIPAL **/ int main(int argc, char* argv[]) { LogConsole::createInstance(); int screen_width = 1280; int screen_height = 720; glutInit(&argc, argv); glutInitContextVersion(3, 0); glutSetOption( GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS ); glutInitWindowSize(screen_width, screen_height); glutInitWindowPosition(0, 0); glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA | GLUT_MULTISAMPLE); glEnable(GL_MULTISAMPLE); Log::log(Log::ENGINE_INFO, (toString(argc) + " arguments en ligne de commande.").c_str()); bool gameMode = true; for (int i = 0; i < argc; i++) { if (argv[i][0] == 'w') { Log::log(Log::ENGINE_INFO, "Arg w mode fenetre.\n"); gameMode = false; } } if (gameMode) { int width = glutGet(GLUT_SCREEN_WIDTH); int height = glutGet(GLUT_SCREEN_HEIGHT); char gameModeStr[200]; sprintf(gameModeStr, "%dx%d:32@60", width, height); glutGameModeString(gameModeStr); g_main_window_id = glutEnterGameMode(); } else { g_main_window_id = glutCreateWindow("MyNecraft"); glutReshapeWindow(screen_width, screen_height); } if (g_main_window_id < 1) { Log::log(Log::ENGINE_ERROR, "Erreur creation de la fenetre."); exit(EXIT_FAILURE); } GLenum glewInitResult = glewInit(); if (glewInitResult != GLEW_OK) { Log::log(Log::ENGINE_ERROR, ("Erreur init glew " + std::string((char*)glewGetErrorString(glewInitResult))).c_str()); _cprintf("ERROR : %s", glewGetErrorString(glewInitResult)); exit(EXIT_FAILURE); } //Affichage des capacités du système Log::log(Log::ENGINE_INFO, ("OpenGL Version : " + std::string((char*)glGetString(GL_VERSION))).c_str()); glutDisplayFunc(update); glutReshapeFunc(resizeFunction); glutKeyboardFunc(keyboardDownFunction); glutKeyboardUpFunc(keyboardUpFunction); glutSpecialFunc(specialDownFunction); glutSpecialUpFunc(specialUpFunction); glutMouseFunc(mouseFunction); glutMotionFunc(mouseMoveActiveFunction); glutPassiveMotionFunc(mouseMovePassiveFunction); glutIgnoreKeyRepeat(1); //Initialisation du renderer g_renderer = NYRenderer::getInstance(); g_renderer->setRenderObjectFun(renderObjects); g_renderer->setRender2DFun(render2d); //g_renderer->setLightsFun(setLights); g_renderer->setLightsFun(setLightsBasedOnDayTime); //g_renderer->setBackgroundColor(NYColor(0, 181.f / 255.f, 221.f / 255.f, 1)); g_program = g_renderer->createProgram("shaders/psbase.glsl", "shaders/vsbase.glsl"); g_renderer->initialise(true); //On applique la config du renderer glViewport(0, 0, g_renderer->_ScreenWidth, g_renderer->_ScreenHeight); g_renderer->resize(g_renderer->_ScreenWidth, g_renderer->_ScreenHeight); //Ecran de jeu uint16 x = 10; uint16 y = 10; g_screen_jeu = new GUIScreen(); g_screen_manager = new GUIScreenManager(); //Bouton pour afficher les params BtnParams = new GUIBouton(); BtnParams->Titre = std::string("Params"); BtnParams->X = x; BtnParams->setOnClick(clickBtnParams); g_screen_jeu->addElement(BtnParams); y += BtnParams->Height + 1; LabelFps = new GUILabel(); LabelFps->Text = "FPS"; LabelFps->X = x; LabelFps->Y = y; LabelFps->Visible = true; g_screen_jeu->addElement(LabelFps); y += BtnParams->Height + 1; LabelCam = new GUILabel(); LabelCam->Text = "Position"; LabelCam->X = x; LabelCam->Y = y; LabelCam->Visible = true; g_screen_jeu->addElement(LabelCam); //Ecran de parametrage x = 10; y = 10; g_screen_params = new GUIScreen(); GUIBouton * btnClose = new GUIBouton(); btnClose->Titre = std::string("Close"); btnClose->X = x; btnClose->setOnClick(clickBtnCloseParam); g_screen_params->addElement(btnClose); y += btnClose->Height + 1; y += 10; x += 10; GUILabel * label = new GUILabel(); label->X = x; label->Y = y; label->Text = "Param :"; g_screen_params->addElement(label); y += label->Height + 1; g_slider = new GUISlider(); g_slider->setPos(x, y); g_slider->setMaxMin(1, 0); g_slider->Visible = true; g_screen_params->addElement(g_slider); y += g_slider->Height + 1; y += 10; //Ecran a rendre g_screen_manager->setActiveScreen(g_screen_jeu); //Init Camera g_renderer->_Camera->setPosition(NYVert3Df(-300, -300, 1300)); g_renderer->_Camera->setLookAt(NYVert3Df(1300, 1300, 500)); //Fin init moteur //Init application //Init Timer g_timer = new NYTimer(); //On start g_timer->start(); //Generation du monde g_world = new NYWorld(); g_world->_FacteurGeneration = 1; g_world->init_world(); avatar = new NYAvatar(g_renderer->_Camera, g_world, NYVert3Df(1, 1, 900)); glutMainLoop(); return 0; }
int main(int argc, char** argv) { int buffering = GLUT_DOUBLE; struct dirent* direntp; DIR* dirp; int models; glutInitWindowSize(512, 512); glutInit(&argc, argv); while (--argc) { if (strcmp(argv[argc], "-sb") == 0) buffering = GLUT_SINGLE; else model_file = argv[argc]; } if (!model_file) { model_file = "data/dolphins.obj"; } glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | buffering); glutCreateWindow("Smooth"); glutReshapeFunc(reshape); glutDisplayFunc(display); glutKeyboardFunc(keyboard); glutMouseFunc(mouse); glutMotionFunc(motion); models = glutCreateMenu(menu); dirp = opendir(DATA_DIR); if (!dirp) { fprintf(stderr, "%s: can't open data directory.\n", argv[0]); } else { while ((direntp = readdir(dirp)) != NULL) { if (strstr(direntp->d_name, ".obj")) { entries++; glutAddMenuEntry(direntp->d_name, -entries); } } closedir(dirp); } glutCreateMenu(menu); glutAddMenuEntry("Smooth", 0); glutAddMenuEntry("", 0); glutAddSubMenu("Models", models); glutAddMenuEntry("", 0); glutAddMenuEntry("[w] Toggle wireframe/filled", 'w'); glutAddMenuEntry("[c] Toggle culling on/off", 'c'); glutAddMenuEntry("[n] Toggle face/smooth normals", 'n'); glutAddMenuEntry("[b] Toggle bounding box on/off", 'b'); glutAddMenuEntry("[p] Toggle frame rate on/off", 'p'); glutAddMenuEntry("[t] Toggle model statistics", 't'); glutAddMenuEntry("[m] Toggle color/material/none mode", 'm'); glutAddMenuEntry("[r] Reverse polygon winding", 'r'); glutAddMenuEntry("[s] Scale model smaller", 's'); glutAddMenuEntry("[S] Scale model larger", 'S'); glutAddMenuEntry("[o] Weld redundant vertices", 'o'); glutAddMenuEntry("[+] Increase smoothing angle", '+'); glutAddMenuEntry("[-] Decrease smoothing angle", '-'); glutAddMenuEntry("[W] Write model to file (out.obj)", 'W'); glutAddMenuEntry("", 0); glutAddMenuEntry("[Esc] Quit", 27); glutAttachMenu(GLUT_RIGHT_BUTTON); init(); glutMainLoop(); return 0; }
int main(int argc, char *argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_STENCIL); if((argc > 1) && (strcmpi(argv[1], "--helmet") == 0)) { /*left eye*/ glutInitWindowPosition(0,0); glutInitWindowSize(640, 480); left_eye = glutCreateWindow("Escher World - Left Eye"); glutSetWindow(left_eye); set_window_size(640, 480); glutDisplayFunc(displayleft); glutKeyboardFunc(keyfunc); glutMouseFunc(mouse_button); glutPassiveMotionFunc(passive_mouse_motion); glutMotionFunc(passive_mouse_motion); glutReshapeFunc(set_window_size); /* glutTimerFunc(10,child,1);*/ /* right eye */ glutInitWindowPosition(641,0); glutInitWindowSize(640, 480); right_eye = glutCreateWindow("Escher World - Right Eye"); glutSetWindow(right_eye); set_window_size(640, 480); glutDisplayFunc(displayright); glutKeyboardFunc(keyfunc); glutMouseFunc(mouse_button); glutPassiveMotionFunc(passive_mouse_motion); glutMotionFunc(passive_mouse_motion); glutReshapeFunc(set_window_size); glutSetWindow(left_eye); create_menus(); init(); /* Initialize the scene */ init_scene(FILENAME); glutSetWindow(right_eye); create_menus(); create_menus(); init(); /* Initialize the scene */ init_scene(FILENAME); #ifdef USE_HELMET /* main_helmet(); signal(SIGUSR1, cleanup); */ birdinit(); /* glutTimerFunc(10,child,1);*/ #endif } else { glutInitWindowPosition(64,64); glutInitWindowSize(768, 832); glut_window = glutCreateWindow("Escher World"); glutSetWindow(glut_window); set_window_size(768, 832); helmet = !helmet; glutDisplayFunc(displaymid); glutKeyboardFunc(keyfunc); glutMouseFunc(mouse_button); glutPassiveMotionFunc(passive_mouse_motion); glutMotionFunc(passive_mouse_motion); glutReshapeFunc(set_window_size); create_menus(); init(); /* Initialize the scene */ init_scene(FILENAME); } glutMainLoop(); return 0; }