Ejemplo n.º 1
0
void init(int &argc, char* argv[], float width, float height) {
  glutInit(&argc, argv);
  int DISPLAY_TYPE = GLUT_RGBA | GLUT_DOUBLE;
  if(ALLOW_BLUR) {
    DISPLAY_TYPE = DISPLAY_TYPE | GLUT_ACCUM;
  }
  glutInitDisplayMode(DISPLAY_TYPE);
  glutInitWindowSize(width, height);
  glutCreateWindow("Newtonia");

  //glEnable(GL_DEPTH_TEST);
  //glDepthFunc(GL_LESS);
  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
  glEnable(GL_LINE_SMOOTH);
  glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
  glEnable(GL_POINT_SMOOTH);
  if(ALLOW_BLUR) {
    glEnable(GL_ACCUM);
    glClear(GL_ACCUM_BUFFER_BIT);
  }

  glutDisplayFunc(draw);
  glutKeyboardFunc(keyboard);
  glutKeyboardUpFunc(keyboard_up);
  glutSpecialFunc(special);
  glutSpecialUpFunc(special_up);
  glutReshapeFunc(resize);
  glutVisibilityFunc(isVisible);
}
Ejemplo n.º 2
0
int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize (500, 500); 
    glutInitWindowPosition (100, 100);
    glutCreateWindow (argv[0]);
    init ();
    glutDisplayFunc(display); 
    glutReshapeFunc(reshape);
    
    //keyboard inputs
    glutKeyboardFunc(keyboard);
    
    //30 frames per second
    glutTimerFunc(30, timerFunc, 0);
    
    //special keyboard inputs like the up, down, left, right arrow keys
    glutSpecialFunc(control);
    glutSpecialUpFunc(letgo);
    
    
    glutMainLoop();
    return 0;
}
Ejemplo n.º 3
0
static void
glutStuff(int argc, const char *argv[])
{
	glutInit(&argc, (char**)argv);
	
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
	
	glutInitWindowSize(640, 480);
	glutCreateWindow(demoTitle(demoIndex));
	
	initGL();
	
	glutReshapeFunc(reshape);
	glutDisplayFunc(display);
//	glutIdleFunc(idle);
	glutTimerFunc(SLEEP_TICKS, timercall, 0);

	glutIgnoreKeyRepeat(1);
	glutKeyboardFunc(keyboard);
	
	glutSpecialFunc(arrowKeyDownFunc);
	glutSpecialUpFunc(arrowKeyUpFunc);

	glutMotionFunc(mouse);
	glutPassiveMotionFunc(mouse);
	glutMouseFunc(click);
}
Ejemplo n.º 4
0
int main( int argc, char **argv ) {
    glutInit( &argc, argv );
    glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGBA );
    glutInitWindowSize( 640, 480 );
    glutCreateWindow( "Origami Simulation C++" );
    glClearColor( 0.0, 0.0, 0.0, 1.0 );

    glutReshapeFunc( reshape );
    glutDisplayFunc( display );
    glutTimerFunc(1000/State.fps , timer , 0);
    glutMouseFunc( mouse );
    glutMotionFunc( motion );
    glutKeyboardFunc( keyboard );
    glutKeyboardUpFunc( keyboardUp );
    glutSpecialFunc( special );
    glutSpecialUpFunc( specialUp );
    glutCreateMenu( menu );
    glutAddMenuEntry( "Quit (Q)", 1 );
    glutAddMenuEntry( "Rotation On/Off (R)", 2 );
    glutAddMenuEntry( "Coordinates Axis On/Off (A)", 3 );
    glutAddMenuEntry( "Save Folding", 4 );
    glutAddMenuEntry( "Load Folding", 5 );
    glutAddMenuEntry("Animation On/Off", 6);
    glutAddMenuEntry("Undo a Fold (Z)", 7);
    glutAddMenuEntry("Initialize Folds (I)", 8);
    glutAttachMenu( GLUT_RIGHT_BUTTON );
    glutMainLoop();
    return 0;
}
Ejemplo n.º 5
0
int main(int argc, char **argv) 
{

	// Initialize the window with depth, double buffering and RGBA colors
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
	glutInitWindowPosition(100,100);
	glutInitWindowSize(320,320);
	glutCreateWindow("The Middle of Nowhere");

	// Enable depth calculations
	glEnable(GL_DEPTH_TEST);

	// renderScene will be our main drawing routine invoked everytime
	glutDisplayFunc(renderScene);
	glutIdleFunc(renderScene);
	
	// If the window is resized
	glutReshapeFunc(changeSize);

	// Keyboard event processing
	glutIgnoreKeyRepeat(1);
	glutKeyboardFunc(processNormalKeys);
	glutSpecialFunc(pressKey);
	glutSpecialUpFunc(releaseKey);

	// Mouse event processing
	glutMouseFunc(mouseButton);
	glutMotionFunc(mouseMove);
	
	// Start the scene
	glutMainLoop();

	return 0;
}
Ejemplo n.º 6
0
/** Activate a screen and make it current.
    @ingroup	gui
    @param	screen	Screen to activate
    @warning	The current screen at the call time is deactivated.
 */
void
GfuiScreenActivate(void *screen)
{
	if ((GfuiScreen) && (GfuiScreen->onDeactivate)) GfuiScreen->onDeactivate(GfuiScreen->userDeactData);
	
	GfuiScreen = (tGfuiScreen*)screen;
	
	glutKeyboardFunc(gfuiKeyboard);
	glutSpecialFunc(gfuiSpecial);
	glutKeyboardUpFunc(gfuiKeyboardUp);
	glutSpecialUpFunc(gfuiSpecialUp);
	glutMouseFunc(gfuiMouse);
	glutMotionFunc(gfuiMotion);
	glutPassiveMotionFunc(gfuiPassiveMotion);
	glutIdleFunc((void(*)(void))NULL);
	
	if (GfuiScreen->onlyCallback == 0) {
		if (GfuiScreen->hasFocus == NULL) {
			gfuiSelectNext(NULL);
		}
		glutDisplayFunc(GfuiDisplay);
	} else {
		glutDisplayFunc(GfuiDisplayNothing);
	}
	
	if (GfuiScreen->onActivate) GfuiScreen->onActivate(GfuiScreen->userActData);
	
	if (GfuiScreen->onlyCallback == 0) {
		GfuiDisplay();
		glutPostRedisplay();
	}
}
Ejemplo n.º 7
0
void MainWindow::initGlut()
{
	// Create dummy arguments for command line options
	int dummy_argc = 1;
	char *dummy_argv[1];
	dummy_argv[0] = new char[255];
	dummy_argv[0] = (char*)"Main Window";

	// Initialize glut toolkit
	glutInit(&dummy_argc, dummy_argv);
	glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
	glutInitWindowPosition(100,100);
	glutInitWindowSize(762, 576);
	glutCreateWindow("3D-Viewer");
	glutSetKeyRepeat(1);

	//Register callback functions
	glutDisplayFunc(MainWindow::callback_render);
	glutReshapeFunc(MainWindow::callback_reshape);
	glutMouseFunc(MainWindow::callback_mouse);
	glutMotionFunc(MainWindow::callback_motion);
	glutKeyboardFunc(MainWindow::callback_key);
	glutKeyboardUpFunc(MainWindow::callback_keyUp);
	glutSpecialFunc(MainWindow::callback_specialkey);
	glutSpecialUpFunc(MainWindow::callback_specialkeyUp);
	glutTimerFunc(15, MainWindow::callback_timer, 0);
	// glutIdleFunc(MainWindow::callback_render);

	// Init OpenGL stuff
	initGL();

	// Call glut main loop to hold window at top
	glutMainLoop();
}
Ejemplo n.º 8
0
//---------------------------------------------------------
int main(int argc, char** argv)
{ 
	glutInit(&argc, argv);
	Game.m_screenW = INITIAL_WORLD_SIZE;
	Game.m_screenH = INITIAL_WORLD_SIZE;
	glutInitWindowSize(Game.m_screenW,Game.m_screenH);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH );
	glutCreateWindow("AIsteroids");

	glutReshapeFunc(Reshape);
	glutDisplayFunc(Display);
	glutIdleFunc(Idle);
	glutVisibilityFunc(Visible);
	
	//sets up the keyboard functions
	glutKeyboardFunc(Key);	
	glutKeyboardUpFunc(KeyUp);	
	glutSpecialFunc(SpecialKey);	
	glutSpecialUpFunc(SpecialKeyUp);	

	glInitColorArray();
	srand(time(NULL));	
	Game.StartGame();
	glutMainLoop();
  return 0;             
}
Ejemplo n.º 9
0
int main (int argc, char **argv)
{
   //Configure initial window state
   glutInit(&argc, argv); 
   glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
   glutInitWindowPosition (5, 5);
   glutInitWindowSize (640, 640);
   int win = glutCreateWindow ("Imgui demo");

   printGlInfo();

   //Register callback functions with glut. 
   glutDisplayFunc(display); 
   glutKeyboardFunc(keyboard);
   glutSpecialFunc(special);
   glutKeyboardUpFunc(keyboard_up);
   glutSpecialUpFunc(special_up);
   glutMouseFunc(mouse);
   glutMotionFunc(motion);
   glutPassiveMotionFunc(motion);

   glutIdleFunc(idle);

   initOpenGl();
   ImGui_ImplGlut_Init(); // initialize the imgui system

   //Enter the glut event loop.
   glutMainLoop();
   glutDestroyWindow(win);
   return 0;		
}
Ejemplo n.º 10
0
int main(int argc, char **argv)
{
	// set window values
	win1.width = 640*1.5;
	win1.height = 480*1.5;
	win1.title = "Tutorial 4";
	win1.fovAngle = 45;
	win1.zNear = 0.1f;
	win1.zFar = 500.0f;

	//initialize and run program
	glutInit(&argc, argv);                                      // GLUT initialization
	glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);  // Display Mode
	glutInitWindowSize(win1.width, win1.height);					// set window size
	win1.id = glutCreateWindow(win1.title);					    // create Window

	glutDisplayFunc(display);									// register Display Function
	glutKeyboardUpFunc(keyboardUp);								    // register Keyboard Handler
	glutKeyboardFunc(keyboardDown);								    // register Keyboard Handler
	glutSpecialUpFunc(specialUp);
	glutSpecialFunc(specialDown);
	glutCloseFunc(close);

	GLenum res = glewInit();
	if (res != GLEW_OK) {
		fprintf(stderr, "Error: '%s'\n", glewGetErrorString(res));
		return 1;
	}

	initShaders();
	initialize();
	glutMainLoop();												// run GLUT mainloop
	return 0;
}
Ejemplo n.º 11
0
void GlutRenderer::initGraphics(int width, int height)
{
	m_glutScreenWidth = width;
	m_glutScreenHeight = height;
		
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);

	glutInitWindowSize(m_glutScreenWidth, m_glutScreenHeight);
	glutCreateWindow("GPU rigid body pipeline2");
	glutKeyboardFunc(glutKeyboardCallback);
	glutKeyboardUpFunc(glutKeyboardUpCallback);
	glutSpecialFunc(glutSpecialKeyboardCallback);
	glutSpecialUpFunc(glutSpecialKeyboardUpCallback);
	glutReshapeFunc(glutReshapeCallback);
	glutIdleFunc(glutIdleCallback);
	glutMouseFunc(glutMouseFuncCallback);
	glutPassiveMotionFunc(glutMotionFuncCallback);
	glutMotionFunc(glutMotionFuncCallback);
	glutDisplayFunc( glutDisplayCallback );

	GLenum err = glewInit();
	if (GLEW_OK != err)
	{
		printf("Error: %s\n", glewGetErrorString(err));
	}

	glClearColor(0.6f,0.6f,1.f,1.f);
}
Ejemplo n.º 12
0
void glutStuff(int argc, const char *argv[])
{

	glutInitWindowSize(900,600);
	glutInitWindowPosition(100,100);
	glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
	// glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE );
	glutInit(&argc, const_cast<char**>(argv));

	glutCreateWindow("J7");


	glutDisplayFunc(display);
	glutIdleFunc(idle);
	glutReshapeFunc(reshape);
  glutKeyboardFunc(keyDown);        // key down 
  glutKeyboardUpFunc(keyUp);        // key up  
  glutSpecialFunc(keySpecialDown);  // special key down 
  glutSpecialUpFunc(keySpecialUp);  // special key up
  glutPassiveMotionFunc(mouseMove); // for moving the mouse
  glutMouseFunc(mouse); // for scroll wheel
  
    glutSetCursor(GLUT_CURSOR_NONE); // hide cursor
  	glutWarpPointer((w/2), (h/2));

}
Ejemplo n.º 13
0
int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
    glutInitWindowPosition(100,100); // seta a posição da janela
    glutInitWindowSize(600,400); // seta o tamanho da janela
    glutCreateWindow("Trabalho CG"); // título da janela

    glutDisplayFunc(renderScene); // função de dispĺay
    glutReshapeFunc(changeSize); // redesenho
    glutIdleFunc(renderScene);

    glutIgnoreKeyRepeat(1);
    glutKeyboardFunc(processNormalKeys);
    glutSpecialFunc(pressKey);
    glutSpecialUpFunc(releaseKey);

    glutMouseFunc(mouseButton);
    glutMotionFunc(mouseMove);

    glEnable(GL_DEPTH_TEST);

    glutMainLoop(); // deixa o app em loop

    return 1;
}
Ejemplo n.º 14
0
int main(int argc, char** argv){

	glutInit(&argc, argv);	

	glutInitDisplayMode (GLUT_DOUBLE | GLUT_ALPHA );
	glutInitContextVersion (3, 3);
	glutInitContextProfile(GLUT_CORE_PROFILE);

	glutInitWindowSize (windowWidth, windowHeight); 
	glutInitWindowPosition (300, 200);
	glutCreateWindow ("My window GL");

	if(gl3wInit()<0)
		return 1;

	glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION);
	
	init();
	glutDisplayFunc(display); 
	glutReshapeFunc(reshape);
	glutSpecialFunc(keyboardS);
	glutSpecialUpFunc(keyboardSpecialUpFunc);
	glutMouseFunc(mouseFcn);
	glutMotionFunc(mouseMoveFnc);
	glutMouseWheelFunc(mouseWheelFnc);
	glutMainLoop();

	finalizeProgram(gouraudShading);
	return(0);
}
int main(int argc, char **argv) {

	// init GLUT and create window
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
	glutInitWindowPosition(200, 100);
	glutInitWindowSize(800, 600);
	glutCreateWindow("Lighthouse3D - GLUT Tutorial");

	// register callbacks
	glutDisplayFunc(renderScene);
	glutReshapeFunc(changeSize);
	glutIdleFunc(renderScene);

	glutSpecialFunc(pressKey);

	// here are the new entries
	glutIgnoreKeyRepeat(1);
	glutSpecialUpFunc(releaseKey);

	// OpenGL init
	glEnable(GL_DEPTH_TEST);

	// enter GLUT event processing cycle
	glutMainLoop();
	
	return 1;
}
Ejemplo n.º 16
0
int main( int argc, char** argv )
{
    // initialize
    glutInit( &argc, argv );
    glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH );
    glutInitWindowSize( windowW, windowH );
    glutCreateWindow( "CSE 40166 Midterm Project" );
    
    // set callbacks
    glutDisplayFunc( display );
    glutReshapeFunc( resize );
    glutKeyboardFunc( keyboard );
    glutSpecialFunc( keyboardSpecials );
    glutKeyboardUpFunc( keyboardUp );
    glutSpecialUpFunc( keyboardSpecialsUp );
    glutTimerFunc( mspf, move, 0 );
    
    // setup data
    if( !init() )
    {
        exit( EXIT_FAILURE );
    }
    
    // run
    glutMainLoop();
    
    return EXIT_SUCCESS;
}
Ejemplo n.º 17
0
void GraphicalEngine::Init(int argc, char * argv[])						//inicjacja parametrow OpenGl i tworzenie okna
{

	for (int i = 0; i < 255; i++) {
		Instance->keyboard[i] = false;
	}


	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH | GLUT_STENCIL);
	glutInitWindowSize(Instance->resolution.Width, Instance->resolution.Height);

	glutCreateWindow(WINDOW_TITLE);
	//glutFullScreen();
	glutKeyboardFunc(GraphicalEngine::KeyboardFunc);
	glutKeyboardUpFunc(GraphicalEngine::KeyboardUpFunc);
	glutSpecialFunc(GraphicalEngine::SpecialFunc);
	glutSpecialUpFunc(GraphicalEngine::SpecialUpFunc);
	glutDisplayFunc(GraphicalEngine::DisplayFunc);
	glutPassiveMotionFunc(GraphicalEngine::PassiveMotionFunc);
	glutReshapeFunc(GraphicalEngine::ReshapeFunc);
	glutIdleFunc(GraphicalEngine::DisplayFunc);
	GLenum err = glewInit();
	if (GLEW_OK != err)
	{
		fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
	}
	int major = 0, minor = 0;
	const char * version = (char *)glGetString(GL_VERSION);
	if (sscanf(version, "%d.%d", &major, &minor) != 2)
	{
		printf("Bledny format wersji OpenGL\n");

	}
}
Ejemplo n.º 18
0
//------------------------------------------------------------
void ofAppGlutWindow::initializeWindow(){


    //----------------------
    // setup the callbacks

    glutMouseFunc(mouse_cb);
    glutMotionFunc(motion_cb);
    glutPassiveMotionFunc(passive_motion_cb);
    glutIdleFunc(idle_cb);
    glutDisplayFunc(display);

    glutKeyboardFunc(keyboard_cb);
    glutKeyboardUpFunc(keyboard_up_cb);
    glutSpecialFunc(special_key_cb);
    glutSpecialUpFunc(special_key_up_cb);

    glutReshapeFunc(resize_cb);

#ifdef TARGET_OSX
	//glutDragEventFunc(dragEvent);
#endif

    nFramesSinceWindowResized = 0;

    #ifdef TARGET_WIN32
        //----------------------
        // this is specific to windows (respond properly to close / destroy)
        fixCloseWindowOnWin32();
    #endif

}
Ejemplo n.º 19
0
void CG1Helper::initApplication(CGContext* &_context, int width, int height, int windowScale)
{
  init_timer();
  _context = new CGContext(width,height);
  smContext = _context;
  //smContext.cgViewport(100,100);
  int argc = 1;
  char** argv = new char*[1];
  argv[0] = new char[2];
  argv[0][0] = 'a';
  argv[0][1] = 0;
  glutInit(&argc, argv);
  glutInitDisplayMode (GLUT_RGBA |  GLUT_DEPTH | GLUT_DOUBLE | GLUT_ALPHA | GLUT_MULTISAMPLE);
  int scale = windowScale>0?windowScale:1;
  glutInitWindowSize(width*scale, height*scale);
  glutCreateWindow("CG1 Template");

  glGenTextures(1, &FBTexture);
  glBindTexture(GL_TEXTURE_2D,FBTexture);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height,0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
  glBindTexture(GL_TEXTURE_2D,0);

  glutDisplayFunc(m_displayFunc);
  glutReshapeFunc(m_reshapeFunc);
  glutIdleFunc(m_idleFunc);
  glutKeyboardFunc(m_keyboardFunc);
  glutKeyboardUpFunc(m_keyboardUpFunc);
  glutSpecialFunc(m_specialKeyboardFunc);
  glutSpecialUpFunc(m_specialKeyboardUpFunc);
  delete [] argv[0];
  delete [] argv;
}
Ejemplo n.º 20
0
////////////////////////////////////////////////////
//メイン関数
////////////////////////////////////////////////////
int main(int argc, char *argv[])
{

	glutInit(&argc, argv);
	glutInitWindowSize(1200, 840);
	glutCreateWindow("game");

	glutDisplayFunc(display);
	glutTimerFunc(0, timer, 0);

	//マウス操作
	glutMouseFunc(mouse);
	glutMotionFunc(motion);
	glutPassiveMotionFunc(passiveMotion);

	//キーボード操作
	glutKeyboardFunc(keyboard);
	glutKeyboardUpFunc(keyboardUp);
	glutSpecialFunc(special);
	glutSpecialUpFunc(specialUp);

	glutIgnoreKeyRepeat(GL_TRUE);

	init();
	glutMainLoop();

}
Ejemplo n.º 21
0
	void GlutFramework::startFramework(
	        int argc, char *argv[], std::string title, int width, int height,
	        int posx, int posy, double fps) {

	    // Sets the instance to this, used in the callback wrapper functions
		setInstance();
		this->frameTime = 1.0 / fps * 1000.0;

		// Initialize GLUT
		glutInit(&argc, argv);
		glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
		glutInitWindowSize(width, height);
		glutInitWindowPosition(0, 100);
		this->window = glutCreateWindow(title.c_str());

        init();                     // Initialize

		// Function callbacks with wrapper functions
        glutDisplayFunc(displayWrapper);
		glutReshapeFunc(reshapeWrapper);
        glutIdleFunc(runWrapper);
		glutMouseFunc(mouseButtonPressWrapper);
		glutMotionFunc(mouseMoveWrapper);
		glutKeyboardFunc(keyboardDownWrapper);
		glutKeyboardUpFunc(keyboardUpWrapper);
		glutSpecialFunc(specialKeyboardDownWrapper);
		glutSpecialUpFunc(specialKeyboardUpWrapper);
		glutMainLoop();
	}
Ejemplo n.º 22
0
int main(int argc, char *argv[]){
	// OpenGL initialization
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_ALPHA);
	// 
	glutInitWindowSize(640,480);
	// 
	glutCreateWindow("OpenGL");
	// 
	initOpenGL();

	GLenum err = glewInit();
	if(GLEW_OK != err){
		printf("Error: %s", glewGetErrorString(err));
	}
	
	// display scene
	glutDisplayFunc(drawScene);	

	// choose function when window reshape
    glutReshapeFunc( reshapeScreen );

	glutKeyboardFunc(keyDown);
	glutKeyboardUpFunc(keyUp);
	
	glutSpecialFunc(specialKeyDown);
	glutSpecialUpFunc(specialKeyUp);

	//Mouse
	glutMouseFunc(mouseFunction);
	glutMainLoop();

	return 0;
}
Ejemplo n.º 23
0
int main(int argc, char** argv)
{
	if (argc != 2) {
		printf("usage: luaplayer script.lua\n");
		return 1;
	}
	g_vram_base = fb;
	memset(fb, 0, WIDTH * HEIGHT * 2);

  initMikmod();
	initGraphics();
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
	glutInitWindowPosition(50, 50);
	glutInitWindowSize(WIDTH, HEIGHT);
	
	glutCreateWindow("Lua Player by klozz");
	glutDisplayFunc(display);
	glutReshapeFunc(reshape);
	glutIgnoreKeyRepeat(1);
	glutKeyboardFunc(keyboard);
	glutKeyboardUpFunc(keyboardUp);
	glutSpecialFunc(special);
	glutSpecialUpFunc(specialUp);
	
	glutIdleFunc(idle);
	DWORD threadID;
	HANDLE luaThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) LuaThread, argv[1], 0, &threadID);
	glutMainLoop();
	return 0;
}
Ejemplo n.º 24
0
///////////////////////////////////////////////////////////////////////////////
// initialize GLUT for windowing
///////////////////////////////////////////////////////////////////////////////
int initGLUT(int argc, char **argv) {
    // GLUT stuff for windowing
    // initialization openGL window.
    // it is called before any other GLUT routine
    glutInit(&argc, argv);

    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_ALPHA); // display mode

    glutInitWindowSize(SCREEN_WIDTH, SCREEN_HEIGHT);               // window size

    glutInitWindowPosition(100, 100);           // window location

    // finally, create a window with openGL context
    // Window will not displayed until glutMainLoop() is called
    // it returns a unique ID
    int handle = glutCreateWindow(argv[0]);     // param is the title of window

    // register GLUT callback functions
    glutDisplayFunc(displayCB);
    glutTimerFunc(INPUT_UPDATE_TIME, KeyboardTimerCB, INPUT_UPDATE_TIME);		// set up timer callback for updating input state
    glutTimerFunc(NETWORK_UPDATE_TIME, NetworkTimerCB, NETWORK_UPDATE_TIME);	// set up timer callback for Sending info to server
    glutIdleFunc(idleCB);                       // redraw only every given millisec
    glutReshapeFunc(reshapeCB);
    glutKeyboardFunc(keyboardCB);
	glutKeyboardUpFunc(keyboardUpCB);
	glutSpecialFunc(specialKeyCB);			// used for the arrow keys etc.
	glutSpecialUpFunc(specialKeyUpCB);
    glutMouseFunc(mouseCB);
    glutMotionFunc(mouseMotionCB);		// used when the mouse moves and a mouse-button is held
	glutPassiveMotionFunc(mousePassiveMotionCB);	// used when the mouse moves and NO mouse-buttons are held
	
	//glutSetCursor(GLUT_CURSOR_NONE);		// used to hide the cursor

    return handle;
}
Ejemplo n.º 25
0
void startGlutApplication(std::string windowName, int windowWidth, int windowHeight)
{
    int argc = 0;
    char** argv = {};
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_MULTISAMPLE);
    glutInitWindowPosition(0, 0);
    glutInitWindowSize(windowWidth, windowHeight);
    glutCreateWindow(windowName.c_str());

    glutDisplayFunc(::display);
    glutReshapeFunc(::reshape);
    glutKeyboardFunc(::keyboard);
    glutKeyboardUpFunc(::keyboardUp);
    glutMouseFunc(::mouse);
    glutMotionFunc(::mouseMotion);
    glutSpecialFunc(::special);
    glutSpecialUpFunc(::specialUp);

    glEnable(GL_MULTISAMPLE);
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0, windowWidth, windowHeight, 0, -1.0, 1.0);

    glutTimerFunc(updatePeriod, ::update, 0);
    glutMainLoop();
}
Ejemplo n.º 26
0
int main(int argc, char **argv)
{
	srand(get_tick_count());
	memset(&kb, 0, sizeof(kb));
	set_keys();
	player_init(&p1);
	smp_alloc((void*)&p1);
	graphics_init();
	physics_init();
	glutInit(&argc, argv);
	glutInitWindowPosition(200, 100);
	glutInitWindowSize(window_x, window_y);
	glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
	glutCreateWindow(PROGRAM_NAME);
	glutDisplayFunc(graphics_loop);
	glutIdleFunc(graphics_loop);
	glutReshapeFunc(reshape);
	glutKeyboardFunc(kb_controller_dn_char);
	glutKeyboardUpFunc(kb_controller_up_char);
	glutSpecialFunc(kb_controller_dn);
	glutSpecialUpFunc(kb_controller_up);
	glutMouseFunc(mouse_handler);
	glutMotionFunc(mouse_motion_handler);
 	glutPassiveMotionFunc(mouse_motion_handler);
	threads.phys_main = thread_create(physics_loop, NULL);
	glutMainLoop();
	return EXIT_SUCCESS; 
}
Ejemplo n.º 27
0
void Sim::init(int* argc, char* argv[], const string& title) {
  glutInit(argc, argv);
  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
  glutInitWindowSize(800, 800);
  glutInitContextVersion(3, 1);
  glutInitContextProfile(GLUT_FORWARD_COMPATIBLE);
  glutInitContextProfile(GLUT_CORE_PROFILE);
  glutCreateWindow(title.c_str());
  glewExperimental = true;
  glewInit();

  glutKeyboardFunc(keyboard_down);
  glutKeyboardUpFunc(keyboard_up);
  glutSpecialFunc(keyboard_special_down);
  glutSpecialUpFunc(keyboard_special_up);
  glutReshapeFunc(reshape);
  
  glutSetKeyRepeat(GLUT_KEY_REPEAT_OFF);
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_TEXTURE_2D);
  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  glClearColor(0.0, 0.0, 0.0, 1.0);
  glShadeModel(GL_SMOOTH);
}
Ejemplo n.º 28
0
int main(int argc, char** argv)
{
    // init GLUT
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
    glutInitWindowSize(640, 480);
    glutInitWindowPosition(300, 200);
    
    // create window
    glutCreateWindow("Arkanoid");
    
    // bind callbacks
    glutDisplayFunc(Director::display);
    glutReshapeFunc(Director::reshape);
    glutTimerFunc(0, Director::timer, 0);
    glutSpecialFunc(Director::keyDown);
    glutSpecialUpFunc(Director::keyUp);
    glutKeyboardFunc(Director::keyDown);
    glutKeyboardUpFunc(Director::keyUp);
    
    // run game scene
    Game game;
    Director::getInstance().run(&game);
    
    // start main loop
    glutMainLoop();
    
    return 0;
}
//-----------------------------------------------------------------------------
// Name: initialize_glut( )
// Desc: Initializes Glut with the global vars
//-----------------------------------------------------------------------------
void initialize_glut(int argc, char *argv[]) {
    // initialize GLUT
    glutInit( &argc, argv );
    // double buffer, use rgb color, enable depth buffer
    glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
    // initialize the window size
    glutInitWindowSize( g_width, g_height );
    // set the window postion
    glutInitWindowPosition( 400, 100 );
    // create the window
    glutCreateWindow( "Vinyl Visualizer");
    // full screen
    if( g_fullscreen )
        glutFullScreen();

    // set the idle function - called when idle
    glutIdleFunc( idleFunc );
    // set the display function - called when redrawing
    glutDisplayFunc( displayFunc );
    // set the reshape function - called when client area changes
    glutReshapeFunc( reshapeFunc );
    // set the keyboard function - called on keyboard events
    glutKeyboardFunc( keyboardFunc );
    // set window's to specialKey callback
    glutSpecialFunc( specialKey );
    // set window's to specialUpKey callback (when the key is up is called)
    glutSpecialUpFunc( specialUpKey );
    // do our own initialization
    initialize_graphics( );  
}
Ejemplo n.º 30
0
// main
int main(int argc, char *argv[]) {
	glutInit(&argc, argv);
	glutInitWindowSize(800, 800);
	glutInitWindowPosition(300, 300);
	glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
	glutCreateWindow("Cottages");
	
	init_menu();
	init_objects();
	init_lights();
	
	glutReshapeFunc(reshape);
	glutDisplayFunc(draw);
	glutIdleFunc(idle);
	glutSpecialFunc(pressSpecialKeys);
	glutSpecialUpFunc(releaseSpecialKeys);
	glutKeyboardUpFunc(releaseKeys);
	glutMotionFunc(motion);
	glutMouseFunc(mouse);
	glutMainLoop();

	delete cottage;
	delete diamond;
	delete lamp;
	delete ground;
	return 0;
	
}