示例#1
0
int
ogl_subwin_main(int argc, char **argv)
{
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGB);
  glutInitWindowSize(210, 210);
  main_w = glutCreateWindow("4 subwindows");
  glutDisplayFunc(ogl_subwin_display);
  glutVisibilityFunc(ogl_subwin_vis);
  glutReshapeFunc(ogl_subwin_reshape);
  glClearColor(1.0, 1.0, 1.0, 1.0);
  w1 = glutCreateSubWindow(main_w, 10, 10, 90, 90);
  glutDisplayFunc(ogl_subwin_display);
  glutVisibilityFunc(ogl_subwin_vis);
  glClearColor(1.0, 0.0, 0.0, 1.0);
  w2 = glutCreateSubWindow(main_w, 110, 10, 90, 90);
  glutDisplayFunc(ogl_subwin_display);
  glutVisibilityFunc(ogl_subwin_vis);
  glClearColor(0.0, 1.0, 0.0, 1.0);
  w3 = glutCreateSubWindow(main_w, 10, 110, 90, 90);
  glutDisplayFunc(ogl_subwin_display);
  glutVisibilityFunc(ogl_subwin_vis);
  glClearColor(0.0, 0.0, 1.0, 1.0);
  w4 = glutCreateSubWindow(main_w, 110, 110, 90, 90);
  glutDisplayFunc(ogl_subwin_display);
  glutVisibilityFunc(ogl_subwin_vis);
  glClearColor(1.0, 1.0, 0.0, 1.0);
  glutMainLoop();
  return 0;             /* ANSI C requires main to return int. */
}
int main(int argc, char** argv) {
	char glutGamemode[32];
	glutInit(&argc, argv);
	setup_camera();
	setup_marker();
	init_voxels_hp();

	// Set up GL context(s) for OpenGL to draw into.
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
	glutInitWindowSize(prefWidth, prefHeight);
	camera_win_id = glutCreateWindow("Camera");
	glutTimerFunc(10, TimeEvent, 1);

	ARGL_CONTEXT_SETTINGS_REF argl_context_ref = NULL;
	// Setup argl library for current context.
	if ((argl_context_ref = arglSetupForCurrentContext()) == NULL) {
		std::cout << "main(): arglSetupForCurrentContext() returned error." << std::endl;
		exit(-1);
	}

	arUtilTimerReset();

	glEnable(GL_TEXTURE_2D);
	glEnable(GL_DEPTH_TEST);
	glClearColor(0.0, 0.0, 0.0, 1.0);
	glutVisibilityFunc(visibility_camera);
	glutIdleFunc(idle_camera);
	glutDisplayFunc(display_camera);
	glutReshapeFunc(reshape);
	glutKeyboardFunc(debug_only);
	setup_voxels();
	camera_set_context(argl_context_ref);
	
	viewer_win_id = glutCreateWindow("Viewer");
	glEnable(GL_TEXTURE_2D);
	glEnable(GL_DEPTH_TEST);
	glClearColor(0.0,0.0,0.0,1.0);
	glutVisibilityFunc(visibility_viewer);
	glutIdleFunc(idle_viewer);
	glutDisplayFunc(display_viewer);
	glutReshapeFunc(reshape_viewer);

	auto voxel_t = std::thread(voxel_carving_routine);
	auto capture_t = std::thread(image_capturing_routine);
	auto should_capture_t = std::thread(should_capture_routine);
	auto a_cam_buffer_t = std::thread(transfer);
	
	voxel_t.detach();
	capture_t.detach();
	should_capture_t.detach();
	a_cam_buffer_t.detach();

	glutMainLoop();

	return 0;
}
示例#3
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;             
}
示例#4
0
文件: glut.cpp 项目: cradle/newtonia
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);
}
示例#5
0
文件: glut.cpp 项目: cradle/newtonia
void isVisible(int state) {
  if(state == GLUT_VISIBLE) {
    last_render_time = last_tick_time = glutGet(GLUT_ELAPSED_TIME);
    glutVisibilityFunc(NULL);
    glutIdleFunc(tick);
  }
}
int main(int argc, char** argv){

	glutInit(&argc,argv);

	//Init OpenGL With Double Buffer in RGB Mode
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);

	glutInitWindowSize(800,600);
	
	glutCreateWindow("3D Model");

	//Set Display Handler
	glutDisplayFunc(Display);

	//Set Keyboard Handler
	glutKeyboardFunc(KeyboardHandler);
	glutSpecialFunc(SpecialKeyboardHandler);

	glutReshapeFunc(ReshapeWindow);
	glutVisibilityFunc(Visible);
	
	Init();


	//OpenGL Main Loop
	glutMainLoop();

	return 0;
}
示例#7
0
int
main(int argc, char **argv)
{
    GLenum type;

    glutInitWindowSize(400, 300);
    glutInit(&argc, argv);
    if (Args(argc, argv) == GL_FALSE) {
        exit(1);
    }
    type = (rgb) ? GLUT_RGB : GLUT_INDEX;
    type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE;
    glutInitDisplayMode(type);

    glutCreateWindow("Olympic");

    Init();

    glutReshapeFunc(Reshape);
    glutKeyboardFunc(Key);
    glutDisplayFunc(DrawScene);

    glutVisibilityFunc(visible);

    glutMainLoop();
    return 0;             /* ANSI C requires main to return int. */
}
示例#8
0
GlutViewer::
GlutViewer(const char* _title, int _width, int _height)
    : width_(_width), height_(_height), draw_mode_(SOLID_SMOOTH), fullscreen_(false),
      bak_left_(0), bak_top_(0), bak_width_(0), bak_height_(0), menuID_(0)
{
    // create window
    glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE | GLUT_ALPHA | GLUT_MULTISAMPLE );
    //glutInitDisplayString("rgb double alpha depth>=16 samples>=16");
    glutInitWindowSize(_width, _height);
    windowID_ = glutCreateWindow(_title);
    windows__[windowID_] = this;


    // register callbacks
    glutDisplayFunc(display__);
    glutKeyboardFunc(keyboard__);
    glutSpecialFunc(special__);
    glutMouseFunc(mouse__);
    glutMotionFunc(motion__);
    glutPassiveMotionFunc(passivemotion__);
    glutReshapeFunc(reshape__);
    glutVisibilityFunc(visibility__);
    glutIdleFunc(idle__);

    //Init glew for windows
    //#ifdef _WIN32
    glewInit();
    //#endif
}
示例#9
0
int main(int argc, char **argv)
{
  int fillmenu = 0;

  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
  glutInitWindowSize(INITW, INITH);
  glutCreateWindow("Worms");

  myinit();

  glutDisplayFunc(mydisplay);
  glutVisibilityFunc(visibility);
  glutReshapeFunc(myreshape);
  glutMouseFunc(handleMouse);

  /* popup menu, courtsey of GLUT */
  fillmenu = glutCreateMenu(menuSelect);
  glutAddMenuEntry("Filled", MENU_FILLED);
  glutAddMenuEntry("Unfilled", MENU_UNFILLED);

  glutCreateMenu(menuSelect);
  glutAddMenuEntry("     WORMS", MENU_NULL);
  glutAddSubMenu("Drawing Mode", fillmenu);
  glutAddMenuEntry("Quit", MENU_QUIT);

  glutAttachMenu(GLUT_RIGHT_BUTTON);

  glutMainLoop();
  return 0;
}
示例#10
0
int
main(int argc, char *argv[])
{
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);

  glutCreateWindow("Spin");
  Object = make_object();
  glCullFace(GL_BACK);
  glDisable(GL_DITHER);
  glShadeModel(GL_FLAT);

  glColor3f(1.0, 1.0, 1.0);

  Xrot = Yrot = Zrot = 0.0;
  Xstep = Step;
  Ystep = Zstep = 0.0;

  glutReshapeFunc(reshape);
  glutKeyboardFunc(key);
  glutVisibilityFunc(visible);
  glutDisplayFunc(draw);

  glutMainLoop();
  return 0;             /* ANSI C requires main to return int. */
}
示例#11
0
int CWindow::SetupWindow(void)
{
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_ALPHA | GLUT_DEPTH);
	glutInitWindowSize(width * scale, height * scale);
	glutInitWindowPosition(10, 20);
	if(glutCreateWindow("ARDeskTop") < 1) {
		exit(-1);
	}

//	glewInit();

	glutDisplayFunc(::Display);
	glutReshapeFunc(::Reshape);
	glutVisibilityFunc(::Visibility);
	glutKeyboardFunc(::Keyboard);
	glutMouseFunc(::Mouse);

	if((arglSettings = arglSetupForCurrentContext()) == 0) {
		exit(-1);
	}

//	if(FUTL_LoadShader("simple.vert", "simple.frag", &shdProg) < 0) return(-1);
//	glUseProgram(shdProg);

	return(1);
}
示例#12
0
static void registerCallbacks ()
{
  glutIdleFunc(gst_glut_IdleFunc);
  glutKeyboardFunc(gst_glut_KeyboardFunc);
  glutSpecialFunc(gst_glut_SpecialFunc);
  glutReshapeFunc(gst_glut_ReshapeFunc);
  glutVisibilityFunc(gst_glut_VisibilityFunc);
  glutDisplayFunc(gst_glut_DisplayFunc); 
  glutMouseFunc(gst_glut_MouseFunc);
  glutMotionFunc(gst_glut_MotionFunc);
  glutPassiveMotionFunc(gst_glut_PassiveMotionFunc);
  glutEntryFunc(gst_glut_EntryFunc);
  glutKeyboardUpFunc(gst_glut_KeyboardUpFunc);
  glutSpecialUpFunc(gst_glut_SpecialUpFunc);
  glutMenuStateFunc(gst_glut_MenuStateFunc);
  glutMenuStatusFunc(gst_glut_MenuStatusFunc);
  glutOverlayDisplayFunc(gst_glut_OverlayDisplayFunc);
  glutWindowStatusFunc(gst_glut_WindowStatusFunc);
  glutSpaceballMotionFunc(gst_glut_SpaceballMotionFunc);
  glutSpaceballRotateFunc(gst_glut_SpaceballRotateFunc);
  glutSpaceballButtonFunc(gst_glut_SpaceballButtonFunc);
  glutButtonBoxFunc(gst_glut_ButtonBoxFunc);
  glutDialsFunc(gst_glut_DialsFunc);
  glutTabletMotionFunc(gst_glut_TabletMotionFunc);
  glutTabletButtonFunc(gst_glut_TabletButtonFunc);
  glutWMCloseFunc(gst_glut_WMCloseFunc);

#if 0
  glutJoystickFunc(gst_glut_JoystickFunc);
  glutMouseWheelFunc(gst_glut_MouseWheelFunc);
  glutCloseFunc(gst_glut_CloseFunc);
  glutMenuDestroyFunc(gst_glut_MenuDestroyFunc);
#endif
}
示例#13
0
int
main(int argc, char *argv[])
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
    glutInitWindowSize(400, 400);
    glutCreateWindow("NURBS Surface");
    glutDisplayFunc(expose);
    glutReshapeFunc(resize);
    glutKeyboardFunc(Key);
    glutMouseFunc(Button);

    glutCreateMenu(Menu);
    glutAddMenuEntry("Trim", 1);
    glutAddMenuEntry("Fill", 2);
    glutAddMenuEntry("Hull", 3);
    glutAddMenuEntry("Exit", 4);
    glutAttachMenu(GLUT_RIGHT_BUTTON);
    glutVisibilityFunc(visibility);

    initialize();

    glutMainLoop();
    return 0;
}
示例#14
0
void runGame()
{
    glDeleteTextures(1,&ThirteenTexture);

    DelayCompensation=1;

    glutIgnoreKeyRepeat(1);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);
    glEnable(GL_NORMALIZE);
    glEnable(GL_BLEND);
    glShadeModel(GL_SMOOTH);
    glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

    //Callbacks setzen: Reaktion auf Mausklicks und -bewegungen, Tastaturaktivit鋞en
    glutMouseFunc(MouseClick);
    glutMotionFunc(MouseMove);
    glutKeyboardFunc(KeyPress);
    glutKeyboardUpFunc(KeyRelease);
    glutSpecialFunc(SpecialKeyPress);
    glutSpecialUpFunc(SpecialKeyRelease);

    glutVisibilityFunc(Visible);
    glutIdleFunc(timerEvent);
    glutDisplayFunc(updateGL);
}
示例#15
0
static void initialize(void)
{
    int attr;

    attr = doublebuffer ? RGBA_DB_attributes : RGBA_SB_attributes;
    glutInitDisplayMode(attr);
    glutInitWindowSize(300, 240);
    glutCreateWindow("Ideas");

    if (multisample) glEnable(GL_POLYGON_SMOOTH); 
    
    init_lights();
    init_materials();

    build_table();

    view_from_spline = calc_spline_params(view_from_ctl, TIME);
    view_to_spline = calc_spline_params(view_to_ctl, TIME);
    light_pos_spline = calc_spline_params(light_pos_ctl, TIME);
    logo_pos_spline = calc_spline_params(logo_pos_ctl, TIME);
    logo_rot_spline = calc_spline_params(logo_rot_ctl, TIME);

    glutReshapeFunc(resize_window);
    glutDisplayFunc(display);
    glutMouseFunc(mouse);
    glutKeyboardFunc(keyboard);
    glutVisibilityFunc(vis);

    glMatrixMode(GL_MODELVIEW);
}
示例#16
0
int main(int argc, char *argv[])
{
  glutInit(&argc, argv);
  glutInitWindowPosition(0, 0);
  glutInitWindowSize(600, 450);


  IndexMode = argc > 1 && strcmp(argv[1], "-ci") == 0;
  if (IndexMode)
     glutInitDisplayMode(GLUT_INDEX | GLUT_DOUBLE);
  else
     glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);

  glutCreateWindow("Bounce");
  Ball = make_ball();
  glCullFace(GL_BACK);
  glEnable(GL_CULL_FACE);
  glDisable(GL_DITHER);
  glShadeModel(GL_FLAT);

  glutDisplayFunc(draw);
  glutReshapeFunc(reshape);
  glutVisibilityFunc(visible);
  glutKeyboardFunc(key);

  if (IndexMode) {
    glutSetColor(RED, 1.0, 0.0, 0.0);
    glutSetColor(WHITE, 1.0, 1.0, 1.0);
    glutSetColor(CYAN, 0.0, 1.0, 1.0);
  }

  glutMainLoop();
  return 0;             /* ANSI C requires main to return int. */
}
示例#17
0
文件: bubble.c 项目: xtmacbook/SGI
int
main(int argc, char** argv) {
    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(512, 512);
    glutInit(&argc, argv);

    glutCreateWindow(argv[0]);
    init(argc > 1 ? argv[1] : "../../data/spheremap.rgb");

    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutKeyboardFunc(key);
    glutSpecialFunc(special);
    glutIdleFunc(animate);
    glutMouseFunc(mouse);
    glutMotionFunc(motion);
    glutVisibilityFunc(visible);

	printf("c   - toggle backface culling\n");
	printf("l   - toggle lighting\n");
	printf("t   - toggle texturing\n");
	printf("u/U - increase/decrease tesselation\n");
	printf("w   - toggle wireframe/filled polygons\n");
	printf("y   - toggle background color\n\n");
	printf("Use the left/right arrows to adjust the frequency of the motion.\n");
	printf("Use the up/down arrows to adjust the scale of the motion.\n\n");

    glutMainLoop();
    return 0;
}
示例#18
0
int
main(int argc, char **argv)
{
  glutInit(&argc, argv);

  if (argc > 1 && !strcmp(argv[1], "-f"))
      fullscreen = GL_TRUE;

  glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE);
  if (fullscreen) {
      glutGameModeString("640x480:16@60");
      glutEnterGameMode();
  } else {
      glutInitWindowSize(400, 400);
      glutCreateWindow("GLUT-based OpenGL skyfly");
  }
  glutDisplayFunc(draw);
  glutReshapeFunc(reshape);
  glutVisibilityFunc(visible);
  glutKeyboardFunc(keyboard);
  glutMouseFunc(mouse);
  glutMotionFunc(motion);
  glutPassiveMotionFunc(motion);
  glutSpecialFunc(special);

  init_misc();
  if (!rgbmode)
    init_cmap();
  init_skyfly();

  glutMainLoop();
  return 0;             /* ANSI C requires main to return int. */
}
示例#19
0
int
main(int argc, char** argv)
{
    glutInitDisplayMode(GLUT_RGB|GLUT_DEPTH|GLUT_DOUBLE);
    glutInitWindowPosition(0, 0);
    glutInitWindowSize(640, 480);
    glutInit(&argc, argv);

    glutCreateWindow("Marbles falling from a box");
    glutDisplayFunc(display);
    glutReshapeFunc(reshape); 
    glutMotionFunc(motion);
    glutMouseFunc(mouse);
    glutKeyboardFunc(keyboard);
    glutCreateMenu(menu);
   // glutAddMenuEntry("Particle", 0);
    //glutAddMenuEntry("", 0);
    glutAddMenuEntry(" Less Marbles or -", '-');
    glutAddMenuEntry(" More flow or +", '+');
    glutAddMenuEntry(" Smaller points or p", 'p');
    glutAddMenuEntry(" Larger points or P", 'P');
  
    glutAddMenuEntry("[Esc] Quit", 27);
    glutAttachMenu(GLUT_RIGHT_BUTTON);
// dynamically allocating memory for the number of particles initially 
   particles = (PSparticle*)malloc(sizeof(PSparticle) * num_particles);

    glutVisibilityFunc(visible);
    glutMainLoop();
    return 0;
}
int main(int argc, char **argv) {
    glutInit(&argc,argv);

    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
    glutInitWindowPosition(MY_WIND_X_POS, MY_WIND_Y_POS);
    glutInitWindowSize(MY_WIND_X_SIZE, MY_WIND_Y_SIZE);

    glutCreateWindow("B581 template code with 3D lighting");

    glutDisplayFunc       (myDisplay);
    glutReshapeFunc       (myReshape);
    glutMouseFunc         (myButton);
    glutMotionFunc        (myMotion);
    glutPassiveMotionFunc (NULL);
    glutIdleFunc          (NULL);
    glutKeyboardFunc      (myKeyboard);
    glutVisibilityFunc    (myVisibility);
    
    fprintf(stderr,"Press ESC or 'q' to Exit.\n");

    myInitGL();
    myInitData(&argc,argv);  /* pass command line arguments for texture */

    /* initialize GLUT menu handler as last one, to take over access
     to GLUT_RIGHT_BUTTON, regardles to what other handlers did to it: */
    myInitMenus();
    glutTimerFunc(0,timer,0);
    glutMainLoop();
    return(EXIT_SUCCESS);
} /* main() */
示例#21
0
void GlutMaster::CallGlutCreateWindow(char * setTitle, GlutWindow * glutWindow){

   // Open new window, record its windowID ,

   int windowID = glutCreateWindow(setTitle);

   glutWindow->SetWindowID(windowID);

   // Store the address of new window in global array
   // so GlutMaster can send events to propoer callback functions.

   viewPorts[windowID] = glutWindow;

   // Hand address of universal static callback functions to Glut.
   // This must be for each new window, even though the address are constant.

   glutDisplayFunc(CallBackDisplayFunc);
   glutIdleFunc(CallBackIdleFunc);
   glutKeyboardFunc(CallBackKeyboardFunc);
   glutSpecialFunc(CallBackSpecialFunc);
   glutMouseFunc(CallBackMouseFunc);
   glutMotionFunc(CallBackMotionFunc);
   glutPassiveMotionFunc(CallBackPassiveMotionFunc);
   glutReshapeFunc(CallBackReshapeFunc);
   glutVisibilityFunc(CallBackVisibilityFunc);
}
示例#22
0
int main(int argc, char **argv)
{
 glutInit(&argc, argv);
 glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA );
 ps.w = 512;
 ps.h = 512;
 glutInitWindowSize(ps.w, ps.h);
 glutInitWindowPosition(100,100);

 glutCreateWindow(argv[0]);
 init();
 glutVisibilityFunc(VisibilityFunc); 
 glutDisplayFunc(DisplayFunc);
 glutReshapeFunc(ReshapeFunc);
 glutKeyboardFunc(KeyboardFunc);
 glutCreateMenu(MenuFunc);
 glutAddMenuEntry("Stereo", 's');
 glutAddMenuEntry("Mono", 'm');
 glutAddMenuEntry("Dodecahedron", '1');
 glutAddMenuEntry("Icosahedron", '2');
 glutAddMenuEntry("Teapot", '3');
 glutAddMenuEntry("Solar system", '4');
 glutAttachMenu(GLUT_RIGHT_BUTTON);
 glutMainLoop();
 return 0;
}
void blender()
{
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
	glutCreateWindow("blender");
	glutDisplayFunc(displaycc);
	glutVisibilityFunc(visible);
	glNewList(1, GL_COMPILE);
	glutSolidIcosahedron();
	glEndList();
	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);
	glLightfv(GL_LIGHT0, GL_AMBIENT, light0_ambient);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_diffuse);
	glLightfv(GL_LIGHT1, GL_POSITION, light1_position);
	glLightfv(GL_LIGHT2, GL_DIFFUSE, light2_diffuse);
	glLightfv(GL_LIGHT2, GL_POSITION, light2_position);
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_CULL_FACE);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_LINE_SMOOTH);
	glLineWidth(2.0);
	glMatrixMode(GL_PROJECTION);
	gluPerspective( /* field of view in degree */ 40.0,/* aspect ratio */ 1.0,/* Z near */ 1.0, /* Z far */ 10.0);
	glMatrixMode(GL_MODELVIEW);
	gluLookAt(0.0, 0.0, 5.0,/* eye is at (0,0,5) */0.0, 0.0, 0.0, /* center is at (0,0,0) */0.0, 1.0, 0.); /* up is in positive Y direction */
	glTranslatef(0.0, 0.6, -1.0);
	glutMouseFunc(clickx);
	glutMainLoop();
}
示例#24
0
int
main(int argc, char **argv)
{
  glutInitWindowSize(500,500);
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
  (void) glutCreateWindow("projtex");
  glewInit();

  if (argc > 1) {
     NumTextures = atoi(argv[1]);
  }
  assert(NumTextures <= MAX_TEX);

  loadTexture = loadImageTextures;
  drawObject = drawCube;
  initialize();
  glutDisplayFunc(display);
  glutKeyboardFunc(key);
  glutReshapeFunc(reshape);
  glutMouseFunc(mouse);
  glutMotionFunc(trackMotion);
  glutVisibilityFunc(vis);
  glutCreateMenu(menu);
  glutAddMenuEntry("Toggle showing projection", 's');
  glutAddMenuEntry("Switch texture", 't');
  glutAddMenuEntry("Switch object", 'o');
  glutAddMenuEntry("Toggle filtering", 'l');
  glutAddMenuEntry("Quit", 666);
  glutAttachMenu(GLUT_RIGHT_BUTTON);
  texture();
  glutMainLoop();
  return 0;             /* ANSI C requires main to return int. */
}
示例#25
0
int
main(int argc, char **argv)
{
  int mode = GLUT_DOUBLE;

  glutInit(&argc, argv);

#ifdef  STEREO
  if (argc > 1)
	  if (stricmp(argv[1],"-stereo") == 0)
		  bStereoRequested = GL_TRUE;
  /* use GLUT to request GL_STEREO quad-buffered display visual */
  if (bStereoRequested)
	  mode |= GLUT_STEREO;
#endif

  glutInitDisplayMode(mode | GLUT_RGB | GLUT_DEPTH);
  glutInitWindowPosition(100, 100);
  glutInitWindowSize(640, 480);
  glutCreateWindow(argv[0]);

  myinit();
  glutReshapeFunc(myReshape);
  glutDisplayFunc(display);
  glutKeyboardFunc(keys);
  glutVisibilityFunc(visibility);
  glutPostRedisplay();
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glutMainLoop();
  return 0;             /* ANSI C requires main to return int. */
}
示例#26
0
int main(int argc, char** argv)
{
  glutInit(&argc, argv);
  glutInitWindowSize(512, 512);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
  glutCreateWindow("AGV example");
  
  glutVisibilityFunc(visible);

  if (Rotating)
    glutIdleFunc(rotatethering);
 
    /*
     * let AGV know if it can mess with the idle function (if we've
     * just installed an idle function, we tell AGV it can't touch it)
     */

  agvInit(!Rotating);
    
    /* 
     * agvInit() installs mouse, motion, and keyboard handles, but 
     * we don't care for this example cause we only use right button menu
     */

  agvMakeAxesList(AXES);  /* create AGV axes */

  myGLInit(); 
  MakeDisplayLists();
  MenuInit();

  glutDisplayFunc(display);

  glutMainLoop();
  return 0;             /* ANSI C requires main to return int. */
}
示例#27
0
int
main(int argc, char *argv[])
{
  glutInit(&argc, argv);
  /* use multisampling if available */
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_MULTISAMPLE);
  glutCreateWindow("glutplane");
  glutDisplayFunc(draw);
  glutKeyboardFunc(keyboard);
  glutVisibilityFunc(visible);
  glutCreateMenu(menu);
  glutAddMenuEntry("Add plane", ADD_PLANE);
  glutAddMenuEntry("Remove plane", REMOVE_PLANE);
  glutAddMenuEntry("Motion", MOTION_ON);
  glutAddMenuEntry("Quit", QUIT);
  glutAttachMenu(GLUT_RIGHT_BUTTON);
  /* setup OpenGL state */
  glClearDepth(1.0);
  glClearColor(0.0, 0.0, 0.0, 0.0);
  glMatrixMode(GL_PROJECTION);
  glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 20);
  glMatrixMode(GL_MODELVIEW);
  /* add three initial random planes */
  srandom(getpid());
  add_plane();
  add_plane();
  add_plane();
  /* start event processing */
  glutMainLoop();
  return 0;             /* ANSI C requires main to return int. */
}
示例#28
0
GlutViewer::GlutViewer(const char *wtitle, int width, int height)
	:m_Width(width)
	,m_Height(height)
{
	// create window
	glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE | GLUT_ALPHA);
	glutInitWindowSize(width, height);
	m_WindowID = glutCreateWindow(wtitle);
	m_Windows[m_WindowID] = this;

	// register callbacks;
	glutDisplayFunc(SDisplay);
	glutKeyboardFunc(SKeyBoard);
	glutSpecialFunc(SSpecial);
	glutMouseFunc(SMouse);
	glutMotionFunc(SMotion);
	glutPassiveMotionFunc(SPassiveMotion);
	glutReshapeFunc(SReshape);
	glutVisibilityFunc(SVisibility);

	// create menu
	m_NDrawModes = 0;
	m_MenuID = glutCreateMenu(SProcessMenu);
	glutAttachMenu(GLUT_RIGHT_BUTTON);

}
示例#29
0
int
ogl_mjksift_main(int argc, char **argv)
{
  int minify_menu, rate_menu;

  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
  glutCreateWindow("mjksift");
  glutDisplayFunc(ogl_mjksift_redraw);
  glMatrixMode(GL_PROJECTION);
  gluPerspective( /* field of view in degree */ 40.0,
  /* aspect ratio */ 1.0,
    /* Z near */ 1.0, /* Z far */ 70.0);
  glMatrixMode(GL_MODELVIEW);
  gluLookAt(0.0, 0.0, 5.0,  /* eye is at (0,0,30) */
    0.0, 0.0, 0.0,      /* center is at (0,0,0) */
    0.0, 1.0, 0.);      /* up is in positive Y direction */
  depth = mjk_depth;
  width = mjk_width;
  height = mjk_height;
  bits = mjk_image;
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  gluBuild2DMipmaps(GL_TEXTURE_2D, depth, width, height,
    GL_RGB, GL_UNSIGNED_BYTE, bits);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
  glEnable(GL_TEXTURE_2D);
  glutVisibilityFunc(ogl_mjksift_visibility);
  minify_menu = glutCreateMenu(minify_select);
  glutAddMenuEntry("Nearest", GL_NEAREST);
  glutAddMenuEntry("Linear", GL_LINEAR);
  glutAddMenuEntry("Nearest mipmap nearest", GL_NEAREST_MIPMAP_NEAREST);
  glutAddMenuEntry("Linear mipmap nearest", GL_LINEAR_MIPMAP_NEAREST);
  glutAddMenuEntry("Nearest mipmap linear", GL_NEAREST_MIPMAP_LINEAR);
  glutAddMenuEntry("Linear mipmap linear", GL_LINEAR_MIPMAP_LINEAR);
  rate_menu = glutCreateMenu(rate_select);
  glutAddMenuEntry(" 2/sec", 500);
  glutAddMenuEntry(" 6/sec", 166);
  glutAddMenuEntry("10/sec", 100);
  glutAddMenuEntry("20/sec", 50);
  glutAddMenuEntry("30/sec", 33);
  glutAddMenuEntry("60/sec", 16);
  glutCreateMenu(menu_select);
  glutAddMenuEntry("Toggle sifting", 1);
  glutAddMenuEntry("Toggle scaling", 2);
  glutAddSubMenu("Minimum frame rate", rate_menu);
  glutAddSubMenu("Minify modes", minify_menu);
  glutAddMenuEntry("Quit", 666);
  glutAttachMenu(GLUT_RIGHT_BUTTON);
  menu_select(3);
  generateTexturedSurface();
  glutMainLoop();
  return 0;             /* ANSI C requires main to return int. */
}
示例#30
0
int
main(int argc, char **argv)
{
  long i;

  glutInit(&argc, argv);
  for (i = 1; i < argc; i++) {
    if (argv[i][0] == '-') {
      switch (argv[i][1]) {
      case 's':
        doubleBuffer = 0;
        break;
      default:
        Usage();
      }
    } else {
      Usage();
    }
  }

  glutInitWindowSize(W, H);
  if (doubleBuffer) {
    glutInitDisplayMode(GLUT_DEPTH | GLUT_RGB | GLUT_DOUBLE | GLUT_MULTISAMPLE);
  } else {
    glutInitDisplayMode(GLUT_DEPTH | GLUT_RGB | GLUT_SINGLE | GLUT_MULTISAMPLE);
  }

  glutCreateWindow("glpuzzle");

  init();

  glGetIntegerv(GL_VIEWPORT, viewport);

  printf("\n");
  printf("r   Reset puzzle\n");
  printf("s   Solve puzzle (may take a few seconds to compute)\n");
  printf("d   Destroy a piece - makes the puzzle easier\n");
  printf("b   Toggles the depth buffer on and off\n");
  printf("\n");
  printf("Left mouse moves pieces\n");
  printf("Middle mouse spins the puzzle\n");
  printf("Right mouse has menu\n");

  glutReshapeFunc(Reshape);
  glutDisplayFunc(redraw);
  glutKeyboardFunc(keyboard);
  glutMotionFunc(motion);
  glutMouseFunc(mouse);
  glutVisibilityFunc(visibility);
  glutCreateMenu(menu);
  glutAddMenuEntry("Solve", 1);
  glutAddMenuEntry("Reset", 2);
  glutAddMenuEntry("Quit", 3);
  glutAttachMenu(GLUT_RIGHT_BUTTON);
  glutMainLoop();
  return 0;             /* ANSI C requires main to return int. */
}