int main(int argc, char* argv[]) { //初始化游戏数据 bblock.SetSize(4); bblock.AddNumber(); //初始化glut glutInit(&argc, argv); //使用双缓冲区、深度缓冲区、模板缓冲区 glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_STENCIL); //获取系统的宽像素 SCREEN_WIDTH = glutGet(GLUT_SCREEN_WIDTH); //获取系统的高像素 SCREEN_HEIGHT = glutGet(GLUT_SCREEN_HEIGHT); //创建窗口,窗口名字为OpenGL Glut Demo glutCreateWindow("2048"); //设置窗口大小 glutReshapeWindow(windowWidth, windowHeight); //窗口居中显示 glutPositionWindow((SCREEN_WIDTH - windowWidth) / 2, (SCREEN_HEIGHT - windowHeight) / 2); //窗口大小变化时的处理函数 glutReshapeFunc(changSize); //设置显示回调函数 glutDisplayFunc(renderScreen); //设置按键输入处理回调函数 glutSpecialFunc(specialKey); //键盘输入 glutKeyboardFunc(keyboard); //处理鼠标 glutMouseFunc(mouse); //滑轮 glutMouseWheelFunc(wheel); //设置全局渲染参数 setupRederingState(); glutMainLoop(); return 0; }
int __main(int* argcp, char** argv) { glutInit(argcp, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_STENCIL); #if (FULL_SCREEN) glutGameModeString("640x480:32@60"); glutEnterGameMode(); #else glutInitWindowSize(960, 720); glutInitWindowPosition(0, 0); glutCreateWindow("Game"); #endif glewInit(); SetCurrentDirectory(L"data"); glClearColor(1.0, 1.0, 1.0, 1.0); glEnable(GL_DEPTH_TEST); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND);//ブレンドの有効化 //glEnable(GL_CULL_FACE); //固定シェーダー用 glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); Init(); glutDisplayFunc(Display); glutKeyboardFunc(Keyboard); glutIdleFunc(Idle); glutReshapeFunc(Resize); glutMouseWheelFunc(wheel); glutMainLoop(); return 0; }
int main(int argc, char *argv[]) { int fractal_window ; glutInitDisplayMode( GLUT_RGB | GLUT_SINGLE ); glutInitWindowSize(500, 250); glutInitWindowPosition ( 140, 140 ) ; glutInit(&argc, argv); if ( argc > 1 ) readConfigFile ( argv[1] ) ; else readConfigFile ( "fractals.dat" ) ; fractal_window = glutCreateWindow( window_title ); glClearColor(1.0, 1.0, 1.0, 1.0); glutReshapeFunc(Reshape); glutKeyboardFunc(Key); glutSpecialFunc(Special); glutDisplayFunc(Display); glutMouseFunc(Mouse); glutMotionFunc(MouseMotion); glutMouseWheelFunc(MouseWheel); glutMainLoop(); printf ( "Back from the 'freeglut' main loop\n" ) ; free ( affine ) ; #ifdef _MSC_VER /* DUMP MEMORY LEAK INFORMATION */ _CrtDumpMemoryLeaks () ; #endif return 0; /* ANSI C requires main to return int. */ }
int main(int argc, char *argv[]) { // Set up the window glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB); glutInitWindowSize(SCREEN_WIDTH, SCREEN_HEIGHT); glutCreateWindow("Fluid Simulation"); // Tell glut where the display function is glutDisplayFunc(Update); glutIdleFunc(Update); // A call to glewInit() must be done after glut is initialized! GLenum res = glewInit(); // Check for any errors if (res != GLEW_OK) { fprintf(stderr, "Error: '%s'\n", glewGetErrorString(res)); return 1; } // Initialize Renderer and Qt Init(); // Specify glut input functions glutKeyboardFunc(KeyboardFunc); glutSpecialFunc(SpecialFunc); glutMouseFunc(MouseButton); glutMotionFunc(MouseMove); glutMouseWheelFunc(MouseWheel); // Begin infinite event loop glutMainLoop(); return 0; }
int setupGLUT(int argc, char** argv) { glutInit(&argc, argv); // glutInitContextVersion(3, 0); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowSize(800, 600); glutInitWindowPosition(100, 100); int windowId = glutCreateWindow("Model Viewer"); glutDisplayFunc(display); glutIdleFunc(idle); glutReshapeFunc(reshape); glutKeyboardFunc(keyboard); glutMouseFunc(mouse); glutMotionFunc(mouseMotion); #ifndef __APPLE__ glutMouseWheelFunc(mouseWheel); #endif return windowId; }
int main(int argc,char **argv) { glutInit(&argc,argv); glutInitWindowPosition(100, 50); glutInitWindowSize(640, 480); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); glutCreateWindow("Outofrange Peel project"); glutDisplayFunc(disp); glutIdleFunc(animate); glutMouseFunc(mouse); glutMotionFunc(mousemove); glutPassiveMotionFunc(mousepassivemove); glutMouseWheelFunc(mousewheel); glutReshapeFunc(resize); if(events) events->Initialize(); glutMainLoop(); return 0; }
//The C-language main procedure int main(int argc,char** argv) { //Initialize glut context. glutInit(&argc,argv); glutInitDisplayMode(GLUT_RGB|GLUT_DEPTH|GLUT_DOUBLE); glutInitWindowSize(1200,1200); glutCreateWindow("GLSL PhongShading"); glutDisplayFunc(Display); glutKeyboardFunc(KeyboardDown); glutKeyboardUpFunc(KeyboardUp); glutMotionFunc(Motion); glutMouseFunc(Mouse); glutMouseWheelFunc(MouseWheel); glutTimerFunc(50,Timer,0); /*Initialize GL glew extension*/ glewInit(); //Check the global variables to make sure glew is supported. Init(); glutMainLoop(); }
// Inicjalizuje meshe i parametry opengl void init() { initializeShaders(); try { g_pCylinderMesh = new Framework::Mesh("UnitCylinder.xml"); g_pShpere1Mesh = new Framework::Mesh("Sphere1.xml"); g_pShpere2Mesh = new Framework::Mesh("Sphere2.xml"); g_pPlaneMesh = new Framework::Mesh("LargePlane.xml"); g_pCubeMesh = new Framework::Mesh("UnitCube.xml"); g_pTetrahedron1Mesh = new Framework::Mesh("UnitTetrahedron1.xml"); } catch(std::exception &except) { printf("%s\n", except.what()); throw; } glutMouseFunc(MouseButton); glutMotionFunc(MouseMotion); glutMouseWheelFunc(MouseWheel); glutKeyboardUpFunc(onKeyUp); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glFrontFace(GL_CW); glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glDepthFunc(GL_LEQUAL); glDepthRange(0.0f, 1.0f); glEnable(GL_DEPTH_CLAMP); glGenBuffers(1, &g_projectionUniformBuffer); glBindBuffer(GL_UNIFORM_BUFFER, g_projectionUniformBuffer); glBufferData(GL_UNIFORM_BUFFER, sizeof(ProjectionBlock), NULL, GL_DYNAMIC_DRAW); glBindBufferRange(GL_UNIFORM_BUFFER, projectionBlockIndex, g_projectionUniformBuffer, 0, sizeof(ProjectionBlock)); glBindBuffer(GL_UNIFORM_BUFFER, 0); }
//Called after the window and OpenGL are initialized. Called exactly once, before the main loop. void init() { InitializeProgram(); try { g_pCylinderMesh = new Framework::Mesh("UnitCylinder.xml"); g_pPlaneMesh = new Framework::Mesh("LargePlane.xml"); } catch(std::exception &except) { printf("%s\n", except.what()); throw; } glutMouseFunc(MouseButton); glutMotionFunc(MouseMotion); glutMouseWheelFunc(MouseWheel); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glFrontFace(GL_CW); glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glDepthFunc(GL_LEQUAL); glDepthRange(0.0f, 1.0f); glEnable(GL_DEPTH_CLAMP); glGenBuffers(1, &g_projectionUniformBuffer); glBindBuffer(GL_UNIFORM_BUFFER, g_projectionUniformBuffer); glBufferData(GL_UNIFORM_BUFFER, sizeof(ProjectionBlock), NULL, GL_DYNAMIC_DRAW); //Bind the static buffers. glBindBufferRange(GL_UNIFORM_BUFFER, g_projectionBlockIndex, g_projectionUniformBuffer, 0, sizeof(ProjectionBlock)); glBindBuffer(GL_UNIFORM_BUFFER, 0); }
//------------------------------------------------------------------------------ void npGlutEventFuncs (void) { //! register keyboard events with GLUT glutKeyboardFunc (npGlutKeyDown); glutKeyboardUpFunc (npGlutKeyUp); glutSpecialFunc (npGlutKeyDownSpecial); glutSpecialUpFunc (npGlutKeyUpSpecial); //! register mouse events with GLUT //glutEntryFunc( npMouseEntry ); //zz only works when clicking glutMouseFunc (npMouseEvent); glutMotionFunc (npMouseMotion); glutPassiveMotionFunc( npMousePosition ); /// Apple GLUT does not support the mouse wheel #ifndef NP_OSX_ //zz-osx debug lde glutMouseWheelFunc (npMouseWheel); #endif //! register display functions with GLUT glutDisplayFunc (npGlutDrawGLScene); glutIdleFunc (npGlutDrawGLSceneIdle); glutReshapeFunc (npGLResizeScene); }
int main(int argc, char* argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize(windowWidth, windowHeight); glutCreateWindow("GLSL Shaders Demo"); glutReshapeFunc(ChangeSize); glutKeyboardFunc(KeyPressFunc); glutSpecialFunc(SpecialKeys); glutDisplayFunc(RenderScene); #ifdef FREEGLUT_VERSION_2_0 glutMouseWheelFunc(MouseWheel); glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); #endif // Create the Menu glutCreateMenu(ProcessMenu); glutAddMenuEntry("Toggle vertex shader (currently ON)", 1); glutAddMenuEntry("Toggle fragment shader (currently ON)", 2); glutAddMenuEntry("Toggle flicker (currently OFF)", 3); glutAttachMenu(GLUT_RIGHT_BUTTON); SetupRC(); glutMainLoop(); if (glDeleteShader && glDeleteProgram) { glDeleteProgram(progObj); glDeleteShader(fShader); glDeleteShader(vShader); } return EXIT_SUCCESS; }
int main(int argc, char* argv[]) { // Initialize GLUT and process user parameters glutInit(&argc, argv); // Request double buffered true color window with Z-buffer glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); // Set the width and height of the window glutInitWindowSize(500, 500); // Set the position of the window glutInitWindowPosition(100, 100); // Create window glutCreateWindow("Cube"); // Enable Z-buffer depth test glEnable(GL_DEPTH_TEST); // Callback functions //glutReshapeFunc(reshape); glutDisplayFunc(display); glutReshapeFunc(reshape); glutSpecialFunc(Keys); glutMouseFunc(mouse); glutMouseWheelFunc(MouseWheel); //Pass control to GLUT for events glutMainLoop(); // Return to OS return 0; }
int main(int argc, char** argv) { testCount = 0; while (g_testEntries[testCount].createFcn != NULL) { ++testCount; } testIndex = b2Clamp(testIndex, 0, testCount-1); testSelection = testIndex; entry = g_testEntries + testIndex; test = entry->createFcn(); glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowSize(width, height); char title[32]; sprintf(title, "Box2D Version %d.%d.%d", b2_version.major, b2_version.minor, b2_version.revision); mainWindow = glutCreateWindow(title); //glutSetOption (GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); glutDisplayFunc(SimulationLoop); /* int theConnection=0; theConnection=setup_rlglue_network(); runEnvironmentEventLoop(theConnection);*/ GLUI_Master.set_glutReshapeFunc(Resize); GLUI_Master.set_glutKeyboardFunc(Keyboard); GLUI_Master.set_glutSpecialFunc(KeyboardSpecial); GLUI_Master.set_glutMouseFunc(Mouse); #ifdef FREEGLUT glutMouseWheelFunc(MouseWheel); #endif glutMotionFunc(MouseMotion); glui = GLUI_Master.create_glui_subwindow( mainWindow, GLUI_SUBWINDOW_RIGHT ); glui->add_statictext("Tests"); GLUI_Listbox* testList = glui->add_listbox("", &testSelection); glui->add_separator(); GLUI_Spinner* velocityIterationSpinner = glui->add_spinner("Vel Iters", GLUI_SPINNER_INT, &settings.velocityIterations); velocityIterationSpinner->set_int_limits(1, 500); GLUI_Spinner* positionIterationSpinner = glui->add_spinner("Pos Iters", GLUI_SPINNER_INT, &settings.positionIterations); positionIterationSpinner->set_int_limits(0, 100); GLUI_Spinner* hertzSpinner = glui->add_spinner("Hertz", GLUI_SPINNER_FLOAT, &settingsHz); hertzSpinner->set_float_limits(5.0f, 200.0f); glui->add_checkbox("Warm Starting", &settings.enableWarmStarting); glui->add_checkbox("Time of Impact", &settings.enableContinuous); //glui->add_separator(); GLUI_Panel* drawPanel = glui->add_panel("Draw"); glui->add_checkbox_to_panel(drawPanel, "Shapes", &settings.drawShapes); glui->add_checkbox_to_panel(drawPanel, "Joints", &settings.drawJoints); glui->add_checkbox_to_panel(drawPanel, "AABBs", &settings.drawAABBs); glui->add_checkbox_to_panel(drawPanel, "Pairs", &settings.drawPairs); glui->add_checkbox_to_panel(drawPanel, "Contact Points", &settings.drawContactPoints); glui->add_checkbox_to_panel(drawPanel, "Contact Normals", &settings.drawContactNormals); glui->add_checkbox_to_panel(drawPanel, "Contact Forces", &settings.drawContactForces); glui->add_checkbox_to_panel(drawPanel, "Friction Forces", &settings.drawFrictionForces); glui->add_checkbox_to_panel(drawPanel, "Center of Masses", &settings.drawCOMs); glui->add_checkbox_to_panel(drawPanel, "Statistics", &settings.drawStats); int32 testCount = 0; TestEntry* e = g_testEntries; while (e->createFcn) { testList->add_item(testCount, e->name); ++testCount; ++e; } glui->add_button("Pause", 0, Pause); glui->add_button("Single Step", 0, SingleStep); glui->add_button("Restart", 0, Restart); glui->add_button("Quit", 0,(GLUI_Update_CB)exit); glui->set_main_gfx_window( mainWindow ); // Use a timer to control the frame rate. glutTimerFunc(framePeriod, Timer, 0); //////////////////////////////////////////////////////////////////////////////////////////// /*const char *task_spec; printf("\nThis is a RL Test program(Start)\n"); task_spec = RL_init(); printf("\nTASK SPEC : %s\n",task_spec); printf("Starting offline demo\n----------------------------\nWill alternate learning for 25 episodes, then freeze policy and evaluate for 10 episodes.\n\n"); printf("After Episode\tMean Return\tStandard Deviation\n-------------------------------------------------------------------------\n"); oa = RL_start(); RL_agent_message("load_policy results.dat"); RL_agent_message("freeze learning");*/ const char* task_spec; task_spec = env_init(); agent_init(task_spec); //////////////////////////////////////////////////////////////////////////////////////////// /* agent_message("load_policy results.dat"); agent_message("freeze learning");*/ glutMainLoop(); return 0; }
int main(int argc, char** argv) { // Place a communicator at serialport (Default COM1) communicator = new Communicator(serialport); // Hide joints settings.drawJoints=0; // Set startup view position settings.viewCenter=b2Vec2(35,16); simulatorPageCount = 0; while (g_simulatorPageEntries[simulatorPageCount].createFcn != NULL) { ++simulatorPageCount; } simulatorPageIndex = b2Clamp(simulatorPageIndex, 0, simulatorPageCount-1); simulatorPageSelection = simulatorPageIndex; entry = g_simulatorPageEntries + simulatorPageIndex; simulatorPage = entry->createFcn(communicator); glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowSize(width, height); char title[32]; sprintf(title, "Educational simulator for control-system development"); mainWindow = glutCreateWindow(title); //glutSetOption (GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); glutDisplayFunc(SimulationLoop); GLUI_Master.set_glutReshapeFunc(Resize); GLUI_Master.set_glutKeyboardFunc(Keyboard); GLUI_Master.set_glutSpecialFunc(KeyboardSpecial); GLUI_Master.set_glutMouseFunc(Mouse); #ifdef FREEGLUT glutMouseWheelFunc(MouseWheel); #endif glutMotionFunc(MouseMotion); glutKeyboardUpFunc(KeyboardUp); glui = GLUI_Master.create_glui_subwindow( mainWindow, GLUI_SUBWINDOW_RIGHT ); glui->add_statictext("Simulator-page:"); GLUI_Listbox* simulatorPageList = glui->add_listbox("", &simulatorPageSelection); int32 simulatorPageCount = 0; SimulatorPageEntry* e = g_simulatorPageEntries; while (e->createFcn) { simulatorPageList->add_item(simulatorPageCount, e->name); ++simulatorPageCount; ++e; } glui->add_separator(); glui->add_edittext( "Serialport:", GLUI_EDITTEXT_TEXT, serialport ); glui->add_button("Apply", 0, (GLUI_Update_CB)SetSerialPort); glui->add_separator(); glui->add_button("Pause", 0, Pause); glui->add_button("Single Step", 0, SingleStep); glui->add_button("Restart", 0, Restart); glui->add_button("Quit", 0,(GLUI_Update_CB)Exit); glui->add_separator(); glui->add_button("Help", 0,(GLUI_Update_CB)Help); glui->add_button("About", 0,(GLUI_Update_CB)About); glui->set_main_gfx_window( mainWindow ); // Use a timer to control the frame rate. glutTimerFunc(framePeriod, Timer, 0); glutMainLoop(); return 0; }
static void keyboard( unsigned char key, int , int ) { int winId = glutGetWindow(); Visualize *currWindow = _windows[winId - 1]; bool signflag = GetSignFlag(); bool fieldflag = GetFieldFlag(); bool meshflag = GetMeshFlag(); bool cellflag = GetCellFlag(); bool gradflag = GetGradientFlag(); bool borderflag = GetBorderFlag(); switch ( key ) { case '-': // Zoom out currWindow->d_angle++; break; case '+': // Zoom in currWindow->d_angle--; break; case 'd': // Show/hide distance field if (fieldflag == true) SetFieldFlag(false); else SetFieldFlag(true); break; case 's': // Toggle signed/unsigned distance field if (signflag == true) SetSignFlag(false); else SetSignFlag(true); break; case 'm': // Show/hide Mesh if (meshflag == true) SetMeshFlag(false); else SetMeshFlag(true); break; case 'c': // Show/hide cell centers if (cellflag == true) SetCellFlag(false); else SetCellFlag(true); break; case 'g': // Show/hide gradients if (gradflag == true) SetGradientFlag(false); else SetGradientFlag(true); break; case 'b': // Show/hide border flags if (borderflag == true) SetBorderFlag(false); else SetBorderFlag(true); break; case 'w': // Display regenerated surface and save it into a file if (newsurf != NULL) { Visualize *window2 = new Visualize(newsurf); glutDisplayFunc(display_cb); // register Display Function glutKeyboardFunc(keyboard); // register Keyboard Handler glutMouseWheelFunc(mouseWheel); // register scrollwheel handler glutSpecialFunc(SpecialInput); // register arrow keys glutMotionFunc(mouse_cb); // Save regenerated surface into a file std::string ext; DistIO::CutExt( _fileName, _fileName, ext ); newsurf->name(_fileName + "_NET"); newsurf->save(_fileName + "_NET" + ext); // Save Distance field into a file DistIO::GetInstance()->SaveDistField (distObj); } break; case 'f': // Save Distance field into a file DistIO::GetInstance()->SaveDistField (distObj); break; default: break; } glutPostRedisplay(); }
int main(int argc, char * argv[]) { char path[256]; engine = new Engine(argc, argv); ShaderProgram* defergbufferShader = new ShaderProgram(); FBO g_buffer(glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT), 1); FBO shadow_buffer(2000, 2000, 1); GET_SHADER_VISBUFFER_PATH(path, 256, "defergbuffer.vert"); if (!defergbufferShader->AddVertexShaderPath(path)) return 0; GET_SHADER_VISBUFFER_PATH(path, 256, "defergbuffer.frag"); if (!defergbufferShader->AddFragmentShaderPath(path)) return 0; if (!defergbufferShader->Link()) return 0; defergbufferShader->SetAttribVertex("vertex_coord"); defergbufferShader->SetAttribNormal("normal_coord"); ShaderProgram* shadowMapShader = new ShaderProgram(); GET_SHADER_VISBUFFER_PATH(path, 256, "shadow.vert"); if (!shadowMapShader->AddVertexShaderPath(path)) return 0; GET_SHADER_VISBUFFER_PATH(path, 256, "shadow.frag"); if (!shadowMapShader->AddFragmentShaderPath(path)) return 0; if (!shadowMapShader->Link()) return 0; shadowMapShader->SetAttribVertex("vertex"); ShaderProgram* shadowRenderShader = new ShaderProgram(); GET_SHADER_VISBUFFER_PATH(path, 256, "shadowRender.vert"); if (!shadowRenderShader->AddVertexShaderPath(path)) return 0; GET_SHADER_VISBUFFER_PATH(path, 256, "shadowRender.frag"); if (!shadowRenderShader->AddFragmentShaderPath(path)) return 0; if (!shadowRenderShader->Link()) return 0; shadowRenderShader->SetAttribVertex("vertex"); shadowRenderShader->SetAttribTexture("texture_coordinate"); // --------------SHADER LOADING-------------------------- GET_MODEL_PATH(path, 256, "bunny_smooth.ply"); Mesh bunny1, bunny2, bunny3; Mesh shadowBunny1, shadowBunny2, shadowBunny3; Mesh square1, square2, square3, square4, square5, square6; Mesh shadowSquare1, shadowSquare2, shadowSquare3, shadowSquare4, shadowSquare5, shadowSquare6; bunny1.Load(path); bunny2.Load(path); bunny3.Load(path); shadowBunny1.Load(path); shadowBunny2.Load(path); shadowBunny3.Load(path); square1.LoadSquare(); square2.LoadSquare(); square3.LoadSquare(); square4.LoadSquare(); square5.LoadSquare(); square6.LoadSquare(); shadowSquare1.LoadSquare(); shadowSquare2.LoadSquare(); shadowSquare3.LoadSquare(); shadowSquare4.LoadSquare(); shadowSquare5.LoadSquare(); shadowSquare6.LoadSquare(); GET_MODEL_PATH(path, 256, "sphere.ply"); Mesh Light1, Light2, Light3; Light1.Load(path); Light2.Load(path); Light3.Load(path); Mesh AmbientFSQ; AmbientFSQ.LoadSquare(); Mesh ShadowRenderFSQ; ShadowRenderFSQ.LoadSquare(); Mesh DeferredBRDFFSQ; DeferredBRDFFSQ.LoadSquare(); // ---------------MODEL LOADING-------------------------- Scene bunnyScene; bunnyScene.addObject(&bunny1); bunnyScene.addObject(&bunny2); bunnyScene.addObject(&bunny3); bunnyScene.addObject(&Light1); bunnyScene.addObject(&Light2); bunnyScene.addObject(&Light3); bunnyScene.addObject(&square1); bunnyScene.addObject(&square2); bunnyScene.addObject(&square3); bunnyScene.addObject(&square4); bunnyScene.addObject(&square5); bunnyScene.addObject(&square6); Scene ambientScene; ambientScene.addObject(&AmbientFSQ); Scene shadowMapScene; shadowMapScene.addObject(&shadowBunny1); shadowMapScene.addObject(&shadowBunny2); shadowMapScene.addObject(&shadowBunny3); shadowMapScene.addObject(&shadowSquare1); shadowMapScene.addObject(&shadowSquare2); shadowMapScene.addObject(&shadowSquare3); shadowMapScene.addObject(&shadowSquare4); shadowMapScene.addObject(&shadowSquare5); shadowMapScene.addObject(&shadowSquare6); Scene shadowRenderScene; shadowRenderScene.addObject(&ShadowRenderFSQ); Scene deferredBRDFScene; deferredBRDFScene.addObject(&DeferredBRDFFSQ); // --------------SCENE LOADING -------------------------- Pass gbufferPass(defergbufferShader, &bunnyScene); Pass shadowPass(shadowMapShader, &shadowMapScene); Pass shadowRenderPass(shadowRenderShader, &shadowRenderScene); gbufferPass.BindAttribNormal(); gbufferPass.BindAttribVertex(); shadowPass.BindAttribVertex(); shadowRenderPass.BindAttribVertex(); shadowRenderPass.BindAttribTexture(); // --------------- BIND ATTRIBUTES --------------------- gbufferPass.BindUniformMatrix4("ViewMatrix", &ViewMatrixPtr); gbufferPass.BindUniformMatrix4("ProjectionMatrix", &ProjectionMatrixPtr); shadowPass.BindUniformMatrix4("ViewMatrix", &Light1ViewMatrixPtr); shadowPass.BindUniformMatrix4("ProjectionMatrix", &ProjectionMatrixPtr); shadowRenderPass.BindUniformMatrix4("shadowMatrix", &Light1ShadowMatrixPtr); shadowRenderPass.BindUniformVec3("lightPos", &Light1PosPtr); shadowRenderPass.BindUniformVec3("eyePos", &EyePosPtr); shadowRenderPass.BindUniformVec3("lightValue", &Light1DiffusePtr); // ------------- BIND PASS-WISE UNIFORMS--------------- gbufferPass.MeshBindUniformMatrix4(&bunny1, "ModelMatrix", &Bunny1ModelMatrixPtr); gbufferPass.MeshBindUniformMatrix4(&bunny1, "NormalMatrix", &Bunny1NormalMatrixPtr); shadowRenderPass.MeshBindUniformVec3(&bunny1, "diffuse", &Bunny1DiffusePtr); shadowRenderPass.MeshBindUniformVec3(&bunny1, "specular", &Bunny1SpecularPtr); gbufferPass.MeshBindUniformMatrix4(&bunny2, "ModelMatrix", &Bunny2ModelMatrixPtr); gbufferPass.MeshBindUniformMatrix4(&bunny2, "NormalMatrix", &Bunny2NormalMatrixPtr); gbufferPass.MeshBindUniformVec3(&bunny2, "diffuse", &Bunny2DiffusePtr); gbufferPass.MeshBindUniformVec3(&bunny2, "specular", &Bunny2SpecularPtr); gbufferPass.MeshBindUniformMatrix4(&bunny3, "ModelMatrix", &Bunny3ModelMatrixPtr); gbufferPass.MeshBindUniformMatrix4(&bunny3, "NormalMatrix", &Bunny3NormalMatrixPtr); gbufferPass.MeshBindUniformVec3(&bunny3, "diffuse", &Bunny3DiffusePtr); gbufferPass.MeshBindUniformVec3(&bunny3, "specular", &Bunny3SpecularPtr); gbufferPass.MeshBindUniformMatrix4(&Light1, "ModelMatrix", &Light1ModelMatrixPtr); gbufferPass.MeshBindUniformMatrix4(&Light1, "NormalMatrix", &Light1NormalMatrixPtr); gbufferPass.MeshBindUniformVec3(&Light1, "diffuse", &Light1DiffusePtr); gbufferPass.MeshBindUniformVec3(&Light1, "specular", &Light1SpecularPtr); gbufferPass.MeshBindUniformMatrix4(&Light2, "ModelMatrix", &Light2ModelMatrixPtr); gbufferPass.MeshBindUniformMatrix4(&Light2, "NormalMatrix", &Light2NormalMatrixPtr); gbufferPass.MeshBindUniformVec3(&Light2, "diffuse", &Light2DiffusePtr); gbufferPass.MeshBindUniformVec3(&Light2, "specular", &Light2SpecularPtr); gbufferPass.MeshBindUniformMatrix4(&Light3, "ModelMatrix", &Light3ModelMatrixPtr); gbufferPass.MeshBindUniformMatrix4(&Light3, "NormalMatrix", &Light3NormalMatrixPtr); gbufferPass.MeshBindUniformVec3(&Light3, "diffuse", &Light3DiffusePtr); gbufferPass.MeshBindUniformVec3(&Light3, "specular", &Light3SpecularPtr); gbufferPass.MeshBindUniformMatrix4(&square1, "ModelMatrix", &Square1ModelMatrixPtr); gbufferPass.MeshBindUniformMatrix4(&square1, "NormalMatrix", &Square1NormalMatrixPtr); gbufferPass.MeshBindUniformVec3(&square1, "diffuse", &Square1DiffusePtr); gbufferPass.MeshBindUniformVec3(&square1, "specular", &Square1SpecularPtr); gbufferPass.MeshBindUniformMatrix4(&square2, "ModelMatrix", &Square2ModelMatrixPtr); gbufferPass.MeshBindUniformMatrix4(&square2, "NormalMatrix", &Square2NormalMatrixPtr); gbufferPass.MeshBindUniformVec3(&square2, "diffuse", &Square2DiffusePtr); gbufferPass.MeshBindUniformVec3(&square2, "specular", &Square2SpecularPtr); gbufferPass.MeshBindUniformMatrix4(&square3, "ModelMatrix", &Square3ModelMatrixPtr); gbufferPass.MeshBindUniformMatrix4(&square3, "NormalMatrix", &Square3NormalMatrixPtr); gbufferPass.MeshBindUniformVec3(&square3, "diffuse", &Square3DiffusePtr); gbufferPass.MeshBindUniformVec3(&square3, "specular", &Square3SpecularPtr); gbufferPass.MeshBindUniformMatrix4(&square4, "ModelMatrix", &Square4ModelMatrixPtr); gbufferPass.MeshBindUniformMatrix4(&square4, "NormalMatrix", &Square4NormalMatrixPtr); gbufferPass.MeshBindUniformVec3(&square4, "diffuse", &Square4DiffusePtr); gbufferPass.MeshBindUniformVec3(&square4, "specular", &Square4SpecularPtr); gbufferPass.MeshBindUniformMatrix4(&square5, "ModelMatrix", &Square5ModelMatrixPtr); gbufferPass.MeshBindUniformMatrix4(&square5, "NormalMatrix", &Square5NormalMatrixPtr); gbufferPass.MeshBindUniformVec3(&square5, "diffuse", &Square5DiffusePtr); gbufferPass.MeshBindUniformVec3(&square5, "specular", &Square5SpecularPtr); gbufferPass.MeshBindUniformMatrix4(&square6, "ModelMatrix", &Square6ModelMatrixPtr); gbufferPass.MeshBindUniformMatrix4(&square6, "NormalMatrix", &Square6NormalMatrixPtr); gbufferPass.MeshBindUniformVec3(&square6, "diffuse", &Square6DiffusePtr); gbufferPass.MeshBindUniformVec3(&square6, "specular", &Square6SpecularPtr); shadowPass.MeshBindUniformMatrix4(&shadowBunny1, "ModelMatrix", &Bunny1ModelMatrixPtr); shadowPass.MeshBindUniformMatrix4(&shadowBunny2, "ModelMatrix", &Bunny2ModelMatrixPtr); shadowPass.MeshBindUniformMatrix4(&shadowBunny3, "ModelMatrix", &Bunny3ModelMatrixPtr); shadowPass.MeshBindUniformMatrix4(&shadowSquare1, "ModelMatrix", &Square1ModelMatrixPtr); shadowPass.MeshBindUniformMatrix4(&shadowSquare2, "ModelMatrix", &Square2ModelMatrixPtr); shadowPass.MeshBindUniformMatrix4(&shadowSquare3, "ModelMatrix", &Square3ModelMatrixPtr); shadowPass.MeshBindUniformMatrix4(&shadowSquare4, "ModelMatrix", &Square4ModelMatrixPtr); shadowPass.MeshBindUniformMatrix4(&shadowSquare5, "ModelMatrix", &Square5ModelMatrixPtr); shadowPass.MeshBindUniformMatrix4(&shadowSquare6, "ModelMatrix", &Square6ModelMatrixPtr); // ------------BIND MESH-WISE UNIFORMS---------------- gbufferPass.SetTarget(&g_buffer); shadowPass.SetTarget(&shadow_buffer); Texture* visibilityTex = g_buffer.GetTexture(0); Texture* shadowTex = shadow_buffer.GetTexture(0); shadowRenderPass.BindTexture("visibilityTexture", visibilityTex); shadowRenderPass.BindTexture("shadowTexture", shadowTex); gbufferPass.SetBlend(false); gbufferPass.SetDepthTest(true); gbufferPass.SetClear(true); shadowPass.SetBlend(false); shadowPass.SetDepthTest(true); shadowPass.SetClear(true); shadowRenderPass.SetBlend(true); shadowRenderPass.SetDepthTest(false); shadowRenderPass.SetClear(false); // ---------------PASS CONFIG -------------------------- engine->addPass(&gbufferPass); engine->addPass(&shadowPass); engine->addPass(&shadowRenderPass); // ----------------ENGINE------------------------------ #ifdef _WIN32 glutMouseWheelFunc(mouseWheel); #endif glutDisplayFunc(Draw); glutMouseFunc(mouseClick); glutMotionFunc(mouseMove); glutKeyboardUpFunc(keyboardPress); glutMainLoop(); 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) { entry = g_testEntries + testIndex; test = entry->createFcn(); glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowSize(width, height); char title[32]; sprintf(title, "Box2D Version %d.%d.%d", b2_version.major, b2_version.minor, b2_version.revision); mainWindow = glutCreateWindow(title); //glutSetOption (GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); glutDisplayFunc(SimulationLoop); GLUI_Master.set_glutReshapeFunc(Resize); GLUI_Master.set_glutKeyboardFunc(Keyboard); GLUI_Master.set_glutSpecialFunc(KeyboardSpecial); GLUI_Master.set_glutMouseFunc(Mouse); glutMouseWheelFunc(MouseWheel); glutMotionFunc(MouseMotion); glui = GLUI_Master.create_glui_subwindow( mainWindow, GLUI_SUBWINDOW_RIGHT ); glui->add_statictext("Tests"); GLUI_Listbox* testList = glui->add_listbox("", &testSelection); glui->add_separator(); GLUI_Spinner* iterationSpinner = glui->add_spinner("Iterations", GLUI_SPINNER_INT, &settings.iterationCount); iterationSpinner->set_int_limits(1, 100); GLUI_Spinner* hertzSpinner = glui->add_spinner("Hertz", GLUI_SPINNER_FLOAT, &settings.hz); hertzSpinner->set_float_limits(5.0f, 200.0f); glui->add_checkbox("Position Correction", &settings.enablePositionCorrection); glui->add_checkbox("Warm Starting", &settings.enableWarmStarting); glui->add_checkbox("Time of Impact", &settings.enableTOI); glui->add_separator(); GLUI_Panel* drawPanel = glui->add_panel("Draw"); glui->add_checkbox_to_panel(drawPanel, "Shapes", &settings.drawShapes); glui->add_checkbox_to_panel(drawPanel, "Joints", &settings.drawJoints); glui->add_checkbox_to_panel(drawPanel, "Core Shapes", &settings.drawCoreShapes); glui->add_checkbox_to_panel(drawPanel, "AABBs", &settings.drawAABBs); glui->add_checkbox_to_panel(drawPanel, "OBBs", &settings.drawOBBs); glui->add_checkbox_to_panel(drawPanel, "Pairs", &settings.drawPairs); glui->add_checkbox_to_panel(drawPanel, "Contact Points", &settings.drawContactPoints); glui->add_checkbox_to_panel(drawPanel, "Contact Normals", &settings.drawContactNormals); glui->add_checkbox_to_panel(drawPanel, "Contact Forces", &settings.drawContactForces); glui->add_checkbox_to_panel(drawPanel, "Friction Forces", &settings.drawFrictionForces); glui->add_checkbox_to_panel(drawPanel, "Center of Masses", &settings.drawCOMs); glui->add_checkbox_to_panel(drawPanel, "Statistics", &settings.drawStats); int32 testCount = 0; TestEntry* e = g_testEntries; while (e->createFcn) { testList->add_item(testCount, e->name); ++testCount; ++e; } glui->add_button("Pause", 0, Pause); glui->add_button("Single Step", 0, SingleStep); glui->add_button("Quit", 0,(GLUI_Update_CB)exit); glui->set_main_gfx_window( mainWindow ); // Use a timer to control the frame rate. glutTimerFunc(framePeriod, Timer, 0); glutMainLoop(); return 0; }
static void init(const WindowInfo &window,const ContextInfo &context, const FramebufferInfo &framebuffer) { //initializam de 2 ori? if(_initialized) { std::cout<<"EROARE! GLUT - nu ma poti initializa de 2 ori, ar rezulta crash/eroare"<<std::endl; return; } //copiaza informatie pentru fereastra,context,framebuffer _context_information = context; _window_information = window; _framebuffer_information = framebuffer; //cerem glut un context OpenGL glutInitContextVersion(context.major_version, context.minor_version); glutInitContextFlags(GLUT_DEBUG); if (context.core) { glutInitContextProfile(GLUT_CORE_PROFILE); } else { glutInitContextProfile(GLUT_COMPATIBILITY_PROFILE); } //argumente fake pentru ca nu folosim glut in linie de comanda int fakeargc = 1; char *fakeargv[] = {"fake", NULL}; glutInit(&fakeargc, fakeargv); glutInitDisplayMode(framebuffer.flags); glutInitWindowPosition(window.start_position_x, window.start_position_y); glutInitWindowSize(window.width, window.height); glutCreateWindow(window.name.c_str()); //leaga functiile locale la GLUT glutIdleFunc(_idleCallback); glutCloseFunc(_closeCallback); glutDisplayFunc(_displayCallback); glutReshapeFunc(_reshapeCallback); glutKeyboardFunc(_keyboardDownCallback); glutKeyboardUpFunc(_keyboardUpCallback); glutSpecialFunc(_specialDownCallback); glutSpecialUpFunc(_specialUpCallback); glutMotionFunc(_motionCallback); glutPassiveMotionFunc(_passiveMotionCallback); glutMouseFunc(_mouseCallback); glutMouseWheelFunc(_mouseWheelCallback); //scrie la consola diverse detalii utile const unsigned char* renderer = glGetString( GL_RENDERER ); const unsigned char* vendor = glGetString( GL_VENDOR ); const unsigned char* version = glGetString( GL_VERSION ); std::cout<<"*******************************************************************************"<<std::endl; std::cout<<"GLUT:initializare"<<std::endl; std::cout<<"GLUT:\tVendor : "<<vendor<<std::endl; std::cout<<"GLUT:\tRenderer : "<<renderer<<std::endl; std::cout<<"GLUT:\tutilizez versiunea de OpenGl : "<<version<<std::endl; std::cout<<"GLUT:\tFereasta initiala se numeste `"<<window.name<<"`, are dimensiunile ("<<window.width<<"X"<<window.height; std::cout<<") incepe de la coordonatele de ecran ("<<window.start_position_x<<"X"<<window.start_position_y; std::cout<<") si "<<((window.is_reshapable)?"este":"nu este")<<" redimensionabila"<<std::endl; std::cout<<"GLUT:\tFramebuffer initial contine buffere(duble) pentru"<<std::endl; if(glutGet(GLUT_WINDOW_RGBA)) { int r_bits, g_bits, b_bits, a_bits; glGetIntegerv(GL_RED_BITS, &r_bits); glGetIntegerv(GL_GREEN_BITS, &g_bits); glGetIntegerv(GL_BLUE_BITS, &b_bits); glGetIntegerv(GL_ALPHA_BITS, &a_bits); std::cout<<"\tCuloare R"<<r_bits<<"G"<<g_bits<<"B"<<b_bits<<"A"<<a_bits<<std::endl; } if(_framebuffer_information.flags&GLUT_DEPTH) { int d_bits; glGetIntegerv(GL_DEPTH_BITS, &d_bits); std::cout<<"\tAdancime DEPTH"<<d_bits<<std::endl; } if(_framebuffer_information.flags&GLUT_STENCIL) { int s_bits; glGetIntegerv(GL_STENCIL_BITS, &s_bits); std::cout<<"\tStencil STENCIL"<<s_bits<<std::endl; } if(_framebuffer_information.flags&GLUT_MULTISAMPLE) { std::cout << "\tmultisampling cu 4 sample-uri per pixel" << std::endl; } std::cout<<"GLUT:\tContextul OpenGL este "<<_context_information.major_version<<"."<<_context_information.minor_version; std::cout<<" si profilul este de "<<((_context_information.core)?"core":"compatibilitate")<<std::endl; std::cout<<"*******************************************************************************"<<std::endl; //cand glut este inchis este returnat la main pentru oportunitatea de cleanup corect glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); //am terminat cu initializarea! _initialized=true; }
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(width, height); glutCreateWindow("OBJParser Demo"); // Callback Registration glutDisplayFunc(Render::renderScene); glutReshapeFunc(IO::changeSize); glutIdleFunc(Render::renderScene); // Mouse and Keyboard Callbacks glutKeyboardFunc(IO::processKeys); glutMouseFunc(IO::processMouseButtons); glutMotionFunc(IO::processMouseMotion); glutMouseWheelFunc ( IO::mouseWheel ) ; if(argc == 2) IO::parseInputFile(argv[1]); else std::cout << "Wrong number of command line arguments\n" << std::endl; // 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"); return 0; } // 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); //glutTimerFunc(1600, timer, 1); glutMainLoop(); // cleaning up textureIdMap.clear(); Render::clearMeshes(); // delete buffers glDeleteBuffers(1,&matricesUniBuffer); return(0); }
/************************************************************************* Constructor. *************************************************************************/ CEGuiOpenGLBaseApplication::CEGuiOpenGLBaseApplication() { // fake args for glutInit int argc = 1; const char* argv = "SampleApp"; // Do GLUT init glutInit(&argc, (char**)&argv); glutInitDisplayMode(GLUT_DEPTH|GLUT_DOUBLE|GLUT_RGBA); glutInitWindowSize(800, 600); glutInitWindowPosition(100, 100); glutCreateWindow("Crazy Eddie's GUI Mk-2 - Sample Application"); glutSetCursor(GLUT_CURSOR_NONE); d_renderer = new CEGUI::OpenGLRenderer(1024); new CEGUI::System(d_renderer); glutDisplayFunc(&CEGuiOpenGLBaseApplication::drawFrame); glutReshapeFunc(&CEGuiOpenGLBaseApplication::reshape); glutMotionFunc(&CEGuiOpenGLBaseApplication::mouseMotion); glutPassiveMotionFunc(&CEGuiOpenGLBaseApplication::mouseMotion); glutMouseFunc(&CEGuiOpenGLBaseApplication::mouseButton); glutKeyboardFunc(&CEGuiOpenGLBaseApplication::keyChar); glutSpecialFunc(&CEGuiOpenGLBaseApplication::keySpecial); #ifdef __FREEGLUT_EXT_H__ glutMouseWheelFunc(&CEGuiOpenGLBaseApplication::handleMouseWheel_freeglut); #endif // Set the clear color glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // initialise the required dirs for the DefaultResourceProvider CEGUI::DefaultResourceProvider* rp = static_cast<CEGUI::DefaultResourceProvider*> (CEGUI::System::getSingleton().getResourceProvider()); #ifndef __APPLE__ const char* dataPathPrefix = getDataPathPrefix(); char resourcePath[PATH_MAX]; // for each resource type, set a resource group directory sprintf(resourcePath, "%s/%s", dataPathPrefix, "schemes/"); rp->setResourceGroupDirectory("schemes", resourcePath); sprintf(resourcePath, "%s/%s", dataPathPrefix, "imagesets/"); rp->setResourceGroupDirectory("imagesets", resourcePath); sprintf(resourcePath, "%s/%s", dataPathPrefix, "fonts/"); rp->setResourceGroupDirectory("fonts", resourcePath); sprintf(resourcePath, "%s/%s", dataPathPrefix, "layouts/"); rp->setResourceGroupDirectory("layouts", resourcePath); sprintf(resourcePath, "%s/%s", dataPathPrefix, "looknfeel/"); rp->setResourceGroupDirectory("looknfeels", resourcePath); sprintf(resourcePath, "%s/%s", dataPathPrefix, "lua_scripts/"); rp->setResourceGroupDirectory("lua_scripts", resourcePath); #if defined(CEGUI_WITH_XERCES) && (CEGUI_DEFAULT_XMLPARSER == XercesParser) sprintf(resourcePath, "%s/%s", dataPathPrefix, "XMLRefSchema/"); rp->setResourceGroupDirectory("schemas", resourcePath); #endif #else rp->setResourceGroupDirectory("schemes", "datafiles/schemes/"); rp->setResourceGroupDirectory("imagesets", "datafiles/imagesets/"); rp->setResourceGroupDirectory("fonts", "datafiles/fonts/"); rp->setResourceGroupDirectory("layouts", "datafiles/layouts/"); rp->setResourceGroupDirectory("looknfeels", "datafiles/looknfeel/"); rp->setResourceGroupDirectory("lua_scripts", "datafiles/lua_scripts/"); #if defined(CEGUI_WITH_XERCES) && (CEGUI_DEFAULT_XMLPARSER == XercesParser) rp->setResourceGroupDirectory("schemas", "XMLRefSchema/"); #endif #endif }
//////////main関数///////////// int main(int argc, char** argv){ cubeSize_ = cubeSize/2.; int i=0, j=0, k=0; clock_t start_time_total,end_time_total; clock_t start_time[fileTotal]; clock_t end_time[fileTotal]; //char * filename[fileTotal]; //並列用 char * model_filename[fileTotal]; char * data_filename[fileTotal]; //Mat shape[fileTotal]; Mat shape_reg[fileTotal]; //Mat shape_temp[fileTotal]; Mat shape_fixed[fileTotal]; //並列用 Mat model_shape[fileTotal]; Mat data_shape[fileTotal]; Mat shape_temp[fileTotal][fileTotal]; Mat my_model_corr[fileTotal]; int myIndex[fileTotal][rows]; float myDist[fileTotal][rows]; RT<float> my_rt[fileTotal]; Mat_<float> model_mean; //modelファイルのデータ数 //model_rows = 16128; //dataファイルのデータ数 //data_rows = 16128; start_time_total = clock(); cout << "-------------" << endl; cout << "ICP Algorithm" << endl; cout << "-------------" << endl; #pragma omp parallel for for(fileCount=0;fileCount<fileTotal;fileCount++) { #pragma region // --- 点群のCSVファイルをcv::Matに取り込む --- if(fileCount>=1){ ///model //csvファイル名 model_filename[fileCount] = (char *)malloc(sizeof(char *) * 100); //sprintf(model_filename[fileCount],"%s/%s/%d.csv",filedir,dir,fileCount); sprintf(model_filename[fileCount],"%s/%s/points%02d.csv",filedir,dir,fileCount); //csvファイルのデータ数 model_rows[fileCount] = rows; //CSVファイル読み込み model_shape[fileCount] = csvread(model_filename[fileCount], model_rows[fileCount], cols); //コンソールにファイル名表示 //cout << "model点群データファイル名 " << model_filename[fileCount] << endl; } ///data //csvファイル名 data_filename[fileCount] = (char *)malloc(sizeof(char *) * 100); //sprintf(data_filename[fileCount],"%s/%s/%d.csv",filedir,dir,(fileCount+1)); sprintf(data_filename[fileCount],"%s/%s/points%02d.csv",filedir,dir,(fileCount+1)); //csvファイルのデータ数 data_rows[fileCount] = rows; //CSVファイル読み込み data_shape[fileCount] = csvread(data_filename[fileCount], data_rows[fileCount], cols); //コンソールにファイル名表示 cout << "点群データファイル名 " << data_filename[fileCount] << endl; #pragma endregion if(fileCount>=1){ #pragma region // --- ICPによるレジストレーション --- #if 1 // --- ICP実行する --- //実行時間計測開始 start_time[fileCount] = clock(); cout << "\t標準ICP開始" << endl; //ICP with flann search and unit quaternion method //cout << "kd-tree探索+クォータニオンにより[R/t]を推定します" << endl << endl; ClosestPointFlann model_shape_flann (model_shape[fileCount]); RT_L2 <float, SolveRot_eigen<float>> rt_solver; ICP <ClosestPointFlann> icp (model_shape_flann, rt_solver); icp.set(data_shape[fileCount]); icp.reg(100, 1.0e-6); //実行時間計測終了 end_time[fileCount] = clock(); //cout << "icp result : [R/t] =" << endl << (icp.rt) << endl << endl; cout << "\t" << data_filename[fileCount] << " icp error =" << icp.dk << endl; cout << "\t" << data_filename[fileCount] << " 実行時間 = " << (float)(end_time[fileCount] - start_time[fileCount])/CLOCKS_PER_SEC << "秒" << endl << endl; //データをローカル変数に格納 //my_model_corr[fileCount] = Mat::zeros(rows, cols, CV_32F); my_model_corr[fileCount].create(rows, cols, CV_32F); icp.model_corr.copyTo(my_model_corr[fileCount]); icp.rt.copyTo(my_rt[fileCount]); for(int k=0;k<data_rows[fileCount];k++){ myIndex[fileCount][k] = icp.index[k]; myDist[fileCount][k] = icp.distance[k]; } #else // --- ICP実行しない場合 --- shape_reg[fileCount] = data_shape[fileCount]; #endif #pragma endregion }else{ shape_reg[fileCount] = data_shape[fileCount]; } } #pragma region // --- 座標変換 --- //平均値の計算 reduce(shape_reg[0], model_mean, 0, CV_REDUCE_AVG); #pragma omp parallel for private(i,j,k) for(fileCount=0;fileCount<fileTotal;fileCount++) { if(fileCount>=1){ //得られたrtをdatashapeに適用 //その前にshape_tempの初期化 for(k=0;k<fileTotal;k++) { shape_temp[fileCount][k] = cv::Mat::zeros(data_rows[fileCount], cols, CV_32F); } shape_temp[fileCount][fileCount] = data_shape[fileCount]; for(k=0;k<fileCount;k++) { shape_temp[fileCount][fileCount-(k+1)] = my_rt[(fileCount-k)].transform(shape_temp[fileCount][fileCount-k]); } shape_reg[fileCount] = shape_temp[fileCount][0]; } shape_fixed[fileCount] = shape_reg[fileCount] - repeat(model_mean, shape_reg[fileCount].rows, 1); /* //メモリ割り当て points[fileCount] = (GLfloat *)malloc(sizeof(float)*data_rows[fileCount]*cols); //座標値をGLpointsに入れる for(i=0;i<data_rows[fileCount];i++){ for(j=0;j<cols;j++){ points[fileCount][i*cols+j] = shape_fixed[fileCount].at<float>(i,j); } }*/ #pragma endregion } #pragma region // --- OpenGLにデータ渡す --- //メモリ割り当て allpoints = (GLfloat *)malloc(sizeof(float)*rows*fileTotal*cols); for(fileCount=0;fileCount<fileTotal;fileCount++) { //座標値をallpointsに入れる for(int i=0;i<rows;i++){ for(int j=0;j<cols;j++){ allpoints[fileCount*rows*cols+i*cols+j] = shape_fixed[fileCount].at<float>(i,j); } } } #pragma endregion #pragma region // --- カメラRTの計算 --- Mat cameraRT[fileTotal]; Mat cameraR[fileTotal]; Mat cameraT[fileTotal]; cameraRT[0] = Mat::eye(4,4,CV_32F); cameraR[0] = Mat::eye(3,3,CV_32F); cameraT[0] = Mat::zeros(1,3,CV_32F); for(i=1;i<fileTotal;i++){ cameraRT[i] = Mat::eye(4,4,CV_32F); cameraR[i] = Mat::eye(3,3,CV_32F); cameraT[i] = Mat::zeros(1,3,CV_32F); Mat r = my_rt[i].operator()(Range(0,3),Range(0,3)); cameraR[i] = cameraR[i-1]*r.t(); Mat t = my_rt[i].operator()(Range(3,4),Range(0,3)); cameraT[i] = t*cameraR[i-1].t() + cameraT[i-1]; cameraRT[i].at<float>(0,0) = cameraR[i].at<float>(0,0); cameraRT[i].at<float>(0,1) = cameraR[i].at<float>(0,1); cameraRT[i].at<float>(0,2) = cameraR[i].at<float>(0,2); cameraRT[i].at<float>(1,0) = cameraR[i].at<float>(1,0); cameraRT[i].at<float>(1,1) = cameraR[i].at<float>(1,1); cameraRT[i].at<float>(1,2) = cameraR[i].at<float>(1,2); cameraRT[i].at<float>(2,0) = cameraR[i].at<float>(2,0); cameraRT[i].at<float>(2,1) = cameraR[i].at<float>(2,1); cameraRT[i].at<float>(2,2) = cameraR[i].at<float>(2,2); cameraRT[i].at<float>(3,0) = cameraT[i].at<float>(0,0); cameraRT[i].at<float>(3,1) = cameraT[i].at<float>(0,1); cameraRT[i].at<float>(3,2) = cameraT[i].at<float>(0,2); } #pragma endregion // --- データ出力 --- #if FILEOUTPUT /////////////////////////////// // 全ての点群(shape_fixed)をまとめて書き出し // pcd // FILE *outfp; char outfilename[100]; sprintf(outfilename,"%s/%s/result_xyz.pcd",outdir,dir); outfp = fopen(outfilename,"w"); if(outfp == NULL){ printf("%sファイルが開けません\n",outfilename); return -1; } int red = 255*256*256; int green = 255*256*256 + 255*256; int white = 255*256*256 + 255*256 + 255; fprintf(outfp,"# .PCD v.7 - Point Cloud Data file format\nVERSION .7\nFIELDS x y z rgb\nSIZE 4 4 4 4\nTYPE F F F F\nCOUNT 1 1 1 1\nWIDTH %d\nHEIGHT 1\nVIEWPOINT 0 0 0 1 0 0 0\nPOINTS %d\nDATA ascii\n", rows*fileTotal, rows*fileTotal); for(i=0;i<fileTotal;i++){ for(j=0;j<data_rows[i];j++){ fprintf(outfp,"%f %f %f %d\n", shape_reg[i].at<float>(j,0), shape_reg[i].at<float>(j,1), shape_reg[i].at<float>(j,2), green+(int)floor(255.*(i+1)/fileTotal)); } } fclose(outfp); /////////////////////////////// // 全ての点群(shape_fixed)をまとめて書き出し // csv // sprintf(outfilename,"%s/%s/allpoints.csv",outdir,dir); outfp = fopen(outfilename,"w"); if(outfp == NULL){ printf("%sファイルが開けません\n",outfilename); return -1; } for(i=0;i<fileTotal;i++){ for(j=0;j<data_rows[i];j++){ fprintf(outfp,"%f %f %f\n", shape_reg[i].at<float>(j,0), shape_reg[i].at<float>(j,1), shape_reg[i].at<float>(j,2)); } } fclose(outfp); /////////////////////////////// // 全ての点群(shape_fixed)をまとめて書き出し // result_xyz.csv // sprintf(outfilename,"%s/%s/result_xyz_icp.csv",outdir,dir); outfp = fopen(outfilename,"w"); if(outfp == NULL){ printf("%sファイルが開けません\n",outfilename); return -1; } for(i=0;i<fileTotal;i++){ for(j=0;j<data_rows[i];j++){ fprintf(outfp,"%f,%f,%f\n", shape_reg[i].at<float>(j,0), shape_reg[i].at<float>(j,1), shape_reg[i].at<float>(j,2)); } } fclose(outfp); ////////////////////////////////// // Corr(対応点), Index(対応点の要素番号), Distance(対応点間距離)の書き出し // FILE *outfp_corr; char outfilename_corr[100]; for(fileCount=1;fileCount<fileTotal;fileCount++){ ///Indexファイル sprintf(outfilename_corr,"%s/%s/index%02d.csv",outdir,dir,(fileCount)); outfp_corr = fopen(outfilename_corr,"w"); if(outfp_corr == NULL){ printf("%sファイルが開けません\n",outfilename_corr); return -1; } for(j=0;j<data_rows[fileCount];j++){ fprintf(outfp_corr,"%d\n", myIndex[fileCount][j]); } fclose(outfp_corr); ///Distanceファイル sprintf(outfilename_corr,"%s/%s/dist%02d.csv",outdir,dir,(fileCount)); outfp_corr = fopen(outfilename_corr,"w"); if(outfp_corr == NULL){ printf("%sファイルが開けません\n",outfilename_corr); return -1; } for(j=0;j<data_rows[fileCount];j++){ fprintf(outfp_corr,"%f\n", myDist[fileCount][j]); } fclose(outfp_corr); } for(fileCount=0;fileCount<fileTotal;fileCount++){ if(fileCount<(fileTotal-1)){ ///Corr点群ファイル sprintf(outfilename_corr,"%s/%s/corr%02d.csv",outdir,dir,(fileCount+1)); outfp_corr = fopen(outfilename_corr,"w"); if(outfp_corr == NULL){ printf("%sファイルが開けません\n",outfilename_corr); return -1; } for(j=0;j<data_rows[fileCount];j++){ //fprintf(outfp_corr,"%f %f %f\n", my_model_corr[fileCount].at<float>(j,0), my_model_corr[fileCount].at<float>(j,1), my_model_corr[fileCount].at<float>(j,2)); fprintf(outfp_corr,"%f %f %f\n", shape_reg[fileCount].at<float>(myIndex[fileCount+1][j],0), shape_reg[fileCount].at<float>(myIndex[fileCount+1][j],1), shape_reg[fileCount].at<float>(myIndex[fileCount+1][j],2)); } fclose(outfp_corr); }else{ ///Corr点群ファイル sprintf(outfilename_corr,"%s/%s/corr%02d.csv",outdir,dir,(fileCount+1)); outfp_corr = fopen(outfilename_corr,"w"); if(outfp_corr == NULL){ printf("%sファイルが開けません\n",outfilename_corr); return -1; } for(j=0;j<data_rows[fileCount];j++){ //fprintf(outfp_corr,"%f %f %f\n", my_model_corr[fileCount].at<float>(j,0), my_model_corr[fileCount].at<float>(j,1), my_model_corr[fileCount].at<float>(j,2)); fprintf(outfp_corr,"%f %f %f\n", shape_reg[fileCount].at<float>(j,0), shape_reg[fileCount].at<float>(j,1), shape_reg[fileCount].at<float>(j,2)); } fclose(outfp_corr); } } ///////////////////// // RTの書き出し // //my_rt[0]に恒等変換を代入 //Mat rt0 = (Mat_<float>(4,4) << 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); Mat rt0 = Mat::eye(4,4,CV_32F); rt0.copyTo(my_rt[0]); // Open File Storage char rtfilename[100]; sprintf(rtfilename,"%s/%s/rt.xml",outdir,dir); cv::FileStorage cvfs(rtfilename,CV_STORAGE_WRITE); cv::WriteStructContext ws(cvfs, "mat_rt", CV_NODE_SEQ); // create node for(int i=0; i<fileTotal; i++){ cv::write(cvfs,"",cameraRT[i]); } cvfs.release(); #endif //--- OpenGLで表示 --- #if GLVIEW // --- GLUT initialize --- initFlag(); initParam(); //window1 glutInit(&argc, argv); glutInitWindowPosition(0, 0); glutInitWindowSize(window_w, window_h); glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE ); window1 = glutCreateWindow("Window1"); glutMouseFunc(mouse); glutMotionFunc(drag); glutPassiveMotionFunc(passive); glutMouseWheelFunc ( MouseWheel ) ;//ホイールコールバック glutDisplayFunc(disp); glutIdleFunc(myGlutIdle); glutKeyboardFunc(glut_keyboard); glutIdleFunc(animate); glClearColor(0.0, 0.0, 0.0, 0.5); //背景色 glutMainLoop(); #endif //実行時間計測終了 end_time_total = clock(); cout << "-------------" << endl; cout << " Finish " << endl; cout << "-------------" << endl; cout << "プログラム実行時間 = " << (float)(end_time_total - start_time_total)/CLOCKS_PER_SEC << "秒" << endl << endl; //cvNamedWindow ("WaitKey", CV_WINDOW_AUTOSIZE); //cvWaitKey(0); return 0; }
int main(int argc, char **argv) { // GLUT initialization. glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_MULTISAMPLE); glEnable(GL_MULTISAMPLE); glutInitWindowSize(width, height); glutCreateWindow("Codebase 1, 3.3+ Edition"); glewInit(); if (glewIsSupported("GL_VERSION_2_0")) printf("Ready for OpenGL 2.0\n"); else { printf("OpenGL 2.0 not supported\n"); exit(1); } printf("%s\n", glGetString(GL_VERSION)); Controls = new controls(height, width); //Shaders glutDisplayFunc(Display); InitializeResources(); Controls->setCntrlsViewMatrix(ViewMatrix); Controls->setCntrlsProjectionMatrix(ProjectionMatrix); Controls->setVector(indexed_vertices); Controls->btInitDefaultMotionState(); glutReshapeFunc(ReshapeWindow); glutMotionFunc(Controls->mouseMoveWrapper); glutIdleFunc(Idle); glutKeyboardFunc(Controls->keyboardWrapper); glutMouseFunc(Controls->mouseButtonPressWrapper); glutMouseWheelFunc(Controls->Mouse_wheelWrapper); // Enter GLUT loop. glutMainLoop(); return 0; }