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