int main(int argc, char* argv[])
{
GLint i;
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(windowWidth, windowHeight);
glutCreateWindow("Vertex Blending Demo");
glutReshapeFunc(ChangeSize);
glutKeyboardFunc(KeyPressFunc);
glutSpecialFunc(SpecialKeys);
glutDisplayFunc(RenderScene);
SetupRC();
// Create the menus
mainMenu = glutCreateMenu(ProcessMenu);
glutAddMenuEntry("Toggle vertex blending (currently ON)", 1);
glutAddMenuEntry("Show bones (currently OFF)", 2);
if (lowLevelAvailable && highLevelAvailable)
{
if (useHighLevel)
{
glutAddMenuEntry("Switch to low-level vertex shader", 3);
}
else
{
glutAddMenuEntry("Switch to high-level vertex shader", 3);
}
}
glutAttachMenu(GLUT_RIGHT_BUTTON);
glutMainLoop();
if (glDeleteObjectARB)
{
for (i = 0; i < TOTAL_SHADERS; i++)
{
glDeleteObjectARB(progObj[i]);
glDeleteObjectARB(vShader[i]);
}
}
return 0;
}
int main(int argc, char* argv[])
{
GLint i;
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(windowWidth, windowHeight);
glutCreateWindow("Vertex Shaders Demo");
glutReshapeFunc(ChangeSize);
glutKeyboardFunc(KeyPressFunc);
glutSpecialFunc(SpecialKeys);
glutDisplayFunc(RenderScene);
SetupRC();
// Create the menus
shaderMenu = glutCreateMenu(ProcessMenu);
for (i = 0; i < TOTAL_SHADERS; i++)
{
char menuEntry[128];
sprintf(menuEntry, "\"%s\"", shaderNames[i]);
glutAddMenuEntry(menuEntry, 1+i);
}
mainMenu = glutCreateMenu(ProcessMenu);
{
char menuEntry[128];
sprintf(menuEntry, "Choose vertex shader (currently \"%s\")", shaderNames[0]);
glutAddSubMenu(menuEntry, shaderMenu);
}
glutAttachMenu(GLUT_RIGHT_BUTTON);
glutMainLoop();
if (glDeleteShader && glDeleteProgram)
{
for (i = 0; i < TOTAL_SHADERS; i++)
{
glDeleteProgram(progObj[i]);
glDeleteShader(vShader[i]);
}
}
return 0;
}
int main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(800,600);
glutCreateWindow("F-16 Thunderbird");
glutReshapeFunc(ChangeSize);
glutDisplayFunc(RenderScene);
SetupRC();
glutTimerFunc(5, TimerFunction, 1);
glutMainLoop();
ShutdownRC();
return 0;
}
int main (int argc, char * argv[])
{
glutInit(&argc, argv);
// Double buffered, RGBA with depth buffer
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutInitWindowSize(800, 600);
glutCreateWindow("Skelton GLUT app");
glutReshapeFunc(ChangeSize);
glutKeyboardFunc(KeyPressFunc);
glutDisplayFunc(RenderScene);
SetupRC();
glutMainLoop();
return 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");
glutReshapeFunc(ChangeSize);
glutDisplayFunc(RenderScene);
glutSpecialFunc(SpecialKeys);
GLenum err = glewInit();
if(GLEW_OK != err) {
fprintf(stderr, "GLEW Error: %s\n", glewGetErrorString(err));
return 1;
}
SetupRC();
glutMainLoop();
return 0;
}
int main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutCreateWindow("Evolution");
glutReshapeFunc(ChangeSize);
glutSpecialFunc(SpecialKeys);
glutKeyboardFunc(NormalKeys);
glutDisplayFunc(RenderScene);
SetupRC();
glutTimerFunc(33, TimerFunction, 1);
glutMainLoop();
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
HANDLE hMutex;
hMutex = CreateMutex(NULL,FALSE,L"ToPatcher");
if(GetLastError() == ERROR_ALREADY_EXISTS)
{
printf("이미 실행중입니다");
return 0;
}
SetupRC();
ScenePatch();
Quit();
CloseHandle(hMutex);
return 0;
}
int main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
glutInitWindowSize(800,600);
glutCreateWindow("Bounce");
glutDisplayFunc(RenderScene);
glutReshapeFunc(ChangeSize);
glutTimerFunc(33, TimerFunction, 1);
SetupRC();
const char* str = (const char*)glGetString(GL_EXTENSIONS);
printf("%s", str);
glutMainLoop();
return 0;
}
//Start Main Program.
void main(int argc, char* argv[])
{
//Initiate glut
glutInit(&argc,argv);
//Initiate DisplayMode
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
//Create an Window with X
glutCreateWindow("Partition and Region Line - 20130219");
//set Callback Func - Display Routine
glutDisplayFunc(RenderScene);
//set Callback Func - Reshape Routine
glutReshapeFunc(ChangeSize);
//set Callback Func - Special Key Input Routine
glutSpecialFunc(SpecialKeys);
//set Rendering Option
SetupRC();
//Start Routine
glutMainLoop();
}
int main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_STENCIL);
glutInitWindowSize(800,600);
glutCreateWindow("OpenGL SphereWorld Demo + Texture Maps");
glutReshapeFunc(ChangeSize);
glutDisplayFunc(RenderScene);
glutSpecialFunc(SpecialKeys);
SetupRC();
glutTimerFunc(33, TimerFunction, 1);
glutMainLoop();
ShutdownRC();
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowPosition(0, 0);
glutInitWindowSize(GWindowWidth, GWindowHeigth);
glutCreateWindow("Homework4");
glutDisplayFunc(RenderScene);
glutReshapeFunc(ChangeSize);
glutSpecialFunc(KeyControl);
glutTimerFunc(2000, TimerFunc, 1);
SetupRC();
glutMainLoop();
return 0;
}
int main(void)
{
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowPosition(0, 0);
glutInitWindowSize(512, 512);
glutCreateWindow("Triangle");
glutCreateMenu(ProcessMenu);
glutAddMenuEntry("은면 제거", 1);
glutAddMenuEntry("깊이 테스트", 2);
glutAddMenuEntry("뒷면 라인 그리기", 3);
glutAttachMenu(GLUT_RIGHT_BUTTON);
glutDisplayFunc(RenderScene);
glutReshapeFunc(ChangeSize);
glutSpecialFunc(KeyControl);
SetupRC();
glutMainLoop();
}
//////////////////////////////////////////////////////
// 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;
}
int main(int argc, char ** argv)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("GLRect");
glutDisplayFunc(RenderScene);
glutReshapeFunc(ChangeSize);
SetupRC();
glutMainLoop();
// glutInit(&argc, argv);
// glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
// glutInitWindowSize(400, 400);
// glutInitWindowPosition(100, 200);
// glutCreateWindow("Our first GLUT application!");
// glutDisplayFunc(Display);
// Initialize();
// glutMainLoop();
return 0;
}
int main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitWindowSize(800,640);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutCreateWindow("Roda Automatica");
glutReshapeFunc(ChangeSize);
glutSpecialFunc(SpecialKeys);
glutKeyboardFunc(keyboard);
glutDisplayFunc(RenderScene);
//glutTimerFunc(330, TimerFunction, 1);
SetupRC();
glutMainLoop();
return 0;
}
int main(int argc, char* argv[])
{
gltSetWorkingDirectory(argv[0]);
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(800,600);
glutCreateWindow("OpenGL SphereWorld with Texture Rectangle");
glutReshapeFunc(ChangeSize);
glutDisplayFunc(RenderScene);
glutSpecialFunc(SpecialKeys);
SetupRC();
glutMainLoop();
ShutdownRC();
return 0;
}
int main(int argc, char* argv)
{
printf("Version: %s\nExtensions: %s\n", glGetString(GL_VERSION), glGetString(GL_EXTENSIONS));
printf("Delay: %d\n", DELAY);
glutInit(&argc, &argv);
glutInitWindowSize(1280, 400);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutCreateWindow("Hello Sine-Waves!");
glutDisplayFunc(RenderScene);
glutReshapeFunc(ChangeSize);
glutTimerFunc(DELAY, TimerFunction, 1);
SetupRC();
glutMainLoop();
}
int main(int argc, char* argv[])
{
gltSetWorkingDirectory(argv[0]);
glfwInit();
glfwSetErrorCallback(OnError);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); //We don't want the old OpenGL
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
GLFWwindow* window = glfwCreateWindow(800, 600, "Shaded Triangle", NULL, NULL);
glfwSetFramebufferSizeCallback(window, ChangeSize);
glfwMakeContextCurrent(window);
glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (err != GLEW_OK) {
fprintf(stderr, "GLEW Error: %s\n", glewGetErrorString(err));
return 1;
}
printf("GLSL Version: %s\nGL Renderer: %s\nGL Version: %s\n",
glGetString(GL_SHADING_LANGUAGE_VERSION),
glGetString(GL_RENDERER),
glGetString(GL_VERSION)
);
SetupRC();
while(!glfwWindowShouldClose(window))
{
glfwPollEvents();
RenderScene(window);
}
ShutdownRC();
return 0;
}
int main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(windowWidth, windowHeight);
glutCreateWindow("Pixel Buffer Object Demo");
glutReshapeFunc(ChangeSize);
glutKeyboardFunc(KeyPressFunc);
glutSpecialFunc(SpecialKeys);
glutDisplayFunc(RenderScene);
glutIdleFunc(RenderScene);
SetupRC();
// Create the menus
usageMenu = glutCreateMenu(ProcessMenu);
glutAddMenuEntry("GL_STREAM_DRAW", 3);
glutAddMenuEntry("GL_STREAM_READ", 4);
glutAddMenuEntry("GL_STREAM_COPY", 5);
glutAddMenuEntry("GL_STATIC_DRAW", 6);
glutAddMenuEntry("GL_STATIC_READ", 7);
glutAddMenuEntry("GL_STATIC_COPY", 8);
glutAddMenuEntry("GL_DYNAMIC_DRAW", 9);
glutAddMenuEntry("GL_DYNAMIC_READ", 10);
glutAddMenuEntry("GL_DYNAMIC_COPY", 11);
mainMenu = glutCreateMenu(ProcessMenu);
glutAddMenuEntry("Toggle PBO usage (currently OFF)", 1);
glutAddMenuEntry("Toggle motion blur (currently ON)", 2);
glutAddSubMenu("Choose PBO usage (currently GL_STREAM_COPY)", usageMenu);
glutAttachMenu(GLUT_RIGHT_BUTTON);
glutMainLoop();
for (int i = 0; i < 3; i++)
{
if (!usePBOs)
free(pixels[i]);
}
return 0;
}
void main(int args, char* argv[])
{
GLenum err;
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
err = glewInit();
if(GLEW_OK != err){
printf("Error:%s\n", glewGetErrorString(err));
return;
}
glutCreateWindow("VBO");
glutPositionWindow(100,100);
glutDisplayFunc(DisplayFunc);
glutReshapeFunc(ReshapeFunc);
SetupRC();
glutMainLoop();
}
int main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(800, 600);
glutCreateWindow("Smoothing Out The Jaggies");
// Create the Menu
glutCreateMenu(ProcessMenu);
glutAddMenuEntry("Antialiased Rendering",1);
glutAddMenuEntry("Normal Rendering",2);
glutAttachMenu(GLUT_RIGHT_BUTTON);
glutReshapeFunc(ChangeSize);
glutDisplayFunc(RenderScene);
SetupRC();
glutMainLoop();
return 0;
}
int main(int argc, char* argv[])
{
Initial();
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB|GLUT_DEPTH );
glutInitWindowPosition(0,0);
glutInitWindowSize(WINDOW_WIDTH,WINDOW_HEIGHT);
glutCreateWindow("Hücresel Otomatlar Trafik Simülasyonu(CPU)");
glutReshapeFunc(ChangeSize);
glutTimerFunc(WAIT,waitAndRedraw,1);
glutDisplayFunc(RenderScene);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
initMenus();
SetupRC();
glutMainLoop();
return 0;
}
// Parte principal - ponto de incio de execucao
// Cria janela
// Inicializa aspectos relacionados a janela e a geracao da imagem
// Especifica a funcao de callback de desenho
int main( int argc, char** argv)
{
// Indica que deve ser usado um unico buffer para armazenamento da imagem e representacao de cores RGB
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
// Cria uma janela com o titulo especificado
glutCreateWindow("Programa Basico OpenGL");
// Especifica para a OpenGL que funcao deve ser chamada para geracao da imagem
glutDisplayFunc(RenderScene);
// Executa a inicializacao de parametros de exibicao
SetupRC();
// Dispara a "maquina de estados" de OpenGL
glutMainLoop();
return 0;
}
int main(int argc, char *argv[])
{
// Initialize GLUT and GLEW, then create a window.
////////////////////
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowPosition(100, 100);
glutInitWindowSize(800, 600);
glutCreateWindow("HW1 - 103062372"); // You cannot use OpenGL functions before this line; The OpenGL context must be created first by glutCreateWindow()!
glewInit();
dumpInfo();
////////////////////
inittexture();
// Initialize OpenGL states.
////////////////////////
SetupRC(); //initial
////////////////////////
BuildMenu(); //build menu
// Register GLUT callback functions.
///////////////////////////////
glutDisplayFunc(My_Display);
glutReshapeFunc(My_Reshape);
glutMouseFunc(My_Mouse);
glutMotionFunc(My_MouseMove);
glutKeyboardFunc(My_Keyboard);
glutSpecialFunc(My_SpecialKeys);
glutTimerFunc(timer_speed, My_Timer, 0);
///////////////////////////////
// Enter main event loop.
//////////////
glutMainLoop();
//////////////
return 0;
}
int main(int argc, char* argv[]) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_STENCIL);
glutInitWindowSize(1024, 768);
glutCreateWindow("Piramida");
glutReshapeFunc(ChangeSize);
glutDisplayFunc(RenderScene);
GLenum err = glewInit();
if (GLEW_OK != err) {
fprintf(stderr, "GLEW Error: %s\n", glewGetErrorString(err));
return 1;
}
SetupRC();
glutMainLoop();
return 0;
}
int main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(800, 600);
glutCreateWindow("Texture Arrays");
glutReshapeFunc(ChangeSize);
glutDisplayFunc(RenderScene);
GLenum err = glewInit();
if (GLEW_OK != err) {
fprintf(stderr, "GLEW Error: %s\n", glewGetErrorString(err));
return 1;
}
SetupRC();
glutMainLoop();
return 0;
}
int main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutCreateWindow("Triangles Constructing Fan Example");
glutReshapeFunc(ChangeSize);
glutSpecialFunc(SpecialKeys);
glutDisplayFunc(RenderScene);
SetupRC();
// utworzenie podmenu - Prymitywy
int MenuPrimitive = glutCreateMenu(Menu);
glutAddMenuEntry("GL_CULL_FACE", GL_CULL_FACE);
glutAddMenuEntry("GL_DEPTH_TEST", GL_DEPTH_TEST);
glutAddMenuEntry("Polygon mode LINE", GL_LINE);
glutAddMenuEntry("Polygon mode FILL", GL_FILL);
glutAddMenuEntry("Wyjecie", EXIT);
// okre lenie przycisku myszki obs uguj cego menu podr czne
glutAttachMenu(GLUT_RIGHT_BUTTON);
glutMainLoop();
return 0;
}
int main(int args, char *argv[])
{
glutInit(&args, argv);
glutInitWindowSize(windowWidth, windowHeight);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutCreateWindow("Occlusion");
glutDisplayFunc(RenderScene);
SetupRC();
glutReshapeFunc(ChangeSize);
glutCreateMenu(ProcessMenu);
glutAddMenuEntry("Toogle occlusion culling(currently OFF)", 1);
glutAttachMenu(GLUT_RIGHT_BUTTON);
glutSpecialFunc(SpecialKey);
glutMainLoop();
glDeleteQueries(27, queryIDs);
return 0;
}
int main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutCreateWindow("Triangle Culling Example");
// Create the Menu
glutCreateMenu(ProcessMenu);
glutAddMenuEntry("Toggle depth test",1);
glutAddMenuEntry("Toggle cull backface",2);
glutAddMenuEntry("Toggle outline back",3);
glutAttachMenu(GLUT_RIGHT_BUTTON);
glutReshapeFunc(ChangeSize);
glutSpecialFunc(SpecialKeys);
glutDisplayFunc(RenderScene);
SetupRC();
glutMainLoop();
return 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;
}
