Пример #1
0
/**
 * Main entry point for GLUT based programs
 */
int main(int argc, char* argv[])
{
	gltSetWorkingDirectory(argv[0]);

	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_STENCIL);
	glutInitWindowSize(800, 600);
	glutCreateWindow("Triangle");

	gltShowVersionInfo();

	// Create the menu
	glutCreateMenu(ProcessMenu);
	glutAddMenuEntry("Btn1",1);
	glutAddMenuEntry("Btn2",2);
	glutAttachMenu(GLUT_RIGHT_BUTTON);

	glutReshapeFunc(ChangeSize);
	glutDisplayFunc(RenderScene);
	glutSpecialFunc(SpecialKeys);
	glutKeyboardFunc(KeyPressFunc);

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

	SetupRC();

	glutMainLoop();

	OnExit();

	return 0;
}
Пример #2
0
/*******************************************************************************
 GLUT initialization.
*******************************************************************************/
void initGlut(int argc, char* argv[])
{
    glutInit(&argc, argv); /* Initialize GLUT. */
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(500, 500);
    glutCreateWindow("Sphere-sphere Contact Example");

    glutDisplayFunc(displayFunction); /* Setup GLUT callbacks. */
    glutMouseFunc(handleMouse);
    glutIdleFunc(handleIdle);

    glutCreateMenu(handleMenu);    
    glutAddMenuEntry("Quit", 0);
    glutAttachMenu(GLUT_RIGHT_BUTTON);
}
Пример #3
0
int main(int argc, char** argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
	glutInitWindowSize(height, width);
	glutInitWindowPosition(100, 100);
	glutCreateWindow(argv[0]);
	init();
	glutDisplayFunc(display);
	glutReshapeFunc(reshape);
	glutMotionFunc(MotionCallback);
	glutMouseFunc(mouse);
	glutKeyboardFunc(keyboard);
	glutSpecialFunc(processSpecialKeys);
	glutCreateMenu(mainMenu);
		glutAddMenuEntry("UP ARROW: Zoom In", 1);
		glutAddMenuEntry("DOWN ARROW: Zoom Out", 2);
		glutAddMenuEntry("RIGHT ARROW: Move To The Right", 3);
		glutAddMenuEntry("LEFT ARROW: Move To The Left", 4);
		glutAddMenuEntry("Esc: Exit", 27);
	glutAttachMenu(GLUT_RIGHT_BUTTON);
	glutMainLoop();
	return 0;
}
Пример #4
0
int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(250, 250);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("Hello Haptics");
    glutCreateMenu(glutMenu);
    glutAddMenuEntry("Quit", 0);
    glutAttachMenu(GLUT_RIGHT_BUTTON);
    init();
    glutDisplayFunc(display);
    glutMainLoop();
    return 0;
}
Пример #5
0
int main() {
  glutInit( &argc, const_cast<char**>( argv ) );
  glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_STENCIL | GLUT_ALPHA );
  glutInitWindowSize( 640, 480 );

  uintptr_t win1 = glutCreateWindow("Test");
  glutSetWindow( win1 );
  uintptr_t menu1 = glutCreateMenu( menuFunc );
  glutSetMenu( menu1 );
  glutAddMenuEntry( "Test 1", 1 );
  glutAddMenuEntry( "Test 2", 2 );
  glutAttachMenu( GLUT_RIGHT_BUTTON );

  glutDisplayFunc( displayFunc );
  glutMotionFunc( motionFunc );
  glutKeyboardFunc( keyboardFunc );
  glutMouseFunc( mouseFunc );
  glutTimerFunc( 100, timerFunc, 0 );
  
  glutMainLoop();


return 0;
}
Пример #6
0
void setMenuEntries(bool init)
{
  int i, sub1, sub2;

  if ( init )
  {
    sub1 = glutCreateMenu(selectMaterials);
    for (i = 0; i < materialsMenuEntries; i++)
      glutAddMenuEntry(materialsMenu[i].label, i);

    sub2 = glutCreateMenu(selectLighting);
    for (i = 0; i < lightingMenuEntries; i++) 
      glutAddMenuEntry(lightingMenu[i].label, i);

    glutCreateMenu(selectMain);

    for(i = 0; i < mainMenuEntries; i++)
      glutAddMenuEntry(mainMenu[i].label, i);

    glutAddSubMenu("materials", sub1);
    glutAddSubMenu("lighting", sub2);
    glutAttachMenu(GLUT_RIGHT_BUTTON);
  }
}
Пример #7
0
static void init()
{
	glDisable(GL_DITHER);
	
	std::string ver((const char*)glGetString(GL_VERSION));
	assert(!ver.empty());
	std::istringstream verStream(ver);
	
	int major, minor;
	char dummySep;
	verStream >> major >> dummySep >> minor;
	const bool useVertexArrays = ((major>=1) && (minor>=1));
	
	const GLfloat data[] = {
		-1.f, -1.f, 0.f,
		1.f, -1.f, 0.f,
		0.f, 1.f, 0.f};
	
	if (useVertexArrays) {
		glEnableClientState(GL_VERTEX_ARRAY);
		glVertexPointer(3, GL_FLOAT, 0, data);
	}
	
	listID = glGenLists(1);
	glNewList(listID, GL_COMPILE);
	
	if (useVertexArrays)
		glDrawArrays(GL_TRIANGLES, 0, 3);
	else
	{
		glBegin(GL_TRIANGLES);
		glVertex3fv(&data[0]);
		glVertex3fv(&data[3]);
		glVertex3fv(&data[6]);
		glEnd();
	}
	
	glEndList();
	
	assert(glGetError()==GL_NO_ERROR);
	
	glutDisplayFunc(display);
	glutReshapeFunc(reshape);
	
	glutCreateMenu(mainMenuCB);
	glutAddMenuEntry("Quit", QUIT_VALUE);
	glutAttachMenu(GLUT_RIGHT_BUTTON);
}
Пример #8
0
void createMenu(void)
{
    int submenuID = glutCreateMenu( myMenu );
    glutAddMenuEntry("Task 1", 1);
    glutAddMenuEntry("Task 2", 2);
    glutAddMenuEntry("Task 3", 3);
    glutAddMenuEntry("Task 4", 4);
    glutAddMenuEntry("Bonus", 5);

    /* Create main menu. */
    glutCreateMenu(myMenu); 
    glutAddSubMenu("Task Selection", submenuID );
    glutAddMenuEntry("Rotation on/off", 10);
    glutAddMenuEntry("BackFace Culling on/off", 11);
    glutAddMenuEntry("Polygon Fill mode line/fill", 12 );
    glutAddMenuEntry("Quit", 99);

    /* Menu will be invoked by the right mouse button */
    glutAttachMenu(GLUT_RIGHT_BUTTON);  

}
Пример #9
0
void
time6(int value)
{
  if (value != 6) {
    printf("FAIL: time6 expected 6\n");
    exit(1);
  }
  glutMenuStateFunc(mstatus);
  glutMenuStatusFunc(mstatus2);
  glutCreateMenu(menu2);
  glutAddMenuEntry("name", 46);
  glutAttachMenu(GLUT_LEFT_BUTTON);
  glutAttachMenu(GLUT_MIDDLE_BUTTON);
  glutAttachMenu(GLUT_RIGHT_BUTTON);
  printf("Pop up menu with any mouse button and select the item\n");
}
Пример #10
0
int			main(int argc, char** argv)
{
  /*
   * initialize GLUT and open a window
   */
  glutInit(&argc, argv);
  glutInitWindowSize(512, 512);
  glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
  glutCreateWindow("Sunlight");
  glutDisplayFunc(redrawCB);
  glutReshapeFunc(reshapeCB);
  glutMouseFunc(mouseCB);
  glutMotionFunc(motionCB);
  glutKeyboardFunc(keyCB);

  /*
   * make the menu
   */
  glutCreateMenu(handleMenu);
  glutAddMenuEntry("SUNLIGHT", 0);
  glutAddMenuEntry("Show Globe *", MENU_SHOW_GLOBE);
  glutAddMenuEntry("Show Map", MENU_SHOW_MAP);
  glutAddMenuEntry("Adjust Globe *", MENU_ADJUST_GLOBE);
  glutAddMenuEntry("Adjust Day", MENU_ADJUST_DAY);
  glutAddMenuEntry("Adjust Time", MENU_ADJUST_TIME);
  glutAddMenuEntry("Quit", MENU_QUIT);
  glutAttachMenu(GLUT_RIGHT_BUTTON);

  /*
   * initialize GL
   */
  initProjection();
  gluLookAt(0.0, 0.0, 3.0,
	    0.0, 0.0, 0.0,
	    0.0, 1.0, 0.0);
  initSunlight();
  glEnable(GL_LIGHTING);
  glEnable(GL_CULL_FACE);
  glEnable(GL_TEXTURE_2D);

  /*
   * initialize data structures
   */
  initSphere();
  initMap();
  initTexture("globe.raw");

  glutMainLoop();
  return 0;             /* ANSI C requires main to return int. */
}
Пример #11
0
void createMenu(){
	int subMenu_id=glutCreateMenu(subMenu);
	glutAddMenuEntry("Left",1);
	glutAddMenuEntry("Right",2);
	glutAddMenuEntry("Up",3);
	glutAddMenuEntry("Down",4);
	glutCreateMenu(menu);
	if(screenWidth>800 && screenHeight>500)  //nema smisla prikazivati ako vec nemamo FULL SCREEN!
		glutAddMenuEntry("Exit Full Screen",2);
	glutAddMenuEntry("Zoom in",3);
	glutAddMenuEntry("Zoom out",4);
	glutAddSubMenu("Move to",subMenu_id);
	glutAttachMenu(GLUT_RIGHT_BUTTON);
}
int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
   glutInitWindowSize (500, 500); 
   glutInitWindowPosition (100, 100);
   glutCreateWindow (argv[0]);
   init ();
   glutDisplayFunc(display); 
   glutReshapeFunc(reshape);
    glutCreateMenu(Select);
	glutAddMenuEntry("save image",0);
	glutAttachMenu(GLUT_RIGHT_BUTTON);
   glutMainLoop();
   return 0;
}
// Initialize GL
//*****************************************************************************
bool InitGL(int* argc, char **argv )
{
    // init GLUT and GLUT window
    glutInit(argc, argv);
    glutInitDisplayMode(GLUT_RGBA | GLUT_ALPHA | GLUT_DOUBLE | GLUT_DEPTH);
    glutInitWindowPosition (glutGet(GLUT_SCREEN_WIDTH)/2 - iGraphicsWinWidth/2, 
                            glutGet(GLUT_SCREEN_HEIGHT)/2 - iGraphicsWinHeight/2);
    glutInitWindowSize(iGraphicsWinWidth, iGraphicsWinHeight);
    iGLUTWindowHandle = glutCreateWindow("OpenCL/OpenGL post-processing");
#if !(defined (__APPLE__) || defined(MACOSX))
    glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS);
#endif

    // register GLUT callbacks
    glutDisplayFunc(DisplayGL);
    glutKeyboardFunc(KeyboardGL);
    glutReshapeFunc(Reshape);
    glutTimerFunc(REFRESH_DELAY, timerEvent, 0);

    // create GLUT menu
    iGLUTMenuHandle = glutCreateMenu(mainMenu);
    glutAddMenuEntry("Toggle Post-processing (Blur filter) ON/OFF <spacebar>", ' ');
    glutAddMenuEntry("Toggle Processor between GPU and CPU [p]", 'p');
    glutAddMenuEntry("Toggle GL animation (rotation) ON/OFF [a]", 'a');
    glutAddMenuEntry("Increment blur radius [+ or =]", '=');
    glutAddMenuEntry("Decrement blur radius [- or _]", '-');
    glutAddMenuEntry("Quit <esc>", '\033');
    glutAttachMenu(GLUT_RIGHT_BUTTON);

    // init GLEW
    glewInit();
    GLboolean bGLEW = glewIsSupported("GL_VERSION_2_0 GL_ARB_pixel_buffer_object"); 
    oclCheckErrorEX(bGLEW, shrTRUE, pCleanup);

    // default initialization
    glClearColor(0.5, 0.5, 0.5, 1.0);
    glDisable(GL_DEPTH_TEST);

    // viewport
    glViewport(0, 0, iGraphicsWinWidth, iGraphicsWinHeight);

    // projection
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(60.0, (GLfloat)iGraphicsWinWidth / (GLfloat) iGraphicsWinHeight, 0.1, 10.0);
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    glEnable(GL_LIGHT0);
    float red[] = { 1.0, 0.1, 0.1, 1.0 };
    float white[] = { 1.0, 1.0, 1.0, 1.0 };
    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, red);
    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, white);
    glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 60.0);

    return true;
}
Пример #14
0
int main(int argc, char** argv)
{
	int scale, translate, rotate, menu;
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
   glutInitWindowSize (500, 500); 
   glutInitWindowPosition (100, 100);
   glutCreateWindow (argv[0]);
   
	init ();

	scale = glutCreateMenu(menu_choice);
		glutAddMenuEntry("2", TWO);
		glutAddMenuEntry("0.5", HALF);
	translate = glutCreateMenu(menu_choice);
		glutAddMenuEntry("Up", UP);
		glutAddMenuEntry("Down", DOWN);
		glutAddMenuEntry("Left", LEFT);
		glutAddMenuEntry("Right", RIGHT);
	rotate = glutCreateMenu(menu_choice);
		glutAddMenuEntry("X", X);
		glutAddMenuEntry("Y", Y);
		glutAddMenuEntry("Z", Z);
	
	menu = glutCreateMenu(menu_choice);
		glutAddSubMenu("Scale", scale);
		glutAddSubMenu("Translate", translate);
		glutAddSubMenu("Rotate", rotate);

	glutAttachMenu(GLUT_RIGHT_BUTTON);

   glutDisplayFunc(display); 
   glutReshapeFunc(reshape);

	glutIdleFunc(idle);

   glutMainLoop();
   return 0;
}
Пример #15
0
int main(int argc, char* argv[])
{
    GLint i;

    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(windowWidth, windowHeight);
    glutCreateWindow("Procedural Texture Mapping Demo");
    glutReshapeFunc(ChangeSize);
    glutKeyboardFunc(KeyPressFunc);
    glutSpecialFunc(SpecialKeys);
    glutDisplayFunc(RenderScene);

    SetupRC();

    // Create the menus
    shaderMenu = glutCreateMenu(ProcessMenu);
    for (i = 0; i < TOTAL_SHADER_SETS; i++)
    {
        char menuEntry[128];
        sprintf(menuEntry, "\"%s\"", shaderNames[i]);
        glutAddMenuEntry(menuEntry, 1+i);
    }

    mainMenu = glutCreateMenu(ProcessMenu);
    {
        char menuEntry[128];
        sprintf(menuEntry, "Choose fragment shader (currently \"%s\")", shaderNames[0]);
        glutAddSubMenu(menuEntry, shaderMenu);
    }
    glutAttachMenu(GLUT_RIGHT_BUTTON);

    glutMainLoop();

    if (glDeleteProgram && glDeleteShader)
    {
        for (i = 0; i < TOTAL_SHADER_SETS; i++)
        {
            glDeleteProgram(progObj[i]);
            glDeleteShader(vShader[i]);
            glDeleteShader(fShader[i]);
        }
    }

    return 0;
}
Пример #16
0
static void menuInit()
{
    menuId = glutCreateMenu(menuSelected);

    glutAddMenuEntry("Gaussian blur", GAUSSIAN_BLUR);
    glutAddMenuEntry("Sharpen", SHARPEN);
    glutAddMenuEntry("Mean removal", MEAN_REMOVAL);
    glutAddMenuEntry("Emboss", EMBOSS);
    glutAddMenuEntry("Edge detect", EDGE_DETECT);
    glutAddMenuEntry("None", NO_FILTER);

    glutAddMenuEntry("Quit", QUIT);

    glutAttachMenu(GLUT_RIGHT_BUTTON);
}
Пример #17
0
//////////////////////////////////////////////////////
// Program entry point
int main(int argc, char *argv[])
    {
    gltSetWorkingDirectory(argv[0]);

    // Standard initialization stuff
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowSize(800, 600);
    glutCreateWindow("Anisotropic Tunnel");
    glutReshapeFunc(ChangeSize);
    glutSpecialFunc(SpecialKeys);
    glutDisplayFunc(RenderScene);
    
#ifdef ANGLE
	glutKeyboardFunc(KeyPressFunc);
#else
    // Add menu entries to change filter
    glutCreateMenu(ProcessMenu);
    glutAddMenuEntry("GL_NEAREST",0);
    glutAddMenuEntry("GL_LINEAR",1);
    glutAddMenuEntry("GL_NEAREST_MIPMAP_NEAREST",2);
    glutAddMenuEntry("GL_NEAREST_MIPMAP_LINEAR", 3);
    glutAddMenuEntry("GL_LINEAR_MIPMAP_NEAREST", 4);
    glutAddMenuEntry("GL_LINEAR_MIPMAP_LINEAR", 5);
    glutAddMenuEntry("Anisotropic Filter", 6);
    glutAddMenuEntry("Anisotropic Off", 7);

    glutAttachMenu(GLUT_RIGHT_BUTTON);
    
    GLenum err = glewInit();
    if (GLEW_OK != err) {
        fprintf(stderr, "GLEW Error: %s\n", glewGetErrorString(err));
        return 1;
    }
#endif 
    
    // Startup, loop, shutdown
    SetupRC();
    glutMainLoop();
    ShutdownRC();
    
    return 0;
    }
Пример #18
0
//create the right click menu
void InitMenu(void)
{
	//main menu
	glutCreateMenu(OnMainMenu);
	glutAddMenuEntry("------------------------",         -1);
	glutAddMenuEntry("Toggle fullscreen [f]",         'f');
	glutAddMenuEntry("Toggle animation [s]" ,           's');
	glutAddMenuEntry("Step animation [ ]",              ' ');
	glutAddMenuEntry("------------------------",         -1);
	glutAddMenuEntry("Quit [ESC]",                       '\033');
	glutAttachMenu(GLUT_RIGHT_BUTTON);
}
Пример #19
0
void glut_current_PSF_select() {
	int i;
	int id_current;
	char title[LENGTHBUF];
	char psf_name[LENGTHBUF];
	
	id_current = send_current_PSF();
	for (i=0; i< send_max_loaded_PSF(); i++) {
		if(i != id_current && send_loaded_PSF_flag(i) > 0){
			set_to_current_PSF(i);
			send_current_psf_file_header(psf_name);
			sprintf(title, "%d: %s", i, psf_name);
			glutAddMenuEntry(title,i);
		}
	};
    set_to_current_PSF(id_current);
	return;
}
Пример #20
0
void SubMenu()
{
	SubMenu1 = glutCreateMenu(MenuFunc);
	glutAddMenuEntry("Sphere", 0);
	glutAddMenuEntry("Cube", 2);
	glutAddMenuEntry("Torus", 4);
	glutAddMenuEntry("Teapot", 6);

	SubMenu2 = glutCreateMenu(MenuFunc);
	glutAddMenuEntry("Sphere", 1);
	glutAddMenuEntry("Cube", 3);
	glutAddMenuEntry("Torus", 5);
	glutAddMenuEntry("Teapot", 7);

	MainMenu = glutCreateMenu(MenuFunc);
	glutAddSubMenu("Solid Object", SubMenu1);
	glutAddSubMenu("Wire Object", SubMenu2);

	glutAttachMenu(GLUT_RIGHT_BUTTON);
}
Пример #21
0
void createMenu(void) {
    glutPostRedisplay();
    submenu_id = glutCreateMenu(menu);
    glutAddMenuEntry("Line", 2);
    glutAddMenuEntry("Circle", 3);
    glutAddMenuEntry("Triangle", 4);
    glutAddMenuEntry("Teapot", 5);
    menu_id = glutCreateMenu(menu);
    glutAddMenuEntry("Clear", 1);
    glutAddSubMenu("Draw", submenu_id);
    glutAddMenuEntry("Quit", 0);
    glutAttachMenu(GLUT_RIGHT_BUTTON);
}
/* Initialises the menu of toggles. */
void
create_menu_opengl_cinetheodolite(void) {
    glutCreateMenu(menu_opengl_cinetheodolite);
    //glutAttachMenu(GLUT_LEFT_BUTTON);
    glutAttachMenu(GLUT_RIGHT_BUTTON);
    //glutAddMenuEntry("Shaded", 1);
    glutAddMenuEntry(" start/stop animation 1  : MGI ", _ANIMATION1);
    glutAddMenuEntry(" start/stop animation 2  : qi  ", _ANIMATION2);
    glutAddMenuEntry(" start/stop simulation 1 ,Open Loop : Fq =0 ", _SIMULATION1);
    glutAddMenuEntry(" start/stop simulation 2 , Internal loop : d2qsurdt2=0", _SIMULATION2);
    glutAddMenuEntry(" start/stop simulation 3 , Internal loop : d2qsurdt2=0", _SIMULATION3);
    glutAddMenuEntry(" start/stop simulation 4 , Internal loop : d2qsurdt2=0", _SIMULATION4);
}
Пример #23
0
//==================================================================
void RibRendToy::addDirToMenu( const char *pDirName, const char *pFilesExt )
{
#if defined(WIN32)

	DStr	buff = DUT::SSPrintFS( "%s/*.%s", pDirName, pFilesExt );

	_finddatai64_t	findData;
	intptr_t	handle = _findfirst64( buff.c_str(), &findData );
	if ( handle != -1 )
	{
		int	ret = 0;
		do
		{
			mTestRibFiles.push_back( findData.name );
			mTestRibFilesPaths.push_back( pDirName );

			glutAddMenuEntry(
				DUT::SSPrintFS( "%s / %s", pDirName, findData.name ).c_str(),
				MENUID_FILES + (int)mTestRibFiles.size()-1 );

			ret = _findnext64( handle, &findData );
		} while ( ret == 0 );

		_findclose( handle );
	}

#elif defined(__linux__)

	DIR	*pDir = opendir( pDirName );
	if ( pDir )
	{
		struct dirent *pDirent;

		while ( pDirent = readdir( pDir ) )
		{
			//pDirent->
		}

		closedir( pDir );
	}

#endif

}
Пример #24
0
int
main(int argc, char **argv)
{
	GLboolean fullscreen = GL_FALSE; 
	GLint time_menu;
 	
 	srand(0);

        glutInit(&argc, argv);
	if (argc > 1 && !strcmp(argv[1], "-w"))
		fullscreen = GL_FALSE;

	//glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
	glutInitDisplayString("rgba double depth=24");
	if (fullscreen) {
	  glutGameModeString("1024x768:32");
	  glutEnterGameMode();
	} else {
	  glutInitWindowSize(320, 240);
	  glutCreateWindow("Atlantis Timing");
	}
    Init();
    glutDisplayFunc(Display);
    glutReshapeFunc(Reshape);
    glutKeyboardFunc(Key);
    moving = GL_TRUE;
    glutIdleFunc(Animate);
    glutVisibilityFunc(Visible);
    
    time_menu = glutCreateMenu(timingSelect);
    glutAddMenuEntry("GL_VENDOR", 1);
    glutAddMenuEntry("GL_RENDERER", 2);
    glutAddMenuEntry("GL_VERSION", 3);
    glutAddMenuEntry("GL_EXTENSIONS", 4);
    
    glutCreateMenu(menuSelect);
    glutAddMenuEntry("Start motion", 1);
    glutAddMenuEntry("Stop motion", 2);
    glutAddSubMenu("Timing Mode", time_menu);
    glutAddMenuEntry("Quit", 4);
    
    //glutAttachMenu(GLUT_RIGHT_BUTTON);
    glutAttachMenu(GLUT_RIGHT_BUTTON);
    glutMainLoop();
    return 0;             /* ANSI C requires main to return int. */
}
Пример #25
0
/*
 * Menu creation
 */
void SetUpMenu(void)
{
    int SampleMenu;
    
    SampleMenu = glutCreateMenu(SelectSampleRate);
    glutAddMenuEntry("1", 1);
    glutAddMenuEntry("5", 5);
    glutAddMenuEntry("10", 10);
    glutAddMenuEntry("20", 20);
    glutCreateMenu(MainMenu);
    glutAddMenuEntry("Mouse Motion", 0);
    glutAddMenuEntry("Line antialias", 1);
    glutAddSubMenu("Sample rate", SampleMenu);
    glutAddMenuEntry("Quit", 2);
    glutAttachMenu(GLUT_RIGHT_BUTTON);

}
void OpenGLApplicationBase::setupMenus()
{
	GLuint menu1id = createPolygonMenu();
	GLuint menu2id = createFrontFaceMenu();
	GLuint menu3id = createPointSizeMenu();
	GLuint menu4id = createLineWidthMenu();
	GLuint menu5id = createAntiAliasingMenu();
	//Create main menu
	topMenu = glutCreateMenu(mainMenu);
	glutAddSubMenu("Polygon Mode", menu1id);
	glutAddSubMenu("Rendered Polygon Face", menu2id);
	glutAddSubMenu("Point Size", menu3id);
	glutAddSubMenu("Line Width", menu4id);
	glutAddSubMenu("Anti-aliasing", menu5id);
	glutAddMenuEntry("Quit", 1); //Quit identifier.
	glutAttachMenu(GLUT_RIGHT_BUTTON);//Menu responds to right button


}
Пример #27
0
//Create Right Click Menu
void initMenu()
{
	int id = glutCreateMenu(menu);
	glutSetMenu(id);
	glutAddMenuEntry("Clear", 0);
	glutAddMenuEntry("Play/Pause", 1);
	glutAddMenuEntry("Increment Speed", 2);
	glutAddMenuEntry("Decrement Speed", 3);
	glutAddMenuEntry("Randomize Grid", 4);
	glutAddMenuEntry("Quit", 5);

	glutAttachMenu(GLUT_RIGHT_BUTTON);

}
Пример #28
0
void createMenuEntry(const char* csName, ActionFunc func, int arg)
{
	strcpy(g_MenuEntries[g_MenuBuilder.nCurrMenuItem].csName, csName);

	char key = getRegisteredKey(func, arg);
	if (key != 0)
	{
		if (key == 27)
			strcat(g_MenuEntries[g_MenuBuilder.nCurrMenuItem].csName + strlen(csName), " [Esc]");
		else
			sprintf(g_MenuEntries[g_MenuBuilder.nCurrMenuItem].csName + strlen(csName), " [%c]", key);
	}

	g_MenuEntries[g_MenuBuilder.nCurrMenuItem].pCallbackFunc = func;
	g_MenuEntries[g_MenuBuilder.nCurrMenuItem].nCallbackArg = arg;

	glutAddMenuEntry(g_MenuEntries[g_MenuBuilder.nCurrMenuItem].csName, g_MenuBuilder.nCurrMenuItem);

	(g_MenuBuilder.nCurrMenuItem)++;
}
Пример #29
0
int main(int argc, char * argv[])
{
	gltSetWorkingDirectory(argv[0]);

	glutInit(&argc, argv);
	glutInitDisplayMode(GL_DOUBLE | GL_DEPTH | GL_STENCIL);
	glutInitWindowSize(1440, 900);
	glutCreateWindow("Tunnel @Jingz");

	glutReshapeFunc(ChangeSize);
	glutDisplayFunc(RenderScene);
	glutSpecialFunc(SpecialKeys);

	glutCreateMenu(ProcessMenu);
	glutAddMenuEntry("GL_NEAREST", 0);
	glutAddMenuEntry("GL_LINEAR", 1);
	glutAddMenuEntry("GL_NEAREST_MIPMAP_NEAREST", 2);
	glutAddMenuEntry("GL_NEAREST_MIPMAP_LINEAR", 3);
	glutAddMenuEntry("GL_LINEAR_MIPMAP_NEAREST", 4);
	glutAddMenuEntry("GL_LINEAR_MIPMAP_LINEAR", 5);
	glutAddMenuEntry("Anisotropic Filter", 6);
	glutAddMenuEntry("Anisotropic Off", 7);

	glutAttachMenu(GLUT_RIGHT_BUTTON);

	GLenum err = glewInit();
	if (err != GLEW_OK)
	{
		fprintf(stderr, "GLEW ERROR: %s\n", glewGetErrorString(err));
	}

	SetupRC();

	glutMainLoop();

	ShutdownRC();

	return 0;
}
Пример #30
0
/*!
 *
 */
static void
init(void) 
{
  glClearColor(0.5, 0.5, 0.5, 1.0);
  glShadeModel(GL_SMOOTH);
  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
  glDepthFunc(GL_LEQUAL);
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_CULL_FACE);
  glCullFace(GL_BACK);
  //glDisable(GL_NORMALIZE);
  //glPolygonOffset(1.0, 2);


  file=lib3ds_file_load(filename);
  if (!file) {
    puts("***ERROR*** Loading 3DS file failed.");
    exit(1);
  }
  if (!file->cameras) {
    puts("***ERROR*** No Camera found.");
    lib3ds_file_free(file);
    file=0;
    exit(1);
  }
  if (!camera) {
    camera=file->cameras->name;
  }
  camera_menu_id=glutCreateMenu(camera_menu);
  {
    Lib3dsCamera *c;
    int i;
    for (c=file->cameras,i=0; c; c=c->next,++i) {
      glutAddMenuEntry(c->name, i);
    }
  }
  glutAttachMenu(0);

  lib3ds_file_eval(file,0);
}